深海游弋的鱼 – 第 167 页

Arduino PWM控制逻辑

对于直流电机的速度控制，目前流行的控制逻辑是PWM，关于 Arduino 的PWM，看看图片

板子上标注了“PWM”的区域就是管脚均可以用于这种输出。使用的函数是：

analogWrite(pin, value);

1	analogWrite(pin, value);

注意value值的范围是0~255。

PWM　英文是“Pulse-width modulation”　，PWM是用占空比不同的方波，来模拟“模拟输出”的一种方式。简而言之就是电脑只会输出0和1，那么想输出0.5怎么办呢？于是输出01010101….，平均之后的效果就是0.5了。

现在看看电机的常规驱动电路，H桥

使用单片机来控制直流电机的变速，一般采用调节电枢电压的方式，通过单片机控制PWM1，PWM2,产生可变的脉冲，这样电机上的电压也为宽度可变的脉冲电压。根据公式

U=aVCC

其中：U为电枢电压；a为脉冲的占空比（0<a<1）；VCC直流电压源，这里为5V。

电动机的电枢电压受单片机输出脉冲控制，实现了利用脉冲宽度调制技术（PWM）进行直流电机的变速。

因为在H桥电路中，只有PWM1与PWM2电平互为相反时电机才能驱动，也就是PWM1与PWM2同为高电平或同为低电平时，都不能工作，所以上图中的实际脉冲宽度为B，

我们把PWM波的周期定为1ms，占空比分100级可调（每级级差为10%），这样定时器T0每0.01ms产生一次定时中断，每100次后进入下一个 PWM波的周期。上图中，占空比是60%，即输出脉冲的为0.6ms，断开脉冲为0.4ms，这样电枢电压为5*60%=3V。

我们讨论的是可以正转反转的，如果只按一个方向转，我们就只要把PWM1置为高电平或低电平，只改变另一个PWM2电平的脉冲变化即可，，如下图（Q4导通，Q3闭合，电机只能顺时针调整转动速度）

下面看看摘抄的部分原理

直流电动机转速n=(U-IR)/Kφ

其中U为电枢端电压，I为电枢电流，R为电枢电路总电阻，φ为每极磁通量，K为电动机结构参数。

直流电机转速控制可分为励磁控制法与电枢电压控制法。励磁控制法是控制磁通，其控制功率小，低速时受到磁饱和限制，高速时受到换向火花和换向器结构强度的限制，而且由于励磁线圈电感较大动态响应较差，所以这种控制方法用得很少。大多数应用场合都使用电枢电压控制法。随着电力电子技术的进步，改变电枢电压可通过多种途径实现，其中PWM(脉宽调制)便是常用的改变电枢电压的一种调速方法。

PWM调速控制的基本原理是按一个固定频率来接通和断开电源，并根据需要改变一个周期内接通和断开的时间比(占空比)来改变直流电机电枢上电压的"占空比"，从而改变平均电压，控制电机的转速。在脉宽调速系统中，当电机通电时其速度增加，电机断电时其速度减低。只要按照一定的规律改变通、断电的时间，即可控制电机转速。而且采用PWM技术构成的无级调速系统．启停时对直流系统无冲击，并且具有启动功耗小、运行稳定的特点。

设电机始终接通电源时，电机转速最大为Vmax，且设占空比为D=t／T，则电机的平均速度Vd为：

Vd=VmaxD

由公式可知，当改变占空比D=t／T时，就可以得到不同的电机平均速度Vd，从而达到调速的目的。严格地讲，平均速度与占空比D并不是严格的线性关系，在一般的应用中，可将其近似地看成线性关系。在直流电机驱动控制电路中，PWM信号由外部控制电路提供，并经高速光电隔离电路、电机驱动逻辑与放大电路后，驱动H桥下臂MOSFET的开关来改变直流电机电枢上平均电压，从而控制电机的转速，实现直流电机PWM调速。

原理知道了，那么看看　Arduino Mega 2560 的PWM控制端口信息

1) Arduino 2560 has 12 pins supporting PWM. They are from 2 to 13 included.
2) the PWM default frequency is 490 Hz for all pins, with the exception of pin 13 and 4,whose frequency is 980 Hz (I checked with an oscilloscope).
3) In order to change frequency on pin 'A', we have to change some value in the timer (or register), controlling pin 'A'. This is the list of timers in Arduino Mega 2560:
timer 0 (controls pin 13, 4);
timer 1 (controls pin 12, 11);
timer 2 (controls pin 10, 9);
timer 3 (controls pin 5, 3, 2);
timer 4 (controls pin 8, 7, 6);

As you can see, a given timer controls more than one pin (every change about a timer will affect all pins depending on it!).

4) You can access a timer simply changing in your code (tipically in the setup()), the value of variable TCCRnB, where 'n' is the number of register. So, if we want to change the PWM frequency of pins 10 and 9, we will have to act on TCCR2B .

5) The TCCRnB is a 8 bit number. The first three bits (from right to left!) are called CS02, CS01, CS00, and they are the bits we have to change.
Those bits in fact represent an integer number (from 0 to 7) called 'prescaler' , that Arduino uses to generate the frequency for PWM.

6) First of all, we have to clear these three bits, i.e they must be all set to 0:

int myEraser = 7;             // this is 111 in binary and is used as an eraser
TCCR2B &= ~myEraser;   // this operation (AND plus NOT),  set the three bits in TCCR2B to 0

1 2	int myEraser = 7; // this is 111 in binary and is used as an eraser TCCR2B &= ~myEraser; // this operation (AND plus NOT), set the three bits in TCCR2B to 0

7) now that CS02, CS01, CS00 are clear, we write on them a new value:

int myPrescaler = 3;         // this could be a number in [1 , 6]. In this case, 3 corresponds in binary to 011.
TCCR2B |= myPrescaler;  //this operation (OR), replaces the last three bits in TCCR2B with our new value 011

1 2	int myPrescaler = 3; // this could be a number in [1 , 6]. In this case, 3 corresponds in binary to 011. TCCR2B \|= myPrescaler; //this operation (OR), replaces the last three bits in TCCR2B with our new value 011

now we have a new PWM frequency on pin 9 and 10!

I registered those values on all PWM pins, changing the value of prescaler (the only exception are pins 13 and 14, see later):

prescaler = 1 ---> PWM frequency is 31000 Hz
prescaler = 2 ---> PWM frequency is 4000 Hz
prescaler = 3 ---> PWM frequency is 490 Hz (default value)
prescaler = 4 ---> PWM frequency is 120 Hz
prescaler = 5 ---> PWM frequency is 30 Hz
prescaler = 6 ---> PWM frequency is <20 Hz

(prescalers equal t 0 or 7 are useless).

Those prescaler values are good for all timers (TCCR1B, TCCR2B, TCCR3B, TCCR4B) except for timer 0 (TCCR0B). In this case the values are:

prescaler = 1 ---> PWM frequency is 62000 Hz
prescaler = 2 ---> PWM frequency is 7800 Hz
prescaler = 3 ---> PWM frequency is 980 Hz (default value)
prescaler = 4 ---> PWM frequency is 250 Hz
prescaler = 5 ---> PWM frequency is 60 Hz
prescaler = 6 ---> PWM frequency is <20 Hz

Note that timer 0 is the one on which rely all time functions in Arduino: i.e., if you change this timer, function like delay() or millis() will continue to work but at a different timescale (quicker or slower!!!)

明天修改一下电机的控制代码，把小车代码修改一下，哈哈

Android查看源代码的版本号

确认Android源代码的版本号：

1. 编译的时候在终端中一开始就会打印出来：

    PLATFORM_VERSION：2.3.1

1	PLATFORM_VERSION：2.3.1

2. 直接去make文件中去看：

    build\core\version_defaults.mk  // 搜索该文件中的 PLATFORM_VERSION值

1	build\core\version_defaults.mk // 搜索该文件中的 PLATFORM_VERSION值

编写Arduino支持的C++类库

以下为摘抄的例子，已经亲自验证过，例子是正确的

我们在上一讲中实现了一个TN901红外温度传感器51程序到Arduino程序的转换，如果代码越来越多这样程序的可维护性会随之降低，也不适合团度开发。我们应该把常用的文件封装成C++库，这样在复用的时候就会方便很多。
首先让我们来看下官方的C++类库是怎样的结构，以官方的LCD类库为例，如下图所示：

上面的文件大体是这样的结构：

文件名	文件类型	文件说明
keywords.txt	keywords.txt	Arduino库色标文件
LiquidCrystal.h	.h	C++头文件
LiquidCrystal.cpp	.cpp	C++程序文件

以下几种文件的作用如下：

.h 头文件：头文件作为一种包含功能函数、数据接口声明的载体文件，用于保存程序的声明(declaration)，而定义文件用于保存程序的实现 (implementation)。

.cpp 文件：C++程序源文件主要的逻辑写在这里。

keywords.txt 文件：用来定义库在程序中显示关键字的颜色。

首先我们来尝试下头文件的编写

#ifndef TH901_H  //根据条件进行编译
#define TH901_H

//我们在这中间添加程序主体的代码部分，首先来添加程序的头文件，需要引用什么都可以加进来
#include <inttypes.h> //引用相关的头文件

//之后我们可以预定义一些需要的常量，这样维护起来比较方便，如果常量值改变只要统一修改这里就好
#define TN901_OTADDRESS 0x4c
#define TN901_ETADDRESS 0x66
#define TN901_ENDADDRESS 0x0d

//接下来我们来定义变量和声明程序的方法，需要外部调用和访问的就声明成public,不需要外部访问的就声明为private

class TN901     //定义类主体及类名
{
public:  //以下定义为公共方法
short ET;   //环境温度输出
short OT;   //目标温度输出
void Init(int TN_Data,int TN_Clk,int TN_ACK); //程序初始化
void Read();  //读取方法
void ReadData(char flag); //读取指定地址的数据
int  GetData(); //获取数据
private:  //以下定义为私有方法
int _dataPin;  //数据引脚
int _clkPin;   //时钟引脚
int _ackPin;   //反馈引脚
unsigned char  Data[5];  //数据数组
};
#endif//程序结束

#ifndef TH901_H //根据条件进行编译

#define TH901_H

//我们在这中间添加程序主体的代码部分，首先来添加程序的头文件，需要引用什么都可以加进来

#include <inttypes.h> //引用相关的头文件

//之后我们可以预定义一些需要的常量，这样维护起来比较方便，如果常量值改变只要统一修改这里就好

#define TN901_OTADDRESS 0x4c

#define TN901_ETADDRESS 0x66

#define TN901_ENDADDRESS 0x0d

//接下来我们来定义变量和声明程序的方法，需要外部调用和访问的就声明成public,不需要外部访问的就声明为private

class TN901 //定义类主体及类名

{

public: //以下定义为公共方法

short ET; //环境温度输出

short OT; //目标温度输出

void Init(int TN_Data,int TN_Clk,int TN_ACK); //程序初始化

void Read(); //读取方法

void ReadData(char flag); //读取指定地址的数据

int GetData(); //获取数据

private: //以下定义为私有方法

int _dataPin; //数据引脚

int _clkPin; //时钟引脚

int _ackPin; //反馈引脚

unsigned char Data[5]; //数据数组

};

#endif//程序结束

这样我们一个头文件就写好了.

接下来我们来书写程序的主体，就是CPP文件。

//首先我们引用已经写好的程序头文件
#include "TN901.h"
//之后我们引用一些需要的库文件
#include "TN901.h"
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "Arduino.h"

//首先我们引用已经写好的程序头文件

#include "TN901.h"

//之后我们引用一些需要的库文件

#include "TN901.h"

#include <stdio.h>

#include <string.h>

#include <inttypes.h>

#include "Arduino.h"

然后我们逐一实现在头文件中定义的方法，注意类型要与定义类型相对应。所有的方法都要属于你定义的类名，格式如下

类名::方法名

另外i啊我们要为程序的封装考虑程序应有的结构，总之是怎样使你的库使用起来最方便，在一般的逻辑中尽量减少调用的次数。我们可以把程序的逻辑分割为几个部分来书写。如：

1.初始化
2.实现功能
3.显示数据

当然这个逻辑以具体的程序为准。

我们来尝试写第一个初始化的方法，这样我们可以自己定义程序的端口。

//初始化TN901传感器
void TN901::Init(int TN_Data,int TN_Clk,int TN_ACK)
{
//定义私有端口
_dataPin=TN_Data;
_clkPin=TN_Clk;
_ackPin=TN_ACK;

pinMode(_clkPin, INPUT);
pinMode(_ackPin, OUTPUT);
digitalWrite(_ackPin,HIGH);
}

//初始化TN901传感器

void TN901::Init(int TN_Data,int TN_Clk,int TN_ACK)

{

//定义私有端口

_dataPin=TN_Data;

_clkPin=TN_Clk;

_ackPin=TN_ACK;

pinMode(_clkPin, INPUT);

pinMode(_ackPin, OUTPUT);

digitalWrite(_ackPin,HIGH);

}

然后我们书写程序的主要逻辑部分

//读取数据
void TN901::Read()
{
digitalWrite(_ackPin,LOW);
ReadData(TN901_OTADDRESS);//目标温度的第一个字节为0x4c
if((Data[0]==TN901_OTADDRESS)&&
(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d
{
GetData_OT();
}

delay(1); //等待1毫秒

digitalWrite(_ackPin,LOW);
ReadData(TN901_ETADDRESS);//环境温度的第一个字节为0x66

if((Data[0]==TN901_ETADDRESS)&&
(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d
{
GetData_ET();
}
}

//读取数据

void TN901::Read()

{

digitalWrite(_ackPin,LOW);

ReadData(TN901_OTADDRESS);//目标温度的第一个字节为0x4c

if((Data[0]==TN901_OTADDRESS)&&

(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d

{

GetData_OT();

}

delay(1); //等待1毫秒

digitalWrite(_ackPin,LOW);

ReadData(TN901_ETADDRESS);//环境温度的第一个字节为0x66

if((Data[0]==TN901_ETADDRESS)&&

(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d

{

GetData_ET();

}

最后我们逐一实现程序的运算过程

//读取数据
void TN901::ReadData(char flag)
{
char i,j,k;
byte BitState = 0;          //每次发七帧
for(k=0;k<7;k++)
{
for(j=0;j<5;j++)        //每帧5个字节
{
for(i=0;i<8;i++)
{
int temp= digitalRead(_clkPin);
while(temp)
{
temp = digitalRead(_clkPin);
}
temp= digitalRead(_clkPin);
BitState= digitalRead(_dataPin);
Data[j]= Data[j]<<1;
Data[j]= Data[j]|BitState;

while(!temp)
{
temp = digitalRead(_clkPin);
}
}
}
if(Data[0]==flag)  k=8;
}

digitalWrite(_ackPin,HIGH);
}

//计算环境温度
void TN901::GetData_ET()
{
ET=(Data[1]<<8)|Data[2];
ET = int(((float)ET/16 - 273.15)*100);
}

//计算目标温度
void TN901::GetData_OT()
{
OT=(Data[1]<<8)|Data[2];
OT = int(((float)OT/16 - 273.15)*100);
}

//读取数据

void TN901::ReadData(char flag)

{

char i,j,k;

byte BitState = 0; //每次发七帧

for(k=0;k<7;k++)

{

for(j=0;j<5;j++) //每帧5个字节

{

for(i=0;i<8;i++)

{

int temp= digitalRead(_clkPin);

while(temp)

{

temp = digitalRead(_clkPin);

}

temp= digitalRead(_clkPin);

BitState= digitalRead(_dataPin);

Data[j]= Data[j]<<1;

Data[j]= Data[j]|BitState;

while(!temp)

{

temp = digitalRead(_clkPin);

}

if(Data[0]==flag) k=8;

}

digitalWrite(_ackPin,HIGH);

}

//计算环境温度

void TN901::GetData_ET()

{

ET=(Data[1]<<8)|Data[2];

ET = int(((float)ET/16 - 273.15)*100);

}

//计算目标温度

void TN901::GetData_OT()

{

OT=(Data[1]<<8)|Data[2];

OT = int(((float)OT/16 - 273.15)*100);

}

之后我们来尝试为我们的库编写一个范例程序来测试我们的程序是否运行正常。

#include <TN901.h>  //引用库文件
TN901 tn;           //实 例 化
void setup()
{
Serial.begin(9600);
tn.Init(7,9,8);  //初 始 化
}

void loop()
{
tn.Read();        //数据读取
SerialValue();
delay(200);
}

void SerialValue()
{
Serial.print("OT: ");
Serial.print(tn.OT, DEC);  //输出目标温度
Serial.println(" C");
Serial.print("ET: ");
Serial.print(tn.ET, DEC);  //输出环境温度
Serial.println(" C");
}

#include <TN901.h> //引用库文件

TN901 tn; //实例化

void setup()

{

Serial.begin(9600);

tn.Init(7,9,8); //初始化

}

void loop()

{

tn.Read(); //数据读取

SerialValue();

delay(200);

}

void SerialValue()

{

Serial.print("OT: ");

Serial.print(tn.OT, DEC); //输出目标温度

Serial.println(" C");

Serial.print("ET: ");

Serial.print(tn.ET, DEC); //输出环境温度

Serial.println(" C");

}

好了，我们看到虽然我们花了一点时间编写了库文件，但是在我们使用程序的时候可以非常方便的调用，而且这样逻辑会比较清晰。呵呵。

最后送给大家一个小礼物，就是如何为我们的库编写色标文件，色标文件就是定义你的库中的方法在编译器中显示的颜色
没有色标文件的库显示起来是这样的：

我们可以看到库文件的类名和方法名都是黑色的这样看起来不是很清楚。加上色标文件之后是这样的

我们可以看到TN901这样的类名都被加亮了这样看起来要清楚许多。

实现这个需要定义一个色标文件放在库文件的目录中，格式如下

#######################################
# Syntax Coloring Map For 你的类名
#######################################

#######################################
# Datatypes (KEYWORD1) 数据类型关键字
#######################################

TN901        KEYWORD1

#######################################
# Methods and Functions (KEYWORD2) 方法类型关键字
#######################################

Init        KEYWORD2
Read        KEYWORD2
ReadData        KEYWORD2
GetData        KEYWORD2

#######################################
# Constants (LITERAL1)  常量类型关键字
#######################################

ET        LITERAL1
OT        LITERAL1

#######################################

# Syntax Coloring Map For 你的类名

#######################################

# Datatypes (KEYWORD1) 数据类型关键字

#######################################

TN901 KEYWORD1

#######################################

# Methods and Functions (KEYWORD2) 方法类型关键字

#######################################

Init KEYWORD2

Read KEYWORD2

ReadData KEYWORD2

GetData KEYWORD2

#######################################

# Constants (LITERAL1) 常量类型关键字

#######################################

ET LITERAL1

OT LITERAL1

这样我们的色标文件就写好了，我们把它保存成文件名为keywords.txt的文件放在库文件目录下就可以了。

当我们些库文件全部做好了之后我们就可以把这些文件放在，这样的目录下

energia：energia-0101E0008\hardware\msp430\libraries\
arduino：arduino-1.0.1-windows\arduino-1.0.1\libraries\

这样当你重新打开官方编译器的时候可以看到如下的内容

python在windows的cmd中打印彩色文字

#!/usr/bin/env python
#encoding: utf-8
import ctypes

STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE= -11
STD_ERROR_HANDLE = -12

FOREGROUND_BLACK = 0x0
FOREGROUND_BLUE = 0x01 # text color contains blue.
FOREGROUND_GREEN= 0x02 # text color contains green.
FOREGROUND_RED = 0x04 # text color contains red.
FOREGROUND_INTENSITY = 0x08 # text color is intensified.

BACKGROUND_BLUE = 0x10 # background color contains blue.
BACKGROUND_GREEN= 0x20 # background color contains green.
BACKGROUND_RED = 0x40 # background color contains red.
BACKGROUND_INTENSITY = 0x80 # background color is intensified.

class Color:
 ''' See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winprog/winprog/windows_api_reference.asp
 for information on Windows APIs.'''
 std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)

 def set_cmd_color(self, color, handle=std_out_handle):
   """(color) -> bit
Example: set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY)
"""
  bool = ctypes.windll.kernel32.SetConsoleTextAttribute(handle, color)
  return bool

def reset_color(self):
  self.set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)

def print_red_text(self, print_text):
  self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY)
  print print_text
  self.reset_color()

def print_green_text(self, print_text):
  self.set_cmd_color(FOREGROUND_GREEN | FOREGROUND_INTENSITY)
  print print_text
  self.reset_color()

def print_blue_text(self, print_text):
  self.set_cmd_color(FOREGROUND_BLUE | FOREGROUND_INTENSITY)
  print print_text
  self.reset_color()

def print_red_text_with_blue_bg(self, print_text):
  self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY| BACKGROUND_BLUE | BACKGROUND_INTENSITY)
  print print_text
  self.reset_color()

if __name__ == "__main__":
 clr = Color()
 clr.print_red_text('red')
 clr.print_green_text('green')
 clr.print_blue_text('blue')
 clr.print_red_text_with_blue_bg('background')

#!/usr/bin/env python

#encoding: utf-8

import ctypes

STD_INPUT_HANDLE = -10

STD_OUTPUT_HANDLE= -11

STD_ERROR_HANDLE = -12

FOREGROUND_BLACK = 0x0

FOREGROUND_BLUE = 0x01 # text color contains blue.

FOREGROUND_GREEN= 0x02 # text color contains green.

FOREGROUND_RED = 0x04 # text color contains red.

FOREGROUND_INTENSITY = 0x08 # text color is intensified.

BACKGROUND_BLUE = 0x10 # background color contains blue.

BACKGROUND_GREEN= 0x20 # background color contains green.

BACKGROUND_RED = 0x40 # background color contains red.

BACKGROUND_INTENSITY = 0x80 # background color is intensified.

class Color:

''' See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winprog/winprog/windows_api_reference.asp

for information on Windows APIs.'''

std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)

def set_cmd_color(self, color, handle=std_out_handle):

"""(color) -> bit

Example: set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY)

"""

bool = ctypes.windll.kernel32.SetConsoleTextAttribute(handle, color)

return bool

def reset_color(self):

self.set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)

def print_red_text(self, print_text):

self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY)

print print_text

self.reset_color()

def print_green_text(self, print_text):

self.set_cmd_color(FOREGROUND_GREEN | FOREGROUND_INTENSITY)

print print_text

self.reset_color()

def print_blue_text(self, print_text):

self.set_cmd_color(FOREGROUND_BLUE | FOREGROUND_INTENSITY)

print print_text

self.reset_color()

def print_red_text_with_blue_bg(self, print_text):

self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY| BACKGROUND_BLUE | BACKGROUND_INTENSITY)

print print_text

self.reset_color()

if __name__ == "__main__":

clr = Color()

clr.print_red_text('red')

clr.print_green_text('green')

clr.print_blue_text('blue')

clr.print_red_text_with_blue_bg('background')

通过PPA仓库为ubuntu安装Oracle Java 7

首先先介绍一下什么叫PPA

PPA，表示 Personal Package Archives，也就是个人软件包集。

有很多软件因为种种原因，不能进入官方的 Ubuntu 软件仓库。为了方便 Ubuntu 用户使用，launchpad.net 提供了 ppa，允许用户建立自己的软件仓库，自由的上传软件。PPA 也被用来对一些打算进入 Ubuntu 官方仓库的软件，或者某些软件的新版本进行测试。

在ubuntu系统中，和OpenJDK比起来，如果你更偏爱Oracle JDK（前 Sun JDK），我推荐一种很简便的方法给你。通过一个PPA仓库，你可以很容易的进行安装Oracle JDK（包括JRE）并始终保持最新的版本。

Oracle JDK7本身并不存在于该PPA中，这是因为新的Java授权许可证并不允许这么做（这也是Oracle JDK7从ubuntu官方软件仓库中移除的原因）。PPA中的软件程序自动从Oracle官方网站下载Oracle Java JDK7并把它安装到你的电脑中，就像flashplugin-installer软件包那样。

需要注意的是，该软件包当前还是alpha 版本，可能在有些情况下不能正常工作！该软件包支持代理，但是如果你的ISP或者路由器封禁了一些非标准端口，这可能导致安装失败，这是由于Oracle 在Java7二进制安装包的下载链接中使用了许多重定向！如果因此而导致下载失败，亦或你的电脑在防火墙保护之下，你就需要手动安装 Oracle Java 7了。

安装Oracle Java 7

该软件包提供安装Oracle Java JDK 7 (包括 Java JDK, JRE 和 the Java 浏览器插件)，如果你只需要安装Oracle JRE，请不要使用该PPA。

运行下述命令，即可完成添加PPA、安装最新版本的Oracle Java 7（支持Ubuntu 12.10,12.04, 11.10, 11.04 and 10.04）:

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer

sudo add-apt-repository ppa:webupd8team/java

sudo apt-get update

sudo apt-get install oracle-java7-installer

安装完成之后，如果你想看看是否真的安装成功了，你只需运行下面的命令：

java -version

1	java -version

命令输出应该包含和下面类似的内容：

java version "1.7.0_04"Java(TM) SE Runtime Environment (build 1.7.0_04-20)Java HotSpot(TM) Server VM (build 23.0-b21, mixed mode)

1	java version "1.7.0_04"Java(TM) SE Runtime Environment (build 1.7.0_04-20)Java HotSpot(TM) Server VM (build 23.0-b21, mixed mode)

注：版本号中的”_04″部分可能会与你的不同，这是由于该PPA总是安装最新的Oracle Java 7版本。

如果由于一些其它的原因，当前的Java版本不是1.7.0，你可以尝试运行下面的命令：

sudo update-java-alternatives -s java-7-oracle

1	sudo update-java-alternatives -s java-7-oracle

卸载 Oracle Java 7

如果你不再想使用Oracle Java (JDK) 7，想回归OpenJDK了，你只需卸载Oracle JDK7 Installer，这样OpenJDK就又变成当前使用的java了：

sudo apt-get remove oracle-java7-installer

1	sudo apt-get remove oracle-java7-installer

import-module的注意事项与NDK_MODULE_PATH的配置

引用 http://blog.sina.com.cn/s/blog_4057ab62010197z8.html

import-module的功能
导入外部模块的.mk文件，和 include基本一样。
概念上的区别是include导入的是由我们自己写的.mk。而import-module导入的是外部库、外部模块提供的.mk。
用法上：include的路径是.mk文件的绝对路径。
而import是设置的路径指定到模块的.mk所在目录，是相对于NDK_MODULE_PATH中的路径列表的相对路径。

import-module的使用
$(call import-module,相对路径)

-----------------场景重现---------------------------
比如我的当前模块要调用 cocosdenshion模块。
1\找到模块名字和路径
找到cocosdenshion模块的android.mk的位置。F:\cocos2d-x\CocosDenshion\android\android.mk
打开看到:
LOCAL_MODULE := cocosdenshion_shared
...
include $(BUILD_STATIC_LIBRARY)
那么cocosdenshion模块在我自己的android.mk中引用它是应该叫它cocosdenshion_shared。而且他是个静态库。

2\在Android.mk中引用模块
就像普通代码中引用头文件一样。
在android.mk的最后一行调用
$(call import-module,CocosDenshion/android)
来导入模块。
注意：我的NDK_MODULE_PATH=/cygdrive/f/cocos2d-x 是已经设置好了的。
如果引用的模块里面也有import-module,他的相对路径也要加到NDK_MODULE_PATH中。如果它没被加进去的话。
然后
LOCAL_WHOLE_STATIC_LIBRARIES += cocos_jpeg_static
声明我这模块要引用该静态库模块。
-------------------------------------------------------

import-module的使用注意
1、设置路径时，注意与NDK_MODULE_PATH中的路径相互配合。
1、导入模块的.mk中如果也有import-module，则注意其相对路径也要在NDK_MODULE_PATH中。
2、上面说了import-module和include一样。如果import-module和Include包含了同一个.mk,会报重复包含的错误。

NDK_MODULE_PATH的配置

NDK_MODULE_PATH的作用
NDK_MODULE_PATH是一个很重要的变量，当android.mk中使用了 $(c a l l i m p o r t - m o d u l e, X X X) 函数引入外部库文件时会用到，用以指示该往哪里去找这个文件。如果 N D K_{M} O D U L E_{P} A T H 没有设置或者设置不正确。编译时都是报错 A r e y o u s u r e y o u r N D K_{M} O D U L E_{P} A T H v a r i a b l e i s p r o p e r l y d e f i n e d 。 N D K_{M} O D U L E_{P} A T H 的设置与格式 N D K_{M} O D U L E_{P} A T H 是一个环境变量，不是 a n d r o i d . m k 中设置的变量。 N D K_{M} O D U L E_{P} A T H 多个路径用冒号分割。不是分号！且整个字符串中间不能有空格。格式不正确也会报错上面的错误的。设置 N D K_{M} O D U L E_{P} A T H 的方法 1 、在系统环境里手动添加这个环境变量， 2 、在 b u i l d_{n} a t i v e . s h 中运行 n d k - b u i l d 之前使用 e x p o r t 命令定义环境变量 N D K_{M} O D U L E_{P} A T H 。如： e x p o r t N D K_{M} O D U L E_{P} A T H = 路径 1 : 路径 2 : 路径 33 、直接将 N D K_{M} O D U L E_{P} A T H = 路径 1 : 路径 2 加到 n d k - b u i l d 命令的参数后面。 n d k - b u i l d 的参数最终会直接传给 m a k e . 如：$ NDK_ROOT_LOCAL/ndk-build -C $HELLOWORLD_ROOT NDK_MODULE_PATH=路径1:路径2
(命令 make aaa=213 //在编译makefile之前将aaa当作环境变量设置为213.)

4、还可以在android.mk中设置NDK_MODULE_PATH
在import语句之前加入，
$(c a l l i m p o r t - a d d - p a t h,$ (LOCAL_PATH)/platform/third_party/android/prebuilt)
将一个新的路径加入NDK_MODULE_PATH变量。

Android.mk简介

引用 http://blog.csdn.net/hudashi/article/details/7059006

Android.mk文件是GNU Makefile的一小部分，它用来对Android程序进行编译。
因为所有的编译文件都在同一个 GNU MAKE 执行环境中进行执行，而Android.mk中所有的变量都是全局的。因此，您应尽量少声明变量，不要认为某些变量在解析过程中不会被定义。
一个Android.mk文件可以编译多个模块，每个模块属下列类型之一：
1）APK程序
一般的Android程序，编译打包生成apk文件
2）JAVA库
java类库，编译打包生成jar文件
3)C\C++应用程序
可执行的C\C++应用程序
4）C\C++静态库
编译生成C\C++静态库，并打包成.a文件
5）C\C++共享库
编译生成共享库（动态链接库），并打包成.so文，有且只有共享库才能被安装/复制到您的应用软件（APK）包中。
可以在每一个Android.mk file 中定义一个或多个模块，你也可以在几个模块中使用同一个
源代码文件。编译系统为你处理许多细节问题。例如，你不需要在你的 Android.mk 中列出头文件和依
赖文件。编译系统将会为你自动处理这些问题。这也意味着，在升级 NDK 后，你应该
得到新的toolchain/platform支持，而且不需要改变你的 Android.mk 文件。
注意，NDK的Anroid.mk语法同公开发布的Android平台开源代码的Anroid.mk语法很接近，然而编译系统实现他们的
方式却是不同的，这是故意这样设计的，可以让程序开发人员重用外部库的源代码更容易。
在描述语法细节之前，咱们来看一个简单的"hello world"的例子，比如，下面的文件：
sources/helloworld/helloworld.c
sources/helloworld/Android.mk
'helloworld.c'是一个 JNI 共享库，实现返回"hello world"字符串的原生方法。相应的
Android.mk 文件会象下面这样：
LOCAL_PATH := $(c a l l m y - d i r) i n c l u d e$ (CLEAR_VARS)
LOCAL_MODULE:= helloworld
LOCAL_SRC_FILES := helloworld.c
include $(B U I L D_{S} H A R E D_{L} I B R A R Y) 解释一下几行代码： L O C A L_{P} A T H :=$ (call my-dir)
一个Android.mk file首先必须定义好LOCAL_PATH变量。它表示是当前文件的路径。
在这个例子中，宏函数‘my-dir’, 由编译系统提供，用于返回当前路径(即包含Android.mk file
文件的目录)。
include $(C L E A R_{V} A R S) C L E A R_{V} A R S 由编译系统提供 (可以在 a n d r o i d 安装目录下的 / b u i l d / c o r e / c o n f i g . m k 文件看到其定义，为 C L E A R_{V} A R S :=$ (BUILD_SYSTEM)/clear_vars.mk)，指定让GNU MAKEFILE该脚本为你清除许多 LOCAL_XXX 变量 ( 例如 LOCAL_MODULE ， LOCAL_SRC_FILES ，LOCAL_STATIC_LIBRARIES，等等…)，除 LOCAL_PATH。这是必要的，因为所有的编译文件都在同一个 GNU MAKE 执行环境中，所有的变量都是全局的。所以我们需要先清空这些变量（LOCAL_PATH除外）。又因为LOCAL_PATH总是要求在每个模块中都要进行设置，所以并需要清空它。
另外注意，该语句的意思就是把CLEAR_VARS变量所指向的脚本文件包含进来。
LOCAL_MODULE := helloworld
LOCAL_MODULE 变量必须定义，以标识你在 Android.mk 文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。注意编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'foo'的共享库模块，将会生成'libfoo.so'文件。
注意：如果把库命名为‘libhelloworld’，编译系统将不会添加任何的 lib 前缀，也会生成 libhelloworld.so。
LOCAL_SRC_FILES := helloworld.c
LOCAL_SRC_FILES 变量必须包含将要编译打包进模块中的 C 或 C++源代码文件。不用
在这里列出头文件和包含文件，编译系统将会自动找出依赖型的文件，当然对于包含文件，你包含时指定的路径应该正确。
注意，默认的 C++源码文件的扩展名是‘.cpp’ 。指定一个不同的扩展名也是可能的，只要定义LOCAL_DEFAULT_CPP_EXTENSION 变量，不要忘记开始的小圆点(也就是定义为 ‘.cxx’,而不是‘cxx’)
include $(B U I L D_{S} H A R E D_{L} I B R A R Y) B U I L D_{S} H A R E D_{L} I B R A R Y 是编译系统提供的变量，指向一个 G N U M a k e f i l e 脚本 (应该就是在 b u i l d / c o r e 目录下的 s h a r e d_{l} i b r a r y . m k) ，将根据 L O C A L_{X} X X 系列变量中的值，来编译生成共享库（动态链接库）。如果想生成静态库，则用 B U I L D_{S} T A T I C_{L} I B R A R Y 在 N D K 的 s o u r c e s / s a m p l e s 目录下有更复杂一点的例子，写有注释的 A n d r o i d . m k 文件。二、自定义变量以下是在 A n d r o i d . m k 中依赖或定义的变量列表，可以定义其他变量为自己使用，但是 N D K 编译系统保留下列变量名： - 以 L O C A L_{开} 头的名字（例如 L O C A L_{M} O D U L E ） - 以 P R I V A T E_{,} N D K_{或} A P P_{开} 头的名字（内部使用） - 小写名字（内部使用，例如 ‘ m y - d i r^{'} ）如果为了方便在 A n d r o i d . m k 中定义自己的变量，建议使用 M Y_{前} 缀，一个小例子： M Y_{S} O U R C E S := f o o . c i f n e q ($ (MY_CONFIG_BAR),)
MY_SOURCES += bar.c
endif
LOCAL_SRC_FILES += $(M Y_{S} O U R C E S) 注意： ‘ : =^{'} 是赋值的意思；^{'} + =^{'} 是追加的意思； ‘$ ’表示引用某变量的值。
三、GNU Make系统变量
这些 GNU Make变量在你的 Android.mk 文件解析之前，就由编译系统定义好了。注意在
某些情况下，NDK可能分析 Android.mk 几次，每一次某些变量的定义会有不同。
（1）CLEAR_VARS: 指向一个编译脚本，几乎所有未定义的 LOCAL_XXX 变量都在"Module-description"节中列出。必须在开始一个新模块之前包含这个脚本：include $(C L E A R_{V} A R S) ，用于重置除 L O C A L_{P} A T H 变量外的，所有 L O C A L_{X} X X 系列变量。（ 2 ） B U I L D_{S} H A R E D_{L} I B R A R Y : 指向编译脚本，根据所有的在 L O C A L_{X} X X 变量把列出的源代码文件编译成一个共享库。注意，必须至少在包含这个文件之前定义 L O C A L_{M} O D U L E 和 L O C A L_{S} R C_{F} I L E S 。（ 3 ） B U I L D_{S} T A T I C_{L} I B R A R Y : 一个 B U I L D_{S} H A R E D_{L} I B R A R Y 变量用于编译一个静态库。静态库不会复制到的 A P K 包中，但是能够用于编译共享库。示例： i n c l u d e$ (BUILD_STATIC_LIBRARY)
注意，这将会生成一个名为 lib $(L O C A L_{M} O D U L E) . a 的文件（ 4 ） T A R G E T_{A} R C H : 目标 C P U 平台的名字, 和 a n d r o i d 开放源码中指定的那样。如果是 a r m ，表示要生成 A R M 兼容的指令，与 C P U 架构的修订版无关。（ 5 ） T A R G E T_{P} L A T F O R M : A n d r o i d . m k 解析的时候，目标 A n d r o i d 平台的名字 . 详情可参考 / d e v e l o p m e n t / n d k / d o c s / s t a b l e - a p i s . t x t . a n d r o i d - 3 - > O f f i c i a l A n d r o i d 1.5 s y s t e m i m a g e s a n d r o i d - 4 - > O f f i c i a l A n d r o i d 1.6 s y s t e m i m a g e s a n d r o i d - 5 - > O f f i c i a l A n d r o i d 2.0 s y s t e m i m a g e s （ 6 ） T A R G E T_{A} R C H_{A} B I : 暂时只支持两个 v a l u e ， a r m e a b i 和 a r m e a b i - v 7 a 。在现在的版本中一般把这两个值简单的定义为 a r m ，通过 a n d r o i d 平台内部对它重定义来获得更好的匹配。其他的 A B I 将在以后的 N D K 版本中介绍，它们会有不同的名字。注意虽然所有基于 A R M 的 A B I 都会把^{'} T A R G E T_{A} R C H^{'} 定义成 ‘ a r m^{'} ，但是会有不同的 ‘ T A R G E T_{A} R C H_{A} B I^{'} 。（ 7 ） T A R G E T_{A} B I : 目标平台和 A B I 的组合，它事实上被定义成$ (TARGET_PLATFORM)- $(T A R G E T_{A} R C H_{A} B I) ，在想要在真实的设备中针对一个特别的目标系统进行测试时，会有用。在默认的情况下，它会是^{'} a n d r o i d - 3 - a r m^{'} 。五、模块描述变量下面的变量用于向编译系统描述你的模块。你应该定义在^{'} i n c l u d e$ (CLEAR_VARS)'和'include $(B U I L D_{X} X X X X)^{'} 之间。正如前面描写的那样，$ (CLEAR_VARS)是一个脚本，清除所有这些变量。
（1） LOCAL_PATH: 这个变量用于给出当前文件的路径。必须在 Android.mk 的开头定义，可以这样使用：LOCAL_PATH := $(c a l l m y - d i r) 这个变量不会被$ (CLEAR_VARS)清除，因此每个 Android.mk 只需要定义一次(即使在一个文件中定义了几个模块的情况下)。
（2）LOCAL_MODULE: 这是模块的名字，它必须是唯一的，而且不能包含空格。必须在包含任一的 $(B U I L D_{X} X X X) 脚本之前定义它。模块的名字决定了生成文件的名字。例如，如果一个一个共享库模块的名字是，那么生成文件的名字就是 l i b . s o 。但是，在的 N D K 生成文件中 (或者 A n d r o i d . m k 或者 A p p l i c a t i o n . m k) ，应该只涉及 (引用) 有正常名字的其他模块。（ 3 ） L O C A L_{S} R C_{F} I L E S : 这是要编译的源代码文件列表。只要列出要传递给编译器的文件，因为编译系统自动计算依赖。注意源代码文件名称都是相对于 L O C A L_{P} A T H 的，你可以使用路径部分，例如： L O C A L_{S} R C_{F} I L E S := f o o . c t o t o / b a r . c H e l l o . c 文件之间可以用空格或 T a b 键进行分割, 换行请用 " \" . 如果是追加源代码文件的话，请用 L O C A L_{S} R C_{F} I L E S + = 注意：在生成文件中都要使用 U N I X 风格的斜杠 (/) . w i n d o w s 风格的反斜杠不会被正确的处理。注意：可以 L O C A L_{S} R C_{F} I L E S :=$ (call all-subdir-java-files)这种形式来包含local_path目录下的所有java文件。
（4） LOCAL_CPP_EXTENSION: 这是一个可选变量，用来指定C++代码文件的扩展名，默认是'.cpp',但是可以改变它，比如：
LOCAL_CPP_EXTENSION := .cxx
（5） LOCAL_C_INCLUDES: 可选变量，表示头文件的搜索路径。默认的头文件的搜索路径是LOCAL_PATH目录。
示例:LOCAL_C_INCLUDES := sources/foo或LOCAL_C_INCLUDES := $Double subscripts: use braces to clarify$ (TARGET_ROOT_OUT)
至于LOCAL_MODULE_PATH 和LOCAL_UNSTRIPPED_PATH的区别，暂时还不清楚。
七、GNU Make‘功能’宏
GNU Make‘功能’宏，必须通过使用' $(c a l l)^{'} 来调用，调用他们将返回文本化的信息。（ 1 ） m y - d i r : 返回当前 A n d r o i d . m k 所在的目录的路径，相对于 N D K 编译系统的顶层。这是有用的，在 A n d r o i d . m k 文件的开头如此定义： L O C A L_{P} A T H :=$ (call my-dir)
（2）all-subdir-makefiles: 返回一个位于当前'my-dir'路径的子目录中的所有Android.mk的列表。
例如，看下面的目录层次：
sources/foo/Android.mk
sources/foo/lib1/Android.mk
sources/foo/lib2/Android.mk
如果 sources/foo/Android.mk 包含一行：
include $(c a l l a l l - s u b d i r - m a k e f i l e s) 那么它就会自动包含 s o u r c e s / f o o / l i b 1 / A n d r o i d . m k 和 s o u r c e s / f o o / l i b 2 / A n d r o i d . m k 。这项功能用于向编译系统提供深层次嵌套的代码目录层次。注意，在默认情况下， N D K 将会只搜索在 s o u r c e s / * / A n d r o i d . m k 中的文件。（ 3 ） t h i s - m a k e f i l e : 返回当前 M a k e f i l e 的路径 (即这个函数调用的地方) （ 4 ） p a r e n t - m a k e f i l e : 返回调用树中父 M a k e f i l e 路径。即包含当前 M a k e f i l e 的 M a k e f i l e 路径。（ 5 ） g r a n d - p a r e n t - m a k e f i l e ：返回调用树中父 M a k e f i l e 的父 M a k e f i l e 的路径八、 A n d r o i d . m k 使用模板在一个 A n d r o i d . m k 中可以生成多个 A P K 应用程序， J A V A 库， C \C + + 可执行程序, C \C + + 动态库和 C \C + + 静态库。（ 1 ）编译 A P K 应用程序模板。关于编译 A P K 应用程序的模板请参照《 A n d r o i d . m k 编译 A P K 范例》（ 2 ）编译 J A V A 库模板 L O C A L_{P} A T H :=$ (call my-dir)
include $You can't use 'macro parameter character #' in math mode$ (call all-subdir-java-files)
# Any libraries that this library depends on
LOCAL_JAVA_LIBRARIES := android.test.runner
# The name of the jar file to create
LOCAL_MODULE := sample
# Build a static jar file.
include $(B U I L D_{S} T A T I C_{J} A V A_{L} I B R A R Y) 注： L O C A L_{J} A V A_{L} I B R A R I E S := a n d r o i d . t e s t . r u n n e r 表示生成的 J A V A 库的 j a r 文件名（ 3 ）编译 C / C + + 应用程序模板如下： L O C A L_{P} A T H :=$ (call my-dir)
#include $You can't use 'macro parameter character #' in math mode$ (BUILD_EXECUTABLE)
注：‘:=’是赋值的意思，'+='是追加的意思，‘ $Double subscripts: use braces to clarify$ (call my-dir)
include $You can't use 'macro parameter character #' in math mode$ (BUILD_STATIC_LIBRARY)
和上面相似，BUILD_STATIC_LIBRARY 表示编译一个静态库。
（5）编译C\C++动态库的模板
LOCAL_PATH := $(c a l l m y - d i r) i n c l u d e$ (CLEAR_VARS)
LOCAL_SRC_FILES := helloworld.c
LOCAL_MODULE := libtest_shared
TARGET_PRELINK_MODULES := false
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_SHARED_LIBRARY)
和上面相似，BUILD_SHARED_LIBRARY 表示编译一个共享库。
以上三者的生成结果分别在如下目录中，generic 依具体 target 会变：
out/target/product/generic/obj/APPS
out/target/product/generic/obj/JAVA_LIBRARIES
out/target/product/generic/obj/EXECUTABLE
out/target/product/generic/obj/STATIC_LIBRARY
out/target/product/generic/obj/SHARED_LIBRARY
每个模块的目标文件夹分别为：
1）APK程序：XXX_intermediates
2）JAVA库程序：XXX_intermediates
这里的XXX
3）C\C++可执行程序：XXX_intermediates
4）C\C++静态库： XXX_static_intermediates
5）C\C++动态库： XXX_shared_intermediates

Android NDK 在小米2 中的调试

近几天一直在捣鼓Eclipse下面直接调试NDK ,以前都是从命令行中直接调试，现在听说现在Google已经发布了新的支持Eclipse直接调试的SDK ，心中甚为欣喜，本以为可以很快解决问题，没想到折腾了许久。

1. Android ADT的BUG

ADT 的Eclipse插件从r20 开始就已经支持通过CDT 直接调试NDK ，但是有一个问题，他只支持CDT 8.01以下的版本，原因在于CDT 升级到8.1的时候，修改了文件索引器部分的逻辑，也就是我们按F3可以来回跳转到制定文件的那个东东，导致Android的ADT不能与CDT进行很好的配合，于是编译的时候报告一堆的文件找不到。实际上直接编译是没有问题的，问题不是编译器的问题。

关于这个问题的基本描述在 http://tools.android.com/recent 这个链接上面，因为经常会被墙，索性截图，如下

这个页面中比较详细的描述了怎么使用NDK ，但是请注意从下面的这个 BUG 33788 这个就是讨论了不能在最新的Eclipse 4.2 和CDT8.1上不能正确使用的原因。了解详情的，可以看看这个链接里面的详细讨论。

不过比较欣慰的是，在 ADT 21 Preview 2 中修复了这个问题。但是目前这个版本还没有发布，因此我们要配置ADT到Preview通道。具体的配置信息链接 http://tools.android.com/preview-channel 同样配置一下截图

配置完成之后，最好重建一下工程，基本上提示错误的情况发生的不会太频繁，但是似乎仍旧会发生。也就是这个补丁还不怎么稳定。

一旦还是发生找不到JNI之类的问题，一般可以通过如下图操作来暂时处理掉

2. run-as: Package '<PACKAGE_NAME>' has corrupt installation

根据提示信息，貌似软件包没有正确安装造成的，反复安装调试了很多次，结果照旧，于是怀疑是不是某些其他原因。

好在Android是开源的，那么就比较好处理了，从 4.01的源代码中提取出 run-as部分的源代码，然后调整编译，在可能出问题的地方增加输出，看看到底是什么原因造成的，结果还真找到了。分离出来的源代码以及在此下载 run-as.zip

出问题的代码位置如下

/* must not be readable or writable by others */
if ((st.st_mode & (S_IROTH|S_IWOTH)) != 0)

1 2	/* must not be readable or writable by others */ if ((st.st_mode & (S_IROTH\|S_IWOTH)) != 0)

这句话，意思是目录的权限中，others用户是不能有读写权限的，这个目录就是 /data

源代码的编译是在run-as目录下面执行NDK-Build即可生成的可执行文件run-as在 obj/local/armeabi 目录下面。通过 adb push run-as /system/bin/run-as-log 命令把这个文件放到手机，如果提示没有权限或者只读，请参考这个小米 2 adb remount failed解决办法

注意千万不要动系统自带的run-as 否则系统重启之后，往往起不来。

然后执行

adb shell run-as-log com.aa.bb

1	adb shell run-as-log com.aa.bb

来看看他的输出

"path ="/data" must not be readable or writable by others st.st_mode = 71ff ,S_IROTH= 4 S_IWOTH =2"

1	"path ="/data" must not be readable or writable by others st.st_mode = 71ff ,S_IROTH= 4 S_IWOTH =2"

也就是 run-as 要求 /data目录是不能有others用户的读写权限的。否则就会失败。根本就不是安装错误。

解决方法

adb shell
su #使用root权限（手机已root）
ls -l /data

adb shell

su #使用root权限（手机已root）

ls -l /data

权限信息如下：

4、修改权限

chmod 771 /data
chown system.system /data

1 2	chmod 771 /data chown system.system /data

5、再次执行

ls -l /data

1	ls -l /data

注意，似乎手机重启之后，设置又会还原掉，因此到时候还是需要重新设置。

简单描述一下图中的 chmod函数的参数，注意这个 drwxrwxrwx root root .其中 r = read 定义为 0x004 ,w = write 定义为 0x002 ,x = execute 定义为 0x001 , 那么 rwx 都拥有的话，就是 r | w|x = 7

rwxrwxrwx 分为三组用户依次为，文件拥有者的权限，文件拥有者所在用户组的权限，其他用户的权限

因此 chmod 771 就表示文件拥有者的权限有 r|w|x的全部权限，而其他用户只有执行权限。

java中的native关键字

转载 http://www.blogjava.net/shiliqiang/articles/287920.html

JNI 是Java Native Interface的缩写。从Java 1.1开始，Java Native Interface (JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。

使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的，比如，使用一些旧的库，与硬件、操作系统进行交互，或者为了提高程序的性能。JNI标准至少保证本地代码能工作在任何Java 虚拟机实现下。

JNI（Java Native Interface）的书写步骤

·编写带有native声明的方法的java类
·使用javac命令编译所编写的java类
·使用javah ?jni java类名生成扩展名为h的头文件
·使用C/C++（或者其他编程想语言）实现本地方法
·将C/C++编写的文件生成动态连接库

1) 编写java程序：
这里以HelloWorld为例。
代码1：

class HelloWorld {
public native void displayHelloWorld();

static {
System.loadLibrary("hello");
}

public static void main(String[] args) {
new HelloWorld().displayHelloWorld();
}
}

class HelloWorld {

public native void displayHelloWorld();

static {

System.loadLibrary("hello");

}

public static void main(String[] args) {

new HelloWorld().displayHelloWorld();

}

声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。

Load 动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是 System.loadLibrary();的参数“hello”是动态库的名字。
main()方法
2) 编译没有什么好说的了

javac HelloWorld.java

1	javac HelloWorld.java

3) 生成扩展名为h的头文件

javah /jni HelloWorld

1	javah /jni HelloWorld

头文件的内容：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class HelloWorld */

#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: HelloWorld
* Method: displayHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld
(JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

/* DO NOT EDIT THIS FILE - it is machine generated */

#include

/* Header for class HelloWorld */

#ifndef _Included_HelloWorld

#define _Included_HelloWorld

#ifdef __cplusplus

extern "C" {

#endif

* Class: HelloWorld

* Method: displayHelloWorld

* Signature: ()V

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld

(JNIEnv *, jobject);

#ifdef __cplusplus

}

#endif

（这里我们可以这样理解：这个h文件相当于我们在java里面的接口，这里声明了一个Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。

4) 编写本地方法
实现和由javah命令生成的头文件里面声明的方法名相同的方法。
代码2：

#include "jni.h"
#include "HelloWorld.h"

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)
{
printf("Hello world!\n");
return;
}

#include "jni.h"

#include "HelloWorld.h"

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)

{

printf("Hello world!\n");

return;

}

注意代码2中的第1行，需要将jni.h（该文件可以在%JAVA_HOME%/include文件夹下面找到）文件引入，因为在程序中的JNIEnv、 jobject等类型都是在该头文件中定义的；另外在第2行需要将HelloWorld.h头文件引入（我是这么理解的：相当于我们在编写java程序的时候，实现一个接口的话需要声明才可以，这里就是将HelloWorld.h头文件里面声明的方法加以实现。当然不一定是这样）。然后保存为 HelloWorldImpl.c就 ok了。

5) 生成动态库
这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。

cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll

1	cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll

注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。当然这里修改之后那里也需要修改。另外需要将-I%java_home%\include -I%java_home%\include\win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。

6) 运行程序

java HelloWorld

1	java HelloWorld

JNI（Java Native Interface）调用中考虑的问题

在首次使用JNI的时候有些疑问，后来在使用中一一解决，下面就是这些问题的备忘：

1. java和c是如何互通的？
其实不能互通的原因主要是数据类型的问题，jni解决了这个问题，例如那个c文件中的jstring数据类型就是java传入的String对象，经过jni函数的转化就能成为c的char*。
对应数据类型关系如下表：
Java 类型本地c类型说明
boolean jboolean 无符号，8 位
byte jbyte 无符号，8 位
char jchar 无符号，16 位
short jshort 有符号，16 位
int jint 有符号，32 位
long jlong 有符号，64 位
float jfloat 32 位
double jdouble 64 位
void void N/A

2. 如何将java传入的String参数转换为c的char*，然后使用?
java 传入的String参数，在c文件中被jni转换为jstring的数据类型，在c文件中声明char* test，然后test = (char*)(*env)->GetStringUTFChars(env, jstring, NULL);注意：test使用完后，通知虚拟机平台相关代码无需再访问：(*env)->ReleaseStringUTFChars(env, jstring, test);

3. 将c中获取的一个char*的buffer传递给java？
这个char*如果是一般的字符串的话，作为string传回去就可以了。如果是含有’\0’的buffer，最好作为bytearray传出，因为可以制定copy的length，如果copy到string，可能到’\0’就截断了。
有两种方式传递得到的数据：
一种是在jni中直接new一个byte数组，然后调用函数(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);将buffer的值copy到bytearray中，函数直接return bytearray就可以了。
一种是return错误号，数据作为参数传出，但是java的基本数据类型是传值，对象是传递的引用，所以将这个需要传出的byte数组用某个类包一下，如下：

class RetObj
{
public byte[] bytearray;
}

class RetObj

{

public byte[] bytearray;

}

这个对象作为函数的参数retobj传出，通过如下函数将retobj中的byte数组赋值便于传出。代码如下：

jclass cls;
jfieldID fid;
jbyteArray bytearray;
bytearray = (*env)->NewByteArray(env,len);
(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);
cls = (*env)->GetObjectClass(env, retobj);
fid = (*env)->GetFieldID(env, cls, "retbytes", "[B"]);
(*env)->SetObjectField(env, retobj, fid, bytearray);

jclass cls;

jfieldID fid;

jbyteArray bytearray;

bytearray = (*env)->NewByteArray(env,len);

(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);

cls = (*env)->GetObjectClass(env, retobj);

fid = (*env)->GetFieldID(env, cls, "retbytes", "[B"]);

(*env)->SetObjectField(env, retobj, fid, bytearray);

4. 不知道占用多少空间的buffer，如何传递出去呢？

在jni的c文件中new出空间，传递出去。java的数据不初始化，指向传递出去的空间即可。

Android JNI知识简介

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/linweig/archive/2010/03/26/5417319.aspx

Java Native Interface (JNI)标准是java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI 是本地编程接口，它使得在 Java 虚拟机 (VM) 内部运行的 Java 代码能够与用其它编程语言(如 C、C++ 和汇编语言)编写的应用程序和库进行交互操作。

1.从如何载入.so档案谈起

由于Android的应用层的类都是以Java写的，这些Java类编译为Dex型式的Bytecode之后，必须靠Dalvik虚拟机(VM: Virtual Machine)来执行。VM在Android平台里，扮演很重要的角色。

此外，在执行Java类的过程中，如果Java类需要与C组件沟通时，VM就会去载入C组件，然后让Java的函数顺利地调用到C组件的函数。此时，VM扮演着桥梁的角色，让Java与C组件能通过标准的JNI介面而相互沟通。

应用层的Java类是在虚拟机(VM: Vitual Machine)上执行的，而C件不是在VM上执行，那么Java程式又如何要求VM去载入(Load)所指定的C组件呢? 可使用下述指令：

System.loadLibrary(*.so的档案名);

例如，Android框架里所提供的MediaPlayer.java类，含指令：

public class MediaPlayer{
	static {
		System.loadLibrary("media_jni");
	}
}

public class MediaPlayer{

static {

System.loadLibrary("media_jni");

}

这要求VM去载入Android的/system/lib/libmedia_jni.so档案。载入*.so之后，Java类与*.so档案就汇合起来，一起执行了。

2.如何撰写*.so的入口函数

---- JNI_OnLoad()与JNI_OnUnload()函数的用途

当Android的VM(Virtual Machine)执行到System.loadLibrary()函数时，首先会去执行C组件里的JNI_OnLoad()函数。它的用途有二：

(1) 告诉VM此C组件使用那一个JNI版本。如果你的*.so档没有提供JNI_OnLoad()函数，VM会默认该*.so档是使用最老的JNI 1.1版本。由于新版的JNI做了许多扩充，如果需要使用JNI的新版功能，例如JNI 1.4的java.nio.ByteBuffer,就必须藉由JNI_OnLoad()函数来告知VM。

(2)由于VM执行到System.loadLibrary()函数时，就会立即先呼叫JNI_OnLoad()，所以C组件的开发者可以藉由JNI_OnLoad()来进行C组件内的初期值之设定(Initialization) 。

例如，在Android的/system/lib/libmedia_jni.so档案里，就提供了JNI_OnLoad()函数，其程式码片段为：

//#define LOG_NDEBUG 0
#define LOG_TAG "MediaPlayer-JNI"
jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
	JNIEnv* env = NULL;	
	jint result =-1;
	if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
		LOGE("ERROR: GetEnv failed\n");
		goto bail;
	}
	assert(env != NULL);
	if (register_android_media_MediaPlayer(env) <0) {
	LOGE("ERROR: MediaPlayer native registration failed\n");
	goto bail;
	}

	if (register_android_media_MediaRecorder(env) <0) {
		LOGE("ERROR: MediaRecorder native registration failed\n");
		goto bail;
	}

	if (register_android_media_MediaScanner(env) <0) {
		LOGE("ERROR: MediaScanner native registration failed\n");
		goto bail;
	}

	if (register_android_media_MediaMetadataRetriever(env) <0) {	
		LOGE("ERROR: MediaMetadataRetriever native registration failed\n");
		goto bail;
	}
	/* success -- return valid version number */
	result = JNI_VERSION_1_4;
	bail:
		return result;
}

//#define LOG_NDEBUG 0

#define LOG_TAG "MediaPlayer-JNI"

jint JNI_OnLoad(JavaVM* vm, void* reserved)

{

JNIEnv* env = NULL;

jint result =-1;

if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {

LOGE("ERROR: GetEnv failed\n");

goto bail;

}

assert(env != NULL);

if (register_android_media_MediaPlayer(env) <0) {

LOGE("ERROR: MediaPlayer native registration failed\n");

goto bail;

}

if (register_android_media_MediaRecorder(env) <0) {

LOGE("ERROR: MediaRecorder native registration failed\n");

goto bail;

}

if (register_android_media_MediaScanner(env) <0) {

LOGE("ERROR: MediaScanner native registration failed\n");

goto bail;

}

if (register_android_media_MediaMetadataRetriever(env) <0) {

LOGE("ERROR: MediaMetadataRetriever native registration failed\n");

goto bail;

}

/* success -- return valid version number */

result = JNI_VERSION_1_4;

bail:

return result;

}

此函数回传JNI_VERSION_1_4值给VM，于是VM知道了其所使用的JNI版本了。此外，它也做了一些初期的动作(可呼叫任何本地函数)，例如指令：

if (register_android_media_MediaPlayer(env) <0) {
	LOGE("ERROR: MediaPlayer native registration failed\n");
	goto bail;
}

if (register_android_media_MediaPlayer(env) <0) {

LOGE("ERROR: MediaPlayer native registration failed\n");

goto bail;

}

就将此组件提供的各个本地函数(Native Function)登记到VM里，以便能加快后续呼叫本地函数的效率。

JNI_OnUnload() 函数与JNI_OnLoad()相对应的。在载入C组件时会立即呼叫JNI_OnLoad()来进行组件内的初期动作；而当VM释放该C组件时，则会呼叫 JNI_OnUnload()函数来进行善后清除动作。当VM呼叫JNI_OnLoad()或JNI_Unload()函数时，都会将VM的指针 (Pointer)传递给它们，其参数如下：

jint JNI_OnLoad(JavaVM* vm, void* reserved) { }

jint JNI_OnUnload(JavaVM* vm, void* reserved){ }

在JNI_OnLoad()函数里，就透过VM之指标而取得JNIEnv之指标值，并存入env指标变数里，如下述指令：

jint JNI_OnLoad(JavaVM* vm, void* reserved){
	JNIEnv* env = NULL;
	jint result =-1;
	if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
		LOGE("ERROR: GetEnv failed\n");
		goto bail;
	}
}

jint JNI_OnLoad(JavaVM* vm, void* reserved){

JNIEnv* env = NULL;

jint result =-1;

if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {

LOGE("ERROR: GetEnv failed\n");

goto bail;

}

由于VM通常是多执行绪(Multi-threading)的执行环境。每一个执行绪在呼叫JNI_OnLoad()时，所传递进来的JNIEnv指标值都是不同的。为了配合这种多执行绪的环境，C组件开发者在撰写本地函数时，可藉由JNIEnv指标值之不同而避免执行绪的资料冲突问题，才能确保所写的本地函数能安全地在Android的多执行绪VM里安全地执行。基于这个理由，当在呼叫C组件的函数时，都会将JNIEnv指标值传递给它，如下：

jint JNI_OnLoad(JavaVM* vm, void* reserved){
	JNIEnv* env = NULL;
	if (register_android_media_MediaPlayer(env) <0) {
	}
}

jint JNI_OnLoad(JavaVM* vm, void* reserved){

JNIEnv* env = NULL;

if (register_android_media_MediaPlayer(env) <0) {

}

这 JNI_OnLoad()呼叫register_android_media_MediaPlayer(env)函数时，就将env指标值传递过去。如此，在register_android_media_MediaPlayer()函数就能藉由该指标值而区别不同的执行绪，以便化解资料冲突的问题。

例如，在register_android_media_MediaPlayer()函数里，可撰写下述指令：

if ((*env)->MonitorEnter(env, obj) != JNI_OK) {

}

if ((*env)->MonitorEnter(env, obj) != JNI_OK) {

}

查看是否已经有其他执行绪进入此物件，如果没有，此执行绪就进入该物件里执行了。还有，也可撰写下述指令：

if ((*env)->MonitorExit(env, obj) != JNI_OK) {

}

if ((*env)->MonitorExit(env, obj) != JNI_OK) {

}

查看是否此执行绪正在此物件内执行，如果是，此执行绪就会立即离开。

3.registerNativeMethods()函数的用途

应用层级的Java类别透过VM而呼叫到本地函数。一般是仰赖VM去寻找*.so里的本地函数。如果需要连续呼叫很多次，每次都需要寻找一遍，会多花许多时间。此时，组件开发者可以自行将本地函数向VM进行登记。例如，在Android的/system/lib/libmedia_jni.so档案里的代码段如下：

//#define LOG_NDEBUG 0
#define LOG_TAG "MediaPlayer-JNI"

static JNINativeMethod gMethods[] = {
		{"setDataSource","(Ljava/lang/String;)V",
		(void*)android_media_MediaPlayer_setDataSource},
		{"setDataSource","(Ljava/io/FileDescriptor;JJ)V",
		(void*)android_media_MediaPlayer_setDataSourceFD},
		{"prepare","()V",(void*)android_media_MediaPlayer_prepare},
		{"prepareAsync","()V",(void*)android_media_MediaPlayer_prepareAsync},
		{"_start","()V",(void*)android_media_MediaPlayer_start},
		{"_stop","()V",(void*)android_media_MediaPlayer_stop},
		{"getVideoWidth","()I",(void*)android_media_MediaPlayer_getVideoWidth},
		{"getVideoHeight","()I",(void*)android_media_MediaPlayer_getVideoHeight},
		{"seekTo","(I)V",(void*)android_media_MediaPlayer_seekTo},
		{"_pause","()V",(void*)android_media_MediaPlayer_pause},
		{"isPlaying","()Z",(void*)android_media_MediaPlayer_isPlaying},
		{"getCurrentPosition","()I",(void*)android_media_MediaPlayer_getCurrentPosition},
		{"getDuration","()I",(void*)android_media_MediaPlayer_getDuration},	
		{"_release","()V",(void*)android_media_MediaPlayer_release},	
		{"_reset","()V",(void*)android_media_MediaPlayer_reset},	
		{"setAudioStreamType","(I)V",(void*)android_media_MediaPlayer_setAudioStreamType},	
		{"setLooping","(Z)V",(void*)android_media_MediaPlayer_setLooping},	
		{"setVolume","(FF)V",(void*)android_media_MediaPlayer_setVolume},	
		{"getFrameAt","(I)Landroid/graphics/Bitmap;",	
		(void*)android_media_MediaPlayer_getFrameAt},	
		{"native_setup","(Ljava/lang/Object;)V",	
		(void*)android_media_MediaPlayer_native_setup},	
		{"native_finalize","()V",(void*)android_media_MediaPlayer_native_finalize},	
	};

static int register_android_media_MediaPlayer(JNIEnv *env){
	return AndroidRuntime::registerNativeMethods(env,"android/media/MediaPlayer", gMethods, NELEM(gMethods));
}

jint JNI_OnLoad(JavaVM* vm, void* reserved){
		if (register_android_media_MediaPlayer(env) <0) {	
		LOGE("ERROR: MediaPlayer native registration failed\n");	
		goto bail;
	}

}

//#define LOG_NDEBUG 0

#define LOG_TAG "MediaPlayer-JNI"

static JNINativeMethod gMethods[] = {

{"setDataSource","(Ljava/lang/String;)V",

(void*)android_media_MediaPlayer_setDataSource},

{"setDataSource","(Ljava/io/FileDescriptor;JJ)V",

(void*)android_media_MediaPlayer_setDataSourceFD},

{"prepare","()V",(void*)android_media_MediaPlayer_prepare},

{"prepareAsync","()V",(void*)android_media_MediaPlayer_prepareAsync},

{"_start","()V",(void*)android_media_MediaPlayer_start},

{"_stop","()V",(void*)android_media_MediaPlayer_stop},

{"getVideoWidth","()I",(void*)android_media_MediaPlayer_getVideoWidth},

{"getVideoHeight","()I",(void*)android_media_MediaPlayer_getVideoHeight},

{"seekTo","(I)V",(void*)android_media_MediaPlayer_seekTo},

{"_pause","()V",(void*)android_media_MediaPlayer_pause},

{"isPlaying","()Z",(void*)android_media_MediaPlayer_isPlaying},

{"getCurrentPosition","()I",(void*)android_media_MediaPlayer_getCurrentPosition},

{"getDuration","()I",(void*)android_media_MediaPlayer_getDuration},

{"_release","()V",(void*)android_media_MediaPlayer_release},

{"_reset","()V",(void*)android_media_MediaPlayer_reset},

{"setAudioStreamType","(I)V",(void*)android_media_MediaPlayer_setAudioStreamType},

{"setLooping","(Z)V",(void*)android_media_MediaPlayer_setLooping},

{"setVolume","(FF)V",(void*)android_media_MediaPlayer_setVolume},

{"getFrameAt","(I)Landroid/graphics/Bitmap;",

(void*)android_media_MediaPlayer_getFrameAt},

{"native_setup","(Ljava/lang/Object;)V",

(void*)android_media_MediaPlayer_native_setup},

{"native_finalize","()V",(void*)android_media_MediaPlayer_native_finalize},

};

static int register_android_media_MediaPlayer(JNIEnv *env){

return AndroidRuntime::registerNativeMethods(env,"android/media/MediaPlayer", gMethods, NELEM(gMethods));

}

jint JNI_OnLoad(JavaVM* vm, void* reserved){

if (register_android_media_MediaPlayer(env) <0) {

LOGE("ERROR: MediaPlayer native registration failed\n");

goto bail;

}

当 VM载入libmedia_jni.so档案时，就呼叫JNI_OnLoad()函数。接着，JNI_OnLoad()呼叫 register_android_media_MediaPlayer()函数。此时，就呼叫到 AndroidRuntime::registerNativeMethods()函数，向VM(即AndroidRuntime)登记 gMethods[]表格所含的本地函数了。简而言之，registerNativeMethods()函数的用途有二：

(1)更有效率去找到函数。

(2)可在执行期间进行抽换。由于gMethods[]是一个<名称，函数指针>对照表，在程序执行时，可多次呼叫registerNativeMethods()函数来更换本地函数之指针，而达到弹性抽换本地函数之目的。

4.Andoird 中使用了一种不同传统Java JNI的方式来定义其native的函数。其中很重要的区别是Andorid使用了一种Java 和 C 函数的映射表数组，并在其中描述了函数的参数和返回值。这个数组的类型是JNINativeMethod，定义如下：

typedef struct {
	constchar* name;            /*Java中函数的名字*/
	constchar* signature;      /*描述了函数的参数和返回值*/
	void* fnPtr;               /*函数指针，指向C函数*/
} JNINativeMethod;

typedef struct {

constchar* name; /*Java中函数的名字*/

constchar* signature; /*描述了函数的参数和返回值*/

void* fnPtr; /*函数指针，指向C函数*/

} JNINativeMethod;

其中比较难以理解的是第二个参数，例如

"()V"
"(II)V"
"(Ljava/lang/String;Ljava/lang/String;)V"

"()V"

"(II)V"

"(Ljava/lang/String;Ljava/lang/String;)V"

实际上这些字符是与函数的参数类型一一对应的。

"()" 中的字符表示参数，后面的则代表返回值。例如"()V" 就表示void Func();

"(II)V" 表示 void Func(int, int);

具体的每一个字符的对应关系如下(数组则以”["开始，用两个字符表示)

字符	Java类型	C类型
V	void	void
Z	jboolean	boolean
I	jint	int
J	jlong	long
D	jdouble	double
F	jfloat	float
B	jbyte	byte
C	jchar	char
S	jshort	short
[I	jintArray	int[]
[F	jfloatArray	float[]
[B	jbyteArray	byte[]
[C	jcharArray	char[]
[S	jshortArray	short[]
[D	jdoubleArray	double[]
[J	jlongArray	long[]
[Z	jbooleanArray	boolean[]

上面的都是基本类型。如果Java函数的参数是class，则以"L"开头，以";"结尾，中间是用"/" 隔开的包及类名。而其对应的C函数名的参数则为jobject. 一个例外是String类，其对应的类为jstring

Ljava/lang/String; String jstring
Ljava/net/Socket; Socket jobject

1 2	Ljava/lang/String; String jstring Ljava/net/Socket; Socket jobject

如果JAVA函数位于一个嵌入类，则用$作为类名间的分隔符。

例如

(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z

1	(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z

Android JNI编程实践

一、直接使用java本身jni接口（windows/ubuntu）

1.在Eclipsh中新建一个android应用程序。两个类：一个继承于Activity，UI显示用。另一个包含native方法。编译生成所有类。

jnitest.java文件：

package com.hello.jnitest;import android.app.Activity;
import android.os.Bundle;

publicclass jnitest extends Activity {
	/** Called when the activity is first created. */	
	@Override

	publicvoid onCreate(Bundle savedInstanceState) {		
		super.onCreate(savedInstanceState);		
		setContentView(R.layout.main);		
		Nadd cal =new Nadd();		
		setTitle("The Native Add Result is "+ String.valueOf(cal.nadd(10, 19)));	
	}
}

package com.hello.jnitest;import android.app.Activity;

import android.os.Bundle;

publicclass jnitest extends Activity {

/** Called when the activity is first created. */

@Override

publicvoid onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Nadd cal =new Nadd();

setTitle("The Native Add Result is "+ String.valueOf(cal.nadd(10, 19)));

}

Nadd.java文件：

package com.hello.jnitest;

publicclass Nadd {

	static {	
		System.loadLibrary("Nadd");
	}

	public native int nadd(int a, int b);
}

package com.hello.jnitest;

publicclass Nadd {

static {

System.loadLibrary("Nadd");

}

public native int nadd(int a, int b);

}

2.使用javah命令生成C/C++的.h文件。注意类要包含包名，路径文件夹下要包含所有包中的类，否则会报找不到类的错误。classpath参数指定到包名前一级文件夹，文件夹层次结构要符合java类的组织层次结构。

javah -classpath ../jnitest/bin com.hello.jnitest.Nadd

1	javah -classpath ../jnitest/bin com.hello.jnitest.Nadd

com_hello_jnitest_Nadd .h文件：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>

/* Header for class com_hello_jnitest_Nadd */

#ifndef _Included_com_hello_jnitest_Nadd

#define _Included_com_hello_jnitest_Nadd

	#ifdef __cplusplus

	extern"C" {

	#endif

		/*

		* Class:     com_hello_jnitest_Nadd

		* Method:    nadd

		* Signature: (II)I

		*/

		JNIEXPORT jint JNICALL Java_com_hello_jnitest_Nadd_nadd(JNIEnv *, jobject, jint, jint);

	#ifdef __cplusplus
		}
	#endif
#endif

/* DO NOT EDIT THIS FILE - it is machine generated */

#include <jni.h>

/* Header for class com_hello_jnitest_Nadd */

#ifndef _Included_com_hello_jnitest_Nadd

#define _Included_com_hello_jnitest_Nadd

#ifdef __cplusplus

extern"C" {

#endif

* Class: com_hello_jnitest_Nadd

* Method: nadd

* Signature: (II)I

JNIEXPORT jint JNICALL Java_com_hello_jnitest_Nadd_nadd(JNIEnv *, jobject, jint, jint);

#ifdef __cplusplus

}

#endif

3.编辑.c文件实现native方法。

com_hello_jnitest_Nadd.c文件：

#include <stdlib.h>
#include "com_hello_jnitest_Nadd.h"

JNIEXPORT jint JNICALL Java_com_hello_jnitest_Nadd_nadd(JNIEnv * env, jobject c, jint a, jint b)
{
	return (a+b);
}

#include <stdlib.h>

#include "com_hello_jnitest_Nadd.h"

JNIEXPORT jint JNICALL Java_com_hello_jnitest_Nadd_nadd(JNIEnv * env, jobject c, jint a, jint b)

{

return (a+b);

}

4.编译.c文件生存动态库。

$ arm-none-linux-gnueabi-gcc -I/home/a/work/android/jdk1.6.0_17/include -I/home/a/work/android/jdk1.6.0_17/include/linux -fpic -c com_hello_jnitest_Nadd.c

$ arm-none-linux-gnueabi-ld -T/home/a/CodeSourcery/Sourcery_G++_Lite/arm-none-linux-gnueabi/lib/ldscripts/armelf_linux_eabi.xsc -share -o libNadd.so com_hello_jnitest_Nadd.o

$ arm-none-linux-gnueabi-gcc -I/home/a/work/android/jdk1.6.0_17/include -I/home/a/work/android/jdk1.6.0_17/include/linux -fpic -c com_hello_jnitest_Nadd.c

$ arm-none-linux-gnueabi-ld -T/home/a/CodeSourcery/Sourcery_G++_Lite/arm-none-linux-gnueabi/lib/ldscripts/armelf_linux_eabi.xsc -share -o libNadd.so com_hello_jnitest_Nadd.o

得到libNadd.so文件。

以上在ubuntu中完成。

5.将相应的动态库文件push到avd的system/lib中:adb push libNadd.so /system/lib。若提示Read-only file system错误，运行adb remount命令，即可。

$ adb push libNadd.so /system/lib

1	$ adb push libNadd.so /system/lib

6.在eclipsh中运行原应用程序即可。

对于一中生成的so文件也可采用二中的方法编译进apk包中。只需在工程文件夹中建libs\armeabi文件夹（其他文件夹名无效，只建立libs文件夹也无效），然后将so文件拷入，编译工程即可。

二.使用NDK生成本地方法（ubuntu and windows）

1.安装NDK：解压，然后进入NDK解压后的目录，运行build/host-setup.sh（需要Make 3.81和awk）。若有错，修改host-setup.sh文件：将#!/bin/sh修改为#!/bin/bash，再次运行即可。

2.在apps文件夹下建立自己的工程文件夹，然后在该文件夹下建一文件Application.mk和项project文件夹。

Application.mk文件：

APP_PROJECT_PATH := $(call my-dir)/project
APP_MODULES:= myjni

1 2	APP_PROJECT_PATH := $(call my-dir)/project APP_MODULES:= myjni

3.在project文件夹下建一jni文件夹，然后新建Android.mk和myjni.c。这里不需要用javah生成相应的.h文件，但函数名要包含相应的完整的包、类名。

4.编辑相应文件内容。

Android.mk文件：

# Copyright (C) 2009 The Android Open Source Project#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE    := myjni
LOCAL_SRC_FILES := myjni.c
include $(BUILD_SHARED_LIBRARY)

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

# http://www.apache.org/licenses/LICENSE-2.0

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := myjni

LOCAL_SRC_FILES := myjni.c

include $(BUILD_SHARED_LIBRARY)

myjni.c文件：

#include <string.h>
#include <jni.h>

jstring Java_com_hello_NdkTest_NdkTest_stringFromJNI( JNIEnv* env,jobject thiz )
{
	return (*env)->NewStringUTF(env, "Hello from My-JNI !");
}

#include <string.h>

#include <jni.h>

jstring Java_com_hello_NdkTest_NdkTest_stringFromJNI( JNIEnv* env,jobject thiz )

{

return (*env)->NewStringUTF(env, "Hello from My-JNI !");

}

myjni文件组织：

a@ubuntu:~/work/android/ndk-1.6_r1/apps$ tree myjni
myjni

|-- Application.mk

`-- project

|-- jni

|   |-- Android.mk

|   `-- myjni.c

`-- libs

`-- armeabi

`-- libmyjni.so
4 directories, 4 files

a@ubuntu:~/work/android/ndk-1.6_r1/apps$ tree myjni

myjni

|-- Application.mk

`-- project

|-- jni

| |-- Android.mk

| `-- myjni.c

`-- libs

`-- armeabi

`-- libmyjni.so

4 directories, 4 files

5.编译：

make APP=myjni

1	make APP=myjni

以上内容在ubuntu完成。

6.在eclipsh中创建android application。将myjni中自动生成的libs文件夹拷贝到当前工程文件夹中，编译运行即可。

NdkTest.java文件：

package com.hello.NdkTest;
import android.app.Activity;

import android.os.Bundle;
import android.widget.TextView;

public class NdkTest extends Activity {

	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {	
		super.onCreate(savedInstanceState);		
		TextView  tv =new TextView(this);	
		tv.setText( stringFromJNI() );	
		setContentView(tv);
	}

	public native String  stringFromJNI();
		static {	
			System.loadLibrary("myjni");	
		}
	}
}

package com.hello.NdkTest;

import android.app.Activity;

import android.os.Bundle;

import android.widget.TextView;

public class NdkTest extends Activity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

TextView tv =new TextView(this);

tv.setText( stringFromJNI() );

setContentView(tv);

}

public native String stringFromJNI();

static {

System.loadLibrary("myjni");

}

对于二中生成的so文件也可采用一中的方法push到avd中运行。

2025 年 5 月
一	二	三	四	五	六	日
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31