receiver/src/main.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved.
   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 <app_common.h>
  18 #include <service_app.h>
  19 #include <stdlib.h>
  20 #include <app_event.h>
  21 #include <device/battery.h>
  22 #include <vconf.h>
  23 #include <string>
  24 #include <app_preference.h>
  25 #include <Ecore.h>
  26
  27 #include "main.h"
  28 #include "ft.h"
  29 #include "log.h"
  30 #include "config.h"
  31 #include "receiver_preference.h"
  32 #include "sticker_info.h"
  33
  34 using namespace std;
  35
  36 static bool check_rw_mount();
  37
  38 static bool app_create(void *data)
  39 {
  40     /* Hook to take necessary actions before main event loop starts
  41        Initialize UI resources and application's data
  42        If this function returns true, the main loop of application starts
  43        If this function returns false, the application is terminated */
  44
  45     if (!check_rw_mount()) {
  46         service_app_exit();
  47         return true;
  48     }
  49
  50     STLOGD("");
  51
  52     char log_path[PATH_MAX];
  53     char *data_path = NULL;
  54     data_path = app_get_shared_data_path();
  55     snprintf(log_path, sizeof(log_path), "%s/log", data_path);
  56
  57     if (data_path)
  58         free(data_path);
  59
  60     if (access(log_path, F_OK) != 0) {
  61         if (mkdir(log_path, 0755) == -1) {
  62             STLOGE("directory create error");
  63         }
  64     }
  65
  66     create_sticker_provider_handle();
  67
  68     return true;
  69 }
  70
  71 static bool check_battery_condition()
  72 {
  73     int battery_percentage = 0;
  74     int ret;
  75
  76     // check battery percentage
  77     ret = device_battery_get_percent(&battery_percentage);
  78     if (ret != DEVICE_ERROR_NONE)
  79     {
  80         STLOGW("No sync. Failed to get battery percent. error : %d", ret);
  81         return false;
  82     }
  83
  84     STLOGI("battery percent : %d", battery_percentage);
  85     if (battery_percentage >= MINIMUM_BATTERY)
  86         return true;
  87     else
  88     {
  89         STLOGI("No sync due to insufficient battery");
  90         return false;
  91     }
  92 }
  93
  94 static bool check_sync_time_condition()
  95 {
  96     double last_sync_time;
  97     int feature_flag = 0;
  98     bool result = false;
  99
 100 #ifdef VCONFKEY_STICKER_SUPPORTED_FEATURE
 101     // Check whether oobe has been done
 102     if (vconf_get_int(VCONFKEY_STICKER_SUPPORTED_FEATURE, &feature_flag) == 0 && feature_flag > 0)
 103     {
 104         if (preference_get_double(LAST_SYNC_TIME, &last_sync_time) != PREFERENCE_ERROR_NONE)
 105         {
 106             STLOGD("Can't get last sync time.");
 107             return true;
 108         }
 109
 110         // compare time
 111         double timediff = ecore_time_unix_get() - last_sync_time;
 112         STLOGD("current time : %.3f, last_sync_time : %.3f, diff : %.3f", ecore_time_unix_get(), last_sync_time, timediff);
 113
 114         if (timediff > MAX_WAIT_TIME) {
 115             STLOGD("Starting manual synchronization");
 116             initialize_sap();
 117             request_show_sync_notification();
 118             result = false;
 119         } else {
 120             if (timediff > SYNC_INTERVAL)
 121                 result = true;
 122             else
 123                 result = false;
 124         }
 125     }
 126     else
 127     {
 128         result = false;
 129     }
 130 #endif /* VCONFKEY_STICKER_SUPPORTED_FEATURE */
 131
 132     return result;
 133 }
 134
 135 bool check_rw_mount()
 136 {
 137     char *data_path = NULL;
 138     bool rw_mount = false;
 139     data_path = app_get_shared_data_path();
 140     if (!data_path) return false;
 141
 142     if (access(data_path, R_OK) == 0)
 143         rw_mount = true;
 144
 145     free(data_path);
 146
 147     if (!rw_mount) {
 148         SECURE_LOGE("Can't access rw storage\n");
 149     }
 150
 151     return rw_mount;
 152 }
 153
 154 static void process_request(app_control_h app_control, char *request)
 155 {
 156     char* mode = NULL;
 157     char* type = NULL;
 158
 159     if (strcmp(request, "sync") == 0) {
 160         bool param_error = false;
 161         if (app_control_get_extra_data(app_control, "mode", &mode) != APP_CONTROL_ERROR_NONE) {
 162             STLOGE("No given mode");
 163             param_error = true;
 164         }
 165
 166         if (app_control_get_extra_data(app_control, "type", &type) != APP_CONTROL_ERROR_NONE) {
 167             STLOGE("No given type");
 168             param_error = true;
 169         }
 170
 171         STLOGI("[sync request] mode : %s, type : %s", mode, type);
 172         if (param_error)
 173             goto cleanup;
 174
 175         if (mode && type) {
 176             if (!is_init_sap()) {
 177                 initialize_sap();
 178                 request_all_sticker_data(mode, type);
 179             }
 180         }
 181     }
 182     else if (strcmp(request, "oobe") == 0) {
 183         initialize_sap();
 184         request_sticker_feature();
 185     }
 186     else {
 187         STLOGW("Unknown command : %s", request);
 188         if (!is_init_sap()) {
 189             service_app_exit();
 190         }
 191     }
 192
 193 cleanup:
 194     if (NULL != mode)
 195         free(mode);
 196
 197     if (NULL != type)
 198         free(type);
 199 }
 200
 201 static void process_auto_sync()
 202 {
 203     if (is_init_sap()) {
 204         STLOGD("continue doing current job");
 205         return;
 206     }
 207
 208     if (check_sync_time_condition()) {
 209         if (check_battery_condition()) {
 210             STLOGD("Starting auto synchronization");
 211             initialize_sap();
 212             request_sticker_feature();
 213             request_auto_sync();
 214         }
 215         else {
 216             STLOGI("The status of battery is low");
 217             if (!get_job_progress()) {
 218                 STLOGD("exit");
 219                 service_app_exit();
 220             }
 221         }
 222     }
 223     else {
 224         if (!get_job_progress()) {
 225             STLOGD("exit");
 226             service_app_exit();
 227         }
 228     }
 229 }
 230
 231 static void get_sticker_feature()
 232 {
 233 #ifdef VCONFKEY_STICKER_SUPPORTED_FEATURE
 234     // Check whether oobe has been done
 235     int feature_flag = 0;
 236     if (vconf_get_int(VCONFKEY_STICKER_SUPPORTED_FEATURE, &feature_flag) == 0 && feature_flag == 0) {
 237         STLOGD("Request to get sticker feature");
 238         initialize_sap();
 239         request_sticker_feature();
 240     }
 241     else {
 242         if (!is_init_sap())
 243             service_app_exit();
 244     }
 245 #endif
 246 }
 247
 248 static void app_control(app_control_h app_control, void *data)
 249 {
 250     /* Handle the launch request. */
 251     char* request = NULL;
 252     char* operation = NULL;
 253     char* event_value = NULL;
 254     char* uri = NULL;
 255     const char *event_uri = "event://tizen.system.event.battery_charger_status";
 256     int res;
 257
 258     if (!check_rw_mount())
 259         service_app_exit();
 260
 261     // operation
 262     int ret = app_control_get_operation(app_control, &operation);
 263     if (ret != APP_CONTROL_ERROR_NONE) {
 264         STLOGW("Failed to get operation. error : %d", ret);
 265         return;
 266     }
 267
 268     STLOGD("operation: %s", operation);
 269
 270     if (!operation) {
 271         goto cleanup;
 272     }
 273
 274     if (strcmp(operation, APP_CONTROL_OPERATION_LAUNCH_ON_EVENT) == 0)
 275     {
 276         ret = app_control_get_uri(app_control, &uri);
 277         if (ret == APP_CONTROL_ERROR_NONE && uri)
 278         {
 279             if (strncmp(uri, event_uri, strlen(event_uri) + 1) == 0)
 280             {
 281                 ret = app_control_get_extra_data(app_control, "battery_charger_status", &event_value);
 282                 if (ret == APP_CONTROL_ERROR_NONE && event_value)
 283                 {
 284                     if (string(event_value) == "connected")
 285                     {
 286                         STLOGI("The charger state is connected");
 287                         process_auto_sync();
 288                     }
 289                     free(event_value);
 290                 }
 291             }
 292             free(uri);
 293         }
 294     }
 295     else if (strcmp(operation, APP_CONTROL_OPERATION_DEFAULT) == 0) {
 296         res = app_control_get_extra_data(app_control, "request", &request);
 297         STLOGD("get extra data result : %d, request : %s", res, request);
 298         if (APP_CONTROL_ERROR_NONE == res && NULL != request) {
 299             process_request(app_control, request);
 300         }
 301         else {
 302             STLOGD("booting");
 303             get_sticker_feature();
 304         }
 305     }
 306
 307 cleanup:
 308     if (NULL != operation)
 309         free(operation);
 310
 311     if (NULL != request)
 312         free(request);
 313 }
 314
 315 static void app_terminate(void *data)
 316 {
 317     /* Release all resources. */
 318     STLOGD("");
 319     destroy_sticker_provider_handle();
 320     deinitialize_sap();
 321 }
 322
 323 int main(int argc, char *argv[])
 324 {
 325     int ret = 0;
 326
 327     service_app_lifecycle_callback_s event_callback;
 328     memset(&event_callback, 0x0, sizeof(service_app_lifecycle_callback_s));
 329
 330     event_callback.create = (service_app_create_cb)app_create;
 331     event_callback.terminate = (service_app_terminate_cb)app_terminate;
 332     event_callback.app_control = (service_app_control_cb)app_control;
 333
 334     ret = service_app_main(argc, argv, &event_callback, NULL);
 335     if (ret != APP_ERROR_NONE) {
 336         STLOGE("app_main() is failed. err = %d", ret);
 337     }
 338     return ret;
 339 }