Android Ashmem匿名共享内存 C++实例

~/Android/external/ashmem

----common

      ----ISharedBuffer.h

      ----ISharedBuffer.cpp

----server

      ----SharedBufferServer.cpp

      ----Android.mk

----client

      ----SharedBufferClient.cpp

      ----Android.mk

common/ISharedBuffer.h

#ifndef ISHAREDBUFFER_H_
#define ISHAREDBUFFER_H_

#include <utils/RefBase.h>
#include <binder/IInterface.h>
#include <binder/Parcel.h>

#define SHARED_BUFFER_SERVICE "shy.luo.SharedBuffer"
#define SHARED_BUFFER_SIZE 4
#define LOGD ALOGD
#define LOGE ALOGE
#define LOGI ALOGI
#define LOGW ALOGW

using namespace android;

class ISharedBuffer: public IInterface
{
public:
	DECLARE_META_INTERFACE(SharedBuffer);
	virtual sp<IMemory> getBuffer() = 0;
	
};

class BnSharedBuffer: public BnInterface<ISharedBuffer>
{
public:
	virtual status_t onTransact (uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0);
};
#endif

common/ISharedBuffer.cpp

#define LOG_TAG "ISharedBuffer"

#include <utils/Log.h>
#include <binder/MemoryBase.h>

#include "ISharedBuffer.h"

using namespace android;

enum
{
	GET_BUFFER = IBinder::FIRST_CALL_TRANSACTION
};

class BpSharedBuffer: public BpInterface<ISharedBuffer>
{
public:
	BpSharedBuffer(const sp<IBinder>& impl)
		: BpInterface<ISharedBuffer>(impl)
	{
	}

	sp<IMemory> getBuffer()
	{
		Parcel data;
		data.writeInterfaceToken(ISharedBuffer::getInterfaceDescriptor());

		Parcel reply;
		remote()->transact(GET_BUFFER, data, &reply);

		sp<IMemory> buffer = interface_cast<IMemory> (reply.readStrongBinder());
		
		return buffer;
	}
};

IMPLEMENT_META_INTERFACE(SharedBuffer, "shy.luo.ISharedBuffer");

status_t BnSharedBuffer::onTransact(uint32_t code, const Parcel & data, Parcel * reply, uint32_t flags)
{
	switch(code)
	{
		case GET_BUFFER:
		{
			CHECK_INTERFACE(ISharedBuffer, data, reply);
			
			sp<IMemory> buffer = getBuffer();
			if(buffer != NULL)
			{
				reply->writeStrongBinder(buffer->asBinder(buffer));
			}

			return NO_ERROR;
		}
		default:
		{
			return BBinder::onTransact( code, data, reply, flags);
		}
	}
}

server/Android.mk

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := ../common/ISharedBuffer.cpp \
	SharedBufferServer.cpp
LOCAL_SHARED_LIBRARIES := libcutils libutils libbinder
LOCAL_MODULE := SharedBufferServer
include $(BUILD_EXECUTABLE)

server/SharedBufferServer.cpp

#define LOG_TAG "ISharedBufferServer"
#define TAG "[Server] "

#include <stdlib.h>
#include <fcntl.h>
#include <utils/Log.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <binder/IServiceManager.h>
#include <binder/IPCThreadState.h>

#include "../common/ISharedBuffer.h"


class SharedBufferService : public BnSharedBuffer
{
public:
	SharedBufferService ()
	{
		sp<MemoryHeapBase> heap = new MemoryHeapBase(SHARED_BUFFER_SIZE, 0, "SharedBuffer");
		if(heap != NULL)
		{
			mMemory = new MemoryBase(heap, 0, SHARED_BUFFER_SIZE);

			int32_t* data = (int32_t*)mMemory->pointer();
			if(data != NULL)
			{
				*data = 0;
			}
		}
	}

	virtual ~SharedBufferService ()
	{
		mMemory = NULL;
	}

public:
	static void instantiate ()
	{
		defaultServiceManager ()->addService(String16(SHARED_BUFFER_SERVICE), new SharedBufferService());
	}

	virtual sp<IMemory> getBuffer()
	{
		return mMemory;
	}

private:
	sp<MemoryBase> mMemory;
};

int main(int argc, char** argv)
{
	SharedBufferService::instantiate();

	ProcessState::self()->startThreadPool();
	IPCThreadState::self()->joinThreadPool();

	return 0;
}

client/Android.mk

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := ../common/ISharedBuffer.cpp \
	SharedBufferClient.cpp
LOCAL_SHARED_LIBRARIES := libcutils libutils libbinder
LOCAL_MODULE := SharedBufferClient
include $(BUILD_EXECUTABLE)

client/SharedBufferClient.cpp

#define LOG_TAG "SharedBufferClient"

#include <utils/Log.h>
#include <binder/MemoryBase.h>
#include <binder/IServiceManager.h>
#include "../common/ISharedBuffer.h"

int main()
{
	sp<IBinder> binder = defaultServiceManager()->getService(String16(SHARED_BUFFER_SERVICE));
	if(binder == NULL){
		printf("Failed to get service: %s.\n", SHARED_BUFFER_SERVICE);
		return -1;
	}

	sp<ISharedBuffer> service = ISharedBuffer::asInterface(binder);
	if(service == NULL){
		return -2;
	}


       sp<IMemory> buffer = service->getBuffer();
	if(buffer == NULL){
		return -3;
	}

	
	int32_t* data = (int32_t*)buffer->pointer();
	if(data == NULL){
		return -4;
	}

	printf("The value of the shared buffer is %d. \n", *data);

	*data = *data + 1;

	printf("Add value 1 to the shared buffer. \n");

	return 0;
}

运行结果：