src/sensor/SensorProvider.cpp

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <ctime>
  18 #include <cmath>
  19 #include <SensorRecorderTypes.h>
  20 #include "TypesInternal.h"
  21 #include "SensorProvider.h"
  22
  23 using namespace ctx;
  24
  25 std::map<std::string, SensorProvider*> SensorProvider::__providerMap;
  26
  27 SensorProvider::SensorProvider(const char *subject) :
  28         ContextProvider(subject),
  29         sensorLogger(NULL)
  30 {
  31         __providerMap[subject] = this;
  32 }
  33
  34 SensorProvider::~SensorProvider()
  35 {
  36         __providerMap.erase(getSubject());
  37         delete sensorLogger;
  38 }
  39
  40 int SensorProvider::subscribe(Json option, Json *requestResult)
  41 {
  42         return ERR_NONE;
  43 }
  44
  45 int SensorProvider::unsubscribe(Json option)
  46 {
  47         return ERR_NONE;
  48 }
  49
  50 int SensorProvider::read(Json option, Json *requestResult)
  51 {
  52         int endTime = static_cast<int>(time(NULL)) + 1;
  53         int startTime = endTime - DEFAULT_QUERY_PERIOD - 1;
  54         int anchor = -1;
  55         int interval = -1;
  56
  57         if (option.get(NULL, KEY_START_TIME, &startTime))
  58                 IF_FAIL_RETURN(startTime >= 0, ERR_INVALID_PARAMETER);
  59
  60         if (option.get(NULL, KEY_END_TIME, &endTime))
  61                 IF_FAIL_RETURN(endTime >= 0, ERR_INVALID_PARAMETER);
  62
  63         if (option.get(NULL, KEY_ANCHOR, &anchor))
  64                 IF_FAIL_RETURN(anchor >= 0, ERR_INVALID_PARAMETER);
  65
  66         if (option.get(NULL, KEY_INTERVAL, &interval))
  67                 IF_FAIL_RETURN(interval >= 0, ERR_INVALID_PARAMETER);
  68
  69         if (endTime >= 0 && startTime >= endTime)
  70                 return ERR_INVALID_PARAMETER;
  71
  72         if (interval > 0 && anchor < 0)
  73                 anchor = endTime;
  74
  75         if (anchor >= 0 && interval < 0)
  76                 interval = static_cast<int>(ceil(static_cast<double>(endTime - startTime) / SECONDS_PER_MINUTE));
  77
  78         int ret;
  79         Querier *querier = getQuerier(option);
  80         IF_FAIL_RETURN(querier, ERR_OPERATION_FAILED);
  81
  82         if (interval == 0)
  83                 ret = querier->queryRaw(startTime, endTime);
  84         else if (interval > 0)
  85                 ret = querier->query(startTime, endTime, anchor, interval * SECONDS_PER_MINUTE);
  86         else
  87                 ret = querier->query(startTime, endTime);
  88
  89         if (ret != ERR_NONE)
  90                 delete querier;
  91
  92         return ret;
  93 }
  94
  95 int SensorProvider::write(Json data, Json *requestResult)
  96 {
  97         IF_FAIL_RETURN(sensorLogger, ERR_OPERATION_FAILED);
  98
  99         std::string operation;
 100         std::string pkgId;
 101         Json option;
 102         int retentionPeriod = DEFAULT_RETENTION;
 103
 104         _J("Data", data);
 105
 106         IF_FAIL_RETURN(data.get(NULL, KEY_OPERATION, &operation), ERR_INVALID_PARAMETER);
 107         IF_FAIL_RETURN(data.get(NULL, KEY_CLIENT_PKG_ID, &pkgId), ERR_INVALID_PARAMETER);
 108
 109         data.get(NULL, KEY_OPTION, &option);
 110
 111         if (option.get(NULL, KEY_RETENTION, &retentionPeriod)) {
 112                 retentionPeriod *= SECONDS_PER_HOUR;
 113                 option.remove(NULL, KEY_RETENTION);
 114         }
 115
 116         if (operation == VAL_START)
 117                 return __addClient(pkgId, retentionPeriod, option);
 118         else if (operation == VAL_STOP)
 119                 return __removeClient(pkgId);
 120
 121         return ERR_NOT_SUPPORTED;
 122 }
 123
 124 int SensorProvider::__addClient(std::string pkgId, int retentionPeriod, Json option)
 125 {
 126         Json tmp;
 127         int ret;
 128
 129         /* Validate the retention period */
 130         IF_FAIL_RETURN(retentionPeriod > 0 && retentionPeriod <= MAX_RETENTION_PERIOD, ERR_INVALID_PARAMETER);
 131
 132         /* Check if the app already started Sensor recording */
 133         ret = __clientInfo.get(getSubject(), pkgId, tmp);
 134         IF_FAIL_RETURN(ret != ERR_NONE, ERR_ALREADY_STARTED);
 135         IF_FAIL_RETURN(ret == ERR_NO_DATA, ERR_OPERATION_FAILED);
 136
 137         /* Store the app's request */
 138         if (!__clientInfo.set(getSubject(), pkgId, option, retentionPeriod))
 139                 return ERR_OPERATION_FAILED;
 140
 141         /* If not listening the sensor yet, start */
 142         sensorLogger->start();
 143
 144         return ERR_NONE;
 145 }
 146
 147 int SensorProvider::__removeClient(std::string pkgId)
 148 {
 149         std::vector<Json> options;
 150         int ret;
 151
 152         /* Remove the app's request first */
 153         IF_FAIL_RETURN(__clientInfo.remove(getSubject(), pkgId), ERR_OPERATION_FAILED);
 154
 155         /* Check if there is no client anymore */
 156         ret = __clientInfo.get(getSubject(), options);
 157         IF_FAIL_RETURN(ret != ERR_NONE, ERR_NONE);
 158         IF_FAIL_RETURN(ret == ERR_NO_DATA, ERR_OPERATION_FAILED);
 159
 160         /* Stop listening */
 161         sensorLogger->stop();
 162
 163         return ERR_NONE;
 164 }
 165
 166 void SensorProvider::removeClient(std::string subject, std::string pkgId)
 167 {
 168         __providerMap[subject]->__removeClient(pkgId);
 169 }