AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android系统进程间通信Binder机制在应用程序框架层的Java接口源代码分析

2017-11-08 1080
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

在前面几篇文章中，我们详细介绍了Android系统进程间通信机制Binder的原理，并且深入分析了系统提供的Binder运行库和驱动程序的源代码。细心的读者会发现，这几篇文章分析的Binder接口都是基于C/C++语言来实现的，但是我们在编写应用程序都是基于Java语言的，那么，我们如何使用Java语言来使用系统的Binder机制来进行进程间通信呢？这就是本文要介绍的Android系统应用程序框架层的用Java语言来实现的Binder接口了。

       熟悉Android系统的读者，应该能想到应用程序框架中的基于Java语言的Binder接口是通过JNI来调用基于C/C++语言的Binder运行库来为Java应用程序提供进程间通信服务的了。JNI在Android系统中用得相当普遍，SDK中的Java接口API很多只是简单地通过JNI来调用底层的C/C++运行库从而为应用程序服务的。

       这里，我们仍然是通过具体的例子来说明Binder机制在应用程序框架层中的Java接口，主要就是Service Manager、Server和Client这三个角色的实现了。通常，在应用程序中，我们都是把Server实现为Service的形式，并且通过IServiceManager.addService接口来把这个Service添加到Service Manager，Client也是通过IServiceManager.getService接口来获得Service接口，接着就可以使用这个Service提供的功能了，这个与运行时库的Binder接口是一致的。

       前面我们学习Android硬件抽象层时，曾经在应用程序框架层中提供了一个硬件访问服务HelloService，这个Service运行在一个独立的进程中充当Server的角色，使用这个Service的Client运行在另一个进程中，它们之间就是通过Binder机制来通信的了。这里，我们就使用HelloService这个例子来分析Android系统进程间通信Binder机制在应用程序框架层的Java接口源代码。所以希望读者在阅读下面的内容之前，先了解一下前面在Ubuntu上为Android系统的Application Frameworks层增加硬件访问服务这篇文章。

       这篇文章通过五个情景来学习Android系统进程间通信Binder机制在应用程序框架层的Java接口：1. 获取Service Manager的Java远程接口的过程；2. HelloService接口的定义；3. HelloService的启动过程；4. Client获取HelloService的Java远程接口的过程；5.  Client通过HelloService的Java远程接口来使用HelloService提供的服务的过程。

       一.  获取Service Manager的Java远程接口

       我们要获取的Service Manager的Java远程接口是一个ServiceManagerProxy对象的IServiceManager接口。我们现在就来看看ServiceManagerProxy类是长什么样子的：

 

这里可以看出，ServiceManagerProxy类实现了IServiceManager接口，IServiceManager提供了getService和addService两个成员函数来管理系统中的Service。从ServiceManagerProxy类的构造函数可以看出，它需要一个BinderProxy对象的IBinder接口来作为参数。因此，要获取Service Manager的Java远程接口ServiceManagerProxy，首先要有一个BinderProxy对象。下面将会看到这个BinderProxy对象是如何获得的。

         再来看一下是通过什么路径来获取Service Manager的Java远程接口ServiceManagerProxy的。这个主角就是ServiceManager了，我们也先看一下ServiceManager是长什么样子的：

 

 ServiceManager类有一个静态成员函数getIServiceManager，它的作用就是用来获取Service Manager的Java远程接口了，而这个函数又是通过ServiceManagerNative来获取Service Manager的Java远程接口的。

        接下来，我们就看一下ServiceManager.getIServiceManager这个函数的实现，这个函数定义在frameworks/base/core/java/android/os/ServiceManager.java文件中：

 


  
  
    

   
   
  1. public final class ServiceManager {  
    2. 

   
   
  2.     ......  
    3. 

   
   
  3.     private static IServiceManager sServiceManager;  
    4. 

   
   
  4.     ......  
    5. 

   
   
  5.     private static IServiceManager getIServiceManager() {  
    6. 

   
   
  6.         if (sServiceManager != null) {  
    7. 

   
   
  7.             return sServiceManager;  
    8. 

   
   
  8.         }  
    9. 

   
   
  9.  
    10. 

   
   
  10.         // Find the service manager  
    11. 

   
   
  11.         sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());  
    12. 

   
   
  12.         return sServiceManager;  
    13. 

   
   
  13.     }  
    14. 

   
   
  14.     ......  
    15. 

   
   
  15. } 
    16.

如果其静态成员变量sServiceManager尚未创建，那么就调用ServiceManagerNative.asInterface函数来创建。在调用ServiceManagerNative.asInterface函数之前，首先要通过BinderInternal.getContextObject函数来获得一个BinderProxy对象。

 

        我们来看一下BinderInternal.getContextObject的实现，这个函数定义在frameworks/base/core/java/com/android/internal/os/BinderInternal.java文件中：

 


  
  
    

   
   
  1. public class BinderInternal {  
    2. 

   
   
  2.     ......  
    3. 

   
   
  3.     /**  
    4. 

   
   
  4.     * Return the global "context object" of the system.  This is usually  
    5. 

   
   
  5.     * an implementation of IServiceManager, which you can use to find  
    6. 

   
   
  6.     * other services.  
    7. 

   
   
  7.     */  
    8. 

   
   
  8.     public static final native IBinder getContextObject();  
    9. 

   
   
  9.       
    10. 

   
   
  10.     ......  
    11. 

   
   
  11. } 
    12.

 这里可以看出，BinderInternal.getContextObject是一个JNI方法，它实现在frameworks/base/core/jni/android_util_Binder.cpp文件中：

 


  
  
    

   
   
  1. static jobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz)  
    2. 

   
   
  2. {  
    3. 

   
   
  3.     sp<IBinder> b = ProcessState::self()->getContextObject(NULL);  
    4. 

   
   
  4.     return javaObjectForIBinder(env, b);  
    5. 

   
   
  5. } 
    6.

   这里看到我们熟悉的ProcessState::self()->getContextObject函数，具体可以参考浅谈Android系统进程间通信（IPC）机制Binder中的Server和Client获得Service Manager接口之路一文。ProcessState::self()->getContextObject函数返回一个BpBinder对象，它的句柄值是0，即下面语句：

 


  
  
    

   
   
  1. sp<IBinder> b = ProcessState::self()->getContextObject(NULL); 
    2.

  相当于是：

 


  
  
    

   
   
  1. sp<IBinder> b = new BpBinder(0); 
    2.

     接着调用javaObjectForIBinder把这个BpBinder对象转换成一个BinderProxy对象：

 


  
  
    

   
   
  1. jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)  
    2. 

   
   
  2. {  
    3. 

   
   
  3.     if (val == NULL) return NULL;  
    4. 

   
   
  4.  
    5. 

   
   
  5.     if (val->checkSubclass(&gBinderOffsets)) {  
    6. 

   
   
  6.         // One of our own!  
    7. 

   
   
  7.         jobject object = static_cast<JavaBBinder*>(val.get())->object();  
    8. 

   
   
  8.         //printf("objectForBinder %p: it's our own %p!\n", val.get(), object);  
    9. 

   
   
  9.         return object;  
    10. 

   
   
  10.     }  
    11. 

   
   
  11.  
    12. 

   
   
  12.     // For the rest of the function we will hold this lock, to serialize  
    13. 

   
   
  13.     // looking/creation of Java proxies for native Binder proxies.  
    14. 

   
   
  14.     AutoMutex _l(mProxyLock);  
    15. 

   
   
  15.  
    16. 

   
   
  16.     // Someone else's...  do we know about it?  
    17. 

   
   
  17.     jobject object = (jobject)val->findObject(&gBinderProxyOffsets);  
    18. 

   
   
  18.     if (object != NULL) {  
    19. 

   
   
  19.         jobject res = env->CallObjectMethod(object, gWeakReferenceOffsets.mGet);  
    20. 

   
   
  20.         if (res != NULL) {  
    21. 

   
   
  21.             LOGV("objectForBinder %p: found existing %p!\n", val.get(), res);  
    22. 

   
   
  22.             return res;  
    23. 

   
   
  23.         }  
    24. 

   
   
  24.         LOGV("Proxy object %p of IBinder %p no longer in working set!!!", object, val.get());  
    25. 

   
   
  25.         android_atomic_dec(&gNumProxyRefs);  
    26. 

   
   
  26.         val->detachObject(&gBinderProxyOffsets);  
    27. 

   
   
  27.         env->DeleteGlobalRef(object);  
    28. 

   
   
  28.     }  
    29. 

   
   
  29.  
    30. 

   
   
  30.     object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);  
    31. 

   
   
  31.     if (object != NULL) {  
    32. 

   
   
  32.         LOGV("objectForBinder %p: created new %p!\n", val.get(), object);  
    33. 

   
   
  33.         // The proxy holds a reference to the native object.  
    34. 

   
   
  34.         env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get());  
    35. 

   
   
  35.         val->incStrong(object);  
    36. 

   
   
  36.  
    37. 

   
   
  37.         // The native object needs to hold a weak reference back to the  
    38. 

   
   
  38.         // proxy, so we can retrieve the same proxy if it is still active.  
    39. 

   
   
  39.         jobject refObject = env->NewGlobalRef(  
    40. 

   
   
  40.                 env->GetObjectField(object, gBinderProxyOffsets.mSelf));  
    41. 

   
   
  41.         val->attachObject(&gBinderProxyOffsets, refObject,  
    42. 

   
   
  42.                 jnienv_to_javavm(env), proxy_cleanup);  
    43. 

   
   
  43.  
    44. 

   
   
  44.         // Note that a new object reference has been created.  
    45. 

   
   
  45.         android_atomic_inc(&gNumProxyRefs);  
    46. 

   
   
  46.         incRefsCreated(env);  
    47. 

   
   
  47.     }  
    48. 

   
   
  48.  
    49. 

   
   
  49.     return object;  
    50. 

   
   
  50. } 
    51.

     在介绍这个函数之前，先来看两个变量gBinderOffsets和gBinderProxyOffsets的定义。

 

        先看gBinderOffsets的定义：

 


  
  
    

   
   
  1. static struct bindernative_offsets_t  
    2. 

   
   
  2. {  
    3. 

   
   
  3.     // Class state.  
    4. 

   
   
  4.     jclass mClass;  
    5. 

   
   
  5.     jmethodID mExecTransact;  
    6. 

   
   
  6.  
    7. 

   
   
  7.     // Object state.  
    8. 

   
   
  8.     jfieldID mObject;  
    9. 

   
   
  9.  
    10. 

   
   
  10. } gBinderOffsets; 
    11.

 简单来说，gBinderOffsets变量是用来记录上面第二个类图中的Binder类的相关信息的，它是在注册Binder类的JNI方法的int_register_android_os_Binder函数初始化的：

 


  
  
    

   
   
  1. const char* const kBinderPathName = "android/os/Binder";  
    2. 

   
   
  2.  
    3. 

   
   
  3. static int int_register_android_os_Binder(JNIEnv* env)  
    4. 

   
   
  4. {  
    5. 

   
   
  5.     jclass clazz;  
    6. 

   
   
  6.  
    7. 

   
   
  7.     clazz = env->FindClass(kBinderPathName);  
    8. 

   
   
  8.     LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Binder");  
    9. 

   
   
  9.  
    10. 

   
   
  10.     gBinderOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
    11. 

   
   
  11.     gBinderOffsets.mExecTransact  
    12. 

   
   
  12.         = env->GetMethodID(clazz, "execTransact", "(IIII)Z");  
    13. 

   
   
  13.     assert(gBinderOffsets.mExecTransact);  
    14. 

   
   
  14.  
    15. 

   
   
  15.     gBinderOffsets.mObject  
    16. 

   
   
  16.         = env->GetFieldID(clazz, "mObject", "I");  
    17. 

   
   
  17.     assert(gBinderOffsets.mObject);  
    18. 

   
   
  18.  
    19. 

   
   
  19.     return AndroidRuntime::registerNativeMethods(  
    20. 

   
   
  20.         env, kBinderPathName,  
    21. 

   
   
  21.         gBinderMethods, NELEM(gBinderMethods));  
    22. 

   
   
  22. } 
    23.

    再来看gBinderProxyOffsets的定义：

 


  
  
    

   
   
  1. static struct binderproxy_offsets_t  
    2. 

   
   
  2. {  
    3. 

   
   
  3.     // Class state.  
    4. 

   
   
  4.     jclass mClass;  
    5. 

   
   
  5.     jmethodID mConstructor;  
    6. 

   
   
  6.     jmethodID mSendDeathNotice;  
    7. 

   
   
  7.  
    8. 

   
   
  8.     // Object state.  
    9. 

   
   
  9.     jfieldID mObject;  
    10. 

   
   
  10.     jfieldID mSelf;  
    11. 

   
   
  11.  
    12. 

   
   
  12. } gBinderProxyOffsets; 
    13.

简单来说，gBinderProxyOffsets是用来变量是用来记录上面第一个图中的BinderProxy类的相关信息的，它是在注册BinderProxy类的JNI方法的int_register_android_os_BinderProxy函数初始化的：

 


  
  
    

   
   
  1. const char* const kBinderProxyPathName = "android/os/BinderProxy";  
    2. 

   
   
  2.  
    3. 

   
   
  3. static int int_register_android_os_BinderProxy(JNIEnv* env)  
    4. 

   
   
  4. {  
    5. 

   
   
  5.     jclass clazz;  
    6. 

   
   
  6.  
    7. 

   
   
  7.     clazz = env->FindClass("java/lang/ref/WeakReference");  
    8. 

   
   
  8.     LOG_FATAL_IF(clazz == NULL, "Unable to find class java.lang.ref.WeakReference");  
    9. 

   
   
  9.     gWeakReferenceOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
    10. 

   
   
  10.     gWeakReferenceOffsets.mGet  
    11. 

   
   
  11.         = env->GetMethodID(clazz, "get", "()Ljava/lang/Object;");  
    12. 

   
   
  12.     assert(gWeakReferenceOffsets.mGet);  
    13. 

   
   
  13.  
    14. 

   
   
  14.     clazz = env->FindClass("java/lang/Error");  
    15. 

   
   
  15.     LOG_FATAL_IF(clazz == NULL, "Unable to find class java.lang.Error");  
    16. 

   
   
  16.     gErrorOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
    17. 

   
   
  17.       
    18. 

   
   
  18.     clazz = env->FindClass(kBinderProxyPathName);  
    19. 

   
   
  19.     LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.BinderProxy");  
    20. 

   
   
  20.  
    21. 

   
   
  21.     gBinderProxyOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
    22. 

   
   
  22.     gBinderProxyOffsets.mConstructor  
    23. 

   
   
  23.         = env->GetMethodID(clazz, "<init>", "()V");  
    24. 

   
   
  24.     assert(gBinderProxyOffsets.mConstructor);  
    25. 

   
   
  25.     gBinderProxyOffsets.mSendDeathNotice  
    26. 

   
   
  26.         = env->GetStaticMethodID(clazz, "sendDeathNotice", "(Landroid/os/IBinder$DeathRecipient;)V");  
    27. 

   
   
  27.     assert(gBinderProxyOffsets.mSendDeathNotice);  
    28. 

   
   
  28.  
    29. 

   
   
  29.     gBinderProxyOffsets.mObject  
    30. 

   
   
  30.         = env->GetFieldID(clazz, "mObject", "I");  
    31. 

   
   
  31.     assert(gBinderProxyOffsets.mObject);  
    32. 

   
   
  32.     gBinderProxyOffsets.mSelf  
    33. 

   
   
  33.         = env->GetFieldID(clazz, "mSelf", "Ljava/lang/ref/WeakReference;");  
    34. 

   
   
  34.     assert(gBinderProxyOffsets.mSelf);  
    35. 

   
   
  35.  
    36. 

   
   
  36.     return AndroidRuntime::registerNativeMethods(  
    37. 

   
   
  37.         env, kBinderProxyPathName,  
    38. 

   
   
  38.         gBinderProxyMethods, NELEM(gBinderProxyMethods));  
    39. 

   
   
  39. } 
    40.

 回到前面的javaObjectForIBinder函数中，下面这段代码：

 


  
  
    

   
   
  1. if (val->checkSubclass(&gBinderOffsets)) {  
    2. 

   
   
  2.     // One of our own!  
    3. 

   
   
  3.     jobject object = static_cast<JavaBBinder*>(val.get())->object();  
    4. 

   
   
  4.     //printf("objectForBinder %p: it's our own %p!\n", val.get(), object);  
    5. 

   
   
  5.     return object;  
    6. 

   
   
  6. } 
    7.

前面说过，这里传进来的参数是一个BpBinder的指针，而BpBinder::checkSubclass继承于父类IBinder::checkSubclass，它什么也不做就返回false。

 

        于是函数继续往下执行：

 


  
  
    

   
   
  1. jobject object = (jobject)val->findObject(&gBinderProxyOffsets); 
    2.

 由于这个BpBinder对象是第一创建，它里面什么对象也没有，因此，这里返回的object为NULL。

 

        于是函数又继续往下执行：

 


  
  
    

   
   
  1. object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor); 
    2.

 这里，就创建了一个BinderProxy对象了。创建了之后，要把这个BpBinder对象和这个BinderProxy对象关联起来：
 


  
  
    

   
   
  1. env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get()); 
    2.

 就是通过BinderProxy.mObject成员变量来关联的了，BinderProxy.mObject成员变量记录了这个BpBinder对象的地址。

 

        接下去，还要把它放到BpBinder里面去，下次就要使用时，就可以在上一步调用BpBinder::findObj把它找回来了：

 


  
  
    

   
   
  1. val->attachObject(&gBinderProxyOffsets, refObject,  
    2. 

   
   
  2.                 jnienv_to_javavm(env), proxy_cleanup); 
    3.

   最后，就把这个BinderProxy返回到android_os_BinderInternal_getContextObject函数，最终返回到最开始的ServiceManager.getIServiceManager函数中来了，于是，我们就获得一个BinderProxy对象了。

 

        回到ServiceManager.getIServiceManager中，从下面语句返回：

 


  
  
    

   
   
  1. sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject()); 
    2.

   相当于是：

 


  
  
    

   
   
  1. sServiceManager = ServiceManagerNative.asInterface(new BinderProxy()); 
    2.

 接下去就是调用ServiceManagerNative.asInterface函数了，这个函数定义在frameworks/base/core/java/android/os/ServiceManagerNative.java文件中：

 


  
  
    

   
   
  1. public abstract class ServiceManagerNative ......  
    2. 

   
   
  2. {  
    3. 

   
   
  3.     ......  
    4. 

   
   
  4.     static public IServiceManager asInterface(IBinder obj)  
    5. 

   
   
  5.     {  
    6. 

   
   
  6.         if (obj == null) {  
    7. 

   
   
  7.             return null;  
    8. 

   
   
  8.         }  
    9. 

   
   
  9.         IServiceManager in =  
    10. 

   
   
  10.             (IServiceManager)obj.queryLocalInterface(descriptor);  
    11. 

   
   
  11.         if (in != null) {  
    12. 

   
   
  12.             return in;  
    13. 

   
   
  13.         }  
    14. 

   
   
  14.  
    15. 

   
   
  15.         return new ServiceManagerProxy(obj);  
    16. 

   
   
  16.     }  
    17. 

   
   
  17.     ......  
    18. 

   
   
  18. } 
    19.

  这里的参数obj是一个BinderProxy对象，它的queryLocalInterface函数返回null。因此，最终以这个BinderProxy对象为参数创建一个ServiceManagerProxy对象。

 

       返回到ServiceManager.getIServiceManager中，从下面语句返回：

 


  
  
    

   
   
  1. sServiceManager = ServiceManagerNative.asInterface(new BinderProxy()); 
    2.

    就相当于是：

 


  
  
    

   
   
  1. sServiceManager = new ServiceManagerProxy(new BinderProxy()); 
    2.

 于是，我们的目标终于完成了。

 

      总结一下，就是在Java层，我们拥有了一个Service Manager远程接口ServiceManagerProxy，而这个ServiceManagerProxy对象在JNI层有一个句柄值为0的BpBinder对象与之通过gBinderProxyOffsets关联起来。

      这样获取Service Manager的Java远程接口的过程就完成了。

      二. HelloService接口的定义

      前面我们在学习Android系统的硬件抽象层（HAL）时，在在Ubuntu上为Android系统的Application Frameworks层增加硬件访问服务这篇文章中，我们编写了一个硬件服务HelloService，它的服务接口定义在frameworks/base/core/java/android/os/IHelloService.aidl文件中：

 


  
  
    

   
   
  1. package android.os;  
    2. 

   
   
  2.  
    3. 

   
   
  3. interface IHelloService  
    4. 

   
   
  4. {  
    5. 

   
   
  5.     void setVal(int val);  
    6. 

   
   
  6.     int getVal();  
    7. 

   
   
  7. } 
    8.

这个服务接口很简单，只有两个函数，分别用来读写硬件寄存器。

       注意，这是一个aidl文件，编译后会生成一个IHelloService.java。我们来看一下这个文件的内容隐藏着什么奥秘，可以这么神奇地支持进程间通信。

 


  
  
    

   
   
  1. /*  
    2. 

   
   
  2.  * This file is auto-generated.  DO NOT MODIFY.  
    3. 

   
   
  3.  * Original file: frameworks/base/core/java/android/os/IHelloService.aidl  
    4. 

   
   
  4.  */  
    5. 

   
   
  5. package android.os;  
    6. 

   
   
  6. public interface IHelloService extends android.os.IInterface  
    7. 

   
   
  7. {  
    8. 

   
   
  8.     /** Local-side IPC implementation stub class. */  
    9. 

   
   
  9.     public static abstract class Stub extends android.os.Binder implements android.os.IHelloService  
    10. 

   
   
  10.     {  
    11. 

   
   
  11.         private static final java.lang.String DESCRIPTOR = "android.os.IHelloService";  
    12. 

   
   
  12.         /** Construct the stub at attach it to the interface. */  
    13. 

   
   
  13.         public Stub()  
    14. 

   
   
  14.         {  
    15. 

   
   
  15.             this.attachInterface(this, DESCRIPTOR);  
    16. 

   
   
  16.         }  
    17. 

   
   
  17.  
    18. 

   
   
  18.         /**  
    19. 

   
   
  19.         * Cast an IBinder object into an android.os.IHelloService interface,  
    20. 

   
   
  20.         * generating a proxy if needed.  
    21. 

   
   
  21.         */  
    22. 

   
   
  22.         public static android.os.IHelloService asInterface(android.os.IBinder obj)  
    23. 

   
   
  23.         {  
    24. 

   
   
  24.             if ((obj==null)) {  
    25. 

   
   
  25.                 return null;  
    26. 

   
   
  26.             }  
    27. 

   
   
  27.             android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
    28. 

   
   
  28.             if (((iin!=null)&&(iin instanceof android.os.IHelloService))) {  
    29. 

   
   
  29.                 return ((android.os.IHelloService)iin);  
    30. 

   
   
  30.             }  
    31. 

   
   
  31.             return new android.os.IHelloService.Stub.Proxy(obj);  
    32. 

   
   
  32.         }  
    33. 

   
   
  33.  
    34. 

   
   
  34.         public android.os.IBinder asBinder()  
    35. 

   
   
  35.         {  
    36. 

   
   
  36.             return this;  
    37. 

   
   
  37.         }  
    38. 

   
   
  38.  
    39. 

   
   
  39.         @Override   
    40. 

   
   
  40.         public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
    41. 

   
   
  41.         {  
    42. 

   
   
  42.             switch (code)  
    43. 

   
   
  43.             {  
    44. 

   
   
  44.                 case INTERFACE_TRANSACTION:  
    45. 

   
   
  45.                 {  
    46. 

   
   
  46.                     reply.writeString(DESCRIPTOR);  
    47. 

   
   
  47.                     return true;  
    48. 

   
   
  48.                 }  
    49. 

   
   
  49.                 case TRANSACTION_setVal:  
    50. 

   
   
  50.                 {  
    51. 

   
   
  51.                     data.enforceInterface(DESCRIPTOR);  
    52. 

   
   
  52.                     int _arg0;  
    53. 

   
   
  53.                     _arg0 = data.readInt();  
    54. 

   
   
  54.                     this.setVal(_arg0);  
    55. 

   
   
  55.                     reply.writeNoException();  
    56. 

   
   
  56.                     return true;  
    57. 

   
   
  57.                 }  
    58. 

   
   
  58.                 case TRANSACTION_getVal:  
    59. 

   
   
  59.                 {  
    60. 

   
   
  60.                     data.enforceInterface(DESCRIPTOR);  
    61. 

   
   
  61.                     int _result = this.getVal();  
    62. 

   
   
  62.                     reply.writeNoException();  
    63. 

   
   
  63.                     reply.writeInt(_result);  
    64. 

   
   
  64.                     return true;  
    65. 

   
   
  65.                 }  
    66. 

   
   
  66.             }  
    67. 

   
   
  67.             return super.onTransact(code, data, reply, flags);  
    68. 

   
   
  68.         }  
    69. 

   
   
  69.  
    70. 

   
   
  70.         private static class Proxy implements android.os.IHelloService  
    71. 

   
   
  71.         {  
    72. 

   
   
  72.             private android.os.IBinder mRemote;  
    73. 

   
   
  73.  
    74. 

   
   
  74.             Proxy(android.os.IBinder remote)  
    75. 

   
   
  75.             {  
    76. 

   
   
  76.                 mRemote = remote;  
    77. 

   
   
  77.             }  
    78. 

   
   
  78.  
    79. 

   
   
  79.             public android.os.IBinder asBinder()  
    80. 

   
   
  80.             {  
    81. 

   
   
  81.                 return mRemote;  
    82. 

   
   
  82.             }  
    83. 

   
   
  83.  
    84. 

   
   
  84.             public java.lang.String getInterfaceDescriptor()  
    85. 

   
   
  85.             {  
    86. 

   
   
  86.                 return DESCRIPTOR;  
    87. 

   
   
  87.             }  
    88. 

   
   
  88.  
    89. 

   
   
  89.             public void setVal(int val) throws android.os.RemoteException  
    90. 

   
   
  90.             {  
    91. 

   
   
  91.                 android.os.Parcel _data = android.os.Parcel.obtain();  
    92. 

   
   
  92.                 android.os.Parcel _reply = android.os.Parcel.obtain();  
    93. 

   
   
  93.                 try {  
    94. 

   
   
  94.                     _data.writeInterfaceToken(DESCRIPTOR);  
    95. 

   
   
  95.                     _data.writeInt(val);  
    96. 

   
   
  96.                     mRemote.transact(Stub.TRANSACTION_setVal, _data, _reply, 0);  
    97. 

   
   
  97.                     _reply.readException();  
    98. 

   
   
  98.                 }  
    99. 

   
   
  99.                 finally {  
    100. 

   
   
  100.                     _reply.recycle();  
    101. 

   
   
  101.                     _data.recycle();  
    102. 

   
   
  102.                 }  
    103. 

   
   
  103.             }  
    104. 

   
   
  104.  
    105. 

   
   
  105.             public int getVal() throws android.os.RemoteException  
    106. 

   
   
  106.             {  
    107. 

   
   
  107.                 android.os.Parcel _data = android.os.Parcel.obtain();  
    108. 

   
   
  108.                 android.os.Parcel _reply = android.os.Parcel.obtain();  
    109. 

   
   
  109.                 int _result;  
    110. 

   
   
  110.                 try {  
    111. 

   
   
  111.                     _data.writeInterfaceToken(DESCRIPTOR);  
    112. 

   
   
  112.                     mRemote.transact(Stub.TRANSACTION_getVal, _data, _reply, 0);  
    113. 

   
   
  113.                     _reply.readException();  
    114. 

   
   
  114.                     _result = _reply.readInt();  
    115. 

   
   
  115.                 }  
    116. 

   
   
  116.                 finally {  
    117. 

   
   
  117.                     _reply.recycle();  
    118. 

   
   
  118.                     _data.recycle();  
    119. 

   
   
  119.                 }  
    120. 

   
   
  120.                 return _result;  
    121. 

   
   
  121.             }  
    122. 

   
   
  122.         }  
    123. 

   
   
  123.  
    124. 

   
   
  124.         static final int TRANSACTION_setVal = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
    125. 

   
   
  125.         static final int TRANSACTION_getVal = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);  
    126. 

   
   
  126.     }  
    127. 

   
   
  127.  
    128. 

   
   
  128.     public void setVal(int val) throws android.os.RemoteException;  
    129. 

   
   
  129.     public int getVal() throws android.os.RemoteException;  
    130. 

   
   
  130. } 
    131.

 





本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/965288，如需转载请自行联系原作者

文章标签：
Java
Android开发
C++
开发工具
Ubuntu
API
关键词：
Java机制
Android机制
应用Java接口
应用Java
Java接口
余二五
目录
相关文章
艾利克斯冰
|
7天前
|
JSON Java Apache
非常实用的Http应用框架，杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架，帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口，使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置，提高代码的内聚性和可读性。
艾利克斯冰
40 3
Skyund
|
8天前
|
Java
java线程接口
Thread的构造方法创建对象的时候传入了Runnable接口的对象 ，Runnable接口对象重写run方法相当于指定线程任务，创建线程的时候绑定了该线程对象要干的任务。 Runnable的对象称之为：线程任务对象 不是线程对象 必须要交给Thread线程对象。 通过Thread的构造方法, 就可以把任务对象Runnable,绑定到Thread对象中, 将来执行start方法,就会自动执行Runable实现类对象中的run里面的内容。
Skyund
23 1
东方睿赢
|
14天前
|
Java 开发者
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
东方睿赢
41 4
大数据文摘
|
18天前
|
Java
Java基础（13）抽象类、接口
本文介绍了Java面向对象编程中的抽象类和接口两个核心概念。抽象类不能被实例化，通常用于定义子类的通用方法和属性；接口则是完全抽象的类，允许声明一组方法但不实现它们。文章通过代码示例详细解析了抽象类和接口的定义及实现，并讨论了它们的区别和使用场景。
大数据文摘
24 2
喵手
|
18天前
|
Java 测试技术 API
Java零基础-接口详解
【10月更文挑战第19天】Java零基础教学篇，手把手实践教学！
喵手
18 1
听风的鱼鱼儿
|
5月前
|
监控 Linux 应用服务中间件
探索Linux中的`ps`命令：进程监控与分析的利器
探索Linux中的`ps`命令：进程监控与分析的利器
听风的鱼鱼儿
126 13
Linux学习的那些事儿
|
4月前
|
运维 关系型数据库 MySQL
掌握taskset：优化你的Linux进程，提升系统性能
在多核处理器成为现代计算标准的今天，运维人员和性能调优人员面临着如何有效利用这些处理能力的挑战。优化进程运行的位置不仅可以提高性能，还能更好地管理和分配系统资源。 其中，taskset命令是一个强大的工具，它允许管理员将进程绑定到特定的CPU核心，减少上下文切换的开销，从而提升整体效率。
Linux学习的那些事儿
266 9
掌握taskset：优化你的Linux进程，提升系统性能
香吧香
|
4月前
|
弹性计算 Linux 区块链
Linux系统CPU异常占用（minerd 、tplink等挖矿进程）
Linux系统CPU异常占用（minerd 、tplink等挖矿进程）
香吧香
166 4
Linux系统CPU异常占用（minerd 、tplink等挖矿进程）
历年考试不作弊
|
3月前
|
算法 Linux 调度
探索进程调度：Linux内核中的完全公平调度器
【8月更文挑战第2天】在操作系统的心脏——内核中，进程调度算法扮演着至关重要的角色。本文将深入探讨Linux内核中的完全公平调度器（Completely Fair Scheduler, CFS），一个旨在提供公平时间分配给所有进程的调度器。我们将通过代码示例，理解CFS如何管理运行队列、选择下一个运行进程以及如何对实时负载进行响应。文章将揭示CFS的设计哲学，并展示其如何在现代多任务计算环境中实现高效的资源分配。
历年考试不作弊
73 8
დ旧言~
|
4月前
|
存储 缓存 安全
【Linux】冯诺依曼体系结构与操作系统及其进程
【Linux】冯诺依曼体系结构与操作系统及其进程
დ旧言~
171 1

热门文章

最新文章

  • 1
    Android 11 中的存储机制更新
  • 2
    《Android游戏开发详解》——第1章，第1.1节什么是编程
  • 3
    android处理拍照旋转问题及带来的对内存占用
  • 4
    Android Sqlite数据库版本升级管理初探
  • 5
    离线安装Eclipse的Android ADT开发插件
  • 6
    Android——Fragment介绍
  • 7
    android使用Activity
  • 8
    Android开发1——查找所需要出示权限的内容
  • 9
    实现一个用于显示当前时间的Google Android 窗口小部件（AppWidget）
  • 10
    Android基础：shape的基本用法
  • 1
    binder机制原理面试，安卓app开发教程
    82
  • 2
    Android 浅度解析：AIDL & Binder (1)
    217
  • 3
    Android中Binder在项目中的具体使用详解
    192
  • 4
    Andorid关于Binder几个面试问题
    136
  • 5
    [RK3568 Android11] Binder通信整体框架
    106
  • 6
    Android中的Binder概述
    174
  • 7
    Android中的Binder学习笔记
    197
  • 8
    Spring 全家桶之 Spring Web MVC（五）- Data Binder（下）
    177
  • 9
    Spring 全家桶之 Spring Web MVC（五）- Data Binder（上）
    197
  • 10
    在阿里云上使用 SCS Rocket MQ Binder | 学习笔记
    151

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 观察进程的并发性
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    阿里云OSS设置跨域访问