從java層到SEE層看怎樣得到sesorlist的, 這個過程對java app而言是隱藏的，當java api getDefaulSensor時已經建立。
![]()
frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java
SensorManager sensorManager = new SystemSensorManager(mContext, mHandler.getLooper());
frameworks/base/core/java/android/hardware/SystemSensorManager.java
/** {@hide} */
public SystemSensorManager(Context context, Looper mainLooper) {
synchronized (sLock) {
if (!sNativeClassInited) {
sNativeClassInited = true;
nativeClassInit();
}
}
mMainLooper = mainLooper;
mTargetSdkLevel = context.getApplicationInfo().targetSdkVersion;
mContext = context;
mNativeInstance = nativeCreate(context.getOpPackageName());
// initialize the sensor list
for (int index = 0;; ++index) {
Sensor sensor = new Sensor();
if (!nativeGetSensorAtIndex(mNativeInstance, sensor, index)) break;
mFullSensorsList.add(sensor);
mHandleToSensor.put(sensor.getHandle(), sensor);
}
}
frameworks/base/core/jni/android_hardware_SensorManager.cpp
nativeCreate
(JNIEnv *env, jclass clazz, jstring opPackageName)
{
ScopedUtfChars opPackageNameUtf(env, opPackageName);
//通過類的全局函數，也就是static函數
return (jlong) &SensorManager::getInstanceForPackage(String16(opPackageNameUtf.c_str()));
}
framework/native/libs/sensor/SensorManager.cpp
class SensorManager : public ASensorManager
{
public:
static SensorManager& getInstanceForPackage(const String16& packageName);
}
getInstanceForPackage -> SensorManager sensorManager = new SensorManager(opPackageName);
SensorManager::SensorManager(const String16& opPackageName)
: mSensorList(nullptr), mOpPackageName(opPackageName), mDirectConnectionHandle(1) {
Mutex::Autolock _l(mLock);
assertStateLocked();
}
sp<ISensorServer> mSensorServer;
Vector<Sensor> mSensors;
status_t SensorManager::assertStateLocked() {
waitForSensorService(&mSensorServer);
//通過sensorservice的代理調用
mSensors = mSensorServer->getSensorList(mOpPackageName);
}
frameworks/native/libs/sensor/ISensorServer.cpp
virtual Vector<Sensor> getSensorList(const String16& opPackageName)
{
Parcel data, reply;
data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
data.writeString16(opPackageName);
remote()->transact(GET_SENSOR_LIST, data, &reply);
Sensor s;
Vector<Sensor> v;
uint32_t n = reply.readUint32();
v.setCapacity(n);
while (n) {
n--;
reply.read(s);
v.add(s);
}
return v;
}
//下面到sensor service的實現部分
//SensorService的構造函數中並沒有太多函數呢
class SensorService :
public BinderService<SensorService>,
public BnSensorServer,
protected Thread
{
}
SensorService::SensorService()
: mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED),
mWakeLockAcquired(false) {
mUidPolicy = new UidPolicy(this);
mSensorPrivacyPolicy = new SensorPrivacyPolicy(this);
}
//繼承類的成員函數：onFirstRef
void SensorService::onFirstRef() {
ALOGD("nuSensorService starting...");
SensorDevice& dev(SensorDevice::getInstance());
}
//這裏調到SensorDevice::getInstance(),單例化SensorDevice
#include <utils/Singleton.h>
template <typename TYPE>
class ANDROID_API Singleton
{
public:
static TYPE& getInstance() {
Mutex::Autolock _l(sLock);
TYPE* instance = sInstance;
if (instance == nullptr) {
instance = new TYPE();
sInstance = instance;
}
return *instance;
}
static bool hasInstance() {
Mutex::Autolock _l(sLock);
return sInstance != nullptr;
}
protected:
~Singleton() { }
Singleton() { }
private:
Singleton(const Singleton&);
Singleton& operator = (const Singleton&);
static Mutex sLock;
static TYPE* sInstance;
};
class SensorDevice : public Singleton<SensorDevice>,
public SensorServiceUtil::Dumpable {
}
SensorDevice::SensorDevice()
: mHidlTransportErrors(20),
mRestartWaiter(new HidlServiceRegistrationWaiter()),
mEventQueueFlag(nullptr),
mWakeLockQueueFlag(nullptr),
mReconnecting(false) {
if (!connectHidlService()) {
return;
}
initializeSensorList();
mIsDirectReportSupported =
(checkReturnAndGetStatus(mSensors->unregisterDirectChannel(-1)) != INVALID_OPERATION);
}
//mSensors成員變量是訪問hidl service的代理接口
sp<SensorServiceUtil::ISensorsWrapper> mSensors;
bool SensorDevice::connectHidlService() {
HalConnectionStatus status = connectHidlServiceV2_0();
if (status == HalConnectionStatus::DOES_NOT_EXIST) {
status = connectHidlServiceV1_0();
}
return (status == HalConnectionStatus::CONNECTED);
}
SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV1_0() {
sp<V1_0::ISensors> sensors = V1_0::ISensors::getService();
mSensors = new SensorServiceUtil::SensorsWrapperV1_0(sensors);
}
void SensorDevice::initializeSensorList() {
checkReturn(mSensors->getSensorsList(
[&](const auto &list) {
const size_t count = list.size();
//下面看下hidl service的方法
proprietary/sensors-see/sensors-hal/framework/sensors_hal.cpp
//hidl接口get_sensors_list
int sensors_hal::get_sensors_list(const sensor_t **s_list)
{
int num_sensors = (int)_hal_sensors.size();
sns_logi("num_sensors=%d", num_sensors);
*s_list = &_hal_sensors[0];
return num_sensors;
}
sensors_hal的構造函數
sensors_hal::sensors_hal()
{
init_sensors();
}
void sensors_hal::init_sensors()
{
auto sensors = sensor_factory::instance().get_all_available_sensors();
auto cb = [this](const auto& event, auto wakeup) { _event_queue.push(event, wakeup); };
sns_logi("initializing sensors");
for (unique_ptr<sensor>& s : sensors) {
assert(s != nullptr);
s->register_callback(cb);
s->update_system_prop_details(_is_rt_thread_enable, _atrace_delay_checktime_ms);
const sensor_t& sensor_info = s->get_sensor_info();
sns_logd("%s: %s/%d wakeup=%d", sensor_info.name,
sensor_info.stringType, sensor_info.handle,
(sensor_info.flags & SENSOR_FLAG_WAKE_UP) != 0);
if (((sensor_info.flags & SENSOR_FLAG_WAKE_UP) != 0)
&& (s->get_reporting_mode() == SENSOR_FLAG_CONTINUOUS_MODE)) {
sns_logi("don't add sensor %s: %s/%d wakeup=%d", sensor_info.name,
sensor_info.stringType, sensor_info.handle,
(sensor_info.flags & SENSOR_FLAG_WAKE_UP) != 0);
} else {
_hal_sensors.push_back(sensor_info);
_sensors[sensor_info.handle] = std::move(s);
}
}
}
//現在的關鍵是看怎麼建立的_hal_sensors
//每個新創建的sensor,都是這個模板
static bool heart_beat_module_init()
{
/* register supported sensor types with factory */
sensor_factory::register_sensor(SENSOR_TYPE_HEART_BEAT,
ssc_sensor::get_available_sensors<heart_beat>);
sensor_factory::request_datatype(SSC_DATATYPE_HEART_BEAT);
return true;
}
SENSOR_MODULE_INIT(heart_beat_module_init);
/**
* @brief register a new sensor type to be supported
*
* @param type sensor type as defined in sensors.h
* @param func factory function for creating sensors of this
* type
*
*/
static void register_sensor(int type, get_available_sensors_func func)
{
try {
callbacks().emplace(type, func);//emplace是個啥？
} catch (const std::exception& e) {
sns_loge("failed to register type %d", type);
}
}
/**
* @brief generic function template for creating ssc_sensors of
* a given typename S
*/
template<typename S>
static std::vector<std::unique_ptr<sensor>> get_available_sensors()
{
const char *datatype = S::ssc_datatype();
const std::vector<sensor_uid>& suids =
sensor_factory::instance().get_suids(datatype);
std::vector<std::unique_ptr<sensor>> sensors;
for (const auto& suid : suids) {
if (!(sensor_factory::instance().get_settings()
& DISABLE_WAKEUP_SENSORS_FLAG)) {
try {
sensors.push_back(std::make_unique<S>(suid, SENSOR_WAKEUP));
}
}
try {
sensors.push_back(std::make_unique<S>(suid, SENSOR_NO_WAKEUP));
}
}
return sensors;//這個函數調用時創建了sensor
}
// 這裏_suid_map已經賦值了，啥時候賦值的？
const std::vector<sensor_uid>& sensor_factory::get_suids(const std::string& datatype) const
{
auto it = _suid_map.find(datatype);
if (it != _suid_map.end()) {
return it->second;
} else {
static vector<sensor_uid> empty;
return empty;
}
}
//_suid_map是怎麼構建的？
/**
* @brief singleton class for creating sensor objects of
* multiple types, querying information such as SUIDs,
* attributes. Classes that implement sensors are
* registered here.
*/
class sensor_factory
{}
sensor_factory構造函數
{
choose_right_mandantory_list_db();
/* find available sensors on ssc */
discover_sensors();
if (_suid_map.size() > 0) {
retrieve_attributes();
}
}
static const char* mandatory_sensors_list_file = "/mnt/vendor/persist/sensors/sensors_list.txt";
//文件的內容是所有sensor的name， 文件是怎麼形成的？編譯時形成的？
void sensor_factory::discover_sensors()
{
suid_lookup lookup(
[this](const string& datatype, const auto& suids)
{
this->suids_lookup_callback(datatype, suids);
});
sns_logd("discovering available sensors...");
for (const auto& dt : datatypes()) {
sns_logd("requesting %s", dt.c_str());
lookup.request_suid(dt, true);
}
suid_lookup
suid_lookup是理解怎麼得到suid的關鍵， 簡而言之，通過suid_lookup獲得了suid
當然要通過ssc_connection才能和SEE通信, suid_lookup隱藏了這一細節
#include "ssc_utils.h"
/**
* @brief type alias for an suid event function
*
* param datatype: datatype of of the sensor associated with the
* event
* param suids: vector of suids available for the given datatype
*/
using suid_event_function =
std::function<void(const std::string& datatype,
const std::vector<sensor_uid>& suids)>;
/**
* @brief Utility class for discovering available sensors using
* dataytpe
*
*/
class suid_lookup
{
public:
/**
* @brief creates a new connection to ssc for suid lookup
*
* @param cb callback function for suids
*/
suid_lookup(suid_event_function cb);
/**
* @brief look up the suid for a given datatype, registered
* callback will be called when suid is available for
* this datatype
*
* @param datatype data type for which suid is requested
* @param default_only option to ask for publishing only default
* suid for the given data type. default value is false
*/
void request_suid(std::string datatype, bool default_only = false);
suid_event_function _cb;
void handle_ssc_event(const uint8_t *data, size_t size);
ssc_connection _ssc_conn;
}