Android系统匿名共享内存（Anonymous Shared Memory）C++调用接口分析（6）

   接下来，我们再来看看server模块的实现。在external/ashmem/common目录下，只有一个源文件SharedBufferServer.cpp，它实现了内存共享服务SharedBufferService：

1. #define LOG_TAG "SharedBufferServer"  
2.   
3. #include <utils/Log.h>  
4. #include <binder/MemoryBase.h>  
5. #include <binder/MemoryHeapBase.h>  
6. #include <binder/IServiceManager.h>  
7. #include <binder/IPCThreadState.h>  
8.   
9. #include "../common/ISharedBuffer.h"  
10.   
11. class SharedBufferService : public BnSharedBuffer  
12. {  
13. public:  
14.     SharedBufferService()  
15.     {  
16.         sp<MemoryHeapBase> heap = new MemoryHeapBase(SHARED_BUFFER_SIZE, 0, "SharedBuffer");  
17.         if(heap != NULL)  
18.         {  
19.             mMemory = new MemoryBase(heap, 0, SHARED_BUFFER_SIZE);  
20.   
21.             int32_t* data = (int32_t*)mMemory->pointer();  
22.             if(data != NULL)  
23.             {  
24.                 *data = 0;  
25.             }  
26.         }  
27.     }  
28.   
29.     virtual ~SharedBufferService()  
30.     {  
31.         mMemory = NULL;  
32.     }  
33.   
34. public:  
35.     static void instantiate()  
36.     {  
37.         defaultServiceManager()->addService(String16(SHARED_BUFFER_SERVICE), new SharedBufferService());  
38.     }  
39.   
40.     virtual sp<IMemory> getBuffer()  
41.     {  
42.         return mMemory;  
43.     }  
44.   
45. private:  
46.     sp<MemoryBase> mMemory;  
47. };  
48.   
49. int main(int argc, char** argv)  
50. {  
51.     SharedBufferService::instantiate();  
52.   
53.     ProcessState::self()->startThreadPool();  
54.     IPCThreadState::self()->joinThreadPool();  
55.   
56.     return 0;  
57. }  

        SharedBufferService服务实现了BnSharedBuffer接口。在它的构造函数里面，首先是使用MemoryHeapBase类创建了一个匿名共享内存，大小为SHARED_BUFFER_SIZE。接着，又以这个MemoryHeapBase对象为参数，创建一个MemoryBase对象，这个MemoryBase对象指定要维护的匿名共享内存的的偏移位置为0，大小为SHARED_BUFFER_SIZE，并且，将这个匿名共享内存当作一个整型变量地址，将它初始化为0。最终，这个匿名共享内存对象保存在SharedBufferService类的成员变量mMemory中，这个匿名共享内存对象可以通过成员函数getBuffer来获得。

 

        在Server端应用程序的入口函数main中，首先是调用SharedBufferService静态成员函数instantiate函数来创建一个SharedBufferService实例，然后通过defaultServiceManager函数来获得系统中的Service Manager接口，最后通过这个Service Manager接口的addService函数来把这个SharedBufferService服务添加到Service Manager中去，这样，Client端就可以通过Service Manager来获得这个共享内存服务了。有关Service Manager的实现，请参考前面一篇文章 浅谈Service Manager成为Android进程间通信（IPC）机制Binder守护进程之路 ，而用来获取Service Manager接口的defaultServiceManager函数的实现可以参考另外一篇文章 浅谈Android系统进程间通信（IPC）机制Binder中的Server和Client获得Service Manager接口之路 。初始化好这个共享内存服务之后，程序就通过ProcessState::self()->startThreadPool()函数来创建一个线程等待Client端来请求服务了，最后，程序的主线程也通过IPCThreadState::self()->joinThreadPool()函数来进入到等待Client端来请求服务的状态中。

       我们还需要为这个Server端应用程序编译一个编译脚本，在external/ashmem/server目录下，新建一个Android.mk文件，它的内容如下所示：

1. LOCAL_PATH := $(call my-dir)  
2.   
3. include $(CLEAR_VARS)  
4.   
5. LOCAL_MODULE_TAGS := optional  
6.   
7. LOCAL_SRC_FILES := ../common/ISharedBuffer.cpp \  
8.         SharedBufferServer.cpp  
9.   
10. LOCAL_SHARED_LIBRARIES:= libcutils libutils libbinder  
11.   
12. LOCAL_MODULE := SharedBufferServer  
13.   
14. include $(BUILD_EXECUTABLE)  

        最后，我们再来看看client模块的实现。在external/ashmem/client目录下，只有一个源文件SharedBufferClient.cpp，它的内容如下所示：

1. #define LOG_TAG "SharedBufferClient"  
2.   
3. #include <utils/Log.h>  
4. #include <binder/MemoryBase.h>  
5. #include <binder/IServiceManager.h>  
6.   
7. #include "../common/ISharedBuffer.h"  
8.   
9. int main()  
10. {  
11.         sp<IBinder> binder = defaultServiceManager()->getService(String16(SHARED_BUFFER_SERVICE));  
12.         if(binder == NULL)  
13.         {  
14.                 printf("Failed to get service: %s.\n", SHARED_BUFFER_SERVICE);  
15.                 return -1;  
16.         }  
17.   
18.         sp<ISharedBuffer> service = ISharedBuffer::asInterface(binder);  
19.         if(service == NULL)  
20.         {  
21.                 return -2;  
22.         }  
23.   
24.         sp<IMemory> buffer = service->getBuffer();  
25.         if(buffer == NULL)  
26.         {  
27.                 return -3;  
28.         }  
29.   
30.         int32_t* data = (int32_t*)buffer->pointer();  
31.         if(data == NULL)  
32.         {  
33.                 return -4;  
34.         }  
35.   
36.         printf("The value of the shared buffer is %d.\n", *data);  
37.   
38.         *data = *data + 1;  
39.   
40.         printf("Add value 1 to the shared buffer.\n");  
41.   
42.         return 0;  
43. }  

        在这个文件中，主要就是定义了Client端应用程序的入口函数main，在这个main函数里面，首先通过Service Manager接口获得前面所实现的匿名共享内存服务SharedBufferService的远程接口service，然后通过这个远程接口的getBuffer成员函数获得由Server端提供的一块匿名共享内存接口buffer，最后通过这个匿名共享内存接口获得这个匿名共享内存的基地址data。有了这个匿名共享内存的地址data之后，我们就可以对它进行读写了，先是把这个匿名共享内存当作是一个整型变量地址进行访问，并输出它的值的大小，然后对这个整量变量进行加1的操作，并写回到原来的共享内存空间中去。这样，当Server端应用程序运行之后，第一次运行这个Client端应用程序时，输出的值为0，第二次运行这个个Client端应用程序时，输出的值为1，第三次运行这个个Client端应用程序时，输出的值为3......依次类推，后面我们将在模拟器中对这个分析进行验证，如果验证成功的话，就说明这个匿名共享内存成功地在Server端和Client端实现共享了。