Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> Android Sensor系統剖析(2.3.5)(上)

Android Sensor系統剖析(2.3.5)(上)

編輯:關於Android編程

本文希望通過對androidsensor系統的介紹,使大家在了解android sensor系統架構的同時,會對大家閱讀和分析其他同類型代碼框架有所幫助。 1:概覽 首先看下應用層如何獲取sensor數據 public class SensorActivity extends Activity, implements SensorEventListener {      private final SensorManager mSensorManager;      private final Sensor mAccelerometer;      public SensorActivity() {          //獲取對應服務          mSensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);          //獲取指定sensor對象          mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);      }      protected void onResume() {          super.onResume();          //注冊listener用於數據回調          mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_NORMAL);      }      protected void onPause() {          super.onPause();          mSensorManager.unregisterListener(this);      }      public void onAccuracyChanged(Sensor sensor, int accuracy) {      }      public void onSensorChanged(SensorEvent event) {      }  } 從代碼上看,應用首先要使用sensor service名來獲取SensorManager對象實例,然後調用其成員函數registerListener並傳入listener來得到回調數據。 Sensor service在後台和driver交互獲取數據,各個應用連上service獲取想要的sensor數據,從如上代碼看,沒有任何和service交互的代碼,這一切都被封裝到SensorManager裡了。 2:Sensor service Android輕量級的系統服務,一般都會運行於systemserver內,sensor service夠輕量,當然不能例外。 System server起來時,會創建sensorserivice: //frameworks/base/cmds/system_server/library/system_init.cpp extern "C" status_t system_init() {     LOGI("Entered system_init()");       sp<ProcessState> proc(ProcessState::self());         sp<IServiceManager> sm = defaultServiceManager();     LOGI("ServiceManager: %p\n", sm.get());         sp<GrimReaper> grim = new GrimReaper();     sm->asBinder()->linkToDeath(grim, grim.get(), 0);         char propBuf[PROPERTY_VALUE_MAX];     property_get("system_init.startsurfaceflinger", propBuf, "1");     if (strcmp(propBuf, "1") == 0) {         // Start the SurfaceFlinger         SurfaceFlinger::instantiate();     }     // Start the sensor service     SensorService::instantiate(); ….. } 通過調用SensorService的靜態成員函數instantiate()來初始化並創建sensor service,在詳細介紹這個函數的內部行為之前,先來看下SensorService類的聲明。 //frameworks/base/services/sensorservice/Sensorservice.h class SensorService :         public BinderService<SensorService>,         public BnSensorServer,         protected Thread {    friend class BinderService<SensorService>;    static const nsecs_t MINIMUM_EVENTS_PERIOD =   1000000; // 1000 Hz    SensorService();    virtual ~SensorService();    virtual void onFirstRef();    // Thread interface    virtual bool threadLoop();    // ISensorServer interface     virtual Vector<Sensor> getSensorList();     virtual sp<ISensorEventConnection> createSensorEventConnection();     virtual status_t dump(int fd, const Vector<String16>& args);     class SensorEventConnection : public BnSensorEventConnection {         virtual ~SensorEventConnection();         virtual void onFirstRef();         virtual sp<SensorChannel> getSensorChannel() const;         virtual status_t enableDisable(int handle, bool enabled);         virtual status_t setEventRate(int handle, nsecs_t ns);         sp<SensorService> const mService;         sp<SensorChannel> const mChannel;         mutable Mutex mConnectionLock;         // protected by SensorService::mLock         SortedVector<int> mSensorInfo;     public:         SensorEventConnection(const sp<SensorService>& service);         status_t sendEvents(sensors_event_t const* buffer, size_t count,                 sensors_event_t* scratch = NULL);         bool hasSensor(int32_t handle) const;         bool hasAnySensor() const;         bool addSensor(int32_t handle);         bool removeSensor(int32_t handle);     };     class SensorRecord {         SortedVector< wp<SensorEventConnection> > mConnections;     public:         SensorRecord(const sp<SensorEventConnection>& connection);         bool addConnection(const sp<SensorEventConnection>& connection);         bool removeConnection(const wp<SensorEventConnection>& connection);         size_t getNumConnections() const { return mConnections.size(); }     };     SortedVector< wp<SensorEventConnection> > getActiveConnections() const;     DefaultKeyedVector<int, SensorInterface*> getActiveVirtualSensors() const;     String8 getSensorName(int handle) const;     void recordLastValue(sensors_event_t const * buffer, size_t count);     static void sortEventBuffer(sensors_event_t* buffer, size_t count);     void registerSensor(SensorInterface* sensor);     void registerVirtualSensor(SensorInterface* sensor);     // constants     Vector<Sensor> mSensorList;     DefaultKeyedVector<int, SensorInterface*> mSensorMap;     Vector<SensorInterface *> mVirtualSensorList;     Permission mDump;     status_t mInitCheck;     // protected by mLock     mutable Mutex mLock;     DefaultKeyedVector<int, SensorRecord*> mActiveSensors;     DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors;     SortedVector< wp<SensorEventConnection> > mActiveConnections;     // The size of this vector is constant, only the items are mutable     KeyedVector<int32_t, sensors_event_t> mLastEventSeen; public:     static char const* getServiceName() { return "sensorservice"; }     void cleanupConnection(SensorEventConnection* connection);     status_t enable(const sp<SensorEventConnection>& connection, int handle);     status_t disable(const sp<SensorEventConnection>& connection, int handle);     status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns); };   這個類裡面聲明了很多函數和變量,我們如何區分哪些是框架性接口函數,哪些是功能輔助性的呢?很簡單,看父類就知道了。   class SensorService :         public BinderService<SensorService>,         public BnSensorServer,         protected Thread   SensorService多重繼承自如上三個類,下面簡單介紹下: BinderService<SensorService>: 模板類,主要功能是提供一些靜態函數創建service對象實例,並加到service manager,主要函數有instantiate()等。 Thread: 線程輔助類,調用run創建並啟動線程,然後在線程主函數內會回調threadloop函數,所以我們在使用這個它時,最簡單得做法是派生自它,然後重寫threadloop即可。 BnSensorServer: 這個類派生自ISensorServer,ISensorServer則聲明了sensor server和client之間RPC通信接口,具體如下: class ISensorServer : public IInterface { public:     DECLARE_META_INTERFACE(SensorServer);       virtual Vector<Sensor> getSensorList() = 0;     virtual sp<ISensorEventConnection> createSensorEventConnection() = 0; }; 了解了三個父類的功能後,可以推出SensorService的核心功能如下: 1:SensorService:: instantiate()初始化sensorservice並創建線程 2:threadloop在線程啟動後,從驅動獲取sensor原始數據並通過RPC機制讓sensor client獲取。 3:BnSensorServer的成員函數負責讓sensor client獲取sensor信息和創建connection 接下去我們就從這幾個函數著手進行詳細分析! 先看SensorService:: instantiate():  //frameworks/base/include/binder/BinderService.h template<typename SERVICE> class BinderService { public:     static status_t publish() {         sp<IServiceManager> sm(defaultServiceManager());         return sm->addService(String16(SERVICE::getServiceName()), new SERVICE());     }     static void publishAndJoinThreadPool() {         sp<ProcessState> proc(ProcessState::self());         sp<IServiceManager> sm(defaultServiceManager());         sm->addService(String16(SERVICE::getServiceName()), new SERVICE());         ProcessState::self()->startThreadPool();         IPCThreadState::self()->joinThreadPool();     }     static void instantiate() { publish(); }     static status_t shutdown() {         return NO_ERROR;     } BinderService是模板類,通過代碼可以看到,instantiate直接調用了publish函數,publish函數先獲取service manager,然後new了一個SensorService對象,接著調用addService並將sensor service name和新創建sensorservice對象傳入。 可能有人會問,調用addService的目的是什麼?我們不是通過newSensorService創建sensor後台服務了嗎?是的,服務的確已經啟動了,但是服務的目的是什麼?是供他人使用,你要讓他人使用你,前提是得讓別人找到你,所以我覺得addService的主要功能有兩點: 1:將sensor service信息傳入binderkernel,然後binder kernel生成對應於sensor service的handle,並維護之。 2:service manager得到並維護對應servicename和handle供其他應用獲取。 舉例來說,這就好比你建立了一台設備,你要讓別人連接你這台設備,你需要讓你的設備與寬帶服務器建立撥號連接,然後寬帶服務器給你分配ip,別人拿到ip,就能與你建立通信鏈接了,但是ip太難記了,所以就有了域名 把例子中描述的和android機制對應下,設備對應sensor service,binder kernel對應寬帶服務器,ip對應handle,service name對應域名,那service manager對應什麼?當然是域名解析服務了。 所以現在就很明了了,客戶端要與對應的服務建立通信,只需要通過服務名拿到對應的handle,然後用這個handle組建對應的proxy binder對象即可。 那從代碼中呢,如何區分代碼是用於創建本地服務還是創建遠程代理呢?很簡單,看類命名就可以了,以Sensor service舉例,本地服務類為BnSensorServer,代理類則為BpSensorServer,開到類的開頭沒,Bn以為native binder,Bp則是proxy binder。 Android RPC通信那塊就簡單介紹到這裡,繼續往下看。 服務創建時,new了一個SensorService對象實例,那接下去代碼肯定走SensorService的構造函數: //frameworks/base/services/sensorservice/SensorService.cpp  SensorService::SensorService()     : Thread(false),       mDump("android.permission.DUMP"),       mInitCheck(NO_INIT){ } 看到了,構造函數相當於啥也沒做,既然sensorservice對象傳給了ServiceManager::AddService,我們來看看AddService的函數聲明 virtual status_t addService( const String16& name, const sp<IBinder>& service); 第二個參數是sp強引用對象,而非單純的sensor service指針,在第一次構建sp強引用對象時,會調用onFirstRef(): void SensorService::onFirstRef() {     LOGD("nuSensorService starting...");     SensorDevice& dev(SensorDevice::getInstance());     if (dev.initCheck() == NO_ERROR) {         uint32_t virtualSensorsNeeds =                 (1<<SENSOR_TYPE_GRAVITY) |                 (1<<SENSOR_TYPE_LINEAR_ACCELERATION) |                 (1<<SENSOR_TYPE_ROTATION_VECTOR);         sensor_t const* list;         int count = dev.getSensorList(&list);         mLastEventSeen.setCapacity(count);         for (int i=0 ; i<count ; i++) {             registerSensor( new HardwareSensor(list[i]) );             switch (list[i].type) {                 case SENSOR_TYPE_GRAVITY:                 case SENSOR_TYPE_LINEAR_ACCELERATION:                 case SENSOR_TYPE_ROTATION_VECTOR:                     virtualSensorsNeeds &= ~(1<<list[i].type);                     break;             }         }           if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) {             registerVirtualSensor( new GravitySensor(list, count) );         }         if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) {             registerVirtualSensor( new LinearAccelerationSensor(list, count) );         }         if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {             registerVirtualSensor( new RotationVectorSensor(list, count) );         }           run("SensorService", PRIORITY_URGENT_DISPLAY);         mInitCheck = NO_ERROR;     } } 這個函數先通過SensorDevice:: getInstance獲取SensorDevice對象實例,所以我們接著看SensorDevice的構造函數: SensorDevice::SensorDevice()     :  mSensorDevice(0),        mSensorModule(0) {     status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,             (hw_module_t const**)&mSensorModule);     LOGE_IF(err, "couldn't load %s module (%s)",             SENSORS_HARDWARE_MODULE_ID, strerror(-err));     if (mSensorModule) {         err = sensors_open(&mSensorModule->common, &mSensorDevice);         LOGE_IF(err, "couldn't open device for module %s (%s)",                 SENSORS_HARDWARE_MODULE_ID, strerror(-err));         if (mSensorDevice) {             sensor_t const* list;             ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);             mActivationCount.setCapacity(count);             Info model;             for (size_t i=0 ; i<size_t(count) ; i++) {                 mActivationCount.add(list[i].handle, model);                 //初始將所有sensor設置為未激活狀態                 mSensorDevice->activate(mSensorDevice, list[i].handle, 0);             }         }     } } 通過構造函數可以看出,SensorDevice封裝了對SensorHAL層代碼的調用,主要包含獲取sensor list,poll sensor數據和是否激活指定sensor等,這裡就不詳細描述。 繼續從SensorService::onFirstRef往下走,在得到SensorDevice對象實例後,通過調用dev.getSensorList(&list)獲取sensor list,然後調用registersensor將所有sensor加到SensorService的成員變量mSensorList中。 接下去調用run啟動線程: run("SensorService", PRIORITY_URGENT_DISPLAY);   線程啟動後,threadloop會被回調 bool SensorService::threadLoop() {     LOGD("nuSensorService thread starting...");       const size_t numEventMax = 16 * (1 + mVirtualSensorList.size());     sensors_event_t buffer[numEventMax];     sensors_event_t scratch[numEventMax];     SensorDevice& device(SensorDevice::getInstance());     const size_t vcount = mVirtualSensorList.size();       ssize_t count; do {     //從設備獲取已經激活sensor的數據,如果無一sensor被激活,該動作將會被     //阻塞         count = device.poll(buffer, numEventMax);         if (count<0) {             LOGE("sensor poll failed (%s)", strerror(-count));             break;         }         //獲取最新的數據         recordLastValue(buffer, count);           // handle virtual sensors         if (count && vcount) {             const DefaultKeyedVector<int, SensorInterface*> virtualSensors(                     getActiveVirtualSensors());             const size_t activeVirtualSensorCount = virtualSensors.size();             if (activeVirtualSensorCount) {                 size_t k = 0;                 for (size_t i=0 ; i<size_t(count) ; i++) {                     sensors_event_t const * const event = buffer;                     for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {                         sensors_event_t out;                         if (virtualSensors.valueAt(j)->process(&out, event[i])) {                             buffer[count + k] = out;                             k++;                         }                     }                 }                 if (k) {                     // record the last synthesized values                     recordLastValue(&buffer[count], k);                     count += k;                     // sort the buffer by time-stamps                     sortEventBuffer(buffer, count);                 }             }         }           // 得到已有的client連接         const SortedVector< wp<SensorEventConnection> > activeConnections(                 getActiveConnections());         size_t numConnections = activeConnections.size();         for (size_t i=0 ; i<numConnections ; i++) {             sp<SensorEventConnection> connection(                     activeConnections[i].promote());             if (connection != 0) {                 //將sensor數據發往client端                 connection->sendEvents(buffer, count, scratch);             }         }     } while (count >= 0 || Thread::exitPending());       LOGW("Exiting SensorService::threadLoop!");     return false; } Threadloop主要通過調用sensor HAL函數獲取已激活sensor的數據,然後將獲取到的數據發往已經建立的connection。 Connection是如何建立的?我們之前描述的三個父類的功能中已經有過描述,ISensorServer定義了client和sensor service的RPC通信接口,client端在得到sensor service代理對象後,通過調用createSensorEventConnection與sensorservice建立connection,先看service端的實現代碼: sp<ISensorEventConnection> SensorService::createSensorEventConnection() {     sp<SensorEventConnection> result(new SensorEventConnection(this));     return result; }   Service端僅僅創建了SensorEventConnection對象實例,然後將這個對象實例傳給client端,這裡有兩個疑問: 1:將實例對象傳給client,那是否SensorEventConnection實例也是個RPC服務? 2:sensor service不是保存了active connections,這裡也沒做保存操作,那在哪裡保存?唯一的線索就是構造SensorEventConnection傳入的this指針了。   先看第一個疑問,SensorEventConnection是不是RPC服務,看其構造函數先 class SensorEventConnection : public BnSensorEventConnection 看到沒?父類是Bn開頭的,說明其是native binder,的確是RPC服務,由於這個服務是私底下咱哥倆偷摸用的,所以就無需加入servicemanager了。 那這個connection是怎麼加入sensorservice的action connections的,由於是RPC服務,所以這塊動作應該是由client驅動的。 先看ISensorEventConnection class ISensorEventConnection : public IInterface { public:     DECLARE_META_INTERFACE(SensorEventConnection);     virtual sp<SensorChannel> getSensorChannel() const = 0;     virtual status_t enableDisable(int handle, bool enabled) = 0;     virtual status_t setEventRate(int handle, nsecs_t ns) = 0; }; 共三個接口函數,setEventRate這個應該是設置sensor 數據上報頻率的,跟active connection應該沒啥關系;getSensorChannel是干嘛用的?等會介紹,但是看名字,也不像!剩下就是enableDisable這個函數了 status_t SensorService::SensorEventConnection::enableDisable(         int handle, bool enabled) {     status_t err;     if (enabled) {         err = mService->enable(this, handle);     } else {         err = mService->disable(this, handle);     }     return err; } 如果是enable,調用sensor service的enable函數 status_t SensorService::enable(const sp<SensorEventConnection>& connection,         int handle) {     if (mInitCheck != NO_ERROR)         return mInitCheck;       Mutex::Autolock _l(mLock); SensorInterface* sensor = mSensorMap.valueFor(handle); //將對應sensor激活     status_t err = sensor ? sensor->activate(connection.get(), true) : status_t(BAD_VALUE);     if (err == NO_ERROR) {         SensorRecord* rec = mActiveSensors.valueFor(handle);         if (rec == 0) {             rec = new SensorRecord(connection);             mActiveSensors.add(handle, rec);             if (sensor->isVirtual()) {                 mActiveVirtualSensors.add(handle, sensor);             }         } else {             if (rec->addConnection(connection)) {                 // this sensor is already activated, but we are adding a                 // connection that uses it. Immediately send down the last                 // known value of the requested sensor.                 sensors_event_t scratch;                 sensors_event_t& event(mLastEventSeen.editValueFor(handle));                 if (event.version == sizeof(sensors_event_t)) {                     connection->sendEvents(&event, 1);                 }             }         }         if (err == NO_ERROR) {             // connection now active             //將connection加入active connection中             if (connection->addSensor(handle)) {                 // the sensor was added (which means it wasn't already there)                 // so, see if this connection becomes active                 if (mActiveConnections.indexOf(connection) < 0) {                     mActiveConnections.add(connection);                 }             }         }     }     return err; } 在這個函數中,激活對應sensor,然後將當前connection加入active connection   到這裡,知道了如何創建connection和activeconnection後,還有一個問題就是,sensor數據發送的?大家可能會說,不是通過調用SensorEventConnection ::sendEvents來實現的嗎?但是回過頭看下ISensorEventConnection的三個函數聲明,沒有sendEvents這個函數,也就說sendEvents只是一個供sensorservice端用的public函數而已。 status_t SensorService::SensorEventConnection::sendEvents(         sensors_event_t const* buffer, size_t numEvents,         sensors_event_t* scratch) {     //。。。。     ssize_t size = mChannel->write(scratch, count*sizeof(sensors_event_t));     if (size == -EAGAIN) {         // the destination doesn't accept events anymore, it's probably         // full. For now, we just drop the events on the floor.         LOGW("dropping %d events on the floor", count);         return size;     }       LOGE_IF(size<0, "dropping %d events on the floor (%s)",             count, strerror(-size));       return size < 0 ? status_t(size) : status_t(NO_ERROR); } SensorEvent調用SensorChannel的wirte函數發送sensor數據,mChannel是在SensorEventConnection函數中初始化的。 ssize_t SensorChannel::write(void const* vaddr, size_t size) {     ssize_t len = ::write(mSendFd, vaddr, size);     if (len < 0)         return -errno;     return len; } 從這個函數中看到,sensorservice和client端的sensor數據不是通過RPC機制傳遞的,看下SensorChannel的構造函數 SensorChannel::SensorChannel()     : mSendFd(-1), mReceiveFd(-1) {     int fds[2];     if (pipe(fds) == 0) {         mReceiveFd = fds[0];         mSendFd = fds[1];         fcntl(mReceiveFd, F_SETFL, O_NONBLOCK);         fcntl(mSendFd, F_SETFL, O_NONBLOCK);     } } 明白了,進程間數據共享是通過管道來實現的,現在知道ISensorEventConnection:: getSensorChannel的作用了,用於傳遞Receive FD給client的  www.2cto.com status_t SensorChannel::writeToParcel(Parcel* reply) const {     if (mReceiveFd < 0)         return -EINVAL;       status_t result = reply->writeDupFileDescriptor(mReceiveFd);     close(mReceiveFd);     mReceiveFd = -1;     return result; }   Client端拿到received FD後,就可以讀取sensor數據啦。至此,服務端已經說完了,接下去是客戶端部分的講解。
  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved