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     LOGI("battery percent : %d", battery_percentage);
  85     if (battery_percentage >= MINIMUM_BATTERY)
  86         return true;
  87     else
  88     {
  89         LOGI("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 app_control(app_control_h app_control, void *data)
 155 {
 156     /* Handle the launch request. */
 157     char* request = NULL;
 158     char* mode = NULL;
 159     char* type = NULL;
 160     char* operation = NULL;
 161     char* event_value = NULL;
 162     char* uri = NULL;
 163     const char *event_uri = "event://tizen.system.event.battery_charger_status";
 164     int res;
 165
 166     if (!check_rw_mount())
 167         service_app_exit();
 168
 169     // operation
 170     int ret = app_control_get_operation(app_control, &operation);
 171     if (ret == APP_CONTROL_ERROR_NONE) {
 172         STLOGD("operation: %s", operation);
 173
 174         if (!operation) {
 175             goto cleanup;
 176         }
 177
 178         if (strcmp(operation, APP_CONTROL_OPERATION_LAUNCH_ON_EVENT) == 0)
 179         {
 180             ret = app_control_get_uri(app_control, &uri);
 181             if (ret == APP_CONTROL_ERROR_NONE && uri)
 182             {
 183                 if (strncmp(uri, event_uri, strlen(event_uri) + 1) == 0)
 184                 {
 185                     ret = app_control_get_extra_data(app_control, "battery_charger_status", &event_value);
 186                     if (ret == APP_CONTROL_ERROR_NONE && event_value)
 187                     {
 188                         if (string(event_value) == "connected")
 189                         {
 190                             if (!is_init_sap()) {
 191                                 if (check_sync_time_condition()) {
 192                                     if (check_battery_condition()) {
 193                                         STLOGD("Starting auto synchronization");
 194                                         initialize_sap();
 195                                         request_sticker_feature();
 196                                         request_auto_sync();
 197                                     }
 198                                 }
 199                                 else {
 200                                     if (!get_job_progress())
 201                                     {
 202                                         STLOGD("exit");
 203                                         service_app_exit();
 204                                     }
 205                                 }
 206                             }
 207                             else {
 208                                 STLOGD("continue doing current job");
 209                             }
 210                         }
 211                         free(event_value);
 212                     }
 213                 }
 214                 free(uri);
 215             }
 216         }
 217         else if (strcmp(operation, APP_CONTROL_OPERATION_DEFAULT) == 0) {
 218 #ifdef VCONFKEY_STICKER_SUPPORTED_FEATURE
 219             // Check whether oobe has been done
 220             int feature_flag = 0;
 221             if (vconf_get_int(VCONFKEY_STICKER_SUPPORTED_FEATURE, &feature_flag) == 0 && feature_flag == 0) {
 222                 STLOGD("Request to get sticker feature");
 223                 initialize_sap();
 224                 request_sticker_feature();
 225             }
 226             else {
 227                 if (!is_init_sap())
 228                     service_app_exit();
 229             }
 230 #endif
 231         }
 232     }
 233     else {
 234         STLOGW("Failed to get operation. error : %d", ret);
 235     }
 236
 237     // sync request
 238     res = app_control_get_extra_data(app_control, "request", &request);
 239     if (APP_CONTROL_ERROR_NONE == res && NULL != request) {
 240         if (strcmp(request, "sync") == 0) {
 241             bool param_error = false;
 242             if (app_control_get_extra_data(app_control, "mode", &mode) != APP_CONTROL_ERROR_NONE) {
 243                 STLOGE("No given mode");
 244                 param_error = true;
 245             }
 246
 247             if (app_control_get_extra_data(app_control, "type", &type) != APP_CONTROL_ERROR_NONE) {
 248                 STLOGE("No given type");
 249                 param_error = true;
 250             }
 251
 252             LOGI("[sync request] mode : %s, type : %s", mode, type);
 253             if (param_error)
 254                 goto cleanup;
 255
 256             if (mode && type) {
 257                 if (!is_init_sap()) {
 258                     initialize_sap();
 259                     request_all_sticker_data(mode, type);
 260                 }
 261             }
 262         }
 263         else if (strcmp(request, "oobe") == 0) {
 264             initialize_sap();
 265             request_sticker_feature();
 266         }
 267         else
 268         {
 269             STLOGW("Unknown command : %s", request);
 270             if (!is_init_sap())
 271             {
 272                 service_app_exit();
 273             }
 274         }
 275     }
 276
 277 cleanup:
 278     if (NULL != operation)
 279         free(operation);
 280
 281     if (NULL != request)
 282         free(request);
 283
 284     if (NULL != mode)
 285         free(mode);
 286
 287     if (NULL != type)
 288         free(type);
 289 }
 290
 291 static void app_terminate(void *data)
 292 {
 293     /* Release all resources. */
 294     STLOGD("");
 295     destroy_sticker_provider_handle();
 296     deinitialize_sap();
 297 }
 298
 299 int main(int argc, char *argv[])
 300 {
 301     int ret = 0;
 302
 303     service_app_lifecycle_callback_s event_callback;
 304     memset(&event_callback, 0x0, sizeof(service_app_lifecycle_callback_s));
 305
 306     event_callback.create = (service_app_create_cb)app_create;
 307     event_callback.terminate = (service_app_terminate_cb)app_terminate;
 308     event_callback.app_control = (service_app_control_cb)app_control;
 309
 310     ret = service_app_main(argc, argv, &event_callback, NULL);
 311     if (ret != APP_ERROR_NONE) {
 312         STLOGE("app_main() is failed. err = %d", ret);
 313     }
 314     return ret;
 315 }