Android C++ 共享内存MemoryHeapBase实现IPC进程通信实际案列

于 2017-12-14 15:40:23 发布
阅读量2k 收藏 3
点赞数
分类专栏： Android HAL 文章标签： Android C++ 共享内存Memo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szqsdq/article/details/78795161
版权

    这篇博文讲的是我如何在自定义的系统Service通过MemoryHeapBase共享内存方式实现IPC访问SensorService的数据

    调用方式通过JNI拉起动态库的形式


  一：我们要做Android系统的Sensorservice.cpp添加共享内存

  修改文件地址/frameworks/native/services/sensorservice/SensorService.cpp

                       /frameworks/native/include/gui/ISensorServer.h

                       /frameworks/native/include/gui/SensorManager.h

                       /frameworks/native/libs/gui/ISensorServer.cpp


  1：先看一下SensorService添加获得共享内存的方法在ISensorServer.h里面添加

      

class ISensorServer : public IInterface
{
public:
    DECLARE_META_INTERFACE(SensorServer);

    virtual Vector<Sensor> getSensorList(const String16& opPackageName) = 0;
    virtual sp<ISensorEventConnection> createSensorEventConnection(const String8& packageName,
             int mode, const String16& opPackageName) = 0;
    virtual int32_t isDataInjectionEnabled() = 0;
	virtual sp<IMemory> getSensorSharedMemory(int type) = 0; 
};
getSensorSharedMemory()函数


  2：SensorService作为Server端在threadLoop()里面把从HAL收到的Sensor数据丢到Memory里面

  

从Diff看到我的修改记录，这边由于是封装在动态库里，所以我们看一下自己封装的动态库的源码

//
// Created by Administrator on 2017/12/11.
//

#ifndef SENSORNATIVE_SENSORSERVICEAPI_H
#define SENSORNATIVE_SENSORSERVICEAPI_H

#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <gui/Sensor.h>
#include "SensorUtil.h"

using namespace android;

class SensorServiceApi :public RefBase{


private:

	 virtual void onFirstRef();
     sp<MemoryHeapBase> _mGyroHeapBase;
	 sp<IMemory> _mGyroMemory;
	 SensorEvent* _mGyroBuffer;
    
	 sp<MemoryHeapBase> _mAcclHeapBase;
	 sp<IMemory> _mAcclMemory;
	 SensorEvent* _mAcclBuffer;

	 sp<MemoryHeapBase> _mMagHeapBase;
	 sp<IMemory> _mMagMemory;
	 SensorEvent* _mMagBuffer;

	 sp<MemoryHeapBase> _mLightHeapBase;
	 sp<IMemory> _mLightMemory;
	 SensorEvent* _mLightBuffer;


	 sp<MemoryHeapBase> _mProxiMityHeapBase;
	 sp<IMemory> _mProxiMityMemory;
	 SensorEvent* _mProxiMityBuffer;

	 


protected:



public:
    
     SensorServiceApi();
	 virtual ~SensorServiceApi();

	 virtual sp<IMemory> getSharedMemory(int type);

	 void handlerEvent(sensors_event_t * data);

};


#endif //SENSORNATIVE_SENSORSERVICEAPI_H


//
// Created by Administrator on 2017/12/11.
//

#include <sensornativeapi/SensorServiceApi.h>

SensorServiceApi::SensorServiceApi()
{
  
 
}

void SensorServiceApi::onFirstRef()
{
    int bufsize = sizeof(SensorEvent);

    _mMagHeapBase = new MemoryHeapBase(bufsize, 0, "nvr_sensorevent_magnetic_buffer");
	if(_mMagHeapBase != NULL)
	{
		_mMagMemory = new MemoryBase(_mMagHeapBase, 0, bufsize);

		_mMagBuffer = (SensorEvent*)_mMagMemory->pointer();
		if(_mMagBuffer != NULL)
		{
			memset(_mMagBuffer,0,bufsize);
		}
    }

	_mGyroHeapBase = new MemoryHeapBase(bufsize, 0, "nvr_sensorevent_gyro_buffer");
	if(_mGyroHeapBase != NULL)
	{
		_mGyroMemory = new MemoryBase(_mGyroHeapBase, 0, bufsize);

		_mGyroBuffer = (SensorEvent*)_mGyroMemory->pointer();
		if(_mGyroBuffer != NULL)
		{
			memset(_mGyroBuffer,0,bufsize);
		}
     }

	_mAcclHeapBase = new MemoryHeapBase(bufsize, 0, "nvr_sensorevent_accl_buffer");
	if(_mAcclHeapBase != NULL)
	{
		_mAcclMemory = new MemoryBase(_mAcclHeapBase, 0, bufsize);

		_mAcclBuffer = (SensorEvent*)_mAcclMemory->pointer();
		if(_mAcclBuffer != NULL)
		{
			memset(_mAcclBuffer,0,bufsize);
		}
	}


	_mLightHeapBase = new MemoryHeapBase(bufsize, 0, "nvr_sensorevent_light_buffer");
	if(_mLightHeapBase != NULL)
	{
		_mLightMemory = new MemoryBase(_mLightHeapBase, 0, bufsize);

		_mLightBuffer = (SensorEvent*)_mLightMemory->pointer();
		if(_mLightBuffer != NULL)
		{
			memset(_mLightBuffer,0,bufsize);
		}
    }

	_mProxiMityHeapBase = new MemoryHeapBase(bufsize, 0, "nvr_sensorevent_proxi_buffer");
	if(_mProxiMityHeapBase != NULL)
	{
		_mProxiMityMemory = new MemoryBase(_mProxiMityHeapBase, 0, bufsize);

		_mProxiMityBuffer = (SensorEvent*)_mProxiMityMemory->pointer();
		if(_mProxiMityBuffer != NULL)
		{
			memset(_mProxiMityBuffer,0,bufsize);
		}
    }
}


sp<IMemory> SensorServiceApi::getSharedMemory(int type)
{
	 sp<IMemory> temp;
	 switch(type)
	 {
	   case ASENSOR_TYPE_ACCELEROMETER:
		   temp = _mAcclMemory;
		   break;
	   case ASENSOR_TYPE_GYROSCOPE:
           temp = _mGyroMemory;
		   break;
	   case ASENSOR_TYPE_MAGNETIC_FIELD:
           temp = _mMagMemory;
		   break;
	   case ASENSOR_TYPE_LIGHT:
           temp = _mLightMemory;
		   break; 
	   case ASENSOR_TYPE_PROXIMITY:
           temp = _mProxiMityMemory;
		   break; 

	 }
     return temp;
}

void SensorServiceApi::handlerEvent(sensors_event_t * data)
{
    SensorEvent tempSensorEvent;
	if(data != NULL)
	{
	  tempSensorEvent.type = data->type;
      //ALOGE("shao2 tempvalue, value0 = %ld -- value1 = %ld ---value2 = %ld\n",data->data[0] ,tempSensorEvent.dataArray[1] ,tempSensorEvent.dataArray[2]);
	  memcpy(tempSensorEvent.dataArray,data->data,sizeof(float) * 16);
	  //ALOGE("shao,tempvalue type = %d, value0 = %f -- value1 = %f ---value2 = %f\n", tempSensorEvent.type ,tempSensorEvent.dataArray[0] ,tempSensorEvent.dataArray[1] ,tempSensorEvent.dataArray[2]);
	  switch(data->type)
	  {
		 case ASENSOR_TYPE_ACCELEROMETER:
           if(_mAcclBuffer != NULL)
		   {
			 memcpy(_mAcclBuffer,&tempSensorEvent,sizeof(SensorEvent));
			 //ALOGE("shaoaccltempvalue value0 = %f -- value1 = %f ---value2 = %f\n",tempSensorEvent.dataArray[0] ,tempSensorEvent.dataArray[1] ,tempSensorEvent.dataArray[2]);
		   }
		   break;
	     case ASENSOR_TYPE_GYROSCOPE:
		   if(_mGyroBuffer != NULL)
		   {
			 memcpy(_mGyroBuffer,&tempSensorEvent,sizeof(SensorEvent));
			 //ALOGE("shaogyrotempvalue value0 = %f -- value1 = %f ---value2 = %f\n",tempSensorEvent.dataArray[0] ,tempSensorEvent.dataArray[1] ,tempSensorEvent.dataArray[2]);
		   }
		   break;
		 case ASENSOR_TYPE_MAGNETIC_FIELD:
		   if(_mMagBuffer != NULL)
		   {
			 memcpy(_mMagBuffer,&tempSensorEvent,sizeof(SensorEvent));
			 //ALOGE("shaomagtempvalue value0 = %f -- value1 = %f ---value2 = %f\n",tempSensorEvent.dataArray[0] ,tempSensorEvent.dataArray[1] ,tempSensorEvent.dataArray[2]);
		   }
		   break;
		 case ASENSOR_TYPE_LIGHT:
		   if(_mLightBuffer != NULL)
		   {
			 memcpy(_mLightBuffer,&tempSensorEvent,sizeof(SensorEvent));
			 //ALOGE("shaolighttempvalue value0 = %f -- value1 = %f ---value2 = %f\n",tempSensorEvent.dataArray[0] ,tempSensorEvent.dataArray[1] ,tempSensorEvent.dataArray[2]);
		   }
		   break;
		 case ASENSOR_TYPE_PROXIMITY:
		   if(_mProxiMityBuffer != NULL)
		   {
			 memcpy(_mProxiMityBuffer,&tempSensorEvent,sizeof(SensorEvent));
			 //ALOGE("shaoproxitempvalue value0 = %f -- value1 = %f ---value2 = %f\n" ,tempSensorEvent.dataArray[0] ,tempSensorEvent.dataArray[1] ,tempSensorEvent.dataArray[2]);
		   }
		   break;
	  }
	}

}



SensorServiceApi::~SensorServiceApi()
{
 


}

这边分别用5个Memory分别存储地磁，陀螺仪，重力，光感，距离传感器数据，为什么5个是由于上层的调用接口决定，其实只要用1个Memory就行采用回调机制就OK了，由于业务逻辑不一样这边不讨论

现在SensorService就搞定了，也是是IPC的Server端解决了，现在看一下Client端



二：我们要让自己的Service远程调用共享内存获得数据

我这边封装的动态库是可以给Server端和Client端共用的，这边看一下Client的调用逻辑

 
/*
*Created by Zhongqi.Shao on 2017/11/29.
*SDK合理的情况就是只有1个通道1个looper去轮询每次registerListener的时候更新listener地址
*/

#ifndef SENSORNATIVE_SENSORCLIENT_H
#define SENSORNATIVE_SENSORCLIENT_H

#include <gui/SensorManager.h>
#include <gui/Sensor.h>
#include <jni.h>
#include <JNIHelp.h>
#include <stdarg.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>

#define PACKAGE_NAME "SensorNative"

using namespace android;


class SensorClient:public RefBase{

private:

	 SensorManager* _sensorManager;
	 
	 //packageName对应servicea的Key析构时自动清理connection
	 sp<SensorEventQueue> _sensorEventQueue;

	 virtual void onFirstRef();

public:
	
	 SensorClient();
   
	 virtual ~SensorClient();

	 SensorManager& getNativeSensorManager(const char* packageName);

	 //通过type获得senosr 
	 Sensor const* getDefaultSensor(int type);
     
     int nativeDisableSensor(int type);

	 int nativeEnableSensor(int type, int rate_us);

	 sp<IMemory> getSharedMemory(int type);

};



#endif //SENSORNATIVE_SENSORCLIENT_H

//
// Created by Zhongqi.Shao on 2017/11/29.
//
#include <sensornativeapi/SensorClient.h>
#include <android_os_MessageQueue.h>
#include <android_runtime/AndroidRuntime.h>


 SensorClient::SensorClient()
 {
  
 
 }

 void SensorClient::onFirstRef()
 {

	ALOGD("shao first");
	_sensorManager = &getNativeSensorManager("SensorNative");
    _sensorEventQueue = _sensorManager->createEventQueue(String8("SensorNative"));
 }

SensorManager& SensorClient::getNativeSensorManager(const char* packageName)
{
   return SensorManager::getInstanceForPackage(String16(packageName));
}


Sensor const* SensorClient::getDefaultSensor(int type)
{
     return _sensorManager->getDefaultSensor(type);
}


int SensorClient::nativeEnableSensor(int type, int rate_us)
{
    Sensor const* tempSensor = getDefaultSensor(type);
	if(tempSensor == NULL)
	{
		return -1;
	}
	int handle = tempSensor->getHandle();
	ALOGE("shao native enable sensor type = %d\n",handle);
    return _sensorEventQueue->enableSensor(handle, rate_us, 0, 0);
}

int SensorClient::nativeDisableSensor(int type)
{
	Sensor const* tempSensor = getDefaultSensor(type);
	int handle = tempSensor->getHandle();
    return _sensorEventQueue->disableSensor(handle);
}

sp<IMemory> SensorClient::getSharedMemory(int type)
{
  return _sensorManager->getSharedMemory(type);
}


SensorClient::~SensorClient()
{
  _sensorEventQueue.clear();
  ALOGE("shao sensorclient xigou");
}

到这Client的逻辑就OK了，那我们怎么在自己的系统Service调用呢 当然用JNI了这边看一下JNI吧 


extern "C"
JNIEXPORT void JNICALL jni_registerClient
  (JNIEnv * env, jobject obj,jintArray sensorsArgs,jobject objNibiruService, jfloatArray strach)
{
   ISensorInterface interface;
   interface.initClient();
   jint*  typeArray = env->GetIntArrayElements(sensorsArgs,nullptr);
   jint length = env->GetArrayLength(sensorsArgs);
   interface.enableSensors(length,typeArray);
   ALOGE("shao jniEnableSensors");

}

extern "C"
JNIEXPORT jfloatArray JNICALL jni_getSensorData
        (JNIEnv *env, jobject obj,jint sensorType)
{
    ISensorInterface interface;
	sp<IMemory> memory = interface.getSharedMemory(sensorType);
	if(memory.get() == NULL || memory->pointer() == NULL)
	{
		ALOGE("shao shared_pointer null");
		return NULL;
	}else
	{
	   SensorEvent* pointer = (SensorEvent*)(memory->pointer());
	   if(pointer->type == sensorType)
	   {
	      jfloatArray result = env->NewFloatArray(16);
	      env->SetFloatArrayRegion(result, 0, 16, pointer->dataArray);
		  return result;
	   }else
	   {
		  ALOGE("shao need type = %d, src type = %d\n",sensorType,pointer->type);
	      return NULL;
	   }
	}

}



extern "C"
JNIEXPORT void JNICALL jni_unregisterClient
  (JNIEnv * env, jobject obj,jintArray sensorsArgs)
{
    ISensorInterface interface;
	jint*  typeArray = env->GetIntArrayElements(sensorsArgs,nullptr);
    jint length = env->GetArrayLength(sensorsArgs);
    interface.disableSensor(length,typeArray);
	interface.destroyClient();
    ALOGE("shao jniDisableSensors");
}


最后看一下JNI到动态库的接口类吧


//
// Created by Administrator on 2017/11/29.
//

#include <sensornativeapi/ISensorInterface.h>
#include <inttypes.h>
#include <android/sensor.h>
#include <gui/Sensor.h>

API_EXPORT void ISensorInterface::initClient() 
{
   if(spSensor.get() == NULL)
   {
	  spSensor = new SensorClient();
	   ALOGD("shao initClient");
   }
}


API_EXPORT void ISensorInterface::enableSensors(int count,int* typeArray)
{
   if(spSensor.get() != NULL && typeArray != NULL)
   {
     //spSensor->registerListener(callBackListener);
     for (int i = 0;  i < count;  i++)
     {
        int type =  typeArray[i];
	    spSensor->nativeEnableSensor(type,ms2ns(10));
		ALOGE("shao native register2 and type  = %d,count = %d\n",type,count);
     }
   }
}


API_EXPORT void ISensorInterface::destroyClient()
{
  if(spSensor.get() != NULL)
  {
     spSensor.clear();
  }

}


API_EXPORT void ISensorInterface::disableSensor(int count,int* typeArray)
{
   if(spSensor.get() != NULL  && typeArray != NULL)
   {
     for (int i = 0;  i < count;  i++)
     {
        int type =  typeArray[i];
	    spSensor->nativeDisableSensor(type);
		ALOGE("shao native disable sensor  = %d,count = %d\n",type,count);
     }
   }
}

API_EXPORT sp<IMemory> ISensorInterface::getSharedMemory(int type)
{
   if(spSensor.get() != NULL)
   {
      return spSensor->getSharedMemory(type);
   }
   return NULL;
}


ISensorInterface::~ISensorInterface ()
{

}

到这就结束了 要是看不懂的话就联系我 哈哈


  

  

2359_God
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值