JNIEXPORT jlong JNICALL
Java_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));
}
jobjectArray
Java_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 JNICALL
Java_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);
}
AssetArchive::AssetArchive(JNIEnv* env, jobject javaAssetManager)
: Archive("$asset_root")
{
_assetManagerRef = env->NewGlobalRef(javaAssetManager);
_assetManager = AAssetManager_fromJava(env, _assetManagerRef);
_fixCaseProblem = false;
}
JNIEXPORT void JNICALL
//Java_InterShell_1console_update_1keyboard_1size
//Java_org_d3x0r_InterShell_Chatment_InterShell_1console_update_1keyboard_1size
//Java_org_d3x0r_InterShell_Chatment_InterShell_1console_update_1keyboard_1size(JNIEnv * env, jobject obj, jint keyboard_metric)
//Java_org_d3x0r_sack_InterShell_InterShell_1window_update_1keyboard_1size(JNIEnv * env, jobject obj, jint keyboard_metric)
Java_org_d3x0r_sack_core_NativeStaticLib_start(JNIEnv * env, jobject obj, jobject assetObject )
{
{
pthread_t thread;
engine.wait_for_startup = 1;
{
struct android_app* state = (struct android_app*)malloc( sizeof( struct android_app ) );
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
state->activity = (ANativeActivity*)malloc( sizeof( struct ANativeActivity ) );
state->activity->assetManager = AAssetManager_fromJava(env, assetObject);;
engine.app = state;
}
LOGI( "Create A thread start! *** " );
pthread_create( &thread, NULL, BeginNormalProcess, NULL );
// wait for core initilization to complete, and soft symbols to be loaded.
while( engine.wait_for_startup )
sched_yield();
}
}
AAssetManager* getAssetManager(void) {
JNIEnv* jniEnv = (JNIEnv*)SDL_AndroidGetJNIEnv();
jclass sdlClass = (*jniEnv)->FindClass(jniEnv, "org/libsdl/app/SDLActivity");
if (sdlClass == 0) {
ANDROID_INFO("Cannot find SDLClass");
assert(0);
return NULL;
}
jmethodID mid = (*jniEnv)->GetStaticMethodID(jniEnv, sdlClass, "getContext","()Landroid/content/Context;");
jobject context = (*jniEnv)->CallStaticObjectMethod(jniEnv, sdlClass, mid);
if (context == 0) {
ANDROID_INFO("Cannot find Context");
return NULL;
}
mid = (*jniEnv)->GetMethodID(jniEnv, (*jniEnv)->GetObjectClass(jniEnv, context), "getAssets", "()Landroid/content/res/AssetManager;");
jobject assets = (*jniEnv)->CallObjectMethod(jniEnv, context, mid);
if (assets == 0) {
ANDROID_INFO("Cannot find AssetManager");
return NULL;
}
ANDROID_INFO("Found AssetManager");
return AAssetManager_fromJava(jniEnv, assets);
}
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 JNICALL
Java_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 jlong
JNICALL
Java_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 JNICALL
Java_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);
}
int Java_zte_irrlib_Engine_nativeInitAssetManager(
JNIEnv *env, jobject thiz, jobject amgr)
{
_assetManager = 0;
_assetManager = AAssetManager_fromJava(env, amgr);
if (!_assetManager) return -1;
return 0;
}
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);
}
