第三章笔记(1)

在本章我们将学习以下东西：

1.在java与本地代码之间传递与接收基本类型、对象、数组

2.在本地代码里面处理java对象

3.从本地代码中引起异常

与java基本类型的联系

    一个简单的Java GUI是由一个关键字(一个特殊的字符串)，类型(整形，字符串等等)和一个与所选类型有关的值所定义的接口。接口被插入或者修改的数据将会驻留在本地代码里面。接口也可以被Java客户端回调。程序类似一个键值对，按照指定的Key来去相应的Value,而Value分为Integer和String类型；下面的图片展示了一个程序大概会被怎样构架：

程序的界面：

动手时间——建立一个本地值/关键字Store

首先实现Java方面的代码：

  1.建立一个Java/C++的混合项目

命名为Store

主包为cn.StoreActivity

主Activity为StoreActivity

不要忘了在根目录下面创建Jni文件夹

java方面将会包含三个源文件 Store.java    StoreType.java  和 StoreActivity.java

  2.在res/layout/main.xml文件里面按照下面的图片建立Java GUI。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=""
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    >
<TextView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="Save or retrieve a value from the store:"
    />
    <!-- android:layout_width="wrap_content"-->
    <!-- android:layout_height="match_parent" -->
    <!-- 如果TableLayout头两句写成这样，两个按钮会显示不出来 -->
 <TableLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:stretchColumns="1" >
    <TableRow>
       <TextView
          android:id="@+id/ui_KeyLable"
          android:text="Key:"/>
       <EditText
          android:id="@+id/et_Key">
          <requestFocus></requestFocus>
       </EditText>
    </TableRow>
    <TableRow>
       <TextView
          android:id="@+id/ui_valueLabale"
          android:text="Value:"/>
       <EditText
          android:id="@+id/et_Value"/>

    </TableRow>
    <TableRow>
       <TextView
          android:id="@+id/ui_TypeLable"
          android:layout_height="match_parent"
          android:gravity="center_vertical"
          android:text="Type:"/>
       <Spinner
          android:id="@+id/sp_type"/>
    </TableRow>
 </TableLayout>
  <LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:gravity="right">
    <Button
       android:id="@+id/bt_getValue"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Get value"/>
    <Button
       android:id="@+id/bt_setValue"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Set Value"/>
   </LinearLayout>
</LinearLayout>

3.以enum建立StoreType.java支持ui中type指定的几种数据类型

package cn.StoreActivity;
public enum StoreType {
   Integer,String;
}

4.建立一个新的Store类导入与本地library同名的库，定义我们store将要听过的函数。Store是我们本地代码 的前端。它仅仅支持整型和字符串型

package cn.StoreActivity;
public class Store {
    public native int getInteger(String key);
    public native void setInteger(String key,int Kint);

    public native String getString(String key);
    public native void setString(String key,String string);
}

5.在Jni目录下面，创建定义了数据结构体的Store.h。创建一个StoreType枚举出匹配java方面的类型。
同时创建Store。StoreEntry包含了一个关键字(C字符串)，类型和一个值。StoreValue就是一个包含所有可能值
的集合体：

#ifndef _STORE_H_
#define _STORE_H_

#include "jni.h"
#include <stdint.h>

/*
 * Constants.
 */
#define STORE_MAX_CAPACITY 16


/*
 * Types handled by the store.
 */
typedef enum {
    StoreType_Integer, StoreType_String
} StoreType;

/**
 * Store data structures.
 */
typedef union {
    int32_t mInteger;
    char* mString;
} StoreValue;

typedef struct {
    char* mKey;
    StoreType mType;
    StoreValue mValue;
} StoreEntry;

typedef struct {
    StoreEntry mEntries[STORE_MAX_CAPACITY];
    int32_t mLength;
} Store;

/*
 * Store helper methods.
 */
int32_t isEntryValid(JNIEnv* pEnv, StoreEntry* pEntry,
                     StoreType pType);

StoreEntry* allocateEntry(JNIEnv* pEnv, Store* pStore, jstring pKey);

StoreEntry* findEntry(JNIEnv* pEnv, Store* pStore, jstring pKey,
                      int32_t* pError);

void releaseEntryValue(JNIEnv* pEnv, StoreEntry* pEntry);

#endif

  6.在jni目录下创建定义了数据结构体的Store.h对应的工具类Store.c

#include "Store.h"
#include <string.h>

int32_t isEntryValid(JNIEnv* pEnv, StoreEntry* pEntry,
    StoreType pType) {
    if ((pEntry != NULL) && (pEntry->mType == pType)) {
        return 1;
    }
    return 0;
}

StoreEntry* findEntry(JNIEnv* pEnv, Store* pStore, jstring pKey,
                      int32_t* pError) {
    StoreEntry* lEntry = pStore->mEntries;
    StoreEntry* lEntryEnd = lEntry + pStore->mLength;

    // Compare requested key with every entry key currently stored
    // until we find a matching one.
    const char* lKeyTmp = (*pEnv)->GetStringUTFChars(pEnv, pKey,
                                                     NULL);
    if (lKeyTmp == NULL) {
        if (pError != NULL) {
            *pError = 1;
        }
        return;
    }

    while ((lEntry < lEntryEnd)
        && (strcmp(lEntry->mKey, lKeyTmp) != 0)) {
        ++lEntry;
    }
    (*pEnv)->ReleaseStringUTFChars(pEnv, pKey, lKeyTmp);

    return (lEntry == lEntryEnd) ? NULL : lEntry;
}

StoreEntry* allocateEntry(JNIEnv* pEnv, Store* pStore, jstring pKey){
    // If entry already exists in the store, releases its content
    // and keep its key.
    int32_t lError = 0;
    StoreEntry* lEntry = findEntry(pEnv, pStore, pKey, &lError);
    if (lEntry != NULL) {
        releaseEntryValue(pEnv, lEntry);
    }
    // If entry does not exist, create a new entry right after
    // already allocated entries.
    else if (!lError) {
        // Checks store can accept a new entry.
        if (pStore->mLength >= STORE_MAX_CAPACITY) {
            return NULL;
        }
        lEntry = pStore->mEntries + pStore->mLength;

        // Copies the new key into its final C string buffer.
        const char* lKeyTmp = (*pEnv)->GetStringUTFChars(pEnv, pKey,
                                                         NULL);
        if (lKeyTmp == NULL) {
            return;
        }

        lEntry->mKey = (char*) malloc(strlen(lKeyTmp));
        strcpy(lEntry->mKey, lKeyTmp);
        (*pEnv)->ReleaseStringUTFChars(pEnv, pKey, lKeyTmp);

        ++pStore->mLength;
    }
    return lEntry;
}
void releaseEntryValue(JNIEnv* pEnv, StoreEntry* pEntry) {
    int i;
    switch (pEntry->mType) {
        case StoreType_String:
            free(pEntry->mValue.mString);
            break;
    }
}

 7.使用javah编译cn.StoreActivity.Store生成的JNI的头文件→jni/cn_StoreActivity_Store.h

 8.功能函数和JNI头文件已生成，现在需要写jni源文件→StoreActivity.c

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "cn_StoreActivity_Store.h"
#include "Store.h"

static Store mStore = { {}, 0 };

JNIEXPORT jint JNICALL Java_cn_StoreActivity_Store_getInteger
  (JNIEnv * pEnv, jobject pThis, jstring pKey){
    StoreEntry* lEntry = findEntry(pEnv, &mStore, pKey, NULL);
    if (isEntryValid(pEnv, lEntry, StoreType_Integer)) {
        return lEntry->mValue.mInteger;
    } else {
        return 0;
    }
}

/*
 * Class:     cn_StoreActivity_Store
 * Method:    setInteger
 * Signature: (Ljava/lang/String;I)V
 */
JNIEXPORT void JNICALL Java_cn_StoreActivity_Store_setInteger
(JNIEnv* pEnv, jobject pThis, jstring pKey, jint pInteger) {
   StoreEntry* lEntry = allocateEntry(pEnv, &mStore, pKey);
   if (lEntry != NULL) {
       lEntry->mType = StoreType_Integer;
       lEntry->mValue.mInteger = pInteger;
   }
}
/*
 * Class:     cn_StoreActivity_Store
 * Method:    getString
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_cn_StoreActivity_Store_getString
(JNIEnv* pEnv, jobject pThis, jstring pKey) {
    StoreEntry* lEntry = findEntry(pEnv, &mStore, pKey, NULL);
    if (isEntryValid(pEnv, lEntry, StoreType_String)) {
        // Converts a C string into a Java String.
        return (*pEnv)->NewStringUTF(pEnv, lEntry->mValue.mString);
    } else {
        return NULL;
    }
}
/*
 * Class:     cn_StoreActivity_Store
 * Method:    setString
 * Signature: (Ljava/lang/String;Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_cn_StoreActivity_Store_setString
(JNIEnv* pEnv, jobject pThis, jstring pKey, jstring pString) {
    // Turns the Java string into a temporary C string.
    // GetStringUTFChars() is used here as an example but
    // Here, GetStringUTFChars() to show
    // the way it works. But as what we want is only a copy,
    // GetBooleanArrayRegion() would be be more efficient.
    const char* lStringTmp = (*pEnv)->GetStringUTFChars(pEnv, pString, NULL);
    if (lStringTmp == NULL) {
        return;
    }

    StoreEntry* lEntry = allocateEntry(pEnv, &mStore, pKey);
    if (lEntry != NULL) {
        lEntry->mType = StoreType_String;
        // Copy the temporary C string into its dynamically allocated
        // final location. Then releases the temporary string.
        // Malloc return value should theoretically be checked...
        jsize lStringLength = (*pEnv)->GetStringUTFLength(pEnv, pString);
        lEntry->mValue.mString =
            (char*) malloc(sizeof(char) * (lStringLength + 1));
        strcpy(lEntry->mValue.mString, lStringTmp);
    }
    (*pEnv)->ReleaseStringUTFChars(pEnv, pString, lStringTmp);
}