src/ciss-main.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.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.tizenopensource.org/license
   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 <stdio.h>
  18 #include <appcore-efl.h>
  19 #include <aul.h>
  20 #include <glib-2.0/glib.h>
  21 #include <Ecore.h>
  22 #include <app.h>
  23 #include <app_service.h>
  24
  25 #include "ciss-common.h"
  26 #include "ciss-util.h"
  27 #include "ciss-ussd.h"
  28 #include "ciss-resp.h"
  29 #include "ciss-tapi-request.h"
  30 #include "ciss-parser.h"
  31 #include "ciss-widget.h"
  32
  33 static ciss_appdata_t application_data;
  34
  35 static Eina_Bool __ciss_app_create(void *data);
  36 static void __ciss_app_terminate(void *data);
  37 static void __ciss_app_pause(void *data);
  38 static void __ciss_app_resume(void *data);
  39 static void __ciss_app_service(service_h service, void *data);
  40 static int __ciss_relaunch_handler(void *data);
  41
  42 static Eina_Bool __ciss_app_create(void *data)
  43 {
  44         DBG("Enter");
  45
  46         ciss_appdata_t *ad = (ciss_appdata_t *)data;
  47         _ciss_tapi_event_setup(ad);
  48         ad->win_main = NULL;
  49         ad->layout_main = NULL;
  50         ad->bg = NULL;
  51         ad->popup = NULL;
  52         ad->end_key_event_handler = NULL;
  53         ad->is_sat_request = EINA_FALSE;
  54         ad->service_handle = NULL;
  55         memset(&(ad->tapi_event), 0, sizeof(ciss_tapi_event_t));
  56         memset(&(ad->sat_terminal_response), 0, sizeof(ciss_sat_terminal_response_t));
  57         _ciss_geinlist_item_class_new(ad);
  58
  59         return EINA_TRUE;
  60 }
  61
  62 static void __ciss_app_terminate(void *data)
  63 {
  64         DBG("Enter");
  65
  66         ciss_appdata_t *ad = data;
  67
  68         _ciss_geinlist_item_class_free(ad);
  69         if (ad->win_main) {
  70                 evas_object_del(ad->win_main);
  71                 if (ad->end_key_event_handler)
  72                         ecore_event_handler_del(ad->end_key_event_handler);
  73         }
  74
  75         if (ad->bg) {
  76                 evas_object_del(ad->bg);
  77                 ad->bg = NULL;
  78         }
  79
  80         _ciss_deregister_tel_event(ad);
  81         DBG("Leave");
  82 }
  83
  84 static void __ciss_app_pause(void *data)
  85 {
  86         DBG("Enter");
  87         elm_exit();
  88 }
  89
  90 static void __ciss_app_resume(void *data)
  91 {
  92         DBG("Enter");
  93 }
  94
  95 static void __ciss_app_service(service_h service, void *data)
  96 {
  97         DBG("Enter");
  98
  99         ciss_appdata_t *ad = data;
 100         int err = SERVICE_ERROR_NONE;
 101
 102         if (ad == NULL) {
 103                 ERR("ad == NULL");
 104                 return;
 105         }
 106
 107         err = service_clone(&(ad->service_handle), service);
 108         if (err != SERVICE_ERROR_NONE) {
 109                 ERR("service_clone error - (%d)\n", err);
 110
 111                 if (ad->service_handle) {
 112                         service_destroy(ad->service_handle);
 113                 }
 114                 ad->service_handle = NULL;
 115                 elm_exit();
 116                 return;
 117         }
 118
 119         if (ad->win_main)
 120                 elm_win_activate(ad->win_main);
 121
 122         __ciss_relaunch_handler(data);
 123
 124         if (ad->service_handle) {
 125                 service_destroy(ad->service_handle);
 126                 ad->service_handle = NULL;
 127         }
 128
 129         DBG("Leave");
 130 }
 131
 132 static int __ciss_relaunch_handler(void *data)
 133 {
 134         DBG("Enter");
 135
 136         int ret = 0;
 137         int event_type = 0;
 138 #ifdef _CISS_USE_PARAM
 139         int event_status = 0;
 140         int encoded_data_length;
 141 #endif
 142         int err = SERVICE_ERROR_NONE;
 143
 144         ciss_appdata_t *ad = (ciss_appdata_t *)data;
 145         Evas_Object *popup;
 146         char *launching_mode = NULL;
 147         char *req_string = NULL;
 148         char *key_event_type = NULL;
 149         char *key_status = NULL;
 150         char *key_encoded_data_length = NULL;
 151         char *key_encoded_data = NULL;
 152
 153         err = service_get_extra_data(ad->service_handle, "CISS_LAUNCHING_MODE", &launching_mode);
 154         if (err != SERVICE_ERROR_NONE) {
 155                 DBG("service_get_extra_data for CISS_LAUNCHING_MODE failed - (%d)\n", err);
 156                 return -1;
 157         }
 158
 159         if (strcmp(launching_mode, "REQ") == 0) {
 160                 err = service_get_extra_data(ad->service_handle, "CISS_REQ_STRING", &req_string);
 161                 if (err != SERVICE_ERROR_NONE) {
 162                         DBG("service_get_extra_data for CISS_LAUNCHING_MODE failed - (%d)\n", err);
 163                 }
 164                 retv_if(req_string == NULL, -1);
 165                 DBG("CISS_REQ_STRING=%s", req_string);
 166                 strncpy(ad->req_string, req_string, REQ_STRING_MAX_LEN - 1);
 167                 ciss_err_t ciss_err_code;
 168
 169                 if (ad->win_main == NULL) {
 170                         Evas_Object *win;
 171                         win = _ciss_create_win(PACKAGE);
 172                         retv_if(win == NULL, -1);
 173                         ad->win_main = win;
 174                         evas_object_show(win);
 175                         ad->end_key_event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _ciss_on_end_key_down, NULL);
 176                 }
 177
 178                 if (ad->popup != NULL)  {
 179                         evas_object_del(ad->popup);
 180                         ad->popup = NULL;
 181                 }
 182
 183                 DBG("scale = %f", elm_config_scale_get());
 184
 185                 popup = _ciss_create_noti_popup(ad->win_main, CISS_STR_REQUESTING, NULL, POPUP_DISPLAY_DURATION, ad);
 186                 ad->popup = popup;
 187                 ciss_mmi_context_t      mmi_ctx;
 188
 189                 ciss_err_code = _ciss_parse_req_string(req_string, &mmi_ctx);
 190
 191                 if (ciss_err_code != CISS_ERR_NONE) {
 192                         _ciss_create_error_popup(ad->win_main, ciss_err_code, 2.0, ad);
 193                 } else {
 194                         ciss_err_code = _ciss_send_tapi_request(&mmi_ctx, ad);
 195                         DBG("ciss_err_code(_ciss_send_tapi_request) = %d", ciss_err_code);
 196                         if (ciss_err_code != CISS_ERR_NONE) {
 197                                 _ciss_create_error_popup(ad->win_main, ciss_err_code, 2.0, ad);
 198                         }
 199                 }
 200         } else if (strcmp(launching_mode, "RESP")== 0) {
 201                 err = service_get_extra_data(ad->service_handle, "KEY_EVENT_TYPE", &key_event_type);
 202                 if (err != SERVICE_ERROR_NONE) {
 203                         DBG("service_get_extra_data for KEY_EVENT_TYPE failed - (%d)\n", err);
 204                 }
 205                 event_type = atoi(key_event_type);
 206                 ad->tapi_event.event_type = event_type;
 207 #ifdef _CISS_USE_PARAM
 208                 err = service_get_extra_data(ad->service_handle, "KEY_STATUS", &key_status);
 209                 if (err != SERVICE_ERROR_NONE) {
 210                         DBG("service_get_extra_data for KEY_STATUS failed - (%d)\n", err);
 211                 }
 212                 event_status = atoi(key_status);
 213                 ad->tapi_event.status = event_status;
 214
 215                 err = service_get_extra_data(ad->service_handle, "KEY_ENCODED_DATA_LENGTH", &key_encoded_data_length);
 216                 if (err != SERVICE_ERROR_NONE) {
 217                         DBG("service_get_extra_data for KEY_ENCODED_DATA_LENGTH failed - (%d)\n", err);
 218                 }
 219                 encoded_data_length = atoi(key_encoded_data_length);
 220 #endif
 221                 err = service_get_extra_data(ad->service_handle, "KEY_ENCODED_DATA", &key_encoded_data);
 222                 if (err != SERVICE_ERROR_NONE) {
 223                         DBG("service_get_extra_data for KEY_ENCODED_DATA failed - (%d)\n", err);
 224                 }
 225                 gchar *decoded_data;
 226                 gsize decoded_data_length;
 227
 228                 decoded_data = (gchar *)g_base64_decode((gchar *)key_encoded_data, &decoded_data_length);
 229
 230                 ad->tapi_event.data_length = decoded_data_length;
 231                 ad->tapi_event.p_data = decoded_data;
 232
 233                 DBG("Received Event=0x%x", event_type);
 234
 235                 switch (event_type) {
 236                 case TAPI_EVENT_SS_USSD_IND:
 237                         _ciss_tapi_ussd_resp_handle(0, ad->tapi_event.p_data, ad);
 238                         break;
 239                 case TAPI_SAT_CMD_TYPE_SEND_USSD:
 240                         _ciss_on_tapi_sat_ussd_event(ad->tapi_event.p_data, ad);
 241                         break;
 242                 case TAPI_SAT_CMD_TYPE_SEND_SS:
 243                         _ciss_on_tapi_sat_ss_event(ad->tapi_event.p_data, ad);
 244                         break;
 245                 default:
 246                         ret = -1;
 247                         break;
 248                 }
 249         } else {
 250                 ERR("wrong exec type");
 251                 ret = -1;
 252         }
 253
 254         if (launching_mode) {
 255                 free(launching_mode);
 256                 launching_mode = NULL;
 257         }
 258         if (req_string) {
 259                 free(req_string);
 260                 req_string = NULL;
 261         }
 262         if (key_event_type) {
 263                 free(key_event_type);
 264                 key_event_type = NULL;
 265         }
 266         if (key_status) {
 267                 free(key_status);
 268                 key_status = NULL;
 269         }
 270         if (key_encoded_data_length) {
 271                 free(key_encoded_data_length);
 272                 key_encoded_data_length = NULL;
 273         }
 274         if (key_encoded_data) {
 275                 free(key_encoded_data);
 276                 key_encoded_data = NULL;
 277         }
 278
 279         DBG("Leave");
 280         return ret;
 281 }
 282
 283 int main(int argc, char *argv[])
 284 {
 285         DBG("Enter");
 286
 287         app_event_callback_s event_callback = {0,};
 288
 289         event_callback.create = __ciss_app_create;
 290         event_callback.terminate = __ciss_app_terminate;
 291         event_callback.pause = __ciss_app_pause;
 292         event_callback.resume = __ciss_app_resume;
 293         event_callback.service = __ciss_app_service;
 294
 295         event_callback.low_memory = NULL;
 296         event_callback.low_battery = NULL;
 297         event_callback.device_orientation = NULL;
 298         event_callback.language_changed = NULL;
 299         event_callback.region_format_changed = NULL;
 300
 301         int ret = APP_ERROR_NONE;
 302
 303         memset(&application_data, 0x0, sizeof(ciss_appdata_t));
 304
 305         ret = app_efl_main(&argc, &argv, &event_callback, &application_data);
 306         if (ret != APP_ERROR_NONE) {
 307                 DBG("app_efl_main() is failed (%d)\n", ret);
 308         }
 309
 310         return ret;
 311 }
 312