四：Sensor SLPI层SAM Sensor实例分析
上文中，我们大致了解了物理sensor driver整个流程，但在项目中，一般写这种sensor driver的情况很少。这种sensor driver基本上都是各个vendor厂商提供的，我们也只需要看懂即可。
但是SAM sensor我们完全是可以自己写的，根据一些物理sensor的数据，来实现一些算法。
比如，实现拿起唤醒功能，这个功能在oem手机中非常常见。
基本功能就是：当用户拿起手机时，手机屏幕亮起，此时可以通过脸部识别，来解锁手机等等。
这时好多人可能会说，这不是很简单吗？在framework层就可以做，注册一个加速度传感器，并根据data做一定算法处理。根本不需要再SLPI侧再实现一个SAM sensor。这种思维就是典型的应用层程序员的思想，系统层程序员如果有这种思想，那就很危险了。
为什么不能再framework层上做算法处理呢？
framework层进行算法处理，当系统睡下去怎么办？若是注册Non-Wakeup的sensor的话，在系统suspend时，不会有任何数据上报，如何唤醒系统呢？若是注册Wakeup的sensor的话，系统会被wakelock住，根本睡不下去，这时系统功耗非常高。
可见在framework层做的想法是在系统层面不可能实施的。
那么在SLPI侧实现pick up sensor的思路是什么呢？
pick up sensor在LPSS侧是work的，APSS侧是可以suspend的，当pick up Sensor获取accel sensor的数据满足算法时，会publish event给APSS中client，此时会唤醒系统。唤醒系统后，framework层会根据该sensor type，做相应的操作，比如亮屏、震动等等。。。
Ok，下面我们以该pickup sensor为例，解析下SLPI 侧 SAM Sensor driver。
高通给我们参考的oem sensor实例，下面我们在oem sensor实例上实现pickup sensor。
1：build脚本
根据上文中介绍。各个sensor都是通过xxxx.scons静态添加sensor的。
oem sensor的source code在/slpi/ssc/sensors/oem1中。
if 'USES_SSC_STATIC_LIB_BUILDER' in env:
env.AddSSCSU(inspect.getfile(inspect.currentframe()),
register_func_name = "sns_oem1_register",
clean_pack_list = oem1_clean_pack_list,
binary_lib = oem1_binary_lib,
add_island_files = oem1_island_enable,
diag_ssid = ssid)build脚本会通过register_func_name = “sns_oem1_register”，调到sns_oem1_register函数。
2：Initialization
sns_rc sns_oem1_register(sns_register_cb const *register_api)
{
register_api->init_sensor(sizeof(sns_oem1_sensor_state),
&sns_oem1_api,
&sns_oem1_sensor_instance_api);
return SNS_RC_SUCCESS;
}
sns_sensor_api sns_oem1_api =
{
.struct_len = sizeof(sns_sensor_api),
.init = &sns_oem1_init,
.deinit = &sns_oem1_deinit,
.get_sensor_uid = &sns_oem1_get_sensor_uid,
.set_client_request = &sns_oem1_set_client_request,
.notify_event = &sns_oem1_notify_event,
};
根据前文介绍。sns_register_sensor()注册函数后，会执行sns_sensor_api的init函数。
.init
sns_rc
sns_oem1_init(sns_sensor *const this)
{
sns_oem1_sensor_state *state = (sns_oem1_sensor_state*)this->state->state;
struct sns_service_manager *smgr = this->cb->get_service_manager(this);
float data[3];
state->diag_service = (sns_diag_service*)
smgr->get_service(smgr, SNS_DIAG_SERVICE);
// set default output value corresponding to OEM1_FACING_DOWN to 50. will
// rewrite if registry sensor is available
state->config.down_value = 50.0;
state->first_pass = true;
// determine encoded output event size
state->config.encoded_data_event_len =
pb_get_encoded_size_sensor_stream_event(data, 3);
SNS_SUID_LOOKUP_INIT(state->suid_lookup_data, NULL);
sns_suid_lookup_add(this, &state->suid_lookup_data, "accel");//No.1
sns_suid_lookup_add(this, &state->suid_lookup_data, "amd"); //No.2
#ifndef SUPPORT_DIRECT_SENSOR_REQUEST
sns_suid_lookup_add(this, &state->suid_lookup_data, "resampler");//No.3
#endif
publish_attributes(this); //No.4
SNS_PRINTF(MED, this, "OEM1 init success and attributes published");
return SNS_RC_SUCCESS;
}No.1：sns_suid_look_add添加所需要的sensor。
No.2：添加amd sensor。
No.3：添加resampler sensor。
No.4：并pushlish atrribute。比如sensor name、type、vendor等，Client层会根据该attribute，设置sensor的一些属性，比如on_change、streaming等等
.get_sensor_uid
static sns_sensor_uid const*
sns_oem1_get_sensor_uid(sns_sensor const *this)
{
UNUSED_VAR(this);
static const sns_sensor_uid oem1_suid = OEM1_SUID;
return &oem1_suid;
}oem1_suid是指定的，返回的是oem_suid。
.notify
sns_rc
sns_oem1_notify_event(sns_sensor *const this)
{
sns_oem1_sensor_state *state = (sns_oem1_sensor_state*)this->state->state;
SNS_PRINTF(LOW, this, "sns_oem1_notify_event");
sns_suid_lookup_handle(this, &state->suid_lookup_data);
#ifdef SUPPORT_REGISTRY
if(NULL != state->registry_stream)
{
handle_oem1_registry_event(this);
}
#endif
if(sns_suid_lookup_complete(&state->suid_lookup_data))
{
#ifdef SUPPORT_REGISTRY
if(state->first_pass == true){
state->first_pass = false;
sns_oem1_registry_req(this);
}
#endif
publish_available(this);
sns_suid_lookup_deinit(this, &state->suid_lookup_data);
}
return SNS_RC_SUCCESS;
}
该notify，主要处理init中的event。
通过sns_suid_lookup_handle()，handle一个suid或者attribute event。
通过sns_suid_lookup_complete()，来返回所有sensor data 的suid是否找到。
Initialization分析完毕，Initialization重要东西不多，主要是添加所需要的dependency sensor，比如accel、amd、resampler等等，并获取oem1_suid。然后通过notify_event来查看sensor type的suid是否找到。
3： Activation
sns_sensor_instance_api sns_oem1_sensor_instance_api =
{
.struct_len = sizeof(sns_sensor_instance_api),
.init = &sns_oem1_inst_init,
.deinit = &sns_oem1_inst_deinit,
.set_client_config = &sns_oem1_inst_set_client_config,
.notify_event = &sns_oem1_inst_notify_event
};
当client发送request时，先进入sns_sensor_api中的.set_client_config。
.set_client_config
sns_sensor_instance*
sns_oem1_set_client_request(sns_sensor *const this,
sns_request const *curr_req,
sns_request const *new_req,
bool remove)
{
sns_sensor_instance *curr_inst =
sns_sensor_util_find_instance(
this,
curr_req,
this->sensor_api->get_sensor_uid(this));
sns_sensor_instance *rv_inst = NULL;
SNS_PRINTF(MED, this, "sns_oem1_set_client_request");
if((NULL != curr_inst) && (NULL != new_req) &&
(SNS_STD_MSGID_SNS_STD_FLUSH_REQ == new_req->message_id))
{
SNS_PRINTF(HIGH, this, "Received Flush Request");
this->instance_api->set_client_config(curr_inst, new_req);
rv_inst = curr_inst;
}
else if(remove)
{
if(NULL != curr_inst)
{
curr_inst->cb->remove_client_request(curr_inst, curr_req);
}
}
else
{
pb_istream_t stream;
sns_std_sensor_config config = {0};
sns_std_request request = sns_std_request_init_default;
pb_simple_cb_arg arg =
{ .decoded_struct = &config, .fields = sns_std_sensor_config_fields };
request.payload = (struct pb_callback_s)
{ .funcs.decode = &pb_decode_simple_cb, .arg = &arg };
stream = pb_istream_from_buffer(new_req->request, new_req->request_len);
if(pb_decode(&stream, sns_std_request_fields, &request))
{
sns_request decoded_req = {.message_id = new_req->message_id,
.request_len = sizeof(config), .request = &config };
sns_sensor_instance *match_inst = sns_sensor_util_find_instance_match(
this, &decoded_req, &find_instance_match);
if(NULL == curr_inst)
{
// If this is a request from a new client
if(NULL == match_inst)
{
rv_inst = this->cb->create_instance(this,
(sizeof(sns_oem1_inst_state)));
}
else
{
rv_inst = match_inst;
}
}
else
{
if(NULL != curr_req)
{
curr_inst->cb->remove_client_request(curr_inst, curr_req);
}
if(NULL != match_inst)
{
rv_inst = match_inst;
}
else
{
rv_inst = this->cb->create_instance(this,
(sizeof(sns_oem1_inst_state)));
}
}
if(NULL != rv_inst)
{
rv_inst->cb->add_client_request(rv_inst, new_req);
this->instance_api->set_client_config(rv_inst, &decoded_req);
}
}
else
{
SNS_PRINTF(ERROR, this, "failed to decode request");
}
}
if(NULL != curr_inst && NULL == curr_inst->cb->get_client_request(
curr_inst, this->sensor_api->get_sensor_uid(this), true))
{
this->cb->remove_instance(curr_inst);
}
return rv_inst;
}该函数很简单，
（1）先判断是否有与new_request匹配的sns_sensor_instance，若有直接用match的；
（2）若无，判断是否有当前的sns_sensor_instance即旧的sns_sensor_instance。若有，则通过curr_inst->cb->remove_client_request函数remove掉旧的sns_sensor_instance，并通过this->cb->create_instance()创建一个新的sns_sensor_instance。若无，则直接创建一个新的sns_sensor_instance。
（3）创建好的sns_sensor_instance叫rv_inst，然后通过rv_inst->cb->add_client_request添加新的client request。
（4）并通过this->instance_api->set_client_config处理该新建的sns_sensor_instance ，即rv_inst。
（5）出错处理，若curr_inst不为空，并且curr_inst还可以获取到client_reqeust。说明旧的sns_sensor_instance移除失败。
Ok，create_instance()执行后便进入sns_sensor_instance_api.init()。
set_client_config()执行后便进入sns_sensor_instance_api.set_client_config()。
.init
sns_rc
sns_oem1_inst_init(sns_sensor_instance *this,
sns_sensor_state const *state)
{
sns_rc rc = SNS_RC_SUCCESS;
sns_oem1_inst_state *inst_state =
(sns_oem1_inst_state*)this->state->state;
sns_oem1_sensor_state *sensor_state =
(sns_oem1_sensor_state*)state->state;
sns_service_manager *service_mgr = this->cb->get_service_manager(this);
#ifdef SUPPORT_DIRECT_SENSOR_REQUEST
sns_stream_service *stream_service = (sns_stream_service*)
service_mgr->get_service(service_mgr, SNS_STREAM_SERVICE);
#endif
#ifdef SUPPORT_DIRECT_SENSOR_REQUEST
sns_suid_lookup_get(&sensor_state->suid_lookup_data, "accel", &inst_state->accel_suid);
#else
sns_suid_lookup_get(&sensor_state->suid_lookup_data, "resampler", &inst_state->resampler_suid);
sns_suid_lookup_get(&sensor_state->suid_lookup_data, "accel", &inst_state->accel_suid);
#endif
inst_state->diag_service = (sns_diag_service*)
service_mgr->get_service(service_mgr, SNS_DIAG_SERVICE);
inst_state->down_value = sensor_state->config.down_value;
#ifdef SUPPORT_DIRECT_SENSOR_REQUEST
// start regular stream for accel
stream_service->api->create_sensor_instance_stream(
stream_service,
this,
inst_state->accel_suid,
&inst_state->accel_stream);
#endif
inst_state->inst_config.previous_state = OEM1_UNKNOWN;
inst_state->inst_config.current_state = OEM1_UNKNOWN;
// read platform specific configuration
sns_memscpy(&inst_state->config,
sizeof(inst_state->config),
&sensor_state->config,
sizeof(sensor_state->config) );
return rc;
}该函数，主要是获取resampler、accel等的suid。将suid放到inst_state->xxxx_suid中。
.set_client_config
sns_rc
sns_oem1_inst_set_client_config(sns_sensor_instance *const this,
sns_request const *client_request)
{
sns_rc rc = SNS_RC_SUCCESS;
sns_oem1_inst_state *state = (sns_oem1_inst_state*)this->state->state;
SNS_INST_PRINTF(LOW, this, "sns_oem1_inst_set_client_config");
if(SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_CONFIG == client_request->message_id)
{
// initialize state here
sns_std_sensor_config *client_req =
(sns_std_sensor_config *)(client_request->request);
sns_memscpy(&state->client_config,
sizeof(state->client_config),
client_request->request,
client_request->request_len);
state->config.sample_rate = client_req->sample_rate;
#ifndef SUPPORT_DIRECT_SENSOR_REQUEST
// start streaming from resampler
SNS_INST_PRINTF(LOW, this, "Enable resampler at rate %f", client_req->sample_rate);
sns_service_manager *manager =
this->cb->get_service_manager(this);
sns_stream_service *stream_service =
(sns_stream_service*)manager->get_service(manager, SNS_STREAM_SERVICE);
sns_resampler_config resampler_config = sns_resampler_config_init_default;
size_t encoded_len;
uint8_t buffer[100];
client_req->sample_rate = 25.0f;
sns_memscpy(&resampler_config.sensor_uid, //No.1
sizeof(resampler_config.sensor_uid),
&state->accel_suid,
sizeof(state->accel_suid));
resampler_config.resampled_rate = client_req->sample_rate;
resampler_config.rate_type = SNS_RESAMPLER_RATE_MINIMUM;
resampler_config.filter = false;
// create connection with resampler sensor
stream_service->api->create_sensor_instance_stream( //No.2
stream_service,
this,
state->resampler_suid,
&state->resampler_stream);
if(NULL != state->resampler_stream)
{
encoded_len = pb_encode_request(buffer, sizeof(buffer),
&resampler_config, sns_resampler_config_fields, NULL);
if(0 < encoded_len)
{
sns_request request = (sns_request){
.message_id = SNS_RESAMPLER_MSGID_SNS_RESAMPLER_CONFIG,
.request_len = encoded_len, .request = buffer };
rc = state->resampler_stream->api->send_request(state->resampler_stream, &request);
SNS_INST_PRINTF(MED, this, "oem1 sent accel request to resampler at rate %f", client_req->sample_rate);
}
else
{
SNS_INST_PRINTF(ERROR, this, "oem1 failed to encode resampler config");
}
}
else
{
SNS_INST_PRINTF(ERROR, this, "oem1 resampler stream creation failed");
}
#else // not using the resampler, request accel directly
size_t encoded_len;
uint8_t buffer[20];
// enable accel here
sns_memset(buffer, 0, sizeof(buffer));
client_req->sample_rate = 25.0f;
sns_std_sensor_config accel_config = {.sample_rate = client_req->sample_rate};
SNS_INST_PRINTF(LOW, this, "Enable accel at rate %f", client_req->sample_rate);
encoded_len = pb_encode_request(buffer,
sizeof(buffer),
&accel_config,
sns_std_sensor_config_fields,
NULL);
if(0 < encoded_len && NULL != state->accel_stream )
{
sns_request request = (sns_request){
.message_id = SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_CONFIG,
.request_len = encoded_len, .request = buffer };
state->accel_stream->api->send_request(state->accel_stream, &request);
}
else
{
SNS_INST_PRINTF(ERROR, this, "Error in creating accel stream OR encoding failed");
rc = SNS_RC_NOT_SUPPORTED;
}
SNS_INST_PRINTF(LOW, this, "Processed oem1 config request: enabled accel with"
"sample rate %f, result: %u", state->client_config.sample_rate, rc);
#endif
}
else if(client_request->message_id == SNS_STD_MSGID_SNS_STD_FLUSH_REQ)
{
sns_sensor_util_send_flush_event(NULL, this);
}
else
{
SNS_INST_PRINTF(ERROR, this, "Unsupported request message id %u",
client_request->message_id);
rc = SNS_RC_NOT_SUPPORTED;
}
return rc;
}该函数，首先根据client传入的msg_id做处理。
当message_id = SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_CONFIG时，这时，我们就需要发送accel的request，来获取accel的data了。
这里面有个宏SUPPORT_DIRECT_SENSOR_REQUEST，这里我们不support这个宏，走的是resampler。若support这个宏，则直接发送request给accel。
这里用resampler后，会先发送request给resampler sensor，resampler sensor再获取accel的数据。
No.1中，填充sns_resampler_config。并将state->accel_suid赋给resampler_config.sensor_uid。
No.2中，create_sensor_instance_stream会创建data stream，以后resampler request和event都会走该data stream。
然后通过pb_encode_request，将sns_resampler_config 编码成buffer。
最后填充sns_request request，可以看到request message_id = SNS_RESAMPLER_MSGID_SNS_RESAMPLER_CONFIG ，.request = buffer。然后通过send_request发送出去。
sns_oem1_inst_set_client_config发送完毕后，接下来就是接收event了。
.notify_event
static sns_rc
sns_oem1_inst_notify_event(sns_sensor_instance *const this)
{
sns_rc rc = SNS_RC_SUCCESS;
sns_oem1_process_resampler_event(this);
return rc;static sns_rc sns_oem1_process_resampler_event(sns_sensor_instance *const this)
{
sns_rc rc = SNS_RC_SUCCESS;
sns_oem1_inst_state *state = (sns_oem1_inst_state*)this->state->state;
sns_sensor_event *resampler_event_in = NULL;
SNS_INST_PRINTF(LOW, this, "sns_oem1_inst_process_resampler_event");
resampler_event_in = state->resampler_stream->api->peek_input(state->resampler_stream);
while( NULL != resampler_event_in )
{
if(SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_EVENT == resampler_event_in->message_id) //No.1
{
float data[3] = { 0 };
float oem1_payload[OEM1_NUM_ELEMS];
uint8_t arr_index = 0;
pb_float_arr_arg arg = {
.arr = data,
.arr_len = ARR_SIZE(data),
.arr_index = &arr_index
};
pb_istream_t stream = pb_istream_from_buffer((pb_byte_t*)resampler_event_in->event,resampler_event_in->event_len);
sns_std_sensor_event resampler_data = sns_std_sensor_event_init_default;
resampler_data.data = (struct pb_callback_s) {
.funcs.decode = &pb_decode_float_arr_cb, .arg = &arg
};
if(!pb_decode(&stream, sns_std_sensor_event_fields, &resampler_data)) //No.2
{
SNS_INST_PRINTF(ERROR, this, "Error in decoding resampler event");
}
else
{
if (SNS_STD_SENSOR_SAMPLE_STATUS_UNRELIABLE == resampler_data.status)
{
SNS_INST_PRINTF(LOW, this, " OEM1 received unreliable accel data"
" from resampler ignoring..");
resampler_event_in = state->resampler_stream->api->get_next_input(state->resampler_stream);
continue;
}
//This is dummy logic for OEM1 demonstration purposes
//OEMs can replace with their algo logic
oem1_facing_state current_state = OEM1_UNKNOWN;
SNS_INST_PRINTF(LOW, this,
"resampler accel data: x %d/1000, y %d/1000, z %d/1000",
(int) (1000*data[0]),(int)( 1000*data[1]),(int)(1000*data[2]));
//sns_oem1_procces(this, &input);
state->inst_config.previous_state = state->inst_config.current_state;
if(0 < data[2]) //No.3
{
current_state = OEM1_FACING_UP;
oem1_payload[0]=100;
oem1_payload[1]=data[1];
oem1_payload[2]=data[2];
}
else
{
current_state = OEM1_FACING_DOWN;
oem1_payload[0]= state->down_value;
oem1_payload[1]=data[1];
oem1_payload[2]=data[2];
}
state->inst_config.current_state = current_state;
SNS_INST_PRINTF(LOW, this, "OEM1 output: x %d/1000, y %d/1000, z %d/1000",
(int) (1000*oem1_payload[0]),(int)( 1000*oem1_payload[1]),(int)(1000*oem1_payload[2]));
#ifdef SUPPORT_EVENT_TYPE
if(state->inst_config.current_state != state->inst_config.previous_state)
{
#endif
SNS_INST_PRINTF(MED, this,
"OEM1 last %d current %d",
state->inst_config.current_state,
state->inst_config.previous_state);
rc = pb_send_sensor_stream_event(this, //No.4
NULL,
resampler_event_in->timestamp,
SNS_OEM1_MSGID_SNS_OEM1_DATA,
SNS_STD_SENSOR_SAMPLE_STATUS_ACCURACY_HIGH,
oem1_payload,
OEM1_NUM_ELEMS,
state->config.encoded_data_event_len);
if(SNS_RC_SUCCESS != rc)
{
SNS_INST_PRINTF(ERROR, this, "sns_oem1_inst_notify_event - Error in sending event");
}
#ifdef SUPPORT_EVENT_TYPE
}
#endif
}
}
// check next sample
resampler_event_in = state->resampler_stream->api->get_next_input(state->resampler_stream);
}
return rc;
}No.1：接收到accel的message_id。
No.2：将stream解码成resampler_data的格式。resampler_data.data.arr即为accel的sensor data。
No.3：该处是根据accel数据做算法处理。比如panel朝向，panel加速度等等。
No.4：pb_send_sensor_stream_event来publish event，若算法满足，可以通过该函数publish event，client便接收到event来唤醒系统，最终实现wake up。
Ok，SAM sensor分析完毕，该文与上一篇文章流程基本相似，唯一不同点就是SAM Sensor会Dependency other sensor，并在sns_sensor_instance_api.set_client_config中发送Dependency sensor的request，然后在sns_sensor_instance_api.notify_event中处理获取到的dependency sensor 数据。