在Native code中访问java 对象(II)
在Native code中访问java 对象
接下来我们可以看一下，在native code中，访问非Java Language内置的引用数据类型的方法。
访问非Java Language内置的引用数据类型
访问非Java language内置的引用数据类型，这个topic又可以分为量个小的topic:
- 访问类成员
- 调用类方法
我们会一个接着一个的看一下这些小topic。
访问类成员
Java编程语言支持两种类型的类成员。一个类的每一个实例都会有一份属于他们自己的copy的类的实例成员，以及为一个类所有实例所共享的类的静态成员。JNI有提供一些函数，以便于在native code中获取或者设置对象的实例成员和类的静态成员。首先，我们先来看一段code，这段code 演示了我们在native cod访问类成员的方法：
package com.example.hellojni;
public class FieldAccess {
private String str = "";
private static int staticInt;
public native void accessField();
public void setString(String text) {
str = text;
}
public String getString() {
return str;
}
public native void accessStaticField();
public void setStaticInt(int intValue) {
staticInt = intValue;
}
public int getStaticInt() {
return staticInt;
}
}
FieldAccess 类定义了一个String类型的成员变量str，并定义了访问这个成员变量的方法，还有一个名为accessField()的native方法。FieldAccess也定义了一个int类型的静态成员，同样的，有定义访问这个静态成员的方法和native方法。
在java code中，调用对象的native方法来做操作：
public class HelloJni extends Activity
{
private static final String TAG = "hello-jni";
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
/* Create a TextView and set its content.
* the text is retrieved by calling a native
* function.
*/
TextView tv = new TextView(this);
tv.setText(stringFromJNI());
setContentView(tv);
FieldAccess instanceField = new FieldAccess();
instanceField.setString("abc");
instanceField.accessField();
Log.d(TAG, "In java: " + " instancField.str = \"" + instanceField.getString() + "\"");
instanceField.setStaticInt(100);
instanceField.accessStaticField();
Log.d(TAG, "In java: " + " FieldAccess.staticInt = " + instanceField.getStaticInt());
}
在onCreate()方法中，创建了一个FieldAccess类的实例，为这个实例设置str成员变量的值，并调用这个实例的native方法instancField.accessField()。不久我们即会看到的，在native方法中，会首先输出实例变量str的当前值，随后会给这个成员设置一个新的值。此处，在native方法执行完成之后，会再次输出str成员变量的值。对于静态成员的操作，大体上也是一样的。Java code中设置静态成员的值->native code中读取设置的值，用log输出，然后修改静态成员的值->Java code中再次用log输出静态成员的值。
下面是FieldAccess的native 方法的实现：
static void FieldAccess_accessField(JNIEnv* env, jobject thiz) {
jfieldID fid; /* Store the field ID */
jstring jstr;
const char *str;
/* Get a reference to obj's class */
jclass cls = env->GetObjectClass(thiz);
JniDebug("In native code: ");
/* Look for the instance field str in cls */
fid = env->GetFieldID(cls, "str", "Ljava/lang/String;");
if (fid == NULL) {
JniDebug("fid is NULL.");
return; /* Failed to find the field */
}
/* Read the instance field str */
jstr = (jstring)env->GetObjectField(thiz, fid);
str = env->GetStringUTFChars(jstr, NULL);
if (str == NULL) {
JniDebug("fid is NULL.");
return; /* Out of memory */
}
JniDebug(" instancField.str = \" %s \"", str);
env->ReleaseStringUTFChars(jstr, str);
/* Create a new string and overwrite the instance field */
jstr = env->NewStringUTF("123");
if (jstr == NULL) {
return; /* Out of memory */
}
env->SetObjectField(thiz, fid, jstr);
}
static void FieldAccess_accessStaticField(JNIEnv* env, jobject thiz) {
jfieldID fid; /* Store the field ID */
jint si;
/* Get a reference to obj's class */
jclass cls = env->GetObjectClass(thiz);
JniDebug("In native code: ");
/* Look for the instance field str in cls */
fid = env->GetStaticFieldID(cls, "staticInt", "I");
if (fid == NULL) {
JniDebug("fid is NULL.");
return; /* Failed to find the field */
}
/* Access the static field staticInt */
si = env->GetStaticIntField(cls, fid);
JniDebug(" FieldAccess.staticInt = %d", si);
env->SetStaticIntField(cls, fid, 200);
}
static JNINativeMethod gFieldAccessMethods[] = {
NATIVE_METHOD(FieldAccess, accessField, "()V"),
NATIVE_METHOD(FieldAccess, accessStaticField, "()V"),
};
static JNINativeMethod gMethods[] = {
NATIVE_METHOD(HelloJni, stringFromJNI, "()Ljava/lang/String;"),
NATIVE_METHOD(HelloJni, stringToJNI, "(Ljava/lang/String;)Ljava/lang/String;"),
NATIVE_METHOD(HelloJni, sumIntWithNative, "([III)I"),
NATIVE_METHOD(HelloJni, sumDoubleWithNative, "([DII)D"),
};
void register_com_example_hellojni(JNIEnv* env) {
jniRegisterNativeMethods(env, "com/example/hellojni/HelloJni", gMethods, NELEM(gMethods));
jniRegisterNativeMethods(env, "com/example/hellojni/FieldAccess", gFieldAccessMethods, NELEM(gFieldAccessMethods));
}
运行上面的那些code，我们将会看到如下的log输出：
04-30 19:51:57.542: D/hello-jni(1791): JNI_OnLoad in hello-jni 04-30 19:51:57.702: D/hello-jni(1791): from HelloJni_stringFromJNI 04-30 19:51:57.912: D/hello-jni(1791): In native code: 04-30 19:51:57.912: D/hello-jni(1791): instancField.str = " abc " 04-30 19:51:57.912: D/hello-jni(1791): In java: instancField.str = "123" 04-30 19:51:57.912: D/hello-jni(1791): In native code: 04-30 19:51:57.912: D/hello-jni(1791): FieldAccess.staticInt = 100 04-30 19:51:57.912: D/hello-jni(1791): In java: FieldAccess.staticInt = 200
接下来我们会再对上面的那些code，做更为详细的说明。
访问类实例成员
在native code中，需要有两个步骤来访问类实例成员。第一，调用GetFieldID，由类引用、成员名称和field descriptor获取field ID，如：
fid = env->GetFieldID(cls, "str", "Ljava/lang/String;");
上面的那段示例代码通过对实例引用thiz调用GetObjectClass来获取类引用cls，而这个thiz则是作为第二个参数，被传递给native方法的实现的。一旦获取了field ID，我们就可以将其和对象的引用传递给适当的实例成员访问函数，以访问实例成员：
jstr = (jstring)env->GetObjectField(thiz, fid);
由于strings和arrays是特殊种类的对象，我们使用GetObjectField来访问实例成员。除了Get/SetObjectField之外，JNI也提供了诸如GetIntField和SetFloatField这样的一些函数，以访问原始数据类型的实例成员。这些函数大体上有如下的这些：
android frameworks JNI部分，也有一些code值得我们参考。如JellyBean/frameworks/base/core/jni/android/graphics/Paint.cpp这个文件中的如下的code：
struct JMetricsID {
jfieldID top;
jfieldID ascent;
jfieldID descent;
jfieldID bottom;
jfieldID leading;
};
static jclass gFontMetrics_class;
static JMetricsID gFontMetrics_fieldID;
...
static jfloat getFontMetrics(JNIEnv* env, jobject paint, jobject metricsObj) {
NPE_CHECK_RETURN_ZERO(env, paint);
SkPaint::FontMetrics metrics;
SkScalar spacing = GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
if (metricsObj) {
SkASSERT(env->IsInstanceOf(metricsObj, gFontMetrics_class));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.top, SkScalarToFloat(metrics.fTop));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.ascent, SkScalarToFloat(metrics.fAscent));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.descent, SkScalarToFloat(metrics.fDescent));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.bottom, SkScalarToFloat(metrics.fBottom));
env->SetFloatField(metricsObj, gFontMetrics_fieldID.leading, SkScalarToFloat(metrics.fLeading));
}
return SkScalarToFloat(spacing);
}
...
int register_android_graphics_Paint(JNIEnv* env) {
gFontMetrics_class = env->FindClass("android/graphics/Paint$FontMetrics");
SkASSERT(gFontMetrics_class);
gFontMetrics_class = (jclass)env->NewGlobalRef(gFontMetrics_class);
gFontMetrics_fieldID.top = req_fieldID(env->GetFieldID(gFontMetrics_class, "top", "F"));
gFontMetrics_fieldID.ascent = req_fieldID(env->GetFieldID(gFontMetrics_class, "ascent", "F"));
gFontMetrics_fieldID.descent = req_fieldID(env->GetFieldID(gFontMetrics_class, "descent", "F"));
gFontMetrics_fieldID.bottom = req_fieldID(env->GetFieldID(gFontMetrics_class, "bottom", "F"));
gFontMetrics_fieldID.leading = req_fieldID(env->GetFieldID(gFontMetrics_class, "leading", "F"));
gFontMetricsInt_class = env->FindClass("android/graphics/Paint$FontMetricsInt");
SkASSERT(gFontMetricsInt_class);
gFontMetricsInt_class = (jclass)env->NewGlobalRef(gFontMetricsInt_class);
gFontMetricsInt_fieldID.top = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "top", "I"));
gFontMetricsInt_fieldID.ascent = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "ascent", "I"));
gFontMetricsInt_fieldID.descent = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "descent", "I"));
gFontMetricsInt_fieldID.bottom = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "bottom", "I"));
gFontMetricsInt_fieldID.leading = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "leading", "I"));
int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Paint", methods,
sizeof(methods) / sizeof(methods[0]));
return result;
}
可以看到在android frameworks jni下的这个部分的code，对于android.graphics.Paint.FontMetrics的访问。它是在注册native方法是，先获取到类的各个成员的field ID并保存起来。在native方法的实现中，直接借助于前面保存的field ID，来完成对于对象成员的修改。另外值得我们注意的是，在此处，没有通过GetObjectClass来获取类的引用，而是通过对class descriptor调用FindClass，来获取到类的引用。
访问类静态成员
访问类静态成员与访问类实例成员很相似。由上面访问类static 成员的native code，我们可以看出来，有如下的两点，是访问类静态成员与访问类实例成员所不一样的地方：
- 访问static成员时，我们是通过调用GetStaticFieldID来获取到数据成员field ID的，而不是像访问实例成员时调用GetFieldID那样。而这两个函数的返回值类型则都是一样的，均为jfieldID。
- 获取到field ID之后，我们是传递类引用，而不是一个对象的引用给适当的JNI函数来访问static 成员的。
同样的，我们在此处也对JNI提供的用于访问static 数据成员的函数做一个总结：
最后我们再整体的对于访问类的数据成员的方法做一个总结。访问类的数据成员，大体上需要3个步骤：
- 获取到对于class对象的引用，可以通过FindClass，或者GetObjectClass等
- 通过GetFieldID获取到特定数据成员的field ID
- 通过JNI提供的适当的方法，来读取或者修改类的数据成员，如Get/SetIntField
对类的数据成员进行访问的方法，大体上就如上所述。
调用类方法
Java语言中很许多中的类方法。实例方法(Instance method)只能依托于一个特定的对象来调用，而对于static 方法(static methods)的调用则则独立于类的任何一个具体实例。我们将会在后面再来讨论构造函数。
JNI支持一个完整的系列的函数，以便于我们在native code中执行回调。下面的例子包含两个native方法，他们会分别在native code实现中调用Java语言编写的一个实例方法和一个类静态方法。
package com.example.hellojni;
import android.util.Log;
public class MethodCall {
private static final String TAG = "hello-jni";
public native void nativeMethod();
private void callback() {
Log.d(TAG, "In java");
}
public native void nativeStaticMethod();
private static void callbackStatic() {
Log.d(TAG, "In java staic");
}
}
下面的code是在java code中调用native 方法的部分：
public class HelloJni extends Activity
{
private static final String TAG = "hello-jni";
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
/* Create a TextView and set its content.
* the text is retrieved by calling a native
* function.
*/
TextView tv = new TextView(this);
tv.setText(stringFromJNI());
setContentView(tv);
MethodCall methodCall = new MethodCall();
methodCall.nativeMethod();
methodCall.nativeStaticMethod();
}
下面的code，是前面的code中所声明的native方法的实现：
static void MethodCall_nativeMethod(JNIEnv* env, jobject thiz) {
jclass cls = env->GetObjectClass(thiz);
jmethodID mid = env->GetMethodID(cls, "callback", "()V");
if (mid == NULL) {
JniDebug("mid is NULL, method not found.");
return;
}
JniDebug("In native code");
env->CallVoidMethod(thiz, mid);
}
static void MethodCall_nativeStaticMethod(JNIEnv* env, jobject thiz) {
jclass cls = env->GetObjectClass(thiz);
jmethodID mid = env->GetStaticMethodID(cls, "callbackStatic", "()V");
if (mid == NULL) {
JniDebug("mid is NULL, method not found.");
return;
}
JniDebug("In native code static");
env->CallStaticVoidMethod(cls, mid);
}
static JNINativeMethod gMethodCallMethods[] = {
NATIVE_METHOD(MethodCall, nativeMethod, "()V"),
NATIVE_METHOD(MethodCall, nativeStaticMethod, "()V"),
};
如下则为上面的那些code的log输出：
05-01 03:16:33.491: D/hello-jni(1774): JNI_OnLoad in hello-jni 05-01 03:16:33.621: D/hello-jni(1774): from HelloJni_stringFromJNI 05-01 03:16:33.901: D/hello-jni(1774): In native code 05-01 03:16:33.931: D/hello-jni(1774): In java 05-01 03:16:33.931: D/hello-jni(1774): In native code static 05-01 03:16:33.931: D/hello-jni(1774): In java staic
可以看到，有按照我们的预期，在native code中正确地完成了对于java 语言实现的方法的调用。
调用实例方法
MethodCall_nativeMethod的实现，阐明了在native code中调用实例方法所需要的两个步骤：
- native方法首先需要调用JNI函数GetMethodID。GetMethodID会在给定类中查找特定的方法。可以看到，查找是基于方法名和方法的类型描述符的。如果方法不存在，GetMethodID返回NULL。此处，由native code直接返回会导致在调用MethodCall.nativeMethod()的地方有一个NoSuchMethodError 被抛出。
- 然后，native code调用CallVoidMethod。CallVoidMethod调用一个实例方法，该方法的返回类型为void。我们需要传递对象，method ID和实际的参数(尽管上面的code中，没有参数)给CallVoidMethod。
除了CallVoidMethod，JNI也支持调用具有其他返回值类型的方法。比如，如果我们需要调用一个返回值类型为int的callback，我们可以在native code中使用CallIntMethod。类似地，我们可以使用CallObjectMethod来调用返回对象的方法。
我们也可以使用Call<Type>Method族函数来调用interface方法。只是一定要有interface类型继承method ID。
调用GetMethodID所传递的第三个参数，方法的类型描述符，与我们前面在注册native方法时所遇到的method descriptor的写法是一样的。
可以看一下这族函数：
JNI还提供了其他的一些函数，以方便我们在native code中回调Java方法。更具体的内容可以参考《The Java ™ Native Interface -- Programmer’s Guide and Specification》。
调用类静态方法
与在native code中调用实例方法相似，在native code中调用类静态方法也需要两个步骤：
- 使用GetStaticMethodID，而不是GetMethodID来获取method ID。
- 传递class，method ID和参数给static 方法调用族函数中的一个：CallStaticVoidMethod，CallStaticBooleanMethod等。
允许我们调用实例方法的函数族和允许我们调用类static 方法的函数族之间，最为关键的区别在于，前者都是需要将一个对象的引用作为第二个参数的，而后者则需要将一个class引用作为第二个参数。
在Java语言层级，我们有两种方式可以调用一个类Cls的static方法f()：通过Cls.f()或者通过obj.f()，其中obj是Cls的一个实例。(然而，后者是推荐的编程风格)。在JNI中，从native code调用static方法，我们则总是需要指明class引用。如前面的那段code所示的那样。
在native code中调用static方法的那一族函数，与在native code中调用实例方法的那一族相比，差别不是很大，我们此处就不再列出，具体可以参考《The Java ™ Native Interface -- Programmer’s Guide and Specification》。
Done.