src/ciss-tapi-request.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 <TapiEvent.h>
  18 #include <ITapiSs.h>
  19 #include <ITapiSat.h>
  20 #include <TapiCommon.h>
  21 #include "ciss-tapi-request.h"
  22 #include "ciss-parser.h"
  23 #include "ciss-util.h"
  24 #include "vconf.h"
  25 #include "ciss-debug.h"
  26 #include "ciss-string.h"
  27 #include "ciss-widget.h"
  28 #include "ciss-ussd.h"
  29 #include "ciss-resp.h"
  30 #include "ciss-converter.h"
  31
  32 typedef struct _EventHandler {
  33         int event_type;
  34         unsigned int event_id;
  35         TelAppCallback func;
  36 } EventHandler;
  37
  38 EventHandler event_list[] = {
  39         {TAPI_EVENT_SS_BARRING_CHANGEPASS_CNF, 0, _ciss_on_tapi_ss_event},
  40         {TAPI_EVENT_SS_BARRING_CNF, 0, _ciss_on_tapi_ss_event},
  41         {TAPI_EVENT_SS_BARRING_QUERYSTATUS_CNF, 0, _ciss_on_tapi_ss_event},
  42         {TAPI_EVENT_SS_CLI_QUERYSTATUS_CNF, 0, _ciss_on_tapi_ss_event},
  43         {TAPI_EVENT_SS_FORWARD_CNF, 0, _ciss_on_tapi_ss_event},
  44         {TAPI_EVENT_SS_FORWARD_QUERYSTATUS_CNF, 0, _ciss_on_tapi_ss_event},
  45         {TAPI_EVENT_SS_USSD_CANCEL_CNF, 0, _ciss_on_tapi_ussd_event},
  46         {TAPI_EVENT_SS_USSD_CNF, 0, _ciss_on_tapi_ussd_event},
  47         {TAPI_EVENT_SS_WAITING_CNF, 0, _ciss_on_tapi_ss_event},
  48         {TAPI_EVENT_SS_WAITING_QUERYSTATUS_CNF, 0, _ciss_on_tapi_ss_event},
  49         {TAPI_EVENT_SAT_SEND_SS_IND, 0, _ciss_on_tapi_sat_ss_event},
  50         {TAPI_EVENT_SAT_SEND_USSD_IND, 0, _ciss_on_tapi_sat_ussd_event},
  51         {TAPI_EVENT_SS_REL_COMP_MSG_NOTIFY, 0, _ciss_on_tapi_ss_rel_complete_noti},
  52 };
  53
  54 int _ciss_tapi_event_setup(struct appdata *ad)
  55 {
  56         DBG("Enter");
  57         int i = 0;
  58         int len = 0;
  59         int api_err = -1;
  60
  61         len = sizeof(event_list) / sizeof(EventHandler);
  62
  63         if (tel_init() == 0) {
  64                 for (i = 0; i < len; i++) {
  65                         tel_register_event(event_list[i].event_type, &(event_list[i].event_id), event_list[i].func, (void *)ad);
  66                 }
  67
  68                 if ((api_err = tel_register_app_name("org.tizen.ciss-mmi")) != TAPI_API_SUCCESS)
  69                         DBG("tel_register_app_name failed error=%d", api_err);
  70         } else
  71                 DBG("TelTapiInitEcore() failed.");
  72
  73         DBG("Leave");
  74         return 0;
  75 }
  76
  77 void _ciss_deregister_tel_event(void)
  78 {
  79         DBG("Enter");
  80         int len, ret, i;
  81
  82         len = sizeof(event_list) / sizeof(EventHandler);
  83
  84         for (i = 0; i < len; i++) {
  85                 ret = tel_deregister_event(event_list[i].event_id);
  86                 if (ret != TAPI_API_SUCCESS)
  87                         DBG("tel_deregister_event error=%d", ret);
  88         }
  89
  90         ret = tel_deinit();
  91         if (ret != TAPI_API_SUCCESS)
  92                 DBG("TAPI delinit() ret : %d", ret);
  93 }
  94
  95 ciss_err_t _ciss_send_tapi_request(ciss_mmi_context_t *mmi_ctx)
  96 {
  97         DBG("Enter");
  98
  99         TelSsUssdMsgInfo_t stUssdRecord;
 100         TelSsForwardInfo_t stCfActReq;
 101         TelSsCallBarringInfo_t stCbReq;
 102         TelSsWaitingInfo_t stCwReq;
 103         int RequestId;
 104         TapiResult_t err = TAPI_API_SUCCESS;
 105         ciss_err_t error_code = CISS_ERR_NONE;
 106
 107         if (mmi_ctx->ss_type == TAPI_SS_TYPE_FORWARDING) {
 108                 memset(&stCfActReq, 0, sizeof(TelSsForwardInfo_t));
 109                 stCfActReq.Condition = TAPI_SS_FORWARD_WHEN_UNCONDITIONAL_EV;
 110                 stCfActReq.Condition = (TelSsForwardWhen_t) mmi_ctx->ss_flavor;
 111                 DBG("\n [CISS-ENGINE] ss_flavor= %d,%d", stCfActReq.Condition, mmi_ctx->ss_flavor);
 112
 113                 _ciss_get_tapi_forward_type(mmi_ctx->tapi_bsg, &stCfActReq.Type);
 114                 stCfActReq.NoReplyConditionTimer = mmi_ctx->nr_timer;
 115                 strncpy((char *)stCfActReq.szPhoneNumber, mmi_ctx->divert_number, CISS_NUMBER_LEN_MAX);
 116                 stCfActReq.szPhoneNumber[CISS_NUMBER_LEN_MAX] = '\0';
 117         } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_BARRING) {
 118                 memset(&stCbReq, 0, sizeof(TelSsCallBarringInfo_t));
 119                 stCbReq.Type = (TelSsCallBarType_t) mmi_ctx->ss_flavor;
 120                 DBG("\n [CISS-ENGINE] ss_flavor= %d,%d", stCbReq.Type, mmi_ctx->ss_flavor);
 121                 _ciss_get_tapi_call_type(mmi_ctx->tapi_bsg, &stCbReq.CallType);
 122                 memcpy(&stCbReq.szPassword, mmi_ctx->ss_password, CISS_MAX_PASSWORD_LEN);
 123         } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_WAITING) {
 124                 memset(&stCwReq, 0, sizeof(TelSsWaitingInfo_t));
 125                 _ciss_get_tapi_call_type(mmi_ctx->tapi_bsg, &stCwReq.CallType);
 126         }
 127         switch (mmi_ctx->opcode) {
 128         case registerSS:
 129                 DBG("registerSS");
 130                 /* send a register request */
 131                 if (mmi_ctx->ss_type == TAPI_SS_TYPE_FORWARDING) {
 132                         stCfActReq.Mode = TAPI_CALL_FORWARD_MODE_REGISTRATION_EV;
 133
 134                         err = tel_set_ss_forward(&stCfActReq, &RequestId);
 135                         if (err != TAPI_API_SUCCESS) {
 136                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : REGISTRATION call fails g_err_code = %x", err);
 137                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : REGISTRATION call fails request ID = %d", RequestId);
 138                                 _ciss_get_error_from_tapi_error(&error_code, err);
 139                                 return error_code;
 140                         }
 141                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_BARRING) {
 142
 143                         stCbReq.Mode = TAPI_SS_CALL_BAR_ACTIVATE;
 144
 145                         err = tel_set_ss_barring(&stCbReq, &RequestId);
 146                         if (err != TAPI_API_SUCCESS) {
 147                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : ACTIVATE call fails g_err_code = %x", err);
 148                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : ACTIVATE call fails request ID       = %d", RequestId);
 149                                 _ciss_get_error_from_tapi_error(&error_code, err);
 150                                 return error_code;
 151                         }
 152                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_WAITING) {
 153                         stCwReq.Mode = TAPI_SS_CW_ACTIVATE;
 154                         err = tel_set_ss_waiting(&stCwReq, &RequestId);
 155                         if (err != TAPI_API_SUCCESS) {
 156                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : ACTIVATION call fails g_err_code = %x", err);
 157                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : ACTIVATION call fails request ID  = %d", RequestId);
 158                                 _ciss_get_error_from_tapi_error(&error_code, err);
 159                                 return error_code;
 160                         }
 161                 }
 162                 break;
 163         case eraseSS:
 164                 DBG("eraseSS");
 165                 /* send an erase command */
 166                 if (mmi_ctx->ss_type == TAPI_SS_TYPE_FORWARDING) {
 167                         stCfActReq.Mode = TAPI_CALL_FORWARD_MODE_ERASURE_EV;
 168
 169                         err = tel_set_ss_forward(&stCfActReq, &RequestId);
 170                         if (err != TAPI_API_SUCCESS) {
 171                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : DE-REGISTRATION call fails g_err_code = %x", err);
 172                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : DE-REGISTRATION call fails request = %d", RequestId);
 173                                 _ciss_get_error_from_tapi_error(&error_code, err);
 174                                 return error_code;
 175                         }
 176                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_BARRING) {
 177                         stCbReq.Mode = TAPI_SS_CALL_BAR_DEACTIVATE;
 178
 179                         err = tel_set_ss_barring(&stCbReq, &RequestId);
 180                         if (err != TAPI_API_SUCCESS) {
 181                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : DEACTIVATE call fails g_err_code = %x", err);
 182                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : DEACTIVATE call fails request ID  = %d", RequestId);
 183                                 _ciss_get_error_from_tapi_error(&error_code, err);
 184                                 return error_code;
 185                         }
 186                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_WAITING) {
 187                         stCwReq.Mode = TAPI_SS_CW_DEACTIVATE;
 188
 189                         err = tel_set_ss_waiting(&stCwReq, &RequestId);
 190                         if (err != TAPI_API_SUCCESS) {
 191                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : DEACTIVATION call fails g_err_code = %x", err);
 192                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : DEACTIVATION call fails request ID   = %d", RequestId);
 193                                 _ciss_get_error_from_tapi_error(&error_code, err);
 194                                 return error_code;
 195                         }
 196                 }
 197                 break;
 198         case activateSS:
 199                 DBG("activateSS");
 200                 /* send an activate request */
 201                 if (mmi_ctx->ss_type == TAPI_SS_TYPE_FORWARDING) {
 202                         stCfActReq.Mode = TAPI_CALL_FORWARD_MODE_ENABLE_EV;
 203
 204                         err = tel_set_ss_forward(&stCfActReq, &RequestId);
 205                         if (err != TAPI_API_SUCCESS) {
 206                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : ACTIVATE call fails g_err_code = %x", err);
 207                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : ACTIVATE call fails request ID       = %d", RequestId);
 208                                 _ciss_get_error_from_tapi_error(&error_code, err);
 209                                 return error_code;
 210                         }
 211                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_BARRING) {
 212                         stCbReq.Mode = TAPI_SS_CALL_BAR_ACTIVATE;
 213
 214                         err = tel_set_ss_barring(&stCbReq, &RequestId);
 215                         if (err != TAPI_API_SUCCESS) {
 216                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : ACTIVATE call fails g_err_code = %x", err);
 217                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : ACTIVATE call fails request ID       = %d", RequestId);
 218                                 _ciss_get_error_from_tapi_error(&error_code, err);
 219                                 return error_code;
 220                         }
 221
 222                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_WAITING) {
 223                         stCwReq.Mode = TAPI_SS_CW_ACTIVATE;
 224
 225                         err = tel_set_ss_waiting(&stCwReq, &RequestId);
 226                         if (err != TAPI_API_SUCCESS) {
 227                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : ACTIVATION call fails g_err_code = %x", err);
 228                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : ACTIVATION call fails request ID  = %d", RequestId);
 229                                 _ciss_get_error_from_tapi_error(&error_code, err);
 230                                 return error_code;
 231                         }
 232                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_IDENTIFICATION) {
 233                         DBG("\n [CISS-ENGINE] Don't activated CLI option");
 234                         error_code = CISS_ERR_ILLEGAL_SS_OPER;
 235                         return error_code;
 236                 }
 237                 break;
 238         case deactivateSS:
 239                 DBG("deactivateSS");
 240                 /* deactivate request */
 241                 if (mmi_ctx->ss_type == TAPI_SS_TYPE_FORWARDING) {
 242                         stCfActReq.Mode = TAPI_CALL_FORWARD_MODE_DISABLE_EV;
 243                         err = tel_set_ss_forward(&stCfActReq, &RequestId);
 244                         if (err != TAPI_API_SUCCESS) {
 245                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : DEACTIVATE call fails g_err_code = %x", err);
 246                                 DBG("\n [CISS-ENGINE] tel_set_ss_forward : DEACTIVATE call fails request ID  = %d", RequestId);
 247                                 _ciss_get_error_from_tapi_error(&error_code, err);
 248                                 return error_code;
 249                         }
 250                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_BARRING) {
 251                         stCbReq.Mode = TAPI_SS_CALL_BAR_DEACTIVATE;
 252
 253                         DBG("\n [CISS-ENGINE] **** ss_mode = %d\n", stCbReq.Mode);
 254                         DBG("\n [CISS-ENGINE] **** flavor = %d\n", stCbReq.Type);
 255                         DBG("\n [CISS-ENGINE] **** call type = %d\n", stCbReq.CallType);
 256                         DBG("\n [CISS-ENGINE] **** Pwd = %s\n", stCbReq.szPassword);
 257
 258                         err = tel_set_ss_barring(&stCbReq, &RequestId);
 259                         if (err != TAPI_API_SUCCESS) {
 260                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : DEACTIVATE call fails g_err_code = %x", err);
 261                                 DBG("\n [CISS-ENGINE] tel_set_ss_barring : DEACTIVATE call fails request ID  = %d", RequestId);
 262                                 _ciss_get_error_from_tapi_error(&error_code, err);
 263                                 return error_code;
 264                         }
 265                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_WAITING) {
 266                         stCwReq.Mode = TAPI_SS_CW_DEACTIVATE;
 267                         err = tel_set_ss_waiting(&stCwReq, &RequestId);
 268                         if (err != TAPI_API_SUCCESS) {
 269                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : ACTIVATION call fails g_err_code = %x", err);
 270                                 DBG("\n [CISS-ENGINE] tel_set_ss_waiting : ACTIVATION call fails request ID  = %d", RequestId);
 271                                 _ciss_get_error_from_tapi_error(&error_code, err);
 272                                 return error_code;
 273                         }
 274                 }
 275                 break;
 276         case interrogateSS:
 277                 DBG("interrogateSS");
 278                 /* interrogate request */
 279                 if (mmi_ctx->ss_type == TAPI_SS_TYPE_FORWARDING) {
 280                         err = tel_get_ss_forward_status(stCfActReq.Type, stCfActReq.Condition, &RequestId);
 281                         if (err != TAPI_API_SUCCESS) {
 282                                 DBG("\n [CISS-ENGINE] tel_get_ss_forward_status call fails g_err_code = %x", err);
 283                                 DBG("\n [CISS-ENGINE] tel_get_ss_forward_status : CHECK_STATUS call fails request ID  = %d", RequestId);
 284                                 _ciss_get_error_from_tapi_error(&error_code, err);
 285                                 return error_code;
 286                         }
 287                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_BARRING) {
 288                         err = tel_get_ss_barring_status(stCbReq.Type, stCbReq.CallType, &RequestId);
 289                         if (err != TAPI_API_SUCCESS) {
 290                                 DBG("\n [CISS-ENGINE] tel_get_ss_barring_status call fails g_err_code = %x", err);
 291                                 DBG("\n [CISS-ENGINE] tel_get_ss_barring_status : CHECK_STATUS call fails request ID  = %d", RequestId);
 292                                 _ciss_get_error_from_tapi_error(&error_code, err);
 293                                 return error_code;
 294                         }
 295                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_WAITING) {
 296                         err = tel_get_ss_waiting_status(stCwReq.CallType, &RequestId);
 297                         if (err != TAPI_API_SUCCESS) {
 298                                 DBG("\n [CISS-ENGINE] tel_get_ss_waiting_status call fails g_err_code = %x", err);
 299                                 DBG("\n [CISS-ENGINE] tel_get_ss_waiting_status : fails request ID  = %d", RequestId);
 300                                 _ciss_get_error_from_tapi_error(&error_code, err);
 301                                 return error_code;
 302                         }
 303                 } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_IDENTIFICATION) {
 304                         err = tel_get_ss_cli_status(mmi_ctx->ss_flavor, &RequestId);
 305                         if (err != TAPI_API_SUCCESS) {
 306                                 DBG("\n [CISS-ENGINE] tel_get_ss_cli_status call fails g_err_code = %x", err);
 307                                 DBG("\n [CISS-ENGINE] tel_get_ss_cli_status : fails request ID  = %d", RequestId);
 308                                 _ciss_get_error_from_tapi_error(&error_code, err);
 309                                 return error_code;
 310                         }
 311                 }
 312                 break;
 313         case registerPassword:
 314                 DBG("registerPassword");
 315                 /* password registration request */
 316                 /* check for too short password and mismatch password */
 317                 if (CISS_MAX_PASSWORD_LEN > strlen(mmi_ctx->ss_password) ||
 318                     CISS_MAX_PASSWORD_LEN > strlen(mmi_ctx->ss_new_password) ||
 319                     CISS_MAX_PASSWORD_LEN > strlen(mmi_ctx->ss_new_password2)) {
 320                         /* too short password */
 321                         DBG("\n [CISS-ENGINE] Too short password");
 322                         error_code = CISS_ERR_CB_PWD_TOO_SORT;
 323                         return error_code;
 324                 }
 325
 326                 err = tel_change_ss_barring_password(mmi_ctx->ss_password, mmi_ctx->ss_new_password, mmi_ctx->ss_new_password2, &RequestId);
 327                 if (err != TAPI_API_SUCCESS) {
 328                         DBG("\n [CISS-ENGINE] tel_change_ss_barring_password call request ID = %d", RequestId);
 329                         DBG("\n [CISS-ENGINE] tel_change_ss_barring_password call fails g_err_code = %x", err);
 330                         _ciss_get_error_from_tapi_error(&error_code, err);
 331                         return error_code;
 332                 }
 333                 break;
 334         case processUnstructuredSS_Request:
 335                 DBG("processUnstructuredSS_Request");
 336                 memset(&stUssdRecord, 0, sizeof(TelSsUssdMsgInfo_t));
 337                 stUssdRecord.UssdStringLength = strlen(mmi_ctx->user_string);
 338
 339                 _ciss_strcpy(stUssdRecord.szUssdString, sizeof(stUssdRecord.szUssdString), (char *)mmi_ctx->user_string);
 340
 341                 DBG("\n [CISS-ENGINE] string_length = %d, stUssdRecord.ussd_string = %s", stUssdRecord.UssdStringLength, stUssdRecord.szUssdString);
 342
 343                 err = tel_send_ss_ussd_request(&stUssdRecord, &RequestId);
 344                 if (err != TAPI_API_SUCCESS) {
 345                         DBG("\n [CISS-ENGINE] tel_send_ss_ussd_request call fails g_err_code = %x", err);
 346                         DBG("\n [CISS-ENGINE] tel_send_ss_ussd_request :call fails request ID   = %d", RequestId);
 347                         _ciss_get_error_from_tapi_error(&error_code, err);
 348                         return error_code;
 349                 }
 350                 break;
 351         default:
 352                 error_code = CISS_ERR_UNKNOWN;
 353                 DBG("\n [CISS-ENGINE] Invalid Parsed opcode = %d",
 354                     mmi_ctx->opcode);
 355
 356                 break;
 357         }
 358
 359 #if 0
 360 #ifndef CF_TEST
 361         /* Because tapi sends the CF no reply data for All CF and All conditional CF , we have to make a result flavor with requested data here */
 362         if (mmi_ctx->ss_type == TAPI_SS_TYPE_FORWARDING) {
 363                 memset(&this->ss_result_string, 0, sizeof(ciss_result_t));
 364                 _ciss_get_forward_flavor_type(mmi_ctx->ss_flavor, &this->ss_result_string.szFlavor);
 365
 366                 if (opcode == eraseSS) {
 367                         this->ss_req_data.telecommSvc = mmi_ctx->tapi_bsg;
 368                         this->ss_req_data.service = CISS_SERVICE_DIVERTING;
 369                         this->ss_req_data.flavor = mmi_ctx->ss_flavor;
 370                         this->ss_req_data.action = CISS_ACTION_DEACTIVATE;
 371                         DBG("\n [CISS-ENGINE] this->ss_req_data.action : %d\n", this->ss_req_data.action);
 372                         DBG("\n [CISS-ENGINE] this->ss_req_data.flavor : %d\n", this->ss_req_data.flavor);
 373                         DBG("\n [CISS-ENGINE] this->ss_req_data.telecommSvc : %d\n", this->ss_req_data.telecommSvc);
 374                         DBG("\n [CISS-ENGINE] this->ss_req_data.service : %d\n", this->ss_req_data.service);
 375                 }
 376
 377                 DBG("\n [CISS-ENGINE] Forwarding: Requested ss_flavor =%d\n", this->ss_result_string.szFlavor);
 378         } else if (mmi_ctx->ss_type == TAPI_SS_TYPE_BARRING) {
 379                 memset(&this->ss_result_string, 0, sizeof(ciss_result_t));
 380                 _ciss_get_barring_flavor_type(mmi_ctx->ss_flavor, &this->ss_result_string.szFlavor);
 381
 382                 DBG("\n [CISS-ENGINE] Barring: Requested ss_flavor =%d\n", this->ss_result_string.szFlavor);
 383         }
 384 #endif
 385 #endif
 386         DBG("Leave");
 387         return error_code;
 388 }
 389
 390 int _ciss_on_tapi_sat_ss_event(const TelTapiEvent_t *event, void *data)
 391 {
 392         DBG("Enter");
 393         retv_if(event == NULL, -1);
 394         retv_if(data == NULL, -1);
 395
 396         int ret = -1;
 397         struct appdata *ad = (struct appdata *)data;
 398
 399         DBG("event type=0x%x status=0x%x pDataLen=%d is_sat=%d",event->EventType, event->Status, event->pDataLen, ad->is_sat_request);
 400
 401         if (ad->popup) {
 402                 evas_object_del(ad->popup);
 403                 ad->popup = NULL;
 404         }
 405
 406         TelSatSendSsIndSsData_t send_ss_info;
 407         if (event->pDataLen > 0) {
 408                 memcpy(&send_ss_info, event->pData, sizeof(TelSatSendSsIndSsData_t));
 409
 410                 if (send_ss_info.ssStringLen > 0) {
 411                         ciss_err_t ciss_err_code;
 412                         ad->is_sat_request = EINA_TRUE;
 413                         ad->rel_comp_msg_len = 0;
 414                         ad->cmd_id = send_ss_info.commandId;
 415                         ciss_mmi_context_t      mmi_ctx;
 416                         ciss_err_code = _ciss_parse_req_string((char *)send_ss_info.ssString, &mmi_ctx);
 417
 418                         if (ciss_err_code == CISS_ERR_NONE) {
 419                                 ciss_err_code = _ciss_send_tapi_request(&mmi_ctx);
 420                                 ret = 0;
 421                         } else {
 422                                 TelSatAppsRetInfo_t app_ret_info;
 423                                 app_ret_info.commandId = ad->cmd_id;
 424                                 app_ret_info.commandType = TAPI_SAT_CMD_TYPE_SEND_SS;
 425
 426                                 app_ret_info.appsRet.sendSs.resp = TAPI_SAT_R_NETWORK_UNABLE_TO_PROCESS_COMMAND;
 427                                 app_ret_info.appsRet.sendSs.ssString.stringLen = 0;
 428                                 ret = tel_send_sat_app_exec_result(&app_ret_info);
 429                                 elm_exit();
 430                         }
 431                 }
 432         }
 433         DBG("Leave");
 434         return ret;
 435 }
 436
 437 int _ciss_on_tapi_sat_ussd_event(const TelTapiEvent_t *event, void *data)
 438 {
 439         DBG("Enter");
 440         retv_if(event == NULL, -1);
 441         retv_if(data == NULL, -1);
 442
 443         int ret = -1;
 444         struct appdata *ad = (struct appdata *)data;
 445
 446         DBG("event type=0x%x status=0x%x pDataLen=%d is_sat=%d", event->EventType, event->Status, event->pDataLen, ad->is_sat_request);
 447
 448         if (ad->popup) {
 449                 evas_object_del(ad->popup);
 450                 ad->popup = NULL;
 451         }
 452
 453         TelSatSendUssdIndUssdData_t send_ussd_info;
 454         if (event->pDataLen > 0) {
 455                 memcpy(&send_ussd_info, event->pData, sizeof(TelSatSendUssdIndUssdData_t));
 456
 457                 if (send_ussd_info.ussdStringLen > 0) {
 458                         int req_id;
 459                         ad->is_sat_request = EINA_TRUE;
 460                         ad->cmd_id = send_ussd_info.commandId;
 461                         TelSsUssdMsgInfo_t ussd_info;
 462                         ussd_info.UssdStringLength = send_ussd_info.ussdStringLen;
 463                         if (ussd_info.UssdStringLength >0)
 464                                 memcpy(&ussd_info.szUssdString, send_ussd_info.ussdString, ussd_info.UssdStringLength);
 465                         ret = tel_send_ss_ussd_request(&ussd_info, &req_id);
 466                 }
 467         }
 468         DBG("Leave, return=%d", ret);
 469         return ret;
 470 }
 471
 472 int _ciss_on_tapi_ss_rel_complete_noti(const TelTapiEvent_t *event, void *data)
 473 {
 474         DBG("Enter");
 475         retv_if(event == NULL, -1);
 476         retv_if(data == NULL, -1);
 477
 478         struct appdata *ad = (struct appdata *)data;
 479         TelSsRelCompMsgInfo_t rel_comp_info;
 480
 481         DBG("event type=0x%x status=0x%x pDataLen=%d is_sat=%d",event->EventType, event->Status, event->pDataLen, ad->is_sat_request);
 482         ad->rel_comp_msg_len = 0;
 483
 484         if (ad->is_sat_request == EINA_TRUE) {
 485                 if (event->pDataLen > 0) {
 486                         memcpy(&rel_comp_info, event->pData, event->pDataLen);
 487                         if (rel_comp_info.RelCompMsgLen > 0) {
 488                                 memcpy(ad->rel_comp_msg, rel_comp_info.szRelCompMsg, rel_comp_info.RelCompMsgLen);
 489                                 ad->rel_comp_msg_len = rel_comp_info.RelCompMsgLen;
 490                         }
 491                 }
 492         }
 493         return 0;
 494 }
 495
 496 int _ciss_on_tapi_ss_event(const TelTapiEvent_t *event, void *data)
 497 {
 498         DBG("Enter");
 499         retv_if(event == NULL, -1);
 500         retv_if(data == NULL, -1);
 501
 502         struct appdata *ad = (struct appdata *)data;
 503         TelSsInfo_t ss_info;
 504         int ret = -1;
 505
 506         DBG("event type=0x%x status=0x%x pDataLen=%d is_sat=%d", event->EventType, event->Status, event->pDataLen, ad->is_sat_request);
 507
 508         if (ad->popup) {
 509                 evas_object_del(ad->popup);
 510                 ad->popup = NULL;
 511         }
 512
 513         if (ad->is_sat_request == EINA_TRUE) {
 514                 TelSatAppsRetInfo_t app_ret_info;
 515                 app_ret_info.commandId = ad->cmd_id;
 516                 app_ret_info.commandType = TAPI_SAT_CMD_TYPE_SEND_SS;
 517
 518                 if (event->Status == TAPI_SS_SUCCESS) {
 519                         app_ret_info.appsRet.sendSs.resp = TAPI_SAT_R_SUCCESS;
 520
 521                         if (ad->rel_comp_msg_len >0) {
 522                                 memcpy(app_ret_info.appsRet.sendSs.ssString.string, ad->rel_comp_msg, ad->rel_comp_msg_len);
 523                                 app_ret_info.appsRet.sendSs.ssString.stringLen = ad->rel_comp_msg_len;
 524                         } else
 525                                 app_ret_info.appsRet.sendSs.ssString.stringLen = 0;
 526                 } else {
 527                         app_ret_info.appsRet.sendSs.resp = TAPI_SAT_R_SS_RETURN_ERROR;
 528                         app_ret_info.appsRet.sendSs.ssCause = event->Status;
 529                 }
 530                 ret = tel_send_sat_app_exec_result(&app_ret_info);
 531
 532                 elm_exit();
 533         } else {
 534                 /* create window */
 535                 Evas_Object *content;
 536
 537                 DBG("win=0x%p main=0x%p",ad->win_main, ad->layout_main);
 538
 539                 if (ad->win_main == NULL) {
 540                         Evas_Object *win;
 541                         win = _ciss_create_win(PACKAGE);
 542                         ad->win_main = win;
 543                         retv_if(ad->win_main == NULL, -1);
 544                         ad->end_key_event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _ciss_on_end_key_down, NULL);
 545                         evas_object_show(win);
 546                 }
 547
 548                 DBG("win=0x%p main=0x%p", ad->win_main, ad->layout_main);
 549
 550                 if (event->Status == TAPI_SS_SUCCESS) {
 551                         if (ad->bg == NULL) {
 552                                 ad->bg = _ciss_create_bg(ad->win_main);
 553                                 retv_if(ad->bg == NULL, -1);
 554                         }
 555
 556                         if (ad->layout_main == NULL) {
 557                                 ad->layout_main = _ciss_create_layout_main(ad->win_main);
 558                                 retv_if(ad->layout_main== NULL, -1);
 559                         }
 560                         DBG("win=0x%p main=0x%p", ad->win_main, ad->layout_main);
 561
 562                         if (event->pDataLen > 0) {
 563                                 memcpy(&ss_info, event->pData, sizeof(TelSsInfo_t));
 564                                 if (event->EventType == TAPI_EVENT_SS_CLI_QUERYSTATUS_CNF &&
 565                                         ss_info.SsType == TAPI_SS_TYPE_BARRING) {
 566                                         ss_info.SsType = TAPI_SS_TYPE_IDENTIFICATION;
 567                                 }
 568                                 content = (Evas_Object *)_ciss_create_ss_resp_view(ad->layout_main, &ss_info, ad);
 569                         } else {
 570                                 content = (Evas_Object *)_ciss_create_ss_resp_view(ad->layout_main, NULL, ad);
 571                         }
 572                         retv_if(content == NULL, -1);
 573                         elm_object_part_content_set(ad->layout_main, "elm.swallow.content", content);
 574                 } else {
 575                         ciss_err_t ciss_err;
 576                         _ciss_get_error_from_tapi_error(&ciss_err, event->Status);
 577                         _ciss_create_error_popup(ad->win_main, ciss_err, 2.0, ad);
 578                 }
 579
 580                 ret = 0;
 581         }
 582
 583         DBG("Leave");
 584         return ret;
 585 }
 586
 587 int _ciss_on_tapi_ussd_event(const TelTapiEvent_t *event, void *data)
 588 {
 589         DBG("Enter");
 590         retv_if(event == NULL, -1);
 591         retv_if(data == NULL, -1);
 592
 593         struct appdata *ad = (struct appdata *)data;
 594         TelSsUssdMsgIndInfo_t ussd_info;
 595         int ret = -1;
 596
 597         if (ad->popup) {
 598                 evas_object_del(ad->popup);
 599                 ad->popup = NULL;
 600         }
 601
 602         DBG("event type=0x%x status=0x%x pDataLen=%d is_sat=%d", event->EventType, event->Status, event->pDataLen, ad->is_sat_request);
 603         if (ad->is_sat_request == EINA_TRUE)
 604         {
 605                 TelSatAppsRetInfo_t app_ret_info;
 606                 app_ret_info.commandId = ad->cmd_id;
 607                 app_ret_info.commandType = TAPI_SAT_CMD_TYPE_SEND_USSD;
 608
 609                 if (event->Status == TAPI_SS_SUCCESS) {
 610                         if (event->pDataLen > 0)
 611                                 memcpy(&ussd_info, event->pData, sizeof(TelSsUssdMsgIndInfo_t));
 612
 613                         app_ret_info.appsRet.sendUssd.resp = TAPI_SAT_R_SUCCESS;
 614                         app_ret_info.appsRet.sendUssd.ussdString.stringLen = ussd_info.UssdInfo.UssdStringLength;
 615                         if (app_ret_info.appsRet.sendUssd.ussdString.stringLen > 0)
 616                                 memcpy(app_ret_info.appsRet.sendUssd.ussdString.string, ussd_info.UssdInfo.szUssdString, ussd_info.UssdInfo.UssdStringLength);
 617                 } else {
 618                         app_ret_info.appsRet.sendUssd.resp = TAPI_SAT_R_USSD_RETURN_ERROR;
 619                         app_ret_info.appsRet.sendUssd.ssCause = event->Status;
 620                 }
 621
 622                 tel_send_sat_app_exec_result(&app_ret_info);
 623                 ret = 0;
 624                 elm_exit();
 625         } else {
 626                 /* create window */
 627                 Evas_Object *content;
 628
 629                 if (ad->win_main == NULL) {
 630                         Evas_Object *win;
 631                         win = _ciss_create_win(PACKAGE);
 632                         retv_if(win == NULL, -1);
 633                         ad->win_main = win;
 634                         evas_object_show(win);
 635                         ad->end_key_event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _ciss_on_end_key_down, NULL);
 636                 }
 637
 638                 if (event->Status == TAPI_SS_SUCCESS) {
 639                         if (event->pDataLen > 0)
 640                                 memcpy(&ussd_info, event->pData, sizeof(TelSsUssdMsgIndInfo_t));
 641                         else    {
 642                                 DBG("Telephony USSD data is empty");
 643                                 return -1;
 644                         }
 645
 646                         if (ad->bg == NULL) {
 647                                 ad->bg = _ciss_create_bg(ad->win_main);
 648                                 retv_if(ad->bg == NULL, -1);
 649                         }
 650
 651                         if (ad->layout_main == NULL) {
 652                                 Evas_Object *lo;
 653                                 lo = _ciss_create_layout_main(ad->win_main);
 654                                 retv_if(lo == NULL, -1);
 655                                 ad->layout_main = lo;
 656                         }
 657                         content = (Evas_Object *)_ciss_create_ussd_view(ad->layout_main, &ussd_info, ad);
 658                         retv_if(content == NULL, -1);
 659                         elm_object_part_content_set(ad->layout_main, "elm.swallow.content", content);
 660                 } else {
 661                         ciss_err_t ciss_err;
 662                         _ciss_get_error_from_tapi_error(&ciss_err, event->Status);
 663                         _ciss_create_error_popup(ad->win_main, ciss_err, 2.0, ad);
 664                 }
 665                 ret = 0;
 666         }
 667
 668         DBG("Leave");
 669         return ret;
 670 }
 671