JVM_NATIVE

最新推荐文章于 2023-08-16 14:55:31 发布
最新推荐文章于 2023-08-16 14:55:31 发布
阅读量344 收藏
点赞数
分类专栏： android 文章标签： jni
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiafangxingg/article/details/70598616
版权

jvm 调用native方法，供java访问本地方法。需要java层提供本地方法声明，在通过jvm中运行的jni运行环境对相应的本地声明方法进行注册，以达到native方法和java交互。
example:

#include "JNIHelp.h"
#include "jni.h"
#include "init.h"
#include "callback_interface.h"
#define LOG_NDEBUG 0
#endif
#include "utils/Log.h"
#include "android_runtime/AndroidRuntime.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "can_protocol.h"

namespace android{
    static jobject gObject = NULL;
    static JNIEnv *sCallbackEnv = NULL;
    static JavaVM *g_jvm = NULL;
    //
    static jmethodID method_temperature_change_callback;
    static jmethodID method_wind_force_change_callback;
    static jmethodID method_wind_direction_change_callback;
    static jmethodID method_anion_change_callback;
    static jmethodID method_aqs_change_callback;
    static jmethodID method_clear_fog_prev_change_callback;
    static jmethodID method_clear_fog_suf_change_callback;
    static jmethodID method_inner_loop_change_callback;
    static jmethodID method_auto_mode_change_callback;
    static jmethodID method_ac_change_callback;
    static jmethodID method_ac_max_change_callback;
    static jmethodID method_dual_change_callback;
    static jmethodID method_pm25_change_callback;
    static jmethodID method_fan_change_callback;
    static Init init;
    static CallBack cbs;

#define SERVICE_CLASS_NAME ("com/android/server/air/AirService")
    //

    static bool checkCallbackThread(){
        JNIEnv * env = AndroidRuntime::getJNIEnv();
        if(env == NULL || env != sCallbackEnv){
            ALOGE("Callback env check fail: env: %p, callback: %p",env,sCallbackEnv);
            return false;
        }
        return true;
    }
    //
    void checkAndClearExceptionFromCallback(JNIEnv * env,const char* methodName){
        if(env->ExceptionCheck()){
            ALOGE("An exception was thrown by callback '%s'.",methodName);
            //LOGE_EX(env);
            env->ExceptionClear();
        }
    }
    //
    static void temperature_change_callback(int32_t temperature,int32_t type){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("temperature = %d   type=%d \n",temperature,type);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_temperature_change_callback,(jint)temperature,(jint)type);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void wind_force_change_callback(int32_t windForce){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("wind_force = %d  \n",windForce);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_wind_force_change_callback,(jint)windForce);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void wind_direction_change_callback(int32_t windDirection){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("wind_direction = %d  \n",windDirection);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_wind_direction_change_callback,(jint)windDirection);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void anion_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("anion = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_anion_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void aqs_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("aqs = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_aqs_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void clear_fog_prev_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("clear_fog_prev = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_clear_fog_prev_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void clear_fog_suf_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("clear_fog_suf = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_clear_fog_suf_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void inner_loop_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("inner_loop = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_inner_loop_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void auto_mode_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("auto_mode = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_auto_mode_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void ac_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("ac = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_ac_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void ac_max_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("ac_max = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_ac_max_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void dual_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("dual = %d  \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_dual_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void pm25_change_callback(int pm_val,int type){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("pm25 = %d  type=%d \n",pm_val,type);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_pm25_change_callback,(jint)pm_val,(jint)type);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }

    static void fan_change_callback(bool isOn){
        if(g_jvm != NULL && gObject != NULL){
            JNIEnv *pEnv = NULL;
            ALOGV("fan = %d  type=%d \n",isOn);
            g_jvm->AttachCurrentThread(&pEnv,NULL);
            jclass clazz = pEnv->GetObjectClass(gObject);
            (pEnv)->CallVoidMethod(gObject,method_fan_change_callback,(jboolean)isOn);
            g_jvm->DetachCurrentThread();
        }else{
            ALOGE("gObject == NULL %s",__FUNCTION__);
        }
    }
    //
    static void com_aircondition_cleanup(JNIEnv *env){

    }
    //
    static bool com_aircondition_initialize(JNIEnv*env,jobject object){
        ALOGV("%s",__FUNCTION__);
        cbs.setWindForceCallback(wind_force_change_callback);
        cbs.setTemperatureCallback(temperature_change_callback);
        cbs.setWindDirectionCallback(wind_direction_change_callback);
        cbs.setAnionCallback(anion_change_callback);
        cbs.setAqsCallback(aqs_change_callback);
        cbs.setClearFogPrevCallback(clear_fog_prev_change_callback);
        cbs.setClearFogSufCallback(clear_fog_suf_change_callback);
        cbs.setInnerLoopCallback(inner_loop_change_callback);
        cbs.setAutoModeCallback(auto_mode_change_callback);
        cbs.setACCallback(ac_change_callback);
        cbs.setACMaxCallback(ac_max_change_callback);
        cbs.setDualCallback(dual_change_callback);
        cbs.setPm25Callback(pm25_change_callback);
        cbs.setFanCallback(fan_change_callback);
        init.setCallBacks(&cbs);
        //
        env->GetJavaVM(&g_jvm);
        gObject = env->NewGlobalRef(object);
        //
        int ret = 0;
        if((ret = init.start()) != 0){
            ALOGE("%s Failed!\n",__FUNCTION__);
            return false;
        }
        ALOGV("%s success \n",__FUNCTION__);
        return true;
    }
    //
    static void com_aircondition_classInit(JNIEnv* env,jclass clazz){
        ALOGV("%s",__FUNCTION__);
        jclass callbackClass=env->FindClass(SERVICE_CLASS_NAME);
        method_temperature_change_callback = env->GetMethodID(callbackClass,
                "temperatureChangeCallback","(II)V");
        method_wind_force_change_callback = env->GetMethodID(callbackClass,
                "windForceChangeCallback","(I)V");
        method_wind_direction_change_callback = env->GetMethodID(callbackClass,
                "windDirectionChangeCallback","(I)V");
        method_anion_change_callback = env->GetMethodID(callbackClass,
                "anionChangeCallback","(Z)V");
        method_aqs_change_callback = env->GetMethodID(callbackClass,
                "aqsChangeCallback","(Z)V");
        method_clear_fog_prev_change_callback = env->GetMethodID(callbackClass,
                "clearFogPrevChangeCallback","(Z)V");
        method_clear_fog_suf_change_callback = env->GetMethodID(callbackClass,
                "clearFogSufChangeCallback","(Z)V");
        method_inner_loop_change_callback = env->GetMethodID(callbackClass,
                "innerLoopChangeCallback","(Z)V");
        method_auto_mode_change_callback = env->GetMethodID(callbackClass,
                "autoModeChangeCallback","(Z)V");
        method_ac_change_callback = env->GetMethodID(callbackClass,
                "acChangeCallback","(Z)V");
        method_ac_max_change_callback = env->GetMethodID(callbackClass,
                "acMaxChangeCallback","(Z)V");
        method_dual_change_callback = env->GetMethodID(callbackClass,
                "dualChangeCallback","(Z)V");
        method_pm25_change_callback = env->GetMethodID(callbackClass,
                "pm25ChangeCallback","(II)V");
        method_fan_change_callback = env->GetMethodID(callbackClass,
                "fanChangeCallback","(Z)V");

    }
    //
    //设置温度
    //
    static  void setTemperature(JNIEnv* env,jobject object,jint temperature,jint type){
        if(type == DeviceCan::TEMPERATURE_LEFT){
            init.getDeviceCan().setTemperatureLeft(temperature);
        }else if(type == DeviceCan::TEMPERATURE_RIGHT){
            init.getDeviceCan().setTemperatureRight(temperature);
        }else{
            ALOGE("Unknown temperature type!\n");
        }
    }
    //设置风力
    static void setWindForce(JNIEnv*env,jobject object,int windForce){
        init.getDeviceCan().setWindForce(windForce);
    }
    //设置风向
    static void setWindDirection(JNIEnv*env,jobject object,int windDirection){
        init.getDeviceCan().setWindDirection(windDirection);
    }
    //
    static void setClearFogPrev(JNIEnv *env,jobject object,bool isOn){
        init.getDeviceCan().setClearFogPrev(isOn);
    }
    //
    static void setClearFogSuf(JNIEnv *env,jobject object,bool isOn){
        init.getDeviceCan().setClearFogSuf(isOn);
    }
    //
    static void setInnerLoop(JNIEnv *env,jobject object,bool isOn){
        init.getDeviceCan().setInnerLoop(isOn);
    }
    //
    static void setAutoMode(JNIEnv *env,jobject object,bool isOn){
        init.getDeviceCan().setAutoMode(isOn);
    }
    //
    static void setAC(JNIEnv *env,jobject object,bool isOn){
        init.getDeviceCan().setAC(isOn);
    }
    //
    static void setACMax(JNIEnv *env,jobject object,bool isOn){
        init.getDeviceCan().setACMax(isOn);
    }
    //
    static void setDualMode(JNIEnv *env,jobject object,bool isOn){
        init.getDeviceCan().setDual(isOn);
    }
    //
    static void setAnion(JNIEnv*env,jobject object,bool isOn){
        init.getDeviceCan().setAnion(isOn);
    }
    //
    static void setAQS(JNIEnv*env,jobject object,bool isOn){
        init.getDeviceCan().setAqs(isOn);
    }
    //注册
    static JNINativeMethod gMethods[] = {
        { "setTemperatureNative","(II)V",(void*) setTemperature },
        { "setWindForceNative", "(I)V",(void*)setWindForce},
        { "setWindDirectionNative","(I)V",(void*)setWindDirection},
        { "setClearFogPrevNative","(Z)V",(void*)setClearFogPrev},
        { "setClearFogSufNative","(Z)V",(void*)setClearFogSuf},
        { "setInnerLoopNative","(Z)V",(void*)setInnerLoop},
        { "setAutoModeNative","(Z)V",(void*)setAutoMode},
        { "setACNative","(Z)V",(void*)setAC},
        { "setACMaxNative","(Z)V",(void*)setACMax},
        { "setAnionNative","(Z)V",(void*)setAnion},
        { "setAQSNative","(Z)V",(void*)setAQS},
        { "setDualModeNative","(Z)V",(void*)setDualMode},
        { "cleanUpNative","()V", (void*) com_aircondition_cleanup },
        { "initializeNative","()V", (void*) com_aircondition_initialize },
        { "classInitNative","()V", (void*) com_aircondition_classInit }
    };
    //
    int register_com_aircondition(JNIEnv *env){
        return jniRegisterNativeMethods(env,
                SERVICE_CLASS_NAME,
                gMethods,NELEM(gMethods));
    }
}
jint JNI_OnLoad(JavaVM * jvm,void *reserved){
        JNIEnv *env=NULL;
        int status=0;
        ALOGD(" JNI loaded!");
        if(jvm->GetEnv((void**)&env,JNI_VERSION_1_6)){
            ALOGE("Error,JNI Version miss match!");
            return JNI_ERR;
        }
        if((status = android::register_com_aircondition(env)) < 0){
            return JNI_ERR;
        }
        //
        android::sCallbackEnv = env;
        return JNI_VERSION_1_6;

    }

在System.loadLibrary函数时，该函数会找到对应的动态库，调用JNI_OnLoad函数，

下面定义了函数指针

#ifndef com_aircondition_callback_interface_h
#define com_aircondition_callback_interface_h

typedef void (*TEMPERATURE_CB)(int temperature,int type);
typedef void (*WIND_FORCE_CB)(int windForce);
typedef void (*WIND_DIRECT_CB)(int windDirection);
typedef void (*ANION_CB)(bool isOn);
typedef void (*AQS_CB)(bool isOn);
typedef void (*CLEAR_FOG_PREV_CB)(bool isOn);
typedef void (*CLEAR_FOG_SUF_CB)(bool isOn);
typedef void (*INNER_LOOP_CB)(bool isOn);
typedef void (*AUTO_MODE_CB)(bool isOn);
typedef void (*AC_CB)(bool isOn);
typedef void (*AC_MAX_CB)(bool isOn);
typedef void (*DUAL_CB)(bool isOn);
typedef void (*PM25_CB)(int pm_val,int type);
typedef void (*FAN_CB)(bool isOn);

class CallBack{
public:
    TEMPERATURE_CB getTemperatureCallback()const{return temp_cb;}
    void setTemperatureCallback(const TEMPERATURE_CB cb){temp_cb = cb;}
    WIND_FORCE_CB getWindForceCallback()const{return wind_force_cb;}
    void setWindForceCallback(const WIND_FORCE_CB cb){wind_force_cb = cb;}
    WIND_DIRECT_CB getWindDirectionCallback()const{return wind_direct_cb;}
    void setWindDirectionCallback(const WIND_DIRECT_CB cb){wind_direct_cb = cb;}
    ANION_CB getAnionCallback()const{return anion_cb;}
    void setAnionCallback(ANION_CB cb){anion_cb = cb;}
    AQS_CB getAqsCallback()const{return aqs_cb;}
    void setAqsCallback(AQS_CB cb){aqs_cb = cb;}
    CLEAR_FOG_PREV_CB getClearFogPrevCallback(){return clear_fog_prev_cb;}
    void setClearFogPrevCallback(CLEAR_FOG_PREV_CB cb){clear_fog_prev_cb=cb;}
    CLEAR_FOG_SUF_CB getClearFogSufCallback(){return clear_fog_suf_cb;}
    void setClearFogSufCallback(CLEAR_FOG_SUF_CB cb){clear_fog_suf_cb = cb;}
    INNER_LOOP_CB getInnerLoopCallback(){return inner_loop_cb;}
    void setInnerLoopCallback(INNER_LOOP_CB cb){inner_loop_cb = cb;}
    AUTO_MODE_CB getAutoModeCallback(){return auto_mode_cb;}
    void setAutoModeCallback(AUTO_MODE_CB cb){auto_mode_cb = cb;}
    AC_CB getACCallback(){return ac_cb;}
    void setACCallback(AC_CB cb){ac_cb = cb;}
    AC_MAX_CB getACMaxCallback(){return ac_max_cb;}
    void setACMaxCallback(AC_MAX_CB cb){ac_max_cb = cb;}
    DUAL_CB getDualCallback(){return dual_cb;}
    void setDualCallback(DUAL_CB cb){dual_cb = cb;}
    PM25_CB getPm25Callback(){return pm25_cb;}
    void setPm25Callback(PM25_CB cb){pm25_cb = cb;}
    FAN_CB getFanCallback(){return fan_cb;}
    void setFanCallback(FAN_CB cb){fan_cb = cb;}
private:
    TEMPERATURE_CB temp_cb;
    WIND_FORCE_CB wind_force_cb;
    WIND_DIRECT_CB wind_direct_cb;
    ANION_CB anion_cb;
    AQS_CB aqs_cb;
    CLEAR_FOG_PREV_CB clear_fog_prev_cb;
    CLEAR_FOG_SUF_CB clear_fog_suf_cb;
    INNER_LOOP_CB inner_loop_cb;
    AUTO_MODE_CB auto_mode_cb;
    AC_CB ac_cb;
    AC_MAX_CB ac_max_cb;
    DUAL_CB dual_cb;
    PM25_CB pm25_cb;
    FAN_CB fan_cb;
};
#endif //com_aircondition_callback_interface_h

frameworks/base/core/java/android/app/ContextImpl.java
add:

registerService(AIR_SERVICE, new ServiceFetcher() {
    public Object createService(ContextImpl ctx) {
    IBinder b = ServiceManager.getService(AIR_SERVICE); 
    IAirCondition ac =IAirCondition.Stub.asInterface(b);
    return new AirManager(ac);
}});

获取AirManager直接采用context.getSystemService(AIR_SERVICE);

在frameworks/base/services/java/com/android/server/SystemServer.java

try{
ServiceManager.addService(Context.AIR_SERVICE, new AirService(context));                     }catch(Throwable e){   
}

makefile 中添加 libaircondition_jni

LOCAL_PATH:= $(call my-dir)

# the library
# ============================================================
include $(CLEAR_VARS)

LOCAL_SRC_FILES := \
            $(call all-subdir-java-files) \
        com/android/server/EventLogTags.logtags \
        com/android/server/am/EventLogTags.logtags

LOCAL_MODULE:= services

LOCAL_JAVA_LIBRARIES := android.policy conscrypt telephony-common
LOCAL_REQUIRED_MODULES := libaircondition_jni

include $(BUILD_JAVA_LIBRARY)

include $(BUILD_DROIDDOC)
sdfdagdsfgsdg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk完整源代码(jvm,native,sun)
12-21
jdk完整源代码 sun包源 jvm源 n ative关键字修饰的java方法源 rt.jar nio misc 等等 几乎我们能想到的都包含进来了 sun包不太好找jdk\jdk\src\share\classes路径贴出来 供学习使用
谈谈JVM中Native和方法区的概念
杨荧的CSDN博客
05-22 307
谈谈JVM中Native和方法区的概念
JVM的基础知识点Java的内存模型
天行健，君子以自强不息；地势坤，君子以厚德载物。
08-04 136
阅读文本大概需要3分钟。 Java虚拟机是Java工程师必学的进阶功课，这段时间开始死磕JVM。今天梳理一下JVM的基础知识点Java的内存模型！程序计数器是什么：程序计数器是...
jNI callback
shuaicike的专栏
12-14 562
#include #include #include "tdnmanager.h" #define LOG_TAG "Network" #include "log.h" #include "NetworkCallback.h" #include static const char* const kClassNameNetwork =         "com/apical
Android JNI传递CallBack接口并接收回调
wolf0706的专栏
08-16 731
使用JNI实现将Java接口对象传递给C++代码，并在C++代码中调用接口方法。在Java代码中定义一个CallBack接口和JNI方法。
JVM快速入门(三)——Native，栈内存，堆详解
可达鸭的博客
05-17 1451
Native情景引入 看一段线程代码 public class MyTest { public static void main(String[] args) { Thread t=new Mythread(); t.start(); } } class Mythread extends Thread{ @Override public void run() { for(int i=0;i
【JVM】Native
qq_36525300的博客
02-21 298
从我的上一篇JVM体系结构文章的中可以看出，有三部分，本地方法栈、本地方法库、本地方法接口。这三部分都与”本地“有关系，这一篇文章来一起探讨一下。 Native 首先，我们要先知道 Native 是什么？ Native 在 Java 中是一个关键字，简单来说，Native 主要作用于方法之上，是能让 Java 能调用非 Java 代码的接口。一个 native 方法是指该方法的实现由非 Java...
JVM 学习笔记（1） 类加载器 Native
qq_41935644的博客
02-16 193
类装载器ClassLoader 负责加载class文件，class文件在文件开头有特定的文件标示，将class文件字节码内容加载到内存中，并将这些内容转换成方法区中的运行时数据结构并且ClassLoader只负责class文件的加载，至于它是否可以运行，则由Execution Engine决定。 类加载机制 JVM类加载分为5个过程：加载，验证，准备，解析，初始化，使用，卸载，如下图所示： ...
代码流程分析二：Settings-蓝牙分析-搜索设备原理
lwn
08-12 1874
一：BluetoothSettings中走onResume 二：相当于父类deviceListPreferenceFragment 中走onResume onCreate 三：LocalBluetoothManager类 目的返回BluetoothEventManager 三：BluetoothEventManager
Java native关键字
cumt168的专栏
11-28 2186
 转载自：http://hi.baidu.com/jinliangma/blog/item/cc1e80fa3135ddd9b48f3110.html 一. 什么是Native Method简单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所
jdk,jvm源码
08-24
jvm源码，jvm-native的源码,jvm支行机制,可对jvm的运行过程进行分析 个人网站：https://www.zhangjunbk.com
jvm反汇编插件
04-08
windows下的jvm虚拟机JIT编译代码的反汇编插件以及mac系统下对应的插件
harmonyos2-kotlin-format:Kotlin中JavaString.format()的替代品（JVM、Native、JS）
07-01
的替代品（JVM、Native、JS） 目前没有 String.format() 的原生 Kotlin 模拟。 在 JVM 上，Kotlin 标准库依赖于 Java 实现，因此在为 Native 或 JS 目标构建时不能使用它。 该代码是通过删除所有 Java 依赖项改编而...
korlibs:适用于Kotlin JS + JVM + Native的多平台VideoGame引擎和内聚库
05-05
科里布斯多模块，包括属于korlib的所有库。支持这个项目如果您喜欢这个项目，或者在这里想要您的公司徽标，请考虑 ， 除了确保项目的连续性，您还将获得独家内容。 该存储库仅适用于核心开发人员。...
Android Toast 保持一直显示。
xiafangxingg的博客
02-02 3815
package android.widget; import android.app.ITransientNotification; import android.content.Context; import android.view.Gravity; import android.view.LayoutInflater; import android.view.View; import ja
android在hal下 如何获得对一个内核节点的访问权限
xiafangxingg的博客
12-08 2419
Android 5.0以上，我们发现jni通过hal层去操作内核节点时PERMISSION DENIED 即使在Android源代码工程目录下，进入到system/core/rootdir目录，里面有一个名为ueventd.rc文件，往里面添加一行：/dev/hello 0666 root root ，此操作仍然不能让上层去读写相应的节点， 因为5.0以上采取了SEAndroid/SElinux的安
andriod cs 架构
xiafangxingg的博客
05-05 2363
android中大量采用cs结构来实现应用层和底层服务交互，比较典型的就是android系统中通过getSystemService获取的各类服务。如ams，pms，这些服务是运行在systemserver进程中的， 对于systemserver进程在android中的地位是相当重要的，即由Zygote进程（fork）出来的第一进程，而Zygote进程就是由linux的init进程fork出来的，我
android 悬浮activity实现
xiafangxingg的博客
11-30 2124
当需求我们的activity始终在别的应用的最前端的时候，可以向WindowManager 添加需要的view，oncreate中addview，在ondestory removeview，就能实现悬浮activitywm = (WindowManager) getApplicationContext().getSystemService( Context.WIND
android自定义访问权限
xiafangxingg的博客
12-09 1897
android 中如果我们想让我们的activity或service限制别人的访问，可以加上自定义权限，只有加上我们定义的权限才能访问我们的组件，具体在我们应用中的AndroidManifest.xml 中添加<permission android:name="com.qualcomm.permission.USE_QCRIL_MSG_TUNNEL" android:p
java.net.BindException: Address already in use: JVM_Bind at java.net.DualStackPlainSocketImpl.bind0(Native Method)
最新发布
10-09
出现"java.net.BindException: Address already in use: JVM_Bind"的错误是因为在绑定地址时，该地址已经被其他进程占用了。这通常发生在尝试绑定一个已经被其他程序使用的端口上。 要解决这个问题，可以尝试以下几...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值