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 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                                     else {
 199                                         if (!get_job_progress()) {
 200                                             STLOGD("exit");
 201                                             service_app_exit();
 202                                         }
 203                                     }
 204                                 }
 205                                 else {
 206                                     if (!get_job_progress()) {
 207                                         STLOGD("exit");
 208                                         service_app_exit();
 209                                     }
 210                                 }
 211                             }
 212                             else {
 213                                 STLOGD("continue doing current job");
 214                             }
 215                         }
 216                         free(event_value);
 217                     }
 218                 }
 219                 free(uri);
 220             }
 221         }
 222         else if (strcmp(operation, APP_CONTROL_OPERATION_DEFAULT) == 0) {
 223             // sync request
 224             res = app_control_get_extra_data(app_control, "request", &request);
 225             if (APP_CONTROL_ERROR_NONE == res && NULL != request) {
 226                 if (strcmp(request, "sync") == 0) {
 227                     bool param_error = false;
 228                     if (app_control_get_extra_data(app_control, "mode", &mode) != APP_CONTROL_ERROR_NONE) {
 229                         STLOGE("No given mode");
 230                         param_error = true;
 231                     }
 232
 233                     if (app_control_get_extra_data(app_control, "type", &type) != APP_CONTROL_ERROR_NONE) {
 234                         STLOGE("No given type");
 235                         param_error = true;
 236                     }
 237
 238                     STLOGI("[sync request] mode : %s, type : %s", mode, type);
 239                     if (param_error)
 240                         goto cleanup;
 241
 242                     if (mode && type) {
 243                         if (!is_init_sap()) {
 244                             initialize_sap();
 245                             request_all_sticker_data(mode, type);
 246                         }
 247                     }
 248                 }
 249                 else if (strcmp(request, "oobe") == 0) {
 250                     initialize_sap();
 251                     request_sticker_feature();
 252                 }
 253                 else {
 254                     STLOGW("Unknown command : %s", request);
 255                     if (!is_init_sap()) {
 256                         service_app_exit();
 257                     }
 258                 }
 259             } // end of request
 260             else {
 261                 STLOGD("booting");
 262 #ifdef VCONFKEY_STICKER_SUPPORTED_FEATURE
 263                 // Check whether oobe has been done
 264                 int feature_flag = 0;
 265                 if (vconf_get_int(VCONFKEY_STICKER_SUPPORTED_FEATURE, &feature_flag) == 0 && feature_flag == 0) {
 266                     STLOGD("Request to get sticker feature");
 267                     initialize_sap();
 268                     request_sticker_feature();
 269                 }
 270                 else {
 271                     if (!is_init_sap())
 272                         service_app_exit();
 273                 }
 274             }
 275 #endif
 276         }
 277     }
 278     else {
 279         STLOGW("Failed to get operation. error : %d", ret);
 280     }
 281
 282 cleanup:
 283     if (NULL != operation)
 284         free(operation);
 285
 286     if (NULL != request)
 287         free(request);
 288
 289     if (NULL != mode)
 290         free(mode);
 291
 292     if (NULL != type)
 293         free(type);
 294 }
 295
 296 static void app_terminate(void *data)
 297 {
 298     /* Release all resources. */
 299     STLOGD("");
 300     destroy_sticker_provider_handle();
 301     deinitialize_sap();
 302 }
 303
 304 int main(int argc, char *argv[])
 305 {
 306     int ret = 0;
 307
 308     service_app_lifecycle_callback_s event_callback;
 309     memset(&event_callback, 0x0, sizeof(service_app_lifecycle_callback_s));
 310
 311     event_callback.create = (service_app_create_cb)app_create;
 312     event_callback.terminate = (service_app_terminate_cb)app_terminate;
 313     event_callback.app_control = (service_app_control_cb)app_control;
 314
 315     ret = service_app_main(argc, argv, &event_callback, NULL);
 316     if (ret != APP_ERROR_NONE) {
 317         STLOGE("app_main() is failed. err = %d", ret);
 318     }
 319     return ret;
 320 }