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

JNIEXPORT jlong JNICALLJava_org_gearvrf_NativeImporter_readFileFromAssets(JNIEnv * env,        jobject obj, jobject asset_manager, jstring filename) {    const char* native_string = env->GetStringUTFChars(filename, 0);    AAssetManager* mgr = AAssetManager_fromJava(env, asset_manager);    AAsset* asset = AAssetManager_open(mgr, native_string, AASSET_MODE_UNKNOWN);    if (NULL == asset) {        LOGE("_ASSET_NOT_FOUND_");        return JNI_FALSE;    }    long size = AAsset_getLength(asset);    char* buffer = (char*) malloc(sizeof(char) * size);    AAsset_read(asset, buffer, size);    AssimpImporter* assimp_scene = Importer::readFileFromAssets(            buffer, size);    AAsset_close(asset);    free(buffer);    env->ReleaseStringUTFChars(filename, native_string);    return reinterpret_cast<jlong>(assimp_scene);}

static jboolean EnginePrepare(JNIEnv* env, jclass clzz, jobject assetsMgr/*AAssetManager*/,	jstring filesRoot, jobjectArray plugins /*String[]*/){	AAssetManager* mgr = AAssetManager_fromJava(env, assetsMgr);	int count = env->GetArrayLength(plugins);	vector<string> _plugins;	for (int i = 0; i < count; i++ ) {		jstring ck_plugin = (jstring)env->GetObjectArrayElement(plugins, i);		string _plgin;		GET_CPPSTR_FROM_JSTR(env, ck_plugin, _plgin);		_plugins.push_back(_plgin);	}	string filesroot_str;	GET_CPPSTR_FROM_JSTR(env, filesRoot, filesroot_str);	try {		Vm::android_init(mgr, filesroot_str.c_str(), _plugins);		return true;	}	catch( const vedit::Exception& e ) {		gHook.last_error = "engine prepare failed. cause:";		gHook.last_error += e.what();		return false;	}}

 void Java_co_theengine_loomdemo_LoomDemo_nativeSetPaths(JNIEnv* env, jobject thiz, jstring apkPath, jobject am) {     const char *str = env->GetStringUTFChars(apkPath, NULL);     //cocos2d::CCFileUtils::sharedFileUtils()->setResourcePath(str);     env->ReleaseStringUTFChars(apkPath, str);     loom_setAssetManager(AAssetManager_fromJava(env, am)); }

jobjectArrayJava_org_linaro_glmark2_native_getSceneInfo(JNIEnv* env, jclass clazz,        jobject asset_manager){    static_cast<void>(clazz);    Util::android_set_asset_manager(AAssetManager_fromJava(env, asset_manager));    std::vector<Scene*> scenes;    DummyCanvas canvas;    std::vector<jobject> si_vector;    create_and_add_scenes(scenes, canvas);    /* Create SceneInfo instances for all the scenes */    for (std::vector<Scene*>::const_iterator iter = scenes.begin();            iter != scenes.end();            iter++)    {        jobject si = scene_info_from_scene(env, **iter);        si_vector.push_back(si);    }    /* Create a SceneInfo[] array */    jclass si_cls = env->FindClass("org/linaro/glmark2/SceneInfo");    jobjectArray si_array = env->NewObjectArray(si_vector.size(), si_cls, 0);    /* Populate the SceneInfo[] array */    for (size_t i = 0; i < si_vector.size(); i++)        env->SetObjectArrayElement(si_array, i, si_vector[i]);    Util::dispose_pointer_vector(scenes);    return si_array;}

void setupJniEnv(JNIEnv* _jniEnv, jobject _tangramInstance, jobject _assetManager) {    _jniEnv->GetJavaVM(&jvm);    JNIEnv* jniEnv = _jniEnv;    jniRenderThreadEnv = _jniEnv;    tangramInstance = jniEnv->NewGlobalRef(_tangramInstance);    jclass tangramClass = jniEnv->FindClass("com/mapzen/tangram/MapController");    startUrlRequestMID = jniEnv->GetMethodID(tangramClass, "startUrlRequest", "(Ljava/lang/String;J)Z");    cancelUrlRequestMID = jniEnv->GetMethodID(tangramClass, "cancelUrlRequest", "(Ljava/lang/String;)V");    getFontFilePath = jniEnv->GetMethodID(tangramClass, "getFontFilePath", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");        requestRenderMethodID = _jniEnv->GetMethodID(tangramClass, "requestRender", "()V");    setRenderModeMethodID = _jniEnv->GetMethodID(tangramClass, "setRenderMode", "(I)V");    featureSelectionCbMID = _jniEnv->GetMethodID(tangramClass, "featureSelectionCb", "(Lcom/mapzen/tangram/Properties;)V");    jclass propertiesClass = jniEnv->FindClass("com/mapzen/tangram/Properties");    propertiesConstructorMID = jniEnv->GetMethodID(propertiesClass, "<init>", "(JZ)V");    assetManager = AAssetManager_fromJava(jniEnv, _assetManager);    if (assetManager == nullptr) {        logMsg("ERROR: Could not obtain Asset Manager reference/n");    }}

AssetArchive::AssetArchive(const String& name, AssetArchive* parent, const String& dir): Archive(name){	JNIEnv* env = g_AndroidJNI->getEnv();	if (parent->_assetManagerRef)	{		_assetManagerRef = env->NewGlobalRef(parent->_assetManagerRef);		_assetManager = AAssetManager_fromJava(env, _assetManagerRef);	}	else	{		_assetManagerRef = NULL;		_assetManager = parent->_assetManager;	}	_fixCaseProblem = parent->_fixCaseProblem;	_dir = dir;	if (!_dir.empty())	{		FileUtil::normalizeSeparator(_dir);		// Make sure base to be 'path/' from		if (_dir[_dir.length()-1] != FileUtil::getPathSeparator())			_dir += FileUtil::getPathSeparator();		if (StringUtil::endsWith(_dir, FileUtil::getDamnedPattern1()))			_dir.erase(_dir.size() - FileUtil::getDamnedPattern1().length());	}	load();}

JNIEXPORT long JNICALLJava_com_torchandroid_neuraltalk_lua_LuaManager_initTorch(JNIEnv *env, jobject thiz, jobject assetManager, jstring nativeLibraryDir_){	// get native asset manager. This allows access to files stored in the assets folder	AAssetManager* manager = AAssetManager_fromJava(env, assetManager);	assert( NULL != manager);	const char *nativeLibraryDir = env->GetStringUTFChars(nativeLibraryDir_, 0);	lua_State *L = NULL;	L = inittorch(manager, nativeLibraryDir);// create a lua_State	// load and run file	char file[] = "init-only.lua";	int ret;	long size = android_asset_get_size(file);	if (size != -1) {		char *filebytes = android_asset_get_bytes(file);		ret = luaL_dobuffer(L, filebytes, size, "init-only");		if (ret == 1) {			D("Torch Error doing resource: %s/n", file);			D(lua_tostring(L,-1));		} else {			D("Torch script ran successfully.");		}	}	return (long) L;}

JNIEXPORT void JNICALL    Java_com_android_accelerometergraph_AccelerometerGraphJNI_init(                     JNIEnv *env, jclass type, jobject assetManager) {        (void)type;        AAssetManager *nativeAssetManager = AAssetManager_fromJava(env, assetManager);        gSensorGraph.init(nativeAssetManager);    }

static jboolean LoadAssetDir(JNIEnv* env, jclass clazz, jobject assetmgr/*AssetManager*/, jstring assetDir){	if (assetDir == NULL || assetmgr == NULL) {		gHook.last_error = "empty arguments wen loadAssetDir";		return false;	}	string dir;	GET_CPPSTR_FROM_JSTR(env, assetDir, dir);	if (dir.size() == 0) {		gHook.last_error = "empty arguments wen loadAssetDir";		return false;	}	AAssetManager* mgr = AAssetManager_fromJava(env, assetmgr);	try {		Vm::load_script_assets_dir(mgr, dir.c_str());		return true;	}	catch(const vedit::Exception& e)	{		ostringstream oss;		oss << "loadFileDir failed, cause:"<<e.what();		gHook.last_error = oss.str();		return false;	}}

JNIEXPORT void Java_io_highfidelity_hifiinterface_InterfaceActivity_nativeOnCreate(JNIEnv* env, jobject obj, jobject instance, jobject asset_mgr) {    qDebug() << "nativeOnCreate On thread " << QThread::currentThreadId();    g_assetManager = AAssetManager_fromJava(env, asset_mgr);    auto oldMessageHandler = qInstallMessageHandler(tempMessageHandler);    unpackAndroidAssets();    qInstallMessageHandler(oldMessageHandler);}

JNIEXPORT void JNICALL Java_com_intel_deferredgles_JNIWrapper_init_1asset_1manager(JNIEnv * env, jobject obj, jobject assetManager){    _asset_manager = AAssetManager_fromJava(env, assetManager);    UNUSED_PARAMETER(env);    UNUSED_PARAMETER(obj);}

JNIEXPORT void JNICALL Java_com_intel_textureloader_TextureLoaderLib_createAssetManager(JNIEnv* env, jobject obj, jobject assetManager){    AAssetManager* mgr = AAssetManager_fromJava( env, assetManager );        // Store the assest manager for future use.    SetAssetManager( mgr );   }

JNIEXPORT void JNICALLJava_io_jxcore_node_jxcore_setNativeContext(JNIEnv *env, jobject thiz,                                            jobject context,                                            jobject j_assetManager) {  jxcore::JniHelper::setClassLoaderFrom(context);  assetManager = AAssetManager_fromJava(env, j_assetManager);}

JNIEXPORT jlongJNICALLJava_com_example_android_nnapidemo_MainActivity_initModel(        JNIEnv *env,        jobject /* this */,        jobject _assetManager,        jstring _assetName) {    // Get the file descriptor of the the model data file.    AAssetManager *assetManager = AAssetManager_fromJava(env, _assetManager);    const char *assetName = env->GetStringUTFChars(_assetName, NULL);    AAsset *asset = AAssetManager_open(assetManager, assetName, AASSET_MODE_BUFFER);    if(asset == nullptr) {        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "Failed to open the asset.");        return 0;    }    env->ReleaseStringUTFChars(_assetName, assetName);    off_t offset, length;    int fd = AAsset_openFileDescriptor(asset, &offset, &length);    AAsset_close(asset);    if (fd < 0) {        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,                            "Failed to open the model_data file descriptor.");        return 0;    }    SimpleModel* nn_model = new SimpleModel(length, PROT_READ, fd, offset);    if (!nn_model->CreateCompiledModel()) {        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,                            "Failed to prepare the model.");        return 0;    }    return (jlong)(uintptr_t)nn_model;}

    JNIEXPORT long JNICALL    Java_com_torchandroid_facedemo_CameraClass_initTorch(JNIEnv *env, jobject thiz, jobject assetManager)    {        // get native asset manager. This allows access to files stored in the assets folder        AAssetManager* manager = AAssetManager_fromJava(env, assetManager);        assert( NULL != manager);        lua_State *L = NULL;        L = inittorch(manager); // create a lua_State        // load and run file        char file[] = "main.lua";        int ret;        long size = android_asset_get_size(file);        if (size != -1) {            char *filebytes = android_asset_get_bytes(file);            ret = luaL_dobuffer(L, filebytes, size, "main");            if (ret == 1) {                D("Torch Error doing resource: %s/n", file);                D(lua_tostring(L,-1));            } else {                D("Torch script ran succesfully.");            }        }        lua_register(L,"parse",parse); //This function is used by main.lua.        return (long) L;    }

JNIEXPORT void JNICALL    Java_sample_hawk_com_mybasicappcomponents_jni_AccelerometerGraphJNI_init(                     JNIEnv *env, jclass type, jobject assetManager) {        (void)type;        AAssetManager *nativeAssetManager = AAssetManager_fromJava(env, assetManager);        gSensorGraph.init(nativeAssetManager);    }

 JNIEXPORT jint JNICALL Java_com_ericsson_lispmediaplayer_Player_setAssetManager(         JNIEnv *env, jobject object, jobject assetManager) {     AAssetManager * AssetMgr = NULL;     AssetMgr = AAssetManager_fromJava(env, assetManager);     setAssetManager(AssetMgr); }

	void Init(void* infoPtr)	{        JNIInitInfo* initInfo = static_cast<JNIInitInfo*>(infoPtr);        MB_ASSERT(infoPtr);        g_assetManager = AAssetManager_fromJava(initInfo->env, initInfo->assetManager);        MB_ASSERT(g_assetManager);        MB_LOGINFO("Platform::Init complete");	}

JNIEXPORT void JNICALL Java_com_casaproduction_casaengine_RendererWrapper_initAssetManager(JNIEnv * env, jclass jclazz, 	jobject java_asset_manager){	//UNUSED(jclazz);	AAssetManager *asset_manager = AAssetManager_fromJava(env, java_asset_manager);	IOManager::SetAssetManager(asset_manager);}

std::string loadScriptFromAssets(const std::string& assetName) {  JNIEnv *env = jni::Environment::current();  jobject application = env->CallStaticObjectMethod(    gApplicationHolderClass,    gGetApplicationMethod);  jobject assetManager = env->CallObjectMethod(application, gGetAssetManagerMethod);  return loadScriptFromAssets(AAssetManager_fromJava(env, assetManager), assetName);}

extern "C" JNIEXPORT jlong JNICALLJava_budny_moneykeeper_cv_Recognizer_nativeInitialize(       JNIEnv* j_env, jobject,       jobject j_manager, jstring j_model_filename) {    AAssetManager* manager = AAssetManager_fromJava(j_env, j_manager);    std::string model_filename = jni::stdString(j_env, j_model_filename);    Recognizer* recognizer = new Recognizer(manager, model_filename);    return reinterpret_cast<jlong>(recognizer);}

void loadShaders(JNIEnv *env, jobject &obj) {    AAssetManager *asset_manager = AAssetManager_fromJava(env, obj);    FILE *fd;    fd = android_fopen("vertex.glsl", "r", asset_manager);    gVertexShader = readToString(fd);    fclose(fd);    fd = android_fopen("fragment.glsl", "r", asset_manager);    gFragmentShader = readToString(fd);    fclose(fd);}

JNIEXPORT void JNICALL Java_in_p3d_mobile_P3dViewerJNIWrapper_init_1asset_1manager  (JNIEnv *env, jclass cls, jobject am){	// unused	(void)cls;	LOGD("assetmgr");	AAssetManager* mgr = AAssetManager_fromJava(env, am);	adapter->setAssetManager(mgr);}

    JNIEXPORT void JNICALL    Java_spidermonkey_bindings_runJSFromAssets (JNIEnv* env,                                                jobject thiz,                                                jobject java_assetmanager,                                                jstring java_relativepath) {        LOGD("Java_spidermonkey_bindings_runJSFromAssets");        // relative path        const char* relativepath;        relativepath = env->GetStringUTFChars(java_relativepath, NULL);        if (NULL == relativepath) {            LOGD("relativepath : is NULL");            return; // OutOfMemoryError already thrown        }        LOGD("relativepath : %s", relativepath);        AAssetManager* assetmanager =            AAssetManager_fromJava(env, java_assetmanager);        if (NULL == assetmanager) {            LOGD("assetmanager : is NULL");            return;        }        // read asset data        AAsset* asset =            AAssetManager_open(assetmanager,                               relativepath,                               AASSET_MODE_UNKNOWN);        if (NULL == asset) {            LOGD("asset : is NULL");            return;        }        off_t size = AAsset_getLength(asset);        LOGD("size = %d ", size);        char* buf = (char*) malloc(size+1);        if (NULL == buf) {            LOGD("asset : is NULL");            AAsset_close(asset);            return;        }        int bytesread = AAsset_read(asset, (void*)buf, size);        LOGD("bytesread = %d ", bytesread);        buf[size] = '/0';        AAsset_close(asset);        // run this in SpiderMonkey        jsbindings::runJS((char*) buf);        env->ReleaseStringUTFChars(java_relativepath, relativepath);    }

JNIEXPORT void Java_io_highfidelity_hifiinterface_InterfaceActivity_nativeOnCreate(JNIEnv* env, jobject obj, jobject instance, jobject asset_mgr) {    g_assetManager = AAssetManager_fromJava(env, asset_mgr);    qRegisterMetaType<QAndroidJniObject>("QAndroidJniObject");    __interfaceActivity = QAndroidJniObject(instance);    auto oldMessageHandler = qInstallMessageHandler(tempMessageHandler);    unpackAndroidAssets();    qInstallMessageHandler(oldMessageHandler);    JavaVM* jvm;    env->GetJavaVM(&jvm);    QObject::connect(&AndroidHelper::instance(), &AndroidHelper::androidActivityRequested, [jvm](const QString& a, const bool backToScene, QMap<QString, QString> args) {        JNIEnv* myNewEnv;        JavaVMAttachArgs jvmArgs;        jvmArgs.version = JNI_VERSION_1_6; // choose your JNI version        jvmArgs.name = NULL; // you might want to give the java thread a name        jvmArgs.group = NULL; // you might want to assign the java thread to a ThreadGroup        int attachedHere = 0; // know if detaching at the end is necessary        jint res = jvm->GetEnv((void**)&myNewEnv, JNI_VERSION_1_6); // checks if current env needs attaching or it is already attached        if (JNI_OK != res) {            qDebug() << "[JCRASH] GetEnv env not attached yet, attaching now..";            res = jvm->AttachCurrentThread(reinterpret_cast<JNIEnv **>(&myNewEnv), &jvmArgs);            if (JNI_OK != res) {                qDebug() << "[JCRASH] Failed to AttachCurrentThread, ErrorCode = " << res;                return;            } else {                attachedHere = 1;            }        }        QAndroidJniObject string = QAndroidJniObject::fromString(a);        jboolean jBackToScene = (jboolean) backToScene;        jclass hashMapClass = myNewEnv->FindClass("java/util/HashMap");        jmethodID mapClassConstructor =  myNewEnv->GetMethodID(hashMapClass, "<init>", "()V");        jobject hashmap = myNewEnv->NewObject(hashMapClass, mapClassConstructor);        jmethodID mapClassPut = myNewEnv->GetMethodID(hashMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");        QMap<QString, QString>::iterator i;        for (i = args.begin(); i != args.end(); ++i) {            QAndroidJniObject jKey = QAndroidJniObject::fromString(i.key());            QAndroidJniObject jValue = QAndroidJniObject::fromString(i.value());            myNewEnv->CallObjectMethod(hashmap, mapClassPut, jKey.object<jstring>(), jValue.object<jstring>());        }        __interfaceActivity.callMethod<void>("openAndroidActivity", "(Ljava/lang/String;ZLjava/util/HashMap;)V", string.object<jstring>(), jBackToScene, hashmap);        if (attachedHere) {            jvm->DetachCurrentThread();        }    });    QObject::connect(&AndroidHelper::instance(), &AndroidHelper::hapticFeedbackRequested, [](int duration) {        jint iDuration = (jint) duration;        __interfaceActivity.callMethod<void>("performHapticFeedback", "(I)V", iDuration);    });}

SWIGEXPORT void JNICALL Java_com_cwq_cwqengine_CwqEngineJNI_CwqEngine_1setAssetManager(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject assetManager) {  CwqEngine *arg1 = (CwqEngine *) 0 ;  AAssetManager *arg2 = (AAssetManager *) 0 ;  (void)jenv;  (void)jcls;  (void)jarg1_;  arg1 = *(CwqEngine **)&jarg1;  arg2 = AAssetManager_fromJava(jenv, assetManager);  Resource::setAssetManager(arg2);}