自学教程：C++ Android_JNI_GetEnv函数代码示例

extern "C" const char * orxAndroid_GetInternalStoragePath(){  if (!sstAndroid.zAndroidInternalFilesPath)  {    jmethodID mid;    jobject fileObject;    jstring pathString;    const char *path;    jobject jActivity;    JNIEnv *env = Android_JNI_GetEnv();    mid = env->GetMethodID(env->GetObjectClass(sstAndroid.mActivity), "getFilesDir", "()Ljava/io/File;");    fileObject = env->CallObjectMethod(sstAndroid.mActivity, mid);    if (!fileObject)    {      LOGE("Couldn't get internal directory");      return NULL;    }    // path = fileObject.getAbsolutePath();    mid = env->GetMethodID(env->GetObjectClass(fileObject), "getAbsolutePath", "()Ljava/lang/String;");    pathString = (jstring)env->CallObjectMethod(fileObject, mid);    env->DeleteLocalRef(fileObject);    path = env->GetStringUTFChars(pathString, NULL);    sstAndroid.zAndroidInternalFilesPath = strdup(path);    env->ReleaseStringUTFChars(pathString, path);    env->DeleteLocalRef(pathString);  }  return sstAndroid.zAndroidInternalFilesPath;}

extern DECLSPEC void Android_JNI_StateCallback(void* context, m64p_core_param paramChanged, int newValue){    /*----ParamChanged-----------------     *    --------NewValue--------     *    M64CORE_EMU_STATE           1     *            M64EMU_STOPPED 1     *            M64EMU_RUNNING 2     *            M64EMU_PAUSED  3     *    M64CORE_VIDEO_MODE          2     *    M64CORE_SAVESTATE_SLOT      3     *    M64CORE_SPEED_FACTOR        4     *    M64CORE_SPEED_LIMITER       5	 *    M64CORE_VIDEO_SIZE          6	 *    M64CORE_AUDIO_VOLUME        7	 *    M64CORE_AUDIO_MUTE          8	 *    M64CORE_INPUT_GAMESHARK     9	 *    M64CORE_STATE_LOADCOMPLETE 10	 *            (successful)   1	 *            (unsuccessful) 0	 *    M64CORE_STATE_SAVECOMPLETE 11	 *            (successful)   1	 *            (unsuccessful) 0     */    JNIEnv *env = Android_JNI_GetEnv();    env->CallStaticVoidMethod(mActivityClass, midStateCallback, (int) paramChanged, newValue);}

static int Android_JNI_FileClose(SDL_RWops* ctx, bool release){    LocalReferenceHolder refs(__FUNCTION__);    int result = 0;    JNIEnv *mEnv = Android_JNI_GetEnv();    if (!refs.init(mEnv)) {        SDL_SetError("Failed to allocate enough JVM local references");        return -1;    }    if (ctx) {        if (release) {            mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.fileNameRef);        }        jobject inputStream = (jobject)ctx->hidden.androidio.inputStreamRef;        // inputStream.close();        jmethodID mid = mEnv->GetMethodID(mEnv->GetObjectClass(inputStream),                "close", "()V");        mEnv->CallVoidMethod(inputStream, mid);        mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.inputStreamRef);        mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.readableByteChannelRef);        if (Android_JNI_ExceptionOccurred()) {            result = -1;        }        if (release) {            SDL_FreeRW(ctx);        }    }    return result;}

extern "C" SDL_bool Android_JNI_CreateContext(int majorVersion, int minorVersion,                                int red, int green, int blue, int alpha,                                int buffer, int depth, int stencil,                                int buffers, int samples){    JNIEnv *env = Android_JNI_GetEnv();    jint attribs[] = {        EGL_RED_SIZE, red,        EGL_GREEN_SIZE, green,        EGL_BLUE_SIZE, blue,        EGL_ALPHA_SIZE, alpha,        EGL_BUFFER_SIZE, buffer,        EGL_DEPTH_SIZE, depth,        EGL_STENCIL_SIZE, stencil,        EGL_SAMPLE_BUFFERS, buffers,        EGL_SAMPLES, samples,        EGL_RENDERABLE_TYPE, (majorVersion == 1 ? EGL_OPENGL_ES_BIT : EGL_OPENGL_ES2_BIT),        EGL_NONE    };    int len = SDL_arraysize(attribs);    jintArray array;    array = env->NewIntArray(len);    env->SetIntArrayRegion(array, 0, len, attribs);    jboolean success = env->CallStaticBooleanMethod(mActivityClass, midCreateGLContext, majorVersion, minorVersion, array);    env->DeleteLocalRef(array);    return success ? SDL_TRUE : SDL_FALSE;}

// This function is based on// (1) convert surface to Java BitMap object// (2) call Java PrintHelper to do print job.const char *SurfacePrint(SDL_Surface *surface){    JNIEnv *mEnv = Android_JNI_GetEnv();    jclass mBitmapClass = (*mEnv)->FindClass(mEnv, "android/graphics/Bitmap");    jmethodID mCreateMethod = (*mEnv)->GetStaticMethodID(mEnv, mBitmapClass, "createBitmap", "([IIILandroid/graphics/Bitmap$Config;)Landroid/graphics/Bitmap;");    jintArray mSurfaceArray = (*mEnv)->NewIntArray(mEnv, surface->w * surface->h);    (*mEnv)->SetIntArrayRegion(mEnv,mSurfaceArray, 0, surface->w * surface->h, surface->pixels);    jclass mConfigClass = (*mEnv)->FindClass(mEnv, "android/graphics/Bitmap$Config");    jfieldID mConfigField = (*mEnv)->GetStaticFieldID(mEnv, mConfigClass , "ARGB_8888", "Landroid/graphics/Bitmap$Config;");    jobject mConfig = (*mEnv)->GetStaticObjectField(mEnv, mConfigClass, mConfigField);    jobject mBitMap = (*mEnv)->CallStaticObjectMethod(mEnv, mBitmapClass, mCreateMethod, mSurfaceArray, surface->w, surface->h, mConfig);    jobject mContext = (jobject)SDL_AndroidGetActivity();    jclass mPrintClass = (*mEnv)->FindClass(mEnv, "android/support/v4/print/PrintHelper");    // sometimes android v4 support library may be not ready    if (mPrintClass == NULL)        return "There is no android v4 support library.";    jmethodID mInitMethod = (*mEnv)->GetMethodID(mEnv, mPrintClass, "<init>", "(Landroid/content/Context;)V");    jobject mPrint = (*mEnv)->NewObject(mEnv, mPrintClass, mInitMethod, mContext);    jmethodID mPrintMethod = (*mEnv)->GetMethodID(mEnv, mPrintClass, "printBitmap", "(Ljava/lang/String;Landroid/graphics/Bitmap;)V");    jstring mString = (*mEnv)->NewStringUTF(mEnv, "TuxPaint");    (*mEnv)->CallVoidMethod(mEnv, mPrint, mPrintMethod, mString, mBitMap);    // clean up    (*mEnv)->DeleteLocalRef(mEnv, mSurfaceArray);    (*mEnv)->DeleteLocalRef(mEnv, mConfig);    (*mEnv)->DeleteLocalRef(mEnv, mPrint);    (*mEnv)->DeleteLocalRef(mEnv, mString);    return NULL;}

extern "C" void orxAndroid_JNI_GetDeviceIds(orxS32 deviceIds[4]){  JNIEnv *env = Android_JNI_GetEnv();  jintArray retval = (jintArray) env->CallObjectMethod(sstAndroid.mActivity, sstAndroid.midGetDeviceIds);  env->GetIntArrayRegion(retval, 0, 4, (jint*) &deviceIds[0]);  env->DeleteLocalRef(retval);}

void setCurrLyric(char* lyric){	JNIEnv* theGoodEnv = Android_JNI_GetEnv();		jbyteArray byteArr = (*theGoodEnv)->NewByteArray(theGoodEnv, 300);	(*theGoodEnv)->SetByteArrayRegion(theGoodEnv, byteArr , 0, 300, (jbyte *)lyric);	(*theGoodEnv)->CallStaticVoidMethod(theGoodEnv, pushClazz, pushLyricId, byteArr, 300);	(*theGoodEnv)->DeleteLocalRef(theGoodEnv, byteArr);}

void flushIt(){	JNIEnv* theGoodEnv = Android_JNI_GetEnv();	//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");	//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, pushClazz, "flushIt", "()V");	(*theGoodEnv)->CallStaticIntMethod(theGoodEnv, pushClazz, flushId);	//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);}

void controller(int aa){	JNIEnv* theGoodEnv = Android_JNI_GetEnv();	//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");	//jclass cls = (*envelope)->GetObjectClass(envelope, mine);	//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, clazz, "controlMe", "(I)V");	(*theGoodEnv)->CallStaticVoidMethod(theGoodEnv, pushClazz, controlId, aa);	//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);}

int getBuffer(){	JNIEnv* theGoodEnv = Android_JNI_GetEnv();	//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");	//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, clazz, "bufferSize", "()I");	int r = (int)(*theGoodEnv)->CallStaticIntMethod(theGoodEnv, pushClazz, buffId);	//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);	return r;}

extern "C" SDL_bool Android_JNI_CreateContext(int majorVersion, int minorVersion){    JNIEnv *mEnv = Android_JNI_GetEnv();    if (mEnv->CallStaticBooleanMethod(mActivityClass, midCreateGLContext, majorVersion, minorVersion)) {        return SDL_TRUE;    } else {        return SDL_FALSE;    }}

void JavaBridge::EmulationStopped(void){    JNIEnv *env = Android_JNI_GetEnv();    if (g_Activity != NULL && env != NULL)    {        jmethodID midEmulationStopped = env->GetStaticMethodID(m_NotifierClass, "EmulationStopped", "(Landroid/app/Activity;)V");        env->CallStaticVoidMethod(m_NotifierClass, midEmulationStopped, g_Activity);    }}

void JavaBridge::RecentRomsUpdated(void){    JNIEnv *env = Android_JNI_GetEnv();    if (env)    {        jmethodID midRRecentRomsUpdated = env->GetStaticMethodID(m_GalleryActivityClass, "RecentRomsUpdated", "()V");        env->CallStaticVoidMethod(m_GalleryActivityClass, midRRecentRomsUpdated);    }}

extern "C" int Android_JNI_OpenAudioDevice(int sampleRate, int is16Bit, int channelCount, int desiredBufferFrames){    int audioBufferFrames;    int status;    JNIEnv *env = Android_JNI_GetEnv();    if (!env) {        LOGE("callback_handler: failed to attach current thread");    }    Android_JNI_SetupThread();        __android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device");    audioBuffer16Bit = is16Bit;    audioBufferStereo = channelCount > 1;    env->CallStaticObjectMethod(mActivityClass, midAudioInit, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames);    /* Allocating the audio buffer from the Java side and passing it as the return value for audioInit no longer works on     * Android >= 4.2 due to a "stale global reference" error. So now we allocate this buffer directly from this side. */        if (is16Bit) {        jshortArray audioBufferLocal = env->NewShortArray(desiredBufferFrames * (audioBufferStereo ? 2 : 1));        if (audioBufferLocal) {            audioBuffer = env->NewGlobalRef(audioBufferLocal);            env->DeleteLocalRef(audioBufferLocal);        }    }    else {        jbyteArray audioBufferLocal = env->NewByteArray(desiredBufferFrames * (audioBufferStereo ? 2 : 1));        if (audioBufferLocal) {            audioBuffer = env->NewGlobalRef(audioBufferLocal);            env->DeleteLocalRef(audioBufferLocal);        }    }    if (audioBuffer == NULL) {        __android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer!");        return 0;    }    jboolean isCopy = JNI_FALSE;    if (audioBuffer16Bit) {        audioBufferPinned = env->GetShortArrayElements((jshortArray)audioBuffer, &isCopy);        audioBufferFrames = env->GetArrayLength((jshortArray)audioBuffer);    } else {        audioBufferPinned = env->GetByteArrayElements((jbyteArray)audioBuffer, &isCopy);        audioBufferFrames = env->GetArrayLength((jbyteArray)audioBuffer);    }    if (audioBufferStereo) {        audioBufferFrames /= 2;    }     return audioBufferFrames;}

static voidSeparateEventsHintWatcher(void *userdata, const char *name,                          const char *oldValue, const char *newValue){    jclass mActivityClass = Android_JNI_GetActivityClass();    JNIEnv *env = Android_JNI_GetEnv();    jfieldID fid = (*env)->GetStaticFieldID(env, mActivityClass, "mSeparateMouseAndTouch", "Z");    separate_mouse_and_touch = (newValue && (SDL_strcmp(newValue, "1") == 0));    (*env)->SetStaticBooleanField(env, mActivityClass, fid, separate_mouse_and_touch ? JNI_TRUE : JNI_FALSE);}

extern "C" void Android_JNI_SetActivityTitle(const char *title){    jmethodID mid;    JNIEnv *mEnv = Android_JNI_GetEnv();    mid = mEnv->GetStaticMethodID(mActivityClass,"setActivityTitle","(Ljava/lang/String;)V");    if (mid) {        jstring jtitle = reinterpret_cast<jstring>(mEnv->NewStringUTF(title));        mEnv->CallStaticVoidMethod(mActivityClass, mid, jtitle);        mEnv->DeleteLocalRef(jtitle);    }}

ANativeWindow *Android_JNI_GetNativeWindow(void) {	ANativeWindow *anw;	jobject s;	JNIEnv *env = Android_JNI_GetEnv();	s = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetNativeSurface);	anw = ANativeWindow_fromSurface(env, s);	(*env)->DeleteLocalRef(env, s);	return anw;}

extern "C" void Android_JNI_CloseAudioDevice(){    JNIEnv *env = Android_JNI_GetEnv();    env->CallStaticVoidMethod(mActivityClass, midAudioQuit);    if (audioBuffer) {        env->DeleteGlobalRef(audioBuffer);        audioBuffer = NULL;        audioBufferPinned = NULL;    }}

void scoreloop_submit_score(unsigned int scoreMode, unsigned int scoreValue){    JNIEnv* env = Android_JNI_GetEnv();    if (!env)    {        return;    }    jclass mActivityClass = (*env)->FindClass(env, "com/moonlite/tuxracer/GameActivity");    jmethodID mid = (*env)->GetStaticMethodID(env, mActivityClass, "submitScore", "(II)Z");    if (!mid)    {        return;    }    if (!(*env)->CallStaticBooleanMethod(env, mActivityClass, mid, (int)scoreMode, (int)scoreValue))    {        jstring j_title=(*env)->NewStringUTF(env, ALIAS_PROMPT_TITLE);        jstring j_message=(*env)->NewStringUTF(env, ALIAS_PROMPT_MESSAGE);        if (!getparam_should_prompt_alias())        {            return;        }        stored_score_mode=(int)scoreMode;        stored_score_value=(int)scoreValue;        env = Android_JNI_GetEnv();        if (!env)        {            return;        }        mActivityClass = (*env)->FindClass(env, "com/moonlite/tuxracer/GameActivity");        mid = (*env)->GetStaticMethodID(env, mActivityClass, "promptForAlias", "(II)V");        if (!mid)        {            return;        }        (*env)->CallStaticVoidMethod(env, mActivityClass, mid, (int)scoreMode, (int)scoreValue);        (*env)->DeleteLocalRef(env, j_title);        (*env)->DeleteLocalRef(env, j_message);    }	return;}

extern "C" size_t Android_JNI_FileRead(SDL_RWops* ctx, void* buffer,        size_t size, size_t maxnum){    LocalReferenceHolder refs(__FUNCTION__);    if (ctx->hidden.androidio.assetFileDescriptorRef) {        size_t bytesMax = size * maxnum;        if (ctx->hidden.androidio.size != -1 /*UNKNOWN_LENGTH*/ && ctx->hidden.androidio.position + bytesMax > ctx->hidden.androidio.size) {            bytesMax = ctx->hidden.androidio.size - ctx->hidden.androidio.position;        }        size_t result = read(ctx->hidden.androidio.fd, buffer, bytesMax );        if (result > 0) {            ctx->hidden.androidio.position += result;            return result / size;        }        return 0;    } else {        jlong bytesRemaining = (jlong) (size * maxnum);        jlong bytesMax = (jlong) (ctx->hidden.androidio.size -  ctx->hidden.androidio.position);        int bytesRead = 0;        /* Don't read more bytes than those that remain in the file, otherwise we get an exception */        if (bytesRemaining >  bytesMax) bytesRemaining = bytesMax;        JNIEnv *mEnv = Android_JNI_GetEnv();        if (!refs.init(mEnv)) {            return -1;        }        jobject readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;        jmethodID readMethod = (jmethodID)ctx->hidden.androidio.readMethod;        jobject byteBuffer = mEnv->NewDirectByteBuffer(buffer, bytesRemaining);        while (bytesRemaining > 0) {            // result = readableByteChannel.read(...);            int result = mEnv->CallIntMethod(readableByteChannel, readMethod, byteBuffer);            if (Android_JNI_ExceptionOccurred()) {                return 0;            }            if (result < 0) {                break;            }            bytesRemaining -= result;            bytesRead += result;            ctx->hidden.androidio.position += result;        }        return bytesRead / size;    }}

void JavaBridge::GfxThreadInit(){    WriteTrace(TraceUserInterface, TraceDebug, "Start");    JNIEnv *env = Android_JNI_GetEnv();    if (g_GLThread != NULL && env != NULL)    {        jclass GLThreadClass = env->GetObjectClass(g_GLThread);        jmethodID midThreadStarting = env->GetMethodID(GLThreadClass, "ThreadStarting", "()V");        env->CallVoidMethod(g_GLThread, midThreadStarting);        env->DeleteLocalRef(GLThreadClass);    }    WriteTrace(TraceUserInterface, TraceDebug, "Done");}

// sends message to be handled on the UI event dispatch threadextern "C" int Android_JNI_SendMessage(int command, int param){    JNIEnv *env = Android_JNI_GetEnv();    if (!env) {        return -1;    }    jmethodID mid = env->GetStaticMethodID(mActivityClass, "sendMessage", "(II)V");    if (!mid) {        return -1;    }    env->CallStaticVoidMethod(mActivityClass, mid, command, param);    return 0;}

int nativePush(char* buf, int nframes){	//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");	JNIEnv* theGoodEnv = Android_JNI_GetEnv();	//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, clazz, "buffit", "([BI)V");	jbyteArray byteArr = (*theGoodEnv)->NewByteArray(theGoodEnv, nframes);	(*theGoodEnv)->SetByteArrayRegion(theGoodEnv, byteArr , 0, nframes, (jbyte *)buf);	(*theGoodEnv)->CallStaticVoidMethod(theGoodEnv, pushClazz, pushBuffit, byteArr, nframes);	(*theGoodEnv)->DeleteLocalRef(theGoodEnv, byteArr);	//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);		return 0;}

void orxAndroid_JNI_SetupThread(void) {    /* From http://developer.android.com/guide/practices/jni.html     * Threads attached through JNI must call DetachCurrentThread before they exit. If coding this directly is awkward,     * in Android 2.0 (Eclair) and higher you can use pthread_key_create to define a destructor function that will be     * called before the thread exits, and call DetachCurrentThread from there. (Use that key with pthread_setspecific     * to store the JNIEnv in thread-local-storage; that way it'll be passed into your destructor as the argument.)     * Note: The destructor is not called unless the stored value is != NULL     * Note: You can call this function any number of times for the same thread, there's no harm in it     *       (except for some lost CPU cycles)     */    JNIEnv *env = Android_JNI_GetEnv();    pthread_setspecific(mThreadKey, (void*) env);}

// Since Print work is based on Java PrintHelper class, which may not be supported on some old versionsint IsPrinterAvailable( void ){JNIEnv *mEnv = Android_JNI_GetEnv();jclass mPrintHelperClass = (*mEnv)->FindClass(mEnv, "android/support/v4/print/PrintHelper");if (mPrintHelperClass == NULL)    return 0;jmethodID mSupportMethod = (*mEnv)->GetStaticMethodID(mEnv, mPrintHelperClass, "systemSupportsPrint", "()Z");jboolean support = (*mEnv)->CallStaticBooleanMethod(mEnv, mPrintHelperClass, mSupportMethod);return support ? 1 : 0;}

extern "C" void Android_JNI_WriteAudioBuffer(){    JNIEnv *mAudioEnv = Android_JNI_GetEnv();    if (audioBuffer16Bit) {        mAudioEnv->ReleaseShortArrayElements((jshortArray)audioBuffer, (jshort *)audioBufferPinned, JNI_COMMIT);        mAudioEnv->CallStaticVoidMethod(mActivityClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);    } else {        mAudioEnv->ReleaseByteArrayElements((jbyteArray)audioBuffer, (jbyte *)audioBufferPinned, JNI_COMMIT);        mAudioEnv->CallStaticVoidMethod(mActivityClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);    }    /* JNI_COMMIT means the changes are committed to the VM but the buffer remains pinned */}

void GameCpuRunning(void * /*NotUsed*/){    WriteTrace(TraceUserInterface, TraceDebug, "Start");    bool Running = g_Settings->LoadBool(GameRunning_CPU_Running);    WriteTrace(TraceUserInterface, TraceDebug, Running ? "Game Started" : "Game Stopped");    if (Running)    {        stdstr FileLoc = g_Settings->LoadStringVal(Game_File);        if (FileLoc.length() > 0)        {            AddRecentRom(FileLoc.c_str());        }        g_System->RefreshGameSettings();    }    else    {        JNIEnv *env = Android_JNI_GetEnv();        if (env != NULL)        {            if (g_JavaBridge)            {                WriteTrace(TraceUserInterface, TraceDebug, "Notify java emulation stopped");                g_JavaBridge->EmulationStopped();            }            else            {                WriteTrace(TraceUserInterface, TraceError, "No Java bridge");            }            // call in to java that emulation done            WriteTrace(TraceUserInterface, TraceDebug, "clean up global activity");            env->DeleteGlobalRef(g_Activity);            g_Activity = NULL;            WriteTrace(TraceUserInterface, TraceDebug, "clean up global gl thread");            if (g_JavaBridge)            {                g_JavaBridge->GfxThreadDone();            }            env->DeleteGlobalRef(g_GLThread);            g_GLThread = NULL;        }        else        {            WriteTrace(TraceUserInterface, TraceError, "Failed to get java environment");        }    }    WriteTrace(TraceUserInterface, TraceDebug, "Done");}