Android Sensor详解（9）Sensor ADSP Sensor1 api使用

1.Initialize the Sensor1 Framework

sensor1_error_e error;
error = sensor1_init();
if(error != SENSOR1_SUCCESS){
ALOGE(" sensor1_init returned %d\n", error);
}

2. Open a new Sensor1 connection

sensor1_open(sensor1_handle_s **hndl, sensor1_notify_data_cb_t data_cbf,
intptr_t cb_data );
返回值：SENSOR1_EWOULDBLOCK表明此时sensor framework无法打开handle参数无效直到SENSOR1_MSG_TYPE_RETRY_OPEN信息回传才有机会开启

3.Allocate the request message through Sensor1

sensor1_error_e sensor1_alloc_msg_buf(sensor1_handle_s *hndl, 5
uint16_t size, 6
void **buffer );

4.Zero out the Sensor1 request

memset(buffe, 0, sizeof(buffe) );

5.填写buffer request

6. Fill in the message header for the Sensor1 request

sensor1_msg_header_s
Field
service number
msg_id
msg_slze
txn id
Type
uint32 t
int32 t
uint16 t
uint8 t
Description
The QMI service number as defined by the service
Message ID as defined by the service
Size, in bytes, of the c-structure representing the message
A transaction ID defined by the client in the write request in
sensorl_write(); it may be used by the client to identify which Request
caused this Response; in the notify data callback, the txn_id field is only
valid for msg_type and
SENSORI MSG TYPE RESP INT ERR; indications use t,xn id = O

7. Send the Sensor1 request message

sensor1_error_e sensor1_write(sensor1_handle_s *hndl, sensor1_msg_header_s *msg_hdr,
void *msg_ptr);

8.wait for most 1 sec for response

9. Close the Sensor1 connection

sensor1_close

我写的demo 代码如下：

#include <stdlib.h>
#include <cutils/log.h>
#include "sensor1.h"
#include "sns_smgr_api_v01.h"

#ifndef TRUE
  #define TRUE 1
#endif /* TRUE */
#ifndef FALSE
  #define FALSE 0
#endif /* FALSE */
#ifndef NULL
  #define NULL ((void*)0)
#endif

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

//sensor1 handle
sensor1_handle_s *handle_ptr;
sns_smgr_single_sensor_test_req_msg_v01 *msg_req;//
sensor1_msg_header_s               msg_hdr;//sensor message header
int sensor1_response = 0;
/*******************
 * function
*******************/
void open_debugsensor(sensor1_notify_data_cb_t callbackfunction);
void alloc_request();
void set_request();
void fill_message_header();
void write_request();
void free_request();
void close_debugsensor();
void test_callback(intptr_t data, sensor1_msg_header_s *msg_hdr_ptr, sensor1_msg_type_e msg_type, void *msg_ptr);
/******************/


int main(int argc, char* argv[])
{
    sensor1_error_e error;
    // Initialize the Sensor1 Framework
    printf("[alex]sensor init");
    error = sensor1_init();
    if(error != SENSOR1_SUCCESS){
        ALOGE("[alex]sensor1_init returned %d\n", error);
    }
    // Open a new Sensor1 connection
    open_debugsensor(test_callback);
    //Allocate the request message through Sensor1
    alloc_request();
    //set request message
    set_request();
    // Fill in the message header for the Sensor1 request
    fill_message_header();
    // Send the Sensor1 request message
    write_request();
    // free the request message through Sensor1
    free_request();
    //Close the Sensor1 connection
    close_debugsensor();
    return 0;
}   
void open_debugsensor(sensor1_notify_data_cb_t callbackfunction)
{
    sensor1_error_e error;

    error=sensor1_open(&handle_ptr,callbackfunction,(intptr_t)(&handle_ptr));
    if(error == SENSOR1_EWOULDBLOCK){
        ALOGE("[alex] sensor1_open returned EWOULDBLOCK. Waiting 3 sec for sensor availability\n");
        sleep(3);
        error = sensor1_open(&handle_ptr,callbackfunction,(intptr_t)(&handle_ptr));
        if (error == SENSOR1_SUCCESS) {
            ALOGI("[alex] sensor1 is available now\n");
        } else {
            ALOGE("[alex] sensor1 is still not available\n");
            printf("sensor1_open ERROR\n");
            exit(-1);
        }
    }else if(error != SENSOR1_SUCCESS){
         printf("sensor1_open ERROR\n");
         exit(-1);
     }
}
void alloc_request()
{
     sensor1_error_e error;
     error=sensor1_alloc_msg_buf(handle_ptr,sizeof(sns_smgr_single_sensor_test_req_msg_v01),(void **)&msg_req);
     if(error != SENSOR1_SUCCESS){
         printf("sensor1_alloc_msg_buf ERROR\n");
         exit(-1);
     }
       // Zero out the Sensor1 request
     memset(msg_req, 0, sizeof(sns_smgr_single_sensor_test_req_msg_v01)); 
}
void free_request()
{
     sensor1_error_e error;
     error=sensor1_free_msg_buf(handle_ptr,(void **)msg_req);
     if(error != SENSOR1_SUCCESS){
         printf("sensor1_free_msg_buf ERROR\n");
     }
}
void set_request()
{
    msg_req->SensorID=SNS_SMGR_ID_ACCEL_V01;
    msg_req->DataType=SNS_SMGR_DATA_TYPE_PRIMARY_V01;
    msg_req->TestType=SNS_SMGR_TEST_CONNECTIVITY_V01;
}
void fill_message_header()
{
    msg_hdr.service_number = SNS_SMGR_SVC_ID_V01;
    msg_hdr.msg_id = SNS_SMGR_SINGLE_SENSOR_TEST_RESP_V01;
    msg_hdr.msg_size= sizeof(sns_smgr_single_sensor_test_req_msg_v01);
}
void write_request()
{
    sensor1_error_e error;
    error=sensor1_write(handle_ptr,&msg_hdr,msg_req);
    int timeout=0;
    if(error != SENSOR1_SUCCESS){
        ALOGE("[alex] sensor1_write error, returned %d\n", error);
        if (error != SENSOR1_EWOULDBLOCK) {
            printf("sensor1_write error, returned %d\n",error);
            exit(-1);
        }
    }
    //wait for most 1 sec for response
    sensor1_response = 0;
    while (sensor1_response != 1 && timeout < 1000) {
        usleep(1000);
        timeout++;
    }

    sensor1_response = 0;
    if (timeout >= 1000) {
        printf("ERROR : timeout for response message\n");
        exit(-1);
    }
    else {
        ALOGE("[gsensor_status] sensor1 get response to message\n");
    }
}
void close_debugsensor()
{
    sensor1_error_e error;
    error= sensor1_close(handle_ptr);
    if (error != SENSOR1_SUCCESS) {
        printf("ERROR: sensor1_close returned %d\n",error);
        exit(-1);
    }
}

void test_callback(intptr_t data, sensor1_msg_header_s *msg_hdr_ptr, sensor1_msg_type_e msg_type, void *msg_ptr)
{
    int status = 0;

    if (msg_hdr_ptr == NULL) {
        ALOGE("[gsensor_status] receive NULL msg_hdr_ptr!\n");
    } else {
        fflush(NULL);
    }

    if (msg_type == SENSOR1_MSG_TYPE_RESP) {
        sns_smgr_single_sensor_test_resp_msg_v01* resp_ptr = (sns_smgr_single_sensor_test_resp_msg_v01*) msg_ptr;

        ALOGI("[gsensor_status] received a test response\n");
        if ((resp_ptr->Resp.sns_result_t == 0) && (resp_ptr->Resp.sns_err_t == SENSOR1_SUCCESS)) {
            if (resp_ptr->TestStatus == SNS_SMGR_TEST_STATUS_PENDING_V01) {
                ALOGI("[gsensor_status] Received a test response successfully\n");
            } else {
                    ALOGE("[gsensor_status] test error! TestStatus = %u\n", resp_ptr->TestStatus);
                    ALOGE("ERROR: test error! TestStatus = %u\n", resp_ptr->TestStatus);
                ALOGE("FAIL\n");
                status = 1;
            }
        }
        else {
                ALOGE("[gsensor_status] error found in common resp! sns_result %u sns_err %u\n",
                resp_ptr->Resp.sns_result_t, resp_ptr->Resp.sns_err_t);
                ALOGE("ERROR: error found in common resp! sns_result %u sns_err %u\n",
                resp_ptr->Resp.sns_result_t, resp_ptr->Resp.sns_err_t);
            ALOGE("FAIL\n");
            status = 1;
        }

        sensor1_response = 1;
    } else if (msg_type == SENSOR1_MSG_TYPE_IND) {
        sns_smgr_single_sensor_test_ind_msg_v01 *ind_ptr = (sns_smgr_single_sensor_test_ind_msg_v01*) msg_ptr;

        if (ind_ptr->TestResult == SNS_SMGR_TEST_RESULT_PASS_V01) {
            ALOGI("[gsensor_status] Received a test indication, test result is PASS\n");
            printf("1\n");
        }
        else {
            ALOGE("[gsensor_status] Received a test indication, test result is FAIL\n");
            ALOGE("ERROR: Received a test indication, test result is FAIL\n");
            ALOGE("FAIL\n");
            status = 1;
        }
    } else {
        if (msg_type == SENSOR1_MSG_TYPE_BROKEN_PIPE) {
            ALOGE("[gsensor_status] receive BROKEN_PIPE!!!\n");
            ALOGE("ERROR: receive BROKEN_PIPE!!!\n");
        } else if (msg_type == SENSOR1_MSG_TYPE_RETRY_OPEN) {
            ALOGE("[gsensor_status] receive RETRY_OPEN!!!\n");
            ALOGE("ERROR: receive RETRY_OPEN!!!\n");
        } else {
            ALOGE("[gsensor_status] receive INVALID MSG type!!!, error type = %u\n", msg_type);
            ALOGE("ERROR: receive INVALID MSG type!!!, error type = %u\n", msg_type);
        }
        ALOGE("FAIL");
        status = 1;
    }

    if (msg_ptr != NULL) {
        sensor1_free_msg_buf(*((sensor1_handle_s**)data), msg_ptr);
    }

    if (status) {
        printf("0\n");
        exit(-1);
    }
}
}

希望我的开源能够让高通的BSP开发不再是壁垒