Binder JNI注册

最新推荐文章于 2023-06-27 17:21:57 发布
最新推荐文章于 2023-06-27 17:21:57 发布
阅读量471 收藏 1
点赞数
分类专栏： Android Framework Android_Binder 文章标签： android binder JNI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/super_marie/article/details/120686827
版权
  • 通过上两个篇章,对于Binder的整体框架,以及其中驱动层的逻辑梳理之后,接下来需要对Binder的JNI层注册进行一个梳理

1. Zygote进程的启动

  1. 解析init.rc文件

    • Zygote是由init进程通过解析对应的init.zygote.rc文件进行创建的,这里可以看一下 init.zygote32.rc 文件

      • 文件路径:android/system/core/rootdir/init.zygote32.rc
      //这里会去找app_process文件夹下的app_main.cpp文件
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc reserved_disk
    socket zygote stream 660 root system
    socket usap_pool_primary stream 660 root system
    onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks

  2. 执行app_main.cpp文件

    • 文件路径:android/frameworks/base/cmds/app_process/app_main.cpp

      int main(int argc, char* const argv[])
{
    ....
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    ....
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {		//这里会去判断当下启动的是否是zygote
            zygote = true;		//如果是zygote,那么将zygote标志为置为true
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
        } else if (strcmp(arg, "--application") == 0) {
            application = true;
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
            niceName.setTo(arg + 12);
        } else if (strncmp(arg, "--", 2) != 0) {
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }
    ...
        
    if (zygote) {	//这里判断如果是为zygote,那么会去启动ZygoteInit
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
}

      在app_main.cpp中的main()函数中,最终调用了 runtime.start(),而runtime就是 AppRuntime类

      class AppRuntime : public AndroidRuntime {}

      AppRuntime继承了 AndroidRuntime类,所以最终调用的是 AndroidRuntime.start()函数

2. Binder JNI的注册

  • 如上面的分析,接下来会去调用 AndroidRuntime.start()函数

    • 文件路径:android/framework/base/core/jni/AndroidRuntime.cpp

      void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
 {
     .....
     /*
      * Register android functions.
      */
     if (startReg(env) < 0) {		//注册方法
         ALOGE("Unable to register all android natives\n");
         return;
     }
     .....
 }
 
 /*
  * Register android native functions with the VM.
  */
 /*static*/ int AndroidRuntime::startReg(JNIEnv* env)
 {
     ATRACE_NAME("RegisterAndroidNatives");
     /*
      * This hook causes all future threads created in this process to be
      * attached to the JavaVM.  (This needs to go away in favor of JNI
      * Attach calls.)
      */
     androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
 
     ALOGV("--- registering native functions ---\n");
 
     /*
      * Every "register" function calls one or more things that return
      * a local reference (e.g. FindClass).  Because we haven't really
      * started the VM yet, they're all getting stored in the base frame
      * and never released.  Use Push/Pop to manage the storage.
      */
     env->PushLocalFrame(200);
 
     if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {		//通过此处进行系统JNI的注册
         env->PopLocalFrame(NULL);
         return -1;
     }
     env->PopLocalFrame(NULL);
 
     //createJavaThread("fubar", quickTest, (void*) "hello");
 
     return 0;
 }
 
 static const RegJNIRec gRegJNI[] = {
     ....
     REG_JNI(register_android_os_Binder),
     ....
 }
 
 static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
 {
     for (size_t i = 0; i < count; i++) {
         if (array[i].mProc(env) < 0) {		//这里会循环注册所有的系统JNI,当下只关注Binder的注册
 #ifndef NDEBUG
             ALOGD("----------!!! %s failed to load\n", array[i].mName);
 #endif
             return -1;
         }
     }
     return 0;
 }

      接下来会调用到register_android_os_Binder()函数

3. register_android_os_Binder()

  • 文件路径:android/framework/base/core/jni/android_util_Binder.cpp

    int register_android_os_Binder(JNIEnv* env)
{
    //调用下面三个函数实现注册
    if (int_register_android_os_Binder(env) < 0)
        return -1;
    if (int_register_android_os_BinderInternal(env) < 0)
        return -1;
    if (int_register_android_os_BinderProxy(env) < 0)
        return -1;

    jclass clazz = FindClassOrDie(env, "android/util/Log");
    gLogOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
    gLogOffsets.mLogE = GetStaticMethodIDOrDie(env, clazz, "e",
            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)I");

    clazz = FindClassOrDie(env, "android/os/ParcelFileDescriptor");
    gParcelFileDescriptorOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
    gParcelFileDescriptorOffsets.mConstructor = GetMethodIDOrDie(env, clazz, "<init>",
                                                                 "(Ljava/io/FileDescriptor;)V");

    clazz = FindClassOrDie(env, "android/os/StrictMode");
    gStrictModeCallbackOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
    gStrictModeCallbackOffsets.mCallback = GetStaticMethodIDOrDie(env, clazz,
            "onBinderStrictModePolicyChange", "(I)V");

    clazz = FindClassOrDie(env, "java/lang/Thread");
    gThreadDispatchOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
    gThreadDispatchOffsets.mDispatchUncaughtException = GetMethodIDOrDie(env, clazz,
            "dispatchUncaughtException", "(Ljava/lang/Throwable;)V");
    gThreadDispatchOffsets.mCurrentThread = GetStaticMethodIDOrDie(env, clazz, "currentThread",
            "()Ljava/lang/Thread;");

    return 0;
}

    int_register_android_os_Binder() int_register_android_os_BinderInternal() int_register_android_os_BinderProxy()三个函数其实做的工作是一样的，都是完成java层对应Binder类的注册，从而实现JAVA层和Native层相关函数可以相互调用，下面以int_register_android_os_Binder()函数进行示例解析：

    static const JNINativeMethod gBinderMethods[] = {
     /* name, signature, funcPtr */
    // @CriticalNative
    { "getCallingPid", "()I", (void*)android_os_Binder_getCallingPid },
    // @CriticalNative
    { "getCallingUid", "()I", (void*)android_os_Binder_getCallingUid },
    // @CriticalNative
    { "isHandlingTransaction", "()Z", (void*)android_os_Binder_isHandlingTransaction },
    // @CriticalNative
    { "clearCallingIdentity", "()J", (void*)android_os_Binder_clearCallingIdentity },
    { "restoreCallingIdentity", "(J)V", (void*)android_os_Binder_restoreCallingIdentity },
    // @CriticalNative
    { "setThreadStrictModePolicy", "(I)V", (void*)android_os_Binder_setThreadStrictModePolicy },
    // @CriticalNative
    { "getThreadStrictModePolicy", "()I", (void*)android_os_Binder_getThreadStrictModePolicy },
    // @CriticalNative
    { "setCallingWorkSourceUid", "(I)J", (void*)android_os_Binder_setCallingWorkSourceUid },
    // @CriticalNative
    { "getCallingWorkSourceUid", "()I", (void*)android_os_Binder_getCallingWorkSourceUid },
    // @CriticalNative
    { "clearCallingWorkSource", "()J", (void*)android_os_Binder_clearCallingWorkSource },
    { "restoreCallingWorkSource", "(J)V", (void*)android_os_Binder_restoreCallingWorkSource },
    { "markVintfStability", "()V", (void*)android_os_Binder_markVintfStability},
    { "flushPendingCommands", "()V", (void*)android_os_Binder_flushPendingCommands },
    { "getNativeBBinderHolder", "()J", (void*)android_os_Binder_getNativeBBinderHolder },
    { "getNativeFinalizer", "()J", (void*)android_os_Binder_getNativeFinalizer },
    { "blockUntilThreadAvailable", "()V", (void*)android_os_Binder_blockUntilThreadAvailable },
    { "getExtension", "()Landroid/os/IBinder;", (void*)android_os_Binder_getExtension },
    { "setExtension", "(Landroid/os/IBinder;)V", (void*)android_os_Binder_setExtension },
};

const char* const kBinderPathName = "android/os/Binder";        //sdk中的Binder类路径,即该cpp文件对应的是那个JAVA类

static int int_register_android_os_Binder(JNIEnv* env)
{
    jclass clazz = FindClassOrDie(env, kBinderPathName);

    //下面这三步都是在将Binder.java类相关的信息记录到gBinderOffsets结构中，可以类比为反射获取类信息
    //经过这一层注册，将Binder.java类信息记录在gBinderOffsets结构体中之后，就可以通过gBinderOffsets结构体，在JNI中调用Java层对应的函数
    gBinderOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
    gBinderOffsets.mExecTransact = GetMethodIDOrDie(env, clazz, "execTransact", "(IJJI)Z");
    gBinderOffsets.mGetInterfaceDescriptor = GetMethodIDOrDie(env, clazz, "getInterfaceDescriptor",
        "()Ljava/lang/String;");
    gBinderOffsets.mObject = GetFieldIDOrDie(env, clazz, "mObject", "J");

    //入上面的gBinderMethods数组定义，此处是进行JNI层函数和java层函数的映射关联，后续想找到对应java函数的JNI层实现，
    //需要通过这个关系表找到java函数对应的JNI层的函数名
    //经过这一层注册，就可以根据Java函数找到对应的JNI层函数
    return RegisterMethodsOrDie(
        env, kBinderPathName,
        gBinderMethods, NELEM(gBinderMethods));
}

​

super_marie
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Binder的JNI调用
fw_2012的专栏
10-17 281
JANI的注册 Zygote的启动流程 service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server class main socket zygote stream 660 root system onrestart write /sys/android_power/request_state wake onrestart write /sys/power/
android — JNI注册方法说明
wilson
05-10 146
Jni中还可以采用RegisterNatives来注册jni的方法，注册以后的jni函数的命名可以不需要符合类似javah命令生成的函数的规则 RegisterNatives为JNIEnv的成员函数，声明为： jint (JNICALL *RegisterNatives) (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,j...
Binder机制中Jni
helloworld
06-20 1466
在Service绑定成功后，会调用ServiceConnection的onServiceConnected方法，其中会传入一个IBinder参数。 activity的bindService方法，最终会调用ActivityManagerService的bindService方法： public int bindService(IApplicationThread caller, IBinder to...
Binder ——binder的jni注册和binder驱动
l18320786461的博客
03-09 731
Binder的jni注册和binder驱动
android 系统核心机制binder（10）binder java层JNI初始化
wangdsh的博客
06-06 845
系列文章解读&说明： Android系统核心机制binder的分析主要分为以下部分： android 系统核心机制binder（01）C语言简谈binder android 系统核心机制binder（02）binder驱动层原理 android 系统核心机制binder（03）binder C++层实现 android 系统核心机制binder（04）binder C++层 Te...
Android JNI 进程保活
07-16
2. 通信机制：使用 Binder 或 AIDL 实现Java层与JNI层的通信，确保在必要时可以唤醒应用。 3. 持续运行的任务：在JNI层设置一个循环任务，比如定时发送心跳到服务器，表明进程仍在活动。如果心跳停止，服务器可以...
c++ binder 例子
05-28
1. **ServiceManager**: 管理所有Binder服务的注册和查找，是系统服务的总目录。 2. **IBinder接口**: 所有Binder对象都必须实现的接口，定义了基本的通信方法，如`transact()`。 3. **Binder类**: 是C++层的Binder...
jni学习资源
08-29
2. **JNI函数注册**：学习如何使用`RegisterNatives`或JNI头文件中的`JNIEXPORT`和`JNICALL`宏来注册本地方法。 3. **JNI数据类型**：理解JNI中的基本数据类型，如`jboolean`, `jint`, `jobject`等，以及如何与Java...
binder用例源码
03-07
当Client请求连接到Server时，Server创建一个Binder对象，并通过系统的Service Manager注册，此时Binder生命周期开始。当所有引用都解除时，Binder会被自动销毁，生命周期结束。 ### 3. Binder通信流程 - **Client...
Android技术之JNI和HAL
04-21
3. **注册HAL服务**：将实现好的HAL服务注册到系统中，使得Framework层可以通过Binder机制调用这些服务。 4. **HAL服务的客户端调用**：Framework层或其他组件通过Binder调用HAL服务，实现对硬件设备的访问。 ####...
binder介绍——JNI的架构和实现
管子（zero）的杂乱空间
03-21 177
首先介绍一下JNI设计的目的： JNI是Java Native Interface的缩写： The standard Java class library may not support the platform-dependent features needed by your application. You may already have a library or applic...
binder注册与启动
qq_32671919的博客
08-23 423
binder的jni方法注册 1.zygote启动 1-1.启动zygote进程 zygote是由init进程通过解析 init.zygote.rc 文件而创建的，zygote所对应的可执行程序 app_process，所对应的源文件是 app_main.cpp ，进程名为zygote // system/core/rootdir/init.zygote32.rc service zygote /system/bin/app_process -Xzygote /system/bin --zygot
Android Framework实战开发-binder通信java及jni部分源码分析
liaosongmao1的专栏
10-06 207
csdn在线学习课程，课程咨询答疑和新课信息：QQ交流群：422901085进行课程讨论 android跨进程通信实战视频课程（加群获取优惠） 1、第一部分进程与ServiceManager通信及客户端程序发起调用详解 平时大部分获取ServiceManager中的某一个服务，一般都是最后都是ServiceManager.getService这种方式： //ServiceManager.java中 public static IBinder getService(String name) {
NDK、jni、Binder、AIDL、进程通信有关
fajuary的专栏
03-29 1810
1，请介绍一下NDK2，什么是NDK库？3，jni用过吗？4，如何在jni中注册native函数，有几种注册方式？5，Java 如何调用c、c++语言？6，jni如何调用java 层代码7，进程间通信的方式8，Binder机制9，简述IPC?10，什么是AIDL?11，AIDL解决了什么问题？12，AIDL如何使用？13，Android上的Inter-Process-Communication跨进...
[转]android jni层binder使用/进程通信实例
05-28 3103
Recently, I’ve decided to begin my own hardware journey. The most important part is to choose a proper operating system. I’ve tried to use several embedded Linux systems, but got many portable and deve
Android Binder通信原理(五)：Java 端的service 注册和获取
最新发布
私房菜
06-27 1746
在阐述相关的知识点，先整理个框架图，后面带着框架图来分析过程：Java 端service 的注册使用 ServiceManager.addService()Java 端service 的获取使用 ServiceManager.getService()入口都是通过 ServiceManager.java，文件位于frameworks/base/core/java/android/os/ServiceManager.java。
Android AIDL生成的文件
u011279649的专栏
07-21 1263
AIDL File: ILights.aidl package android.hardware.light; import android.hardware.light.HwLightState; import android.hardware.light.HwLight; /** * Allows controlling logical lights/indicators, mapped to LEDs in a * hardware-specific manner by the HAL im..
AIDL for HALs实战
热门推荐
qq_40731414的博客
09-12 1万+
Google 在Android 11引入了`AIDL for HALs`，旨在代替HIDL原先的作用。在之后的Android版本推荐使用AIDL 实现Hal层的访问。
Android Framework层源码深度解析：Binder与JNI
JNI的注册方法分为静态法和动态法。静态法基于函数命名规则在共享库中查找对应函数，而动态法则是在运行时通过JNI接口查找。 二、init重难点分析 这部分涉及keywords.h的有趣用法和如何利用“DllMain函数”作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值