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         int retentionPeriod = DEFAULT_RETENTION;
 102
 103         _J("Data", data);
 104
 105         IF_FAIL_RETURN(data.get(NULL, KEY_OPERATION, &operation), ERR_INVALID_PARAMETER);
 106         IF_FAIL_RETURN(data.get(NULL, KEY_CLIENT_PKG_ID, &pkgId), ERR_INVALID_PARAMETER);
 107
 108         if (data.get(NULL, KEY_RETENTION, &retentionPeriod))
 109                 retentionPeriod *= SECONDS_PER_HOUR;
 110
 111         /* TODO: remove the operation & pkg id from the json */
 112
 113         if (operation == VAL_START)
 114                 return __addClient(pkgId, retentionPeriod, data);
 115         else if (operation == VAL_STOP)
 116                 return __removeClient(pkgId);
 117
 118         return ERR_NOT_SUPPORTED;
 119 }
 120
 121 int SensorProvider::__addClient(std::string pkgId, int retentionPeriod, Json option)
 122 {
 123         Json tmp;
 124         int ret;
 125
 126         /* Validate the retention period */
 127         IF_FAIL_RETURN(retentionPeriod > 0 && retentionPeriod <= MAX_RETENTION_PERIOD, ERR_INVALID_PARAMETER);
 128
 129         /* Check if the app already started Sensor recording */
 130         ret = __clientInfo.get(getSubject(), pkgId, tmp);
 131         IF_FAIL_RETURN(ret != ERR_NONE, ERR_ALREADY_STARTED);
 132         IF_FAIL_RETURN(ret == ERR_NO_DATA, ERR_OPERATION_FAILED);
 133
 134         /* Store the app's request */
 135         if (!__clientInfo.set(getSubject(), pkgId, option, retentionPeriod))
 136                 return ERR_OPERATION_FAILED;
 137
 138         /* If not listening the sensor yet, start */
 139         sensorLogger->start();
 140
 141         return ERR_NONE;
 142 }
 143
 144 int SensorProvider::__removeClient(std::string pkgId)
 145 {
 146         std::vector<Json> options;
 147         int ret;
 148
 149         /* Remove the app's request first */
 150         IF_FAIL_RETURN(__clientInfo.remove(getSubject(), pkgId), ERR_OPERATION_FAILED);
 151
 152         /* Check if there is no client anymore */
 153         ret = __clientInfo.get(getSubject(), options);
 154         IF_FAIL_RETURN(ret != ERR_NONE, ERR_NONE);
 155         IF_FAIL_RETURN(ret == ERR_NO_DATA, ERR_OPERATION_FAILED);
 156
 157         /* Stop listening */
 158         sensorLogger->stop();
 159
 160         return ERR_NONE;
 161 }
 162
 163 void SensorProvider::removeClient(std::string subject, std::string pkgId)
 164 {
 165         __providerMap[subject]->__removeClient(pkgId);
 166 }