src/client/sensor_internal.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include "sensor_internal.h"
  21 #include <stdlib.h>
  22 #include <sensor_log.h>
  23
  24 /*
  25  * TO-DO-LIST:
  26  * 1. restore session
  27  * 1.1 close socket
  28  * 1.2 listener : start, interval, batch latency, attributes
  29  * 2. power save option / lcd vconf : move to server
  30  * 3. clean up data
  31  * 4. thread-safe : ipc_client
  32  * 5. client-id
  33  * 6. cmd_hello
  34  * 7. stop : unset interval, batch
  35  * 8. get sensor list
  36  */
  37
  38 API int sensord_get_sensors(sensor_type_t type, sensor_t **list, int *count)
  39 {
  40         /*
  41          * 1. get sensor list()
  42          * 2. if sensor list is empty, return -ENODATA
  43          * 3. if id is -EACCESS, return -EACCESS (except ALL_SENSOR)
  44          * 4. list : memory allocation
  45          * 5. return list, count
  46          */
  47
  48         return OP_SUCCESS;
  49 }
  50
  51 API int sensord_get_default_sensor(sensor_type_t type, sensor_t *sensor)
  52 {
  53         /*
  54          * 1. get sensor list()
  55          * 2. if there is no sensor, return -ENODATA
  56          * 3. if id is -EACCESS, return -EACCESS
  57          * 4. if SENSOR_ALL, ???
  58          * 5. return sensor
  59          */
  60
  61         return OP_SUCCESS;
  62 }
  63
  64 API bool sensord_get_type(sensor_t sensor, sensor_type_t *type)
  65 {
  66         /*
  67          * 1. check parameter
  68          * 2. if there is no sensor, return false
  69          */
  70
  71         return true;
  72 }
  73
  74 API const char* sensord_get_name(sensor_t sensor)
  75 {
  76         /*
  77          * 1. if there is no sensor, return NULL
  78          */
  79
  80         return NULL;
  81 }
  82
  83 API const char* sensord_get_vendor(sensor_t sensor)
  84 {
  85         /*
  86          * 1. if there is no sensor, return NULL
  87          */
  88
  89         return NULL;
  90 }
  91
  92 API bool sensord_get_privilege(sensor_t sensor, sensor_privilege_t *privilege)
  93 {
  94         /*
  95          * 1. check parameter
  96          * 2. if there is no sensor, return false
  97          */
  98
  99         return true;
 100 }
 101
 102 API bool sensord_get_min_range(sensor_t sensor, float *min_range)
 103 {
 104         /*
 105          * 1. check parameter
 106          * 2. if there is no sensor, return false
 107          */
 108
 109         return true;
 110 }
 111
 112 API bool sensord_get_max_range(sensor_t sensor, float *max_range)
 113 {
 114         /*
 115          * 1. check parameter
 116          * 2. if there is no sensor, return false
 117          */
 118
 119         return true;
 120 }
 121
 122 API bool sensord_get_resolution(sensor_t sensor, float *resolution)
 123 {
 124         /*
 125          * 1. check parameter
 126          * 2. if there is no sensor, return false
 127          */
 128
 129         return true;
 130 }
 131
 132 API bool sensord_get_min_interval(sensor_t sensor, int *min_interval)
 133 {
 134         /*
 135          * 1. check parameter
 136          * 2. if there is no sensor, return false
 137          */
 138
 139         return true;
 140 }
 141
 142 API bool sensord_get_fifo_count(sensor_t sensor, int *fifo_count)
 143 {
 144         /*
 145          * 1. check parameter
 146          * 2. if there is no sensor, return false
 147          */
 148
 149         return true;
 150 }
 151
 152 API bool sensord_get_max_batch_count(sensor_t sensor, int *max_batch_count)
 153 {
 154         /*
 155          * 1. check parameter
 156          * 2. if there is no sensor, return false
 157          */
 158
 159         return true;
 160 }
 161
 162 API bool sensord_is_wakeup_supported(sensor_t sensor)
 163 {
 164         /*
 165          * 1. check parameter
 166          * 2. if there is no sensor, return false
 167          */
 168
 169         return true;
 170 }
 171
 172 API int sensord_connect(sensor_t sensor)
 173 {
 174         /*
 175          * 1. check parameter
 176          * 2. if there is no sensor, return -EPERM
 177          * 3. sensor is already registered(sensor), it doesn't need to connect server
 178          * 4. create integer handle for only this client
 179          * 5. if it is first connection(client), get client id from server
 180          * 6. if it is first connection(client), start sensor event listener
 181          * 7. sensor initialization : stop, pause_all
 182          * 8. if it is first connection(client), send cmd hello
 183          * 9. if cmd hello is failed and it is first connection(client) stop listener, remove id
 184          */
 185
 186         return 0;
 187 }
 188
 189 API bool sensord_disconnect(int handle)
 190 {
 191         /*
 192          * 1. check parameter(check handle???)
 193          * 2. check state of this handle
 194          * 3. if it is on passive mode, unregister event and unset interval/latency
 195          * 4. if it is not stop, stop it
 196          * 5. if there is no active sensor(client), reset id & byebye and stop listener
 197          */
 198
 199         return true;
 200 }
 201
 202 API bool sensord_register_event(int handle, unsigned int event_type,
 203                 unsigned int interval, unsigned int max_batch_latency, sensor_cb_t cb, void *user_data)
 204 {
 205         /*
 206          * 1. check parameter
 207          * 2. if interval is 0, default interval
 208          * ** if cb is null, how to handle it?
 209          * ** event type is deprecated
 210          */
 211
 212         return true;
 213 }
 214
 215 API bool sensord_unregister_event(int handle, unsigned int event_type)
 216 {
 217         /*
 218          * 1. check parameter
 219          * 2. check previous interval, latency, cb, user_data
 220          * 3. if passive mode is true, set false
 221          * 4. if ret is false, register event
 222          */
 223
 224         return true;
 225 }
 226
 227 API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, void *user_data)
 228 {
 229         /*
 230          * 1. check parameter
 231          */
 232
 233         return true;
 234 }
 235
 236 API bool sensord_unregister_accuracy_cb(int handle)
 237 {
 238         /*
 239          * 1. check parameter
 240          */
 241
 242         return true;
 243 }
 244
 245 API bool sensord_start(int handle, int option)
 246 {
 247         /*
 248          * 1. check parameter
 249          * 2. pause = CONVERT_OPTION_PAUSE_POLICY(option)
 250          * 3. start listener
 251          */
 252
 253         return true;
 254 }
 255
 256 API bool sensord_stop(int handle)
 257 {
 258         /*
 259          * 1. check parameter
 260          * 2. check sensor state, id
 261          * 2.1. if sensor is already stopped, return true
 262          * 3. stop listener
 263          */
 264
 265         return true;
 266 }
 267
 268 API bool sensord_change_event_interval(int handle, unsigned int event_type, unsigned int interval)
 269 {
 270         /*
 271          * 1. check parameter
 272          * 2. if interval is 0, default interval
 273          * 3. if previous interval is lower than interval, return true
 274          * 4. change interval
 275          */
 276
 277         return true;
 278 }
 279
 280 API bool sensord_change_event_max_batch_latency(int handle, unsigned int event_type, unsigned int max_batch_latency)
 281 {
 282         /*
 283          * 1. check parameter
 284          * 2. if previous interval is lower than interval, return true
 285          * 3. change batch latency
 286          */
 287
 288         return true;
 289 }
 290
 291 API bool sensord_set_option(int handle, int option)
 292 {
 293         /*
 294          * change option, always-on/power save option/lcd off/default
 295          */
 296
 297         return true;
 298 }
 299
 300 API int sensord_set_attribute_int(int handle, int attribute, int value)
 301 {
 302         /*
 303          * 1. if ATTRIBUTE_PAUSE_POLICY
 304          * 2. if ATTRIBUTE_AXIS_ORIENTATION
 305          * 3. else attribute
 306          */
 307
 308         return OP_SUCCESS;
 309 }
 310
 311 API int sensord_set_attribute_str(int handle, int attribute, const char *value, int len)
 312 {
 313         /*
 314          * 1. check parameter
 315          * 2. if client id is invalid, return -EPERM
 316          * 3. if there is other problems, return -EPERM
 317          */
 318
 319         return OP_SUCCESS;
 320 }
 321
 322 API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data)
 323 {
 324         /*
 325          * 1. check parameter
 326          * 2. check sensor state(is it really needed?)
 327          * 3. get data
 328          */
 329
 330         return true;
 331 }
 332
 333 API bool sensord_flush(int handle)
 334 {
 335         /*
 336          * 1. check parameter
 337          * 2. check sensor state(is it really needed?)
 338          * 3. flush sensor
 339          */
 340
 341         return true;
 342 }
 343
 344 API bool sensord_set_passive_mode(int handle, bool passive)
 345 {
 346         /* set passive mode*/
 347
 348         return true;
 349 }
 350
 351 API int sensord_external_connect(const char *key, sensor_external_command_cb_t cb, void *user_data)
 352 {
 353         /*
 354          * 1. check parameter
 355          * 2. create handle in this client
 356          * 3. first connection(client)
 357          * 4. cmd_connect for external sensor with key
 358          */
 359         retvm_if(!key, -EPERM, "Invalid key");
 360         return 0;
 361 }
 362
 363 API bool sensord_external_disconnect(int handle)
 364 {
 365         /*
 366          * 1. check parameter
 367          * 2. create handle in this client
 368          * 3. first connection(client)
 369          * 4. cmd_connect for external sensor with key
 370          * 5. disconnect this handle
 371          * 6. if there is no active sensor, remove client id and stop listener
 372          */
 373         return true;
 374 }
 375
 376 API bool sensord_external_post(int handle, unsigned long long timestamp, const float* data, int data_cnt)
 377 {
 378         /*
 379          * 1. check parameter
 380          * 1.1 (data_cnt <= 0) || (data_cnt > POST_DATA_LEN_MAX)), return false
 381          * 2. cmd_post
 382          */
 383
 384         return true;
 385 }
 386
 387 /* deperecated */
 388 API sensor_t sensord_get_sensor(sensor_type_t type)
 389 {
 390         return NULL;
 391 }
 392
 393 /* deprecated */
 394 API bool sensord_get_sensor_list(sensor_type_t type, sensor_t **list, int *sensor_count)
 395 {
 396         return (sensord_get_sensors(type, list, sensor_count) == OP_SUCCESS);
 397 }
 398
 399 /* deprecated */
 400 API bool sensord_register_hub_event(int handle, unsigned int event_type,
 401                 unsigned int interval, unsigned int max_batch_latency, sensorhub_cb_t cb, void *user_data)
 402 {
 403         return false;
 404 }
 405
 406 /* deprecated */
 407 API bool sensord_get_supported_event_types(sensor_t sensor, unsigned int **event_types, int *count)
 408 {
 409         /*
 410          * 1. check parameter
 411          * 2. if there is no sensor, return false
 412          * 3. memory allocation
 413          */
 414         return true;
 415 }
 416
 417 /* deprecated(BUT it is used in C-API....) */
 418 API bool sensord_is_supported_event_type(sensor_t sensor, unsigned int event_type, bool *supported)
 419 {
 420         /*
 421          * 1. check parameter
 422          * 2. if there is no sensor, return false
 423          */
 424         return true;
 425 }
 426
 427 /* deprecated */
 428 API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len)
 429 {
 430         return (sensord_set_attribute_str(handle, 0, data, data_len) == OP_SUCCESS);
 431 }
 432
 433 /* deprecated */
 434 API bool sensord_send_command(int handle, const char *command, int command_len)
 435 {
 436         return (sensord_set_attribute_str(handle, 0, command, command_len) == OP_SUCCESS);
 437 }
 438