// Display the android virtual keyboard.
static void displayKeyboard(android_app* state, bool show)
{ 
    // The following functions is supposed to show / hide functins from a native activity.. but currently do not work. 
    // ANativeActivity_showSoftInput(state->activity, ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT);
    // ANativeActivity_hideSoftInput(state->activity, ANATIVEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY);
    
    // Show or hide the keyboard by calling the appropriate Java method through JNI instead.
    jint result;
    jint flags = 0;
    JavaVM* jvm = state->activity->vm;
    JNIEnv* env;
    jvm->GetEnv((void **)&env, JNI_VERSION_1_6);
    jvm->AttachCurrentThread(&env, NULL);
    if (result == JNI_ERR)
    { 
        return; 
    } 
    // Retrieves NativeActivity. 
    jobject lNativeActivity = state->activity->clazz;
    jclass ClassNativeActivity = env->GetObjectClass(lNativeActivity);

    // Retrieves Context.INPUT_METHOD_SERVICE.
    jclass ClassContext = env->FindClass("android/content/Context");
    jfieldID FieldINPUT_METHOD_SERVICE = env->GetStaticFieldID(ClassContext, "INPUT_METHOD_SERVICE", "Ljava/lang/String;");
    jobject INPUT_METHOD_SERVICE = env->GetStaticObjectField(ClassContext, FieldINPUT_METHOD_SERVICE);
    
    // Runs getSystemService(Context.INPUT_METHOD_SERVICE).
    jclass ClassInputMethodManager = env->FindClass("android/view/inputmethod/InputMethodManager");
    jmethodID MethodGetSystemService = env->GetMethodID(ClassNativeActivity, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
    jobject lInputMethodManager = env->CallObjectMethod(lNativeActivity, MethodGetSystemService, INPUT_METHOD_SERVICE);
    
    // Runs getWindow().getDecorView().
    jmethodID MethodGetWindow = env->GetMethodID(ClassNativeActivity, "getWindow", "()Landroid/view/Window;");
    jobject lWindow = env->CallObjectMethod(lNativeActivity, MethodGetWindow);
    jclass ClassWindow = env->FindClass("android/view/Window");
    jmethodID MethodGetDecorView = env->GetMethodID(ClassWindow, "getDecorView", "()Landroid/view/View;");
    jobject lDecorView = env->CallObjectMethod(lWindow, MethodGetDecorView);
    if (show)
    {
        // Runs lInputMethodManager.showSoftInput(...).
        jmethodID MethodShowSoftInput = env->GetMethodID( ClassInputMethodManager, "showSoftInput", "(Landroid/view/View;I)Z");
        jboolean result = env->CallBooleanMethod(lInputMethodManager, MethodShowSoftInput, lDecorView, flags); 
    } 
    else 
    { 
        // Runs lWindow.getViewToken() 
        jclass ClassView = env->FindClass("android/view/View");
        jmethodID MethodGetWindowToken = env->GetMethodID(ClassView, "getWindowToken", "()Landroid/os/IBinder;");
        jobject lBinder = env->CallObjectMethod(lDecorView, MethodGetWindowToken); 
        
        // lInputMethodManager.hideSoftInput(...). 
        jmethodID MethodHideSoftInput = env->GetMethodID(ClassInputMethodManager, "hideSoftInputFromWindow", "(Landroid/os/IBinder;I)Z"); 
        jboolean lRes = env->CallBooleanMethod( lInputMethodManager, MethodHideSoftInput, lBinder, flags); 
    }
    
    // Finished with the JVM.
    jvm->DetachCurrentThread(); 
}
Example #2
0
void JniManager::toProcessRequest(jobject obj, MonoObject* processRequest)
{
    JNIEnv* env = getEnv();

    MonoDomain* monoDomain = getMonoDomain();

    string c_assemblyName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyName, "()Ljava/lang/String;"));
    string c_assemblyPath = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyPath, "()Ljava/lang/String;"));
    string c_methodName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getMethodName, "()Ljava/lang/String;"));

    MonoString* assemblyName = mono_string_new(monoDomain, c_assemblyName.c_str());
    MonoString* assemblyPath = mono_string_new(monoDomain, c_assemblyPath.c_str());
    MonoString* methodName = mono_string_new(monoDomain, c_methodName.c_str());
    bool fullTrust = env->CallBooleanMethod(obj, getFullTrust);
    bool isSingleton = env->CallBooleanMethod(obj, getIsSingleton);
    bool log = env->CallBooleanMethod(obj, getLog);
    bool notifyEvents = env->CallBooleanMethod(obj, getNotifyEvents);

    MonoObject* exception = NULL;

    void* args[1];
    args[0] = assemblyName;
    mono_runtime_invoke(setAssemblyNameField, processRequest, args, &exception);

    args[0] = assemblyPath;
    mono_runtime_invoke(setAssemblyPathField, processRequest, args, &exception);

    args[0] = methodName;
    mono_runtime_invoke(setMethodNameField, processRequest, args, &exception);

    args[0] = &fullTrust;
    mono_runtime_invoke(setFullTrustField, processRequest, args, &exception);

    args[0] = &log;
    mono_runtime_invoke(setLogField, processRequest, args, &exception);

    args[0] = &isSingleton;
    mono_runtime_invoke(setIsSingletonField, processRequest, args, &exception);

    args[0] = &notifyEvents;
    mono_runtime_invoke(setNotifyEventsField, processRequest, args, &exception);

    if (exception)
    {
        const char* message = mono_string_to_utf8(mono_object_to_string(exception, NULL));
        throwException(message);
    }

    jobject javaMethodArguments = env->CallObjectMethod(obj, getMethodArguments);

    setProperties(env, javaMethodArguments, addMethodArgumentsProperty, processRequest);
    //request->MethodArguments = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getMethodArguments));
    //request->InboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInboundProperties));
    //request->InvocationProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInvocationProperties));
    //request->OutboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getOutboundProperties));
    //request->SessionProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getSessionProperties));
}
Example #3
0
bool Jipopt::get_list_of_nonlinear_variables(Index num_nonlin_vars,Index* pos_nonlin_vars)
{
   if( using_LBFGS )
   {
      jintArray pos_nonlin_vars_j = env->NewIntArray(num_nonlin_vars);

      if( !env->CallBooleanMethod(solver, get_list_of_nonlinear_variables_, num_nonlin_vars, pos_nonlin_vars_j) )
         return false;

      if( pos_nonlin_vars != NULL )
      {
         if( sizeof(jint) == sizeof(Index) )
         {
            env->GetIntArrayRegion(pos_nonlin_vars_j, 0, num_nonlin_vars, reinterpret_cast<jint*>(pos_nonlin_vars));
         }
         else
         {
            jint* tmp = new int[num_nonlin_vars];

            env->GetIntArrayRegion(pos_nonlin_vars_j, 0, num_nonlin_vars, tmp);
            for( int i = 0; i < num_nonlin_vars; ++i )
               pos_nonlin_vars[i] = (Index)tmp[i];

            delete[] tmp;
         }
      }

      return true;
   }

   return false;
}
Example #4
0
bool Jipopt::get_starting_point(Index n, bool init_x, Number* x,
   bool init_z, Number* z_L, Number* z_U,
   Index m, bool init_lambda, Number* lambda)
{
   jdoubleArray xj      = this->xj;
   jdoubleArray z_lj    = this->mult_x_Lj;
   jdoubleArray z_uj    = this->mult_x_Uj;
   jdoubleArray lambdaj = this->mult_gj;

   if( !env->CallBooleanMethod(solver, get_starting_point_, n, init_x, xj, init_z, z_lj, z_uj, m, init_lambda, lambdaj) )
      return false;

   /* Copy from Java to native value */
   if( init_x )
      env->GetDoubleArrayRegion(xj, 0, n, x);

   if( init_z )
   {
      env->GetDoubleArrayRegion(z_lj, 0, n, z_L);
      env->GetDoubleArrayRegion(z_uj, 0, n, z_U);
   }

   if( init_lambda )
      env->GetDoubleArrayRegion(lambdaj, 0, m, lambda);

   return true;
}
Example #5
0
bool Jipopt::get_bounds_info(Index n, Number *x_l, Number *x_u, Index m, Number *g_l, Number *g_u)
{
   jdoubleArray x_lj = NULL;
   jdoubleArray x_uj = NULL;
   jdoubleArray g_lj = NULL;
   jdoubleArray g_uj = NULL;

   assert(x_l != NULL);
   assert(x_u != NULL);
   assert(g_l != NULL);
   assert(g_u != NULL);

   x_lj = env->NewDoubleArray(n);
   x_uj = env->NewDoubleArray(n);
   g_lj = env->NewDoubleArray(m);
   g_uj = env->NewDoubleArray(m);

   if( !env->CallBooleanMethod(solver, get_bounds_info_, n, x_lj, x_uj, m, g_lj, g_uj) )
      return false;

   // Copy from Java to native value
   env->GetDoubleArrayRegion(x_lj, 0, n, x_l);
   env->GetDoubleArrayRegion(x_uj, 0, n, x_u);
   env->GetDoubleArrayRegion(g_lj, 0, m, g_l);
   env->GetDoubleArrayRegion(g_uj, 0, m, g_u);

   return true;
}
//------------------------------------------------------------
ofLoopType ofxAndroidVideoPlayer::getLoopState() const {

	if(!javaVideoPlayer){
		ofLogError("ofxAndroidVideoPlayer") << "getLoopState(): java VideoPlayer not loaded";
		return OF_LOOP_NONE;
	}
	JNIEnv *env = ofGetJNIEnv();
	if (!env) {
		ofLogError("ofxAndroidVideoPlayer") << "getLoopState(): couldn't get environment using GetEnv()";
		return OF_LOOP_NONE;
	}

	jmethodID javaGetLoopStateMethod = env->GetMethodID(javaClass,"getLoopState","()Z");
	if(!javaGetLoopStateMethod){
		ofLogError("ofxAndroidVideoPlayer") << "getLoopState(): couldn't get java GetLoopState for VideoPlayer";
		return OF_LOOP_NONE;
	}

	bool loopState = env->CallBooleanMethod(javaVideoPlayer,javaGetLoopStateMethod);

	if (loopState) {
		return OF_LOOP_NORMAL;
	} else {
		return OF_LOOP_NONE;
	}

};
Example #7
0
bool JSFunction::HasInstanceCallback(JSContextRef ctx, JSObjectRef constructor,
        JSValueRef possibleInstance, JSValueRef* exception)
{
    JNIEnv *env;
    int getEnvStat = jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
    if (getEnvStat == JNI_EDETACHED) {
        jvm->AttachCurrentThread(&env, NULL);
    }
    jclass cls = env->GetObjectClass(thiz);
    jmethodID mid;
    do {
        mid = env->GetMethodID(cls,"hasInstanceCallback","(JJJJ)Z");
        if (!env->ExceptionCheck()) break;
        env->ExceptionClear();
        jclass super = env->GetSuperclass(cls);
        env->DeleteLocalRef(cls);
        if (super == NULL || env->ExceptionCheck()) {
            if (super != NULL) env->DeleteLocalRef(super);
            jvm->DetachCurrentThread();
            return NULL;
        }
        cls = super;
    } while (true);
    env->DeleteLocalRef(cls);

    bool ret = env->CallBooleanMethod(thiz, mid, (jlong)ctx, (jlong)constructor,
            (jlong)possibleInstance, (jlong)exception);

    if (getEnvStat == JNI_EDETACHED) {
        jvm->DetachCurrentThread();
    }
    return ret;
}
Example #8
0
bool HDFSAccessor::copy(char* srcPath, char* destPath)
{
    bool isNewEnv = false;
    JNIEnv* env = JVMState::instance()->getEnv(&isNewEnv);
    if (m_wfxPairObj != NULL)
    {
        jstring srcPathStr = env->NewStringUTF(srcPath);
        jstring destPathStr = env->NewStringUTF(destPath);
        jboolean retVal = env->CallBooleanMethod(m_wfxPairObj, s_WfxPairMetIdCopyPath, srcPathStr, destPathStr);
        if (!JVMState::instance()->exceptionExists(env))
        {
            env->DeleteLocalRef(srcPathStr);
            env->DeleteLocalRef(destPathStr);
            if (isNewEnv)
            {
                JVMState::instance()->releaseEnv();
            }
            return retVal == JNI_TRUE;
        } else
        {
            env->DeleteLocalRef(srcPathStr);
            env->DeleteLocalRef(destPathStr);
        }

    }
    if (isNewEnv)
    {
        JVMState::instance()->releaseEnv();
    }
    return false;
}
Example #9
0
bool HDFSAccessor::mkdir(char* path)
{
    bool isNewEnv = false;
    JNIEnv* env = JVMState::instance()->getEnv(&isNewEnv);
    if (m_wfxPairObj != NULL)
    {
        jstring pathStr = env->NewStringUTF(path);
        jboolean retVal = env->CallBooleanMethod(m_wfxPairObj, s_WfxPairMetIdMkDir, pathStr);
        if (!JVMState::instance()->exceptionExists(env))
        {
            env->DeleteLocalRef(pathStr);
            if (isNewEnv)
            {
                JVMState::instance()->releaseEnv();
            }
            return retVal == JNI_TRUE;
        } else
        {
            env->DeleteLocalRef(pathStr);
        }
    }
    if (isNewEnv)
    {
        JVMState::instance()->releaseEnv();
    }
    return false;
}
bool IsDirectory(const tstring& sPath)
{
	// Check first to see if it's in the assets folder.
	JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
	jobject activity = (jobject)SDL_AndroidGetActivity();
	jclass activity_class = env->GetObjectClass(activity);
	jmethodID activity_class_assetIsDirectory = env->GetMethodID(activity_class, "assetIsDirectory", "(Ljava/lang/String;)Z");

	jstring assetIsDirectory_sFile = env->NewStringUTF(sPath.c_str());
	jboolean assetIsDirectory_result = env->CallBooleanMethod(activity, activity_class_assetIsDirectory, assetIsDirectory_sFile); // activity.assetIsDirectory(file);
	bool bIsDirectory = assetIsDirectory_result;
	env->DeleteLocalRef(assetIsDirectory_sFile);

	if (bIsDirectory)
		return true;

	struct stat stFileInfo;
	bool blnReturn;
	int intStat;

	// Attempt to get the file attributes
	intStat = stat(sPath.c_str(), &stFileInfo);
	if(intStat == 0 && S_ISDIR(stFileInfo.st_mode))
		return true;
	else
		return false;
}
Example #11
0
bool Billing_IsProductPurchased(const char* sku) {
    JNIEnv* env = getEnv();
    jclass k = env->GetObjectClass(jBilling);
    jmethodID m = env->GetMethodID(k, "isProductPurchased", "(Ljava/lang/String;)Z");
    jstring jSku = env->NewStringUTF(sku);
    return env->CallBooleanMethod(jBilling, m, jSku);
}
Example #12
0
 int32_t
 JNIHelper :: isInterrupted()
 {
   JNIEnv * env = this->getEnv();
   if (!env)
     return 0;
   if (env->ExceptionCheck())
     return 1; // a pending exception interrupts us
   if (!mThread_class ||
       !mThread_isInterrupted_mid ||
       !mThread_currentThread_mid)
     // this is an error if these are not set up, but we're
     // going to assume no interrupt then.
     return 0;
   
   jclass cls = static_cast<jclass>(env->NewLocalRef(mThread_class));
   if (!cls)
     return 0;
   
   jobject thread = env->CallStaticObjectMethod(
       cls,
       mThread_currentThread_mid);
   env->DeleteLocalRef(cls);
   if (!thread || env->ExceptionCheck())
     return 1;
   jboolean result = env->CallBooleanMethod(thread,
       mThread_isInterrupted_mid);
   env->DeleteLocalRef(thread);
   if (env->ExceptionCheck())
     result = true;
   if (result != JNI_FALSE)
     return 1;
   return 0; 
 }
ushort s3eNOFhasUserApprovedFeint_platform()
{
    JNIEnv* env = s3eEdkJNIGetEnv();
    //    env->CallVoidMethod(g_Obj, g_s3eNOFhasUserApprovedFeint);
    return env->CallBooleanMethod(g_Obj, g_s3eNOFhasUserApprovedFeint);
    //return S3E_RESULT_SUCCESS;
}
svn_boolean_t
OperationContext::checkTunnel(void *tunnel_baton, const char *tunnel_name)
{
  JNIEnv *env = JNIUtil::getEnv();

  jstring jtunnel_name = JNIUtil::makeJString(tunnel_name);
  if (JNIUtil::isJavaExceptionThrown())
    return false;

  static jmethodID mid = 0;
  if (0 == mid)
    {
      jclass cls = env->FindClass(JAVAHL_CLASS("/callback/TunnelAgent"));
      if (JNIUtil::isJavaExceptionThrown())
        return false;
      mid = env->GetMethodID(cls, "checkTunnel",
                             "(Ljava/lang/String;)Z");
        if (JNIUtil::isJavaExceptionThrown())
          return false;
    }

  jobject jtunnelcb = jobject(tunnel_baton);
  jboolean check = env->CallBooleanMethod(jtunnelcb, mid, jtunnel_name);
  if (JNIUtil::isJavaExceptionThrown())
    return false;

  return svn_boolean_t(check);
}
static bool invoke_javaCallback(int msgType, const char* msgName)
{
    jstring msg_name = NULL;
    UnionJNIEnvToVoid uenv;
    uenv.venv = NULL;
    JNIEnv* env = NULL;
    bool detach = false;
    if (mJvm->GetEnv(&uenv.venv, JNI_VERSION_1_4) != JNI_OK)
    {
        if (mJvm->AttachCurrentThread(&env, NULL) != JNI_OK)
        {
           LOGE("callback_handler: failed to attach current thread\n");
           return false;
        }
        detach = true;
    } else { 
        env = uenv.env;
    }    
    msg_name = env->NewStringUTF(msgName);
    bool result = env->CallBooleanMethod(mjavaApp, method_javaCallback, msgType, msg_name);
    env->DeleteLocalRef(msg_name);
    if (detach)
    {
        if (mJvm->DetachCurrentThread() != JNI_OK)
        {
            LOGE("callback_handler: failed to detach current thread\n");
        }
    }
    return result;
}
	bool OuyaInputView::javaDispatchKeyEvent(long long downTime, long long eventTime, int action, int code,
		int repeat, int metaState, int deviceId, int scancode, int flags, int source)
	{
		JNIEnv* env;
		if (_jvm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK) {
			__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "Failed to get JNI environment!");
			return false;
		}

		if (!env)
		{
			__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "JNI must be initialized with a valid environment!");
			return false;
		}

		if (!_instance)
		{
			__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "_instance is not valid!");
			return false;
		}

		if (!_jmJavaDispatchKeyEvent)
		{
			__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "_jmJavaDispatchKeyEvent is not valid!");
			return false;
		}

		return env->CallBooleanMethod(_instance, _jmJavaDispatchKeyEvent,
			downTime, eventTime, action, code,
			repeat, metaState, deviceId, scancode, flags, source);
	}
/*
 * call back to java to
 * protect fd so that the socket can access internet
 */
int protectFd(int sockfd) {
    JNIEnv *jnienv;
    jnijvm->GetEnv((void **)&jnienv, JNI_VERSION_1_6);
    jclass cls = jnienv->GetObjectClass(jniobj);
    jmethodID protecdMid = jnienv->GetMethodID(cls, "protect", "(I)Z");
    return  jnienv->CallBooleanMethod(jniobj, protecdMid, sockfd);
}
Example #18
0
bool HDFSAccessor::rename(char* oldPath, char* newPath)
{
    bool isNewEnv = false;
    JNIEnv* env = JVMState::instance()->getEnv(&isNewEnv);
    if (m_wfxPairObj != NULL)
    {
        jstring oldPathStr = env->NewStringUTF(oldPath);
        jstring newPathStr = env->NewStringUTF(newPath);
        jboolean retVal = env->CallBooleanMethod(m_wfxPairObj, s_WfxPairMetIdRenPath, oldPathStr, newPathStr);
        if (!JVMState::instance()->exceptionExists(env))
        {
            env->DeleteLocalRef(oldPathStr);
            env->DeleteLocalRef(newPathStr);
            if (isNewEnv)
            {
                JVMState::instance()->releaseEnv();
            }
            return retVal == JNI_TRUE;
        } else
        {
            env->DeleteLocalRef(oldPathStr);
            env->DeleteLocalRef(newPathStr);
        }

    }
    if (isNewEnv)
    {
        JVMState::instance()->releaseEnv();
    }
    return false;
}
//---------------------------------------------------------------------------
void ofxAndroidVideoPlayer::update(){

	JNIEnv *env = ofGetJNIEnv();
	jmethodID javaUpdate = env->GetMethodID(javaClass,"update","()Z");
	if(!javaUpdate){
		ofLogError("ofxAndroidVideoPlayer") << "update(): couldn't get java update for VideoPlayer";
		return;
	}
	bIsFrameNew = env->CallBooleanMethod(javaVideoPlayer,javaUpdate);

	jmethodID javaGetTextureMatrix = env->GetMethodID(javaClass,"getTextureMatrix","([F)V");
	if(!javaGetTextureMatrix){
		ofLogError("ofxAndroidVideoPlayer") << "update(): couldn't get java javaGetTextureMatrix for VideoPlayer";
		return;
	}
	env->CallVoidMethod(javaVideoPlayer,javaGetTextureMatrix,matrixJava);
	jfloat * m = env->GetFloatArrayElements(matrixJava,0);

	ofMatrix4x4 textureMatrix(m);

	ofMatrix4x4 vFlipTextureMatrix;
	vFlipTextureMatrix.scale(1,-1,1);
	vFlipTextureMatrix.translate(0,1,0);
	texture.setTextureMatrix(vFlipTextureMatrix * textureMatrix);
	//texture.getTextureData().tex_t = 1.+1-matrix.getPtr()[0]; // Hack!
	//texture.getTextureData().tex_u = 1.;

	env->ReleaseFloatArrayElements(matrixJava,m,0);

}
Example #20
0
bool HDFSAccessor::hdfsPathExist(char* remotePath)
{
    bool retVal = false;
    bool isNewEnv = false;
    JNIEnv* env = JVMState::instance()->getEnv(&isNewEnv);
    if (m_wfxPairObj != NULL)
    {
        jstring remotePathStr = env->NewStringUTF(remotePath);
        jboolean fileExists = env->CallBooleanMethod(m_wfxPairObj, s_WfxPairMetIdfileExists, remotePathStr);
        if (!JVMState::instance()->exceptionExists(env))
        {
            retVal = fileExists;
            env->DeleteLocalRef(remotePathStr);
            if (isNewEnv)
            {
                JVMState::instance()->releaseEnv();
            }
        } else
        {
            env->DeleteLocalRef(remotePathStr);
        }
    }
    return retVal;

}
static int release_wake_lock_callout(const char *lock_name) {
    JNIEnv *env;
    JavaVM *vm = AndroidRuntime::getJavaVM();
    jint status = vm->GetEnv((void **)&env, JNI_VERSION_1_6);

    if (status != JNI_OK && status != JNI_EDETACHED) {
        ALOGE("%s unable to get environment for JNI call", __func__);
        return BT_STATUS_FAIL;
    }

    if (status == JNI_EDETACHED && vm->AttachCurrentThread(&env, &sAttachArgs) != 0) {
        ALOGE("%s unable to attach thread to VM", __func__);
        return BT_STATUS_FAIL;
    }

    jboolean ret = JNI_FALSE;
    jstring lock_name_jni = env->NewStringUTF(lock_name);
    if (lock_name_jni) {
        ret = env->CallBooleanMethod(sJniAdapterServiceObj, method_releaseWakeLock, lock_name_jni);
        env->DeleteLocalRef(lock_name_jni);
    } else {
        ALOGE("%s unable to allocate string: %s", __func__, lock_name);
    }

    if (status == JNI_EDETACHED) {
        vm->DetachCurrentThread();
    }

    return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
Example #22
0
	void get_row(std::vector<std::string>& row) {
		jint i;
	
		row.clear();
		char str_value[32];

		jboolean flag = env->CallBooleanMethod(instances, jMID_Enumeration_hasMoreElements);

		if( flag ) {
			jobject instance = env->CallObjectMethod(instances, jMID_Enumeration_nextElement);
			jint d = env->CallIntMethod(instance, jMID_WekaInstance_numAttributes);

			jdouble value;
			jboolean iscopy;

			for(i = 0; i < d; i++) {
				value = env->CallDoubleMethod(instance, jMID_WekaInstance_value, i);

				sprintf(str_value, "%g", (double) value);
				row.push_back(std::string(str_value));

				// row push_back classIndex
			}
		}

		return;
	}
void JNIScheduler::resourceOffers(SchedulerDriver* driver,
                                  const vector<Offer>& offers)
{
    jvm->AttachCurrentThread(JNIENV_CAST(&env), NULL);

    jclass clazz = env->GetObjectClass(jdriver);

    jfieldID scheduler = env->GetFieldID(clazz, "scheduler", "Lorg/apache/mesos/Scheduler;");
    jobject jscheduler = env->GetObjectField(jdriver, scheduler);

    clazz = env->GetObjectClass(jscheduler);

    // scheduler.resourceOffers(driver, offers);
    jmethodID resourceOffers =
        env->GetMethodID(clazz, "resourceOffers",
                         "(Lorg/apache/mesos/SchedulerDriver;"
                         "Ljava/util/List;)V");

    // List offers = new ArrayList();
    clazz = env->FindClass("java/util/ArrayList");

    jmethodID _init_ = env->GetMethodID(clazz, "<init>", "()V");
    jobject joffers = env->NewObject(clazz, _init_);

    jmethodID add = env->GetMethodID(clazz, "add", "(Ljava/lang/Object;)Z");

    // Loop through C++ vector and add each offer to the Java list.
    foreach (const Offer& offer, offers) {
        jobject joffer = convert<Offer>(env, offer);
        env->CallBooleanMethod(joffers, add, joffer);
    }
static bool set_wake_alarm_callout(uint64_t delay_millis, bool should_wake, alarm_cb cb, void *data) {
    JNIEnv *env;
    JavaVM *vm = AndroidRuntime::getJavaVM();
    jint status = vm->GetEnv((void **)&env, JNI_VERSION_1_6);

    if (status != JNI_OK && status != JNI_EDETACHED) {
        ALOGE("%s unable to get environment for JNI call", __func__);
        return false;
    }

    if (status == JNI_EDETACHED && vm->AttachCurrentThread(&env, &sAttachArgs) != 0) {
        ALOGE("%s unable to attach thread to VM", __func__);
        return false;
    }

    sAlarmCallback = cb;
    sAlarmCallbackData = data;

    jboolean jshould_wake = should_wake ? JNI_TRUE : JNI_FALSE;
    jboolean ret = env->CallBooleanMethod(sJniAdapterServiceObj, method_setWakeAlarm, (jlong)delay_millis, jshould_wake);
    if (!ret) {
        sAlarmCallback = NULL;
        sAlarmCallbackData = NULL;
    }

    if (status == JNI_EDETACHED) {
        vm->DetachCurrentThread();
    }

    return !!ret;
}
Example #25
0
bool textbox_get_visible(int id) {
	native_shim* shim = get_native_shim();
	JNIEnv *env = shim->env;

	jmethodID method = env->GetMethodID(shim->type, "getTextBoxVisible", "(I)Z");
	return env->CallBooleanMethod(shim->instance, method, id) == JNI_TRUE;
}
std::shared_ptr<std::map<std::string, std::string> > PluginJniHelper::JSONObject2Map(jobject json)
{
	auto stdmap = std::make_shared<std::map<std::string, std::string> >();
	JNIEnv* env = getEnv();
	jclass c_json = env->FindClass("org/json/JSONObject");
	jclass c_iterator = env->FindClass("java/util/Iterator");
	jmethodID m_keys = env->GetMethodID(c_json, "keys", "()Ljava/util/Iterator;");
	jmethodID m_hasNext = env->GetMethodID(c_iterator, "hasNext", "()Z");
	jmethodID m_next = env->GetMethodID(c_iterator, "next", "()Ljava/lang/Object;");
	jmethodID m_getString = env->GetMethodID(c_json, "getString", "(Ljava/lang/String;)Ljava/lang/String;");
	jstring jKeyString = NULL;
	jstring jValueString = NULL;
	jobject jKeys = env->CallObjectMethod(json, m_keys);
	
	while(env->CallBooleanMethod(jKeys, m_hasNext))
	{
		jKeyString = (jstring)(env->CallObjectMethod(jKeys, m_next));
		jValueString = (jstring)(env-> CallObjectMethod(json, m_getString, jKeyString));

		stdmap->insert(std::make_pair(jstring2string(jKeyString), jstring2string(jValueString)));
	}

	env->DeleteLocalRef(jKeys);
	if(jKeyString)
		env->DeleteLocalRef(jKeyString);
	if(jValueString)
		env->DeleteLocalRef(jValueString);
	env->DeleteLocalRef(c_json);
	env->DeleteLocalRef(c_iterator);

	return stdmap;
}
Example #27
0
 virtual bool ShouldCollide(b2Fixture* fixtureA, b2Fixture* fixtureB)
 {
     if( shouldCollideID != 0 )
         return env->CallBooleanMethod( obj, shouldCollideID, (jlong)fixtureA, (jlong)fixtureB );
     else
         return true;
 }
    virtual status_t onTransact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0)
    {
        JNIEnv* env = javavm_to_jnienv(mVM);
	if (NULL == env)
	{
		ALOGE("onTransact() on %p calling object %p fail because env=NULL vm=%p \n", this, mObject, mVM);
		return -EPIPE;
	}

        ALOGV("onTransact() on %p calling object %p in env %p vm %p\n", this, mObject, env, mVM);

        IPCThreadState* thread_state = IPCThreadState::self();
        const int32_t strict_policy_before = thread_state->getStrictModePolicy();

        //printf("Transact from %p to Java code sending: ", this);
        //data.print();
        //printf("\n");
        jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact,
            code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags);
        jthrowable excep = env->ExceptionOccurred();

        if (excep) {
            report_exception(env, excep,
                "*** Uncaught remote exception!  "
                "(Exceptions are not yet supported across processes.)");
            res = JNI_FALSE;

            /* clean up JNI local ref -- we don't return to Java code */
            env->DeleteLocalRef(excep);
        }

        // Check if the strict mode state changed while processing the
        // call.  The Binder state will be restored by the underlying
        // Binder system in IPCThreadState, however we need to take care
        // of the parallel Java state as well.
        if (thread_state->getStrictModePolicy() != strict_policy_before) {
            set_dalvik_blockguard_policy(env, strict_policy_before);
        }

        jthrowable excep2 = env->ExceptionOccurred();
        if (excep2) {
            report_exception(env, excep2,
                "*** Uncaught exception in onBinderStrictModePolicyChange");
            /* clean up JNI local ref -- we don't return to Java code */
            env->DeleteLocalRef(excep2);
        }

        // Need to always call through the native implementation of
        // SYSPROPS_TRANSACTION.
        if (code == SYSPROPS_TRANSACTION) {
            BBinder::onTransact(code, data, reply, flags);
        }

        //aout << "onTransact to Java code; result=" << res << endl
        //    << "Transact from " << this << " to Java code returning "
        //    << reply << ": " << *reply << endl;
        return res != JNI_FALSE ? NO_ERROR : UNKNOWN_TRANSACTION;
    }
    virtual status_t onTransact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0)
    {
        JNIEnv* env = javavm_to_jnienv(mVM);

        ALOGV("onTransact() on %p calling object %p in env %p vm %p\n", this, mObject, env, mVM);

        IPCThreadState* thread_state = IPCThreadState::self();
        const int strict_policy_before = thread_state->getStrictModePolicy();
        thread_state->setLastTransactionBinderFlags(flags);

        //printf("Transact from %p to Java code sending: ", this);
        //data.print();
        //printf("\n");
        jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact,
            code, (int32_t)&data, (int32_t)reply, flags);
        jthrowable excep = env->ExceptionOccurred();

        if (excep) {
            report_exception(env, excep,
                "*** Uncaught remote exception!  "
                "(Exceptions are not yet supported across processes.)");
            res = JNI_FALSE;

            /* clean up JNI local ref -- we don't return to Java code */
            env->DeleteLocalRef(excep);
        }

        // Restore the Java binder thread's state if it changed while
        // processing a call (as it would if the Parcel's header had a
        // new policy mask and Parcel.enforceInterface() changed
        // it...)
        const int strict_policy_after = thread_state->getStrictModePolicy();
        if (strict_policy_after != strict_policy_before) {
            // Our thread-local...
            thread_state->setStrictModePolicy(strict_policy_before);
            // And the Java-level thread-local...
            set_dalvik_blockguard_policy(env, strict_policy_before);
        }

        jthrowable excep2 = env->ExceptionOccurred();
        if (excep2) {
            report_exception(env, excep2,
                "*** Uncaught exception in onBinderStrictModePolicyChange");
            /* clean up JNI local ref -- we don't return to Java code */
            env->DeleteLocalRef(excep2);
        }

        // Need to always call through the native implementation of
        // SYSPROPS_TRANSACTION.
        if (code == SYSPROPS_TRANSACTION) {
            BBinder::onTransact(code, data, reply, flags);
        }

        //aout << "onTransact to Java code; result=" << res << endl
        //    << "Transact from " << this << " to Java code returning "
        //    << reply << ": " << *reply << endl;
        return res != JNI_FALSE ? NO_ERROR : UNKNOWN_TRANSACTION;
    }
tvector<tstring> ListAndroidAssetsDirectory(const tstring& sDirectory, bool bDirectories)
{
	JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
	jobject activity = (jobject)SDL_AndroidGetActivity();

	jclass activity_class = env->GetObjectClass(activity);
	jmethodID activity_class_assetOpenDir = env->GetMethodID(activity_class, "assetOpenDir", "(Ljava/lang/String;)Z");
	jstring assetOpenDir_sDirectory = env->NewStringUTF(sDirectory.c_str());
	jboolean assetOpenDir_success = env->CallBooleanMethod(activity, activity_class_assetOpenDir, assetOpenDir_sDirectory); // activity.assetOpenDir(sDirectory);
	env->DeleteLocalRef(assetOpenDir_sDirectory);

	if (!assetOpenDir_success)
		return tvector<tstring>();

	tvector<tstring> asResult;
	const char* pszDir;

	jmethodID activity_class_assetGetNext = env->GetMethodID(activity_class, "assetGetNext", "()Ljava/lang/String;");
	jmethodID activity_class_assetIsDirectory = env->GetMethodID(activity_class, "assetIsDirectory", "(Ljava/lang/String;)Z");

	jstring dir;

	while ((dir = (jstring)env->CallObjectMethod(activity, activity_class_assetGetNext)) != NULL)
	{
		const char* pszDir = env->GetStringUTFChars(dir, nullptr);
		tstring sDir = pszDir;
		env->ReleaseStringUTFChars(dir, pszDir);

		tstring sFullDir = sDirectory + "/" + sDir;

		if (!bDirectories)
		{
			jstring assetIsDirectory_sFile = env->NewStringUTF(sFullDir.c_str());
			jboolean assetIsDirectory_result = env->CallBooleanMethod(activity, activity_class_assetIsDirectory, assetIsDirectory_sFile); // activity.assetIsDirectory(file);
			bool bIsDirectory = assetIsDirectory_result;
			env->DeleteLocalRef(assetIsDirectory_sFile);

			if (bIsDirectory)
				continue;
		}

		asResult.push_back(sDir);
	}

	return asResult;
}