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 app_create(void *data)
  37 {
  38     /* Hook to take necessary actions before main event loop starts
  39        Initialize UI resources and application's data
  40        If this function returns true, the main loop of application starts
  41        If this function returns false, the application is terminated */
  42
  43     LOGD("");
  44
  45     char log_path[PATH_MAX];
  46     char *data_path = NULL;
  47     data_path = app_get_shared_data_path();
  48     snprintf(log_path, sizeof(log_path), "%s/log", data_path);
  49
  50     if (data_path)
  51         free(data_path);
  52
  53     if (access(log_path, F_OK) != 0) {
  54         if (mkdir(log_path, 0755) == -1) {
  55             LOGE("directory create error");
  56         }
  57     }
  58
  59     create_sticker_provider_handle();
  60
  61     return true;
  62 }
  63
  64 static bool check_battery_condition()
  65 {
  66     int battery_percentage = 0;
  67     int ret;
  68
  69     // check battery percentage
  70     ret = device_battery_get_percent(&battery_percentage);
  71     if (ret != DEVICE_ERROR_NONE)
  72     {
  73         LOGW("No sync. Failed to get battery percent. error : %d", ret);
  74         return false;
  75     }
  76
  77     LOGI("battery percent : %d", battery_percentage);
  78     if (battery_percentage >= MINIMUM_BATTERY)
  79         return true;
  80     else
  81     {
  82         LOGI("No sync due to insufficient battery");
  83         return false;
  84     }
  85 }
  86
  87 static bool check_sync_time_condition()
  88 {
  89     double last_sync_time;
  90     int feature_flag = 0;
  91     bool result = false;
  92
  93 #ifdef VCONFKEY_STICKER_SUPPORTED_FEATURE
  94     // Check whether oobe has been done
  95     if (vconf_get_int(VCONFKEY_STICKER_SUPPORTED_FEATURE, &feature_flag) == 0 && feature_flag > 0)
  96     {
  97         if (preference_get_double(LAST_SYNC_TIME, &last_sync_time) != PREFERENCE_ERROR_NONE)
  98         {
  99             LOGD("Can't get last sync time.");
 100             return true;
 101         }
 102
 103         // compare time
 104         LOGD("current time : %f, last_sync_time : %f", ecore_time_unix_get(), last_sync_time);
 105
 106         if (ecore_time_unix_get() - last_sync_time > MAX_WAIT_TIME) {
 107             initialize_sap();
 108             request_show_sync_notification();
 109             result = false;
 110         } else {
 111             if (ecore_time_unix_get() - last_sync_time > SYNC_INTERVAL)
 112                 result = true;
 113             else
 114                 result = false;
 115         }
 116     }
 117     else
 118     {
 119         result = false;
 120     }
 121 #endif /* VCONFKEY_STICKER_SUPPORTED_FEATURE */
 122
 123     return result;
 124 }
 125
 126 static void app_control(app_control_h app_control, void *data)
 127 {
 128     /* Handle the launch request. */
 129     char* request = NULL;
 130     char* mode = NULL;
 131     char* type = NULL;
 132     char* operation = NULL;
 133     char* event_value = NULL;
 134     char* uri = NULL;
 135     const char *event_uri = "event://tizen.system.event.battery_charger_status";
 136     int res;
 137
 138     // operation
 139     int ret = app_control_get_operation(app_control, &operation);
 140     if (ret == APP_CONTROL_ERROR_NONE) {
 141         LOGD("operation: %s", operation);
 142
 143         if (!operation) {
 144             goto cleanup;
 145         }
 146
 147         if (strcmp(operation, APP_CONTROL_OPERATION_LAUNCH_ON_EVENT) == 0)
 148         {
 149             ret = app_control_get_uri(app_control, &uri);
 150             if (ret == APP_CONTROL_ERROR_NONE && uri)
 151             {
 152                 if (strncmp(uri, event_uri, strlen(event_uri) + 1) == 0)
 153                 {
 154                     ret = app_control_get_extra_data(app_control, "battery_charger_status", &event_value);
 155                     if (ret == APP_CONTROL_ERROR_NONE && event_value)
 156                     {
 157                         if (string(event_value) == "connected")
 158                         {
 159                             if (!is_init_sap()) {
 160                                 if (check_sync_time_condition()) {
 161                                     if (check_battery_condition()) {
 162                                         initialize_sap();
 163                                         request_all_sticker_data("auto", "input");
 164                                     }
 165                                 }
 166                                 else {
 167                                     if (!get_job_progress())
 168                                     {
 169                                         LOGD("exit");
 170                                         service_app_exit();
 171                                     }
 172                                 }
 173                             }
 174                             else {
 175                                 LOGD("continue doing current job");
 176                             }
 177                         }
 178                         free(event_value);
 179                     }
 180                 }
 181                 free(uri);
 182             }
 183         }
 184     }
 185     else {
 186         LOGW("Failed to get operation. error : %d", ret);
 187     }
 188
 189     // sync request
 190     res = app_control_get_extra_data(app_control, "request", &request);
 191     if (APP_CONTROL_ERROR_NONE == res && NULL != request) {
 192         if (strcmp(request, "sync") == 0) {
 193             bool param_error = false;
 194             if (app_control_get_extra_data(app_control, "mode", &mode) != APP_CONTROL_ERROR_NONE) {
 195                 LOGE("No given mode");
 196                 param_error = true;
 197             }
 198
 199             if (app_control_get_extra_data(app_control, "type", &type) != APP_CONTROL_ERROR_NONE) {
 200                 LOGE("No given type");
 201                 param_error = true;
 202             }
 203
 204             LOGI("[sync request] mode : %s, type : %s", mode, type);
 205             if (param_error)
 206                 goto cleanup;
 207
 208             if (mode && type) {
 209                 if (!is_init_sap()) {
 210                     initialize_sap();
 211                     request_all_sticker_data(mode, type);
 212                 }
 213             }
 214         }
 215         else if (strcmp(request, "oobe") == 0) {
 216             initialize_sap();
 217             request_sticker_feature();
 218         }
 219         else
 220         {
 221             LOGW("Unknown command : %s", request);
 222             if (!is_init_sap())
 223             {
 224                 service_app_exit();
 225             }
 226         }
 227     }
 228
 229 cleanup:
 230     if (NULL != operation)
 231         free(operation);
 232
 233     if (NULL != request)
 234         free(request);
 235
 236     if (NULL != mode)
 237         free(mode);
 238
 239     if (NULL != type)
 240         free(type);
 241 }
 242
 243 static void app_terminate(void *data)
 244 {
 245     /* Release all resources. */
 246     LOGD("");
 247     destroy_sticker_provider_handle();
 248     deinitialize_sap();
 249 }
 250
 251 int main(int argc, char *argv[])
 252 {
 253     int ret = 0;
 254
 255     service_app_lifecycle_callback_s event_callback;
 256     memset(&event_callback, 0x0, sizeof(service_app_lifecycle_callback_s));
 257
 258     event_callback.create = (service_app_create_cb)app_create;
 259     event_callback.terminate = (service_app_terminate_cb)app_terminate;
 260     event_callback.app_control = (service_app_control_cb)app_control;
 261
 262     ret = service_app_main(argc, argv, &event_callback, NULL);
 263     if (ret != APP_ERROR_NONE) {
 264         LOGE("app_main() is failed. err = %d", ret);
 265     }
 266     return ret;
 267 }