src/ciss-resp.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 "ciss-common.h"
  18 #include "ciss-widget.h"
  19 #include "ciss-resp.h"
  20 #include "ciss-tapi-request.h"
  21 #include "ciss-converter.h"
  22 #include "ciss-util.h"
  23 #include <TapiEvent.h>
  24
  25 static char resultstring[CISS_MAX_SS_RECORDS][CISS_USSD_DATA_SIZE_MAX];
  26
  27 static void __ciss_create_forward_result_string(ciss_result_t *ciss_result, TelSsInfo_t *ss_info)
  28 {
  29         int i;
  30         DBG("\n [CISS-ENGINE] __ciss_create_forward_result_string: num of param=%d\n", ss_info->NumberOfRecords);
  31         /* Check Network result & Setting Proper result string to display */
  32         /*  Set Supplement service type string */
  33         ciss_result->szSsType = CISS_SERVICE_DIVERTING;
  34         ciss_result->nRecordNum = ss_info->NumberOfRecords;
  35         /* Request from MMI string */
  36
  37         /* No SS Result received case.. */
  38         if (ss_info->NumberOfRecords <= 0) {
  39                 DBG("\n [CISS-ENGINE] __ciss_create_forward_result_string: (ME) parameter num=0!\n");
  40                 /* Set Display string : Default telecommSvc, Flavor, Result */
  41                 ciss_result->nRecordNum = 0;
  42                 _ciss_get_telecomm_svc(TAPI_SS_TS_NONE, &ciss_result->szBearer[0]);
  43                 _ciss_get_result_status_type(TAPI_SS_STATUS_PROVISIONED, &ciss_result->szResult[0]);
  44                 ciss_result->szFlavor = CISS_FLAVOR_NONE;
  45         } else {
  46                 /* Single or Multiple result received case..
  47                 In case of all CF and all conditional CF, tapi always sends a no reply flavor.
  48                 So we have to get the flavor with requested data that is saved in ss_result_string structure. */
  49
  50                 /* Set Display string :  Network result value */
  51                 for (i = 0; i < ss_info->NumberOfRecords; i++) {
  52                         _ciss_get_telecomm_svc(ss_info->SsRecord.ForwardingRecord.rec_class[i].TeleCommService, &ciss_result->szBearer[i]);
  53                         _ciss_get_result_status_type(ss_info->SsRecord.ForwardingRecord.rec_class[i].Status, &ciss_result->szResult[i]);
  54
  55                         if ((ss_info->SsRecord.ForwardingRecord.rec_class[0].ForwardCondition == TAPI_SS_FORWARD_WHEN_NO_ANSWER_EV) &&
  56                             (ss_info->SsRecord.ForwardingRecord.rec_class[i].NoReplyWaitTime != 0)) {
  57                                 ciss_result->nDivertWaitingTime[i] = ss_info->SsRecord.ForwardingRecord.rec_class[i].NoReplyWaitTime;
  58                                 DBG("\n [CISS-ENGINE] __ciss_create_forward_result_string(Multiple %dth): No reply time=%d\n",
  59                                         i, ciss_result->nDivertWaitingTime[i]);
  60                         }
  61                         DBG("\n [CISS-ENGINE] #########forwarding number = %s########\n\n",
  62                                 ss_info->SsRecord.ForwardingRecord.rec_class[i].szCallForwardingNumber);
  63
  64                         if (ss_info->SsRecord.ForwardingRecord.rec_class[i].bCallForwardingNumberPresent) {
  65                                 _ciss_strcpy(ciss_result->szDivertNumber[i],
  66                                         sizeof(ciss_result->szDivertNumber[i]),
  67                                         (char *)ss_info->SsRecord.ForwardingRecord.rec_class[i].szCallForwardingNumber);
  68                                 DBG("\n [CISS-ENGINE] #########forwarding number in response= %s########\n\n",
  69                                         ciss_result->szDivertNumber[i]);
  70                         }
  71                         DBG("\n [CISS-ENGINE] __ciss_create_forward_result_string(Multiple %dth): Bearer = %d, Favor = %d, Status = %d, num=%s\n",
  72                                 i, ss_info->SsRecord.ForwardingRecord.rec_class[i].TeleCommService,
  73                                 ss_info->SsRecord.ForwardingRecord.rec_class[0].ForwardCondition,
  74                                 ss_info->SsRecord.ForwardingRecord.rec_class[i].Status,
  75                                 ciss_result->szDivertNumber[i]);
  76                 }
  77         }
  78
  79 }
  80
  81 static void __ciss_create_barring_result_string(ciss_result_t *ciss_result /*out */, TelSsInfo_t *ss_info /*in */)
  82 {
  83         int i;
  84         /*  Set Supplement service type string */
  85         ciss_result->szSsType = CISS_SERVICE_BARRING;
  86         ciss_result->nRecordNum = ss_info->NumberOfRecords;
  87
  88         if (ss_info->NumberOfRecords <= 0) {
  89                 DBG("\n [CISS-ENGINE] __ciss_create_barring_result_string: (ME) parameter num=0!\n");
  90                 /* Set Display string : Default telecommSvc, Flavor, Result */
  91                 ciss_result->nRecordNum = 0;
  92                 _ciss_get_telecomm_svc(TAPI_SS_TS_NONE, &ciss_result->szBearer[0]);
  93                 _ciss_get_result_status_type(TAPI_SS_STATUS_PROVISIONED, &ciss_result->szResult[0]);
  94         } else {
  95                 /* Single or Multiple result received case.. */
  96                 /* In case of all barring, tapi always sends a BAOC flavor. */
  97                 /* So we have to get the flavor with requested data that is saved in ss_result_string structure. */
  98
  99                 for (i = 0; i < ss_info->NumberOfRecords; i++) {
 100                         _ciss_get_telecomm_svc(ss_info->SsRecord.BarringRecord.rec_class[i].TeleCommService, &ciss_result->szBearer[i]);
 101                         _ciss_get_result_status_type(ss_info->SsRecord.BarringRecord.rec_class[i].Status, &ciss_result->szResult[i]);
 102                         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_barring_cnf(Multiple %dth): Bearer = %d, Favor = %d, Status = %d\n",
 103                                 i, ss_info->SsRecord.BarringRecord.rec_class[i].TeleCommService,
 104                                 ss_info->SsRecord.BarringRecord.rec_class[i].Flavour,
 105                                 ss_info->SsRecord.BarringRecord.rec_class[i].Status);
 106                 }
 107         }
 108 }
 109
 110 static void __ciss_create_waiting_result_string(ciss_result_t *ciss_result /*out */, TelSsInfo_t *ss_info /*in */)
 111 {
 112         TelSsStatus_t WaitingResultStatus;
 113         int i;
 114         /* Check Network result & Setting Proper result string to display */
 115         /* Set Supplement service type string */
 116         ciss_result->szSsType = CISS_SERVICE_WAITING;
 117
 118         /* Call waiting setting result state
 119            1) Interrogate / Activate : all received bearers mean "Activate"
 120            2) Deactivate : All received bearers mean "Deactivate"
 121          */
 122         if (ss_info->SsRecord.WaitingRecord.rec_class[0].Status == TAPI_SS_STATUS_QUIESCENT)
 123                 WaitingResultStatus = TAPI_SS_STATUS_PROVISIONED;
 124         else
 125                 WaitingResultStatus = TAPI_SS_STATUS_ACTIVE;
 126
 127         DBG("\n [CISS-ENGINE] create_waiting_result_string : WaitingResultStatus = %d", WaitingResultStatus);
 128         ciss_result->nRecordNum = ss_info->NumberOfRecords;
 129
 130         /* Request From MMI */
 131         if (ss_info->NumberOfRecords <= 0) {
 132                 DBG("\n [CISS-ENGINE] __ciss_create_waiting_result_string: (ME) parameter num=0!\n");
 133                 /* Set Display string : Default telecommSvc, Flavor, Result */
 134                 _ciss_get_telecomm_svc(TAPI_SS_TS_NONE, &ciss_result->szBearer[0]);
 135                 _ciss_get_result_status_type(TAPI_SS_STATUS_PROVISIONED, &ciss_result->szResult[0]);
 136                 ciss_result->nRecordNum = 0;
 137         } else {
 138                 /* Single or Multiple result received case.. */
 139                 /* Set Display string :  Network result value */
 140
 141                 for (i = 0; i < ss_info->NumberOfRecords; i++) {
 142                         _ciss_get_telecomm_svc(ss_info->SsRecord.WaitingRecord.rec_class[i].TeleCommService, &ciss_result->szBearer[i]);
 143                         _ciss_get_result_status_type(WaitingResultStatus, &ciss_result->szResult[i]);
 144                         DBG("\n [CISS-ENGINE] __ciss_create_waiting_result_string(Multiple %dth): Bearer = %d, Status = %d\n",
 145                                 i, ss_info->SsRecord.WaitingRecord.rec_class[i].TeleCommService,
 146                                 ss_info->SsRecord.WaitingRecord.rec_class[i].Status);
 147                 }
 148         }
 149 }
 150
 151 static void __ciss_create_cli_result_string(ciss_result_t *ciss_result /*out */, TelSsCliRecord_t *pCliRecord /*in */)
 152 {
 153         ciss_result->szSsType = CISS_SERVICE_IDENTIFICATION;
 154         ciss_result->szFlavor = CISS_FLAVOR_NONE;
 155         ciss_result->szBearer[0] = CISS_TELECOMM_SVC_NONE;
 156
 157         switch (pCliRecord->IdentificationType) {
 158         case TAPI_CALLING_LINE_IDENTITY_PRESENTATION:
 159                 ciss_result->cli_type = CISS_CALLING_LINE_IDENTITY_PRESENTATION;
 160                 DBG("\n [CISS-ENGINE] ciss_callId_display_identification: TAPI_CALLING_LINE_IDENTITY_PRESENTATION (ciss_info.cli_record.status=%d)\n", pCliRecord->CliStatus);
 161                 /* CLIP : The CLIP Supplementary Service provides the called party with the possibility to receive the line identity of the calling party.
 162                  ** CLIP is activated with Provisioned . Generally it is provisioned by n/w.
 163                  ** *#30# MMI string is used to check the status:
 164                  ** case1: When CLIP is provisioned and activated.SS status sent by QMOCHA will be TAPI_SS_STATUS_ACTIVE.
 165                  ** UI should display: "Number of caller is shown" or message something like this
 166                  */
 167
 168                 if ((pCliRecord->CliStatus == TAPI_CLI_STATUS_ACTIVATED) ||
 169                         pCliRecord->CliStatus == TAPI_CLI_STATUS_PROVISIONED) {
 170                         /* Display : Caller ID is shown */
 171                         ciss_result->szResult[0] = CISS_STATUS_ACTIVE;
 172                 } else {
 173                         /* case2: When CLIP is not provisioned. SS status sent by QMOCHA will be TAPI_SS_STATUS_NOTHING.
 174                          ** UI should display: "CLIP not subscribed" or message something like this.
 175                          ** commented by Yongseock Choi : According to our police, because of no corresponding UI string, TAPI_SS_STATUS_NOTHING and TAPI_SS_STATUS_QUIESCENT
 176                          ** TAPI_SS_STATUS_REGISTERED are mapped into "Caller ID is not shown".
 177                          */
 178                         /* Display : Caller ID is not shown */
 179                         ciss_result->szResult[0] = CISS_STATUS_NOTHING;
 180                 }
 181                 break;
 182
 183         case TAPI_CALLING_LINE_IDENTITY_RESTRICTION:
 184                 ciss_result->cli_type = CISS_CALLING_LINE_IDENTITY_RESTRICTION;
 185                 DBG("\n [CISS-ENGINE] ciss_callId_display_identification: TAPI_CALLING_LINE_IDENTITY_RESTRICTION (cli_status = %d)\n", pCliRecord->CliStatus);
 186                 /* CLIR : The CLIR Supplementary Service enables the calling party to prevent presentation of its line identity to the called party.
 187                  ** The CLIR Supplementary Service can be offered with one subscription option :
 188                  **     1)permanent (invoked for all relevant calls) or
 189                  **     2)temporary (suppressed by the user on a per call basis).
 190                  **     In temporary mode , defaults values are:
 191                  **     1) presentation restricted: or
 192                  **     2) presentation not restricted(allowed).
 193                  */
 194                 if (pCliRecord->CliStatus == TAPI_CLI_STATUS_ACTIVATED ||
 195                     pCliRecord->CliStatus == TAPI_CLI_STATUS_PROVISIONED ||
 196                     pCliRecord->CliStatus == TAPI_CLI_STATUS_TEMP_RESTRICTED) {
 197                         ciss_result->szResult[0] = CISS_STATUS_ACTIVE;
 198                 } else {
 199                         /* Display : My caller ID sent on calling */
 200                         ciss_result->szResult[0] = CISS_STATUS_NOTHING;
 201                 }
 202                 break;
 203
 204         case TAPI_CONNECTED_LINE_IDENTITY_PRESENTATION:
 205                 ciss_result->cli_type = CISS_CONNECTED_LINE_IDENTITY_PRESENTATION;
 206                 DBG("\n [CISS-ENGINE] ciss_callId_display_identification: TAPI_CONNECTED_LINE_IDENTITY_PRESENTATION (ciss_info.cli_record.cli_status=%d)\n", pCliRecord->CliStatus);
 207                 if (pCliRecord->CliStatus == TAPI_CLI_STATUS_ACTIVATED) {
 208                         /* Display : Answering Caller ID is shown */
 209                         ciss_result->szResult[0] = CISS_STATUS_ACTIVE;
 210                 } else {
 211                         /* Display : Answering Caller ID is not shown */
 212                         ciss_result->szResult[0] = CISS_STATUS_NOTHING;
 213                 }
 214                 break;
 215
 216         case TAPI_CONNECTED_LINE_IDENTITY_RESTRICTION:
 217                 ciss_result->cli_type = CISS_CONNECTED_LINE_IDENTITY_RESTRICTION;
 218                 DBG("\n [CISS-ENGINE] ciss_callId_display_identification: TAPI_CONNECTED_LINE_IDENTITY_RESTRICTION (ciss_info.cli_record.status=%d)\n", pCliRecord->CliStatus);
 219                 if (pCliRecord->CliStatus == TAPI_CLI_STATUS_ACTIVATED) {
 220                         /* Display : My caller ID not sent on answering */
 221                         ciss_result->szResult[0] = CISS_STATUS_ACTIVE;
 222                 } else {
 223                         /* Display : My caller ID sent on answering */
 224                         ciss_result->szResult[0] = CISS_STATUS_NOTHING;
 225                 }
 226                 break;
 227
 228         case TAPI_CALLING_NAME_PRESENTATION:
 229                 ciss_result->cli_type = CISS_CALLING_NAME_PRESENTATION;
 230                 DBG("\n [CISS-ENGINE] ciss_callId_display_identification: TAPI_CALLING_NAME_PRESENTATION (ciss_info.cli_record.status=%d)\n", pCliRecord->CliStatus);
 231                 if ((pCliRecord->CliStatus == TAPI_CLI_STATUS_ACTIVATED) ||
 232                     (pCliRecord->CliStatus == TAPI_CLI_STATUS_PROVISIONED)) {
 233                         /* Display : My caller name sent on answering */
 234                         ciss_result->szResult[0] = CISS_STATUS_ACTIVE;
 235                 } else {
 236                         /* Display : My caller name not sent on answering */
 237                         ciss_result->szResult[0] = CISS_STATUS_NOTHING;
 238                 }
 239                 break;
 240
 241         default:
 242                 ciss_result->cli_type = CISS_CC_VOICE_IDENTIFICATION_NONE;
 243                 ciss_result->szResult[0] = CISS_STATUS_NOTHING;
 244                 DBG("\n [CISS-ENGINE] ciss_callId_display_identification: ERROR  Wrong  tapi_ss_cnap_status_t = %d  come. \n", pCliRecord->IdentificationType);
 245                 break;
 246         }
 247 }
 248
 249 static void __ciss_ui_mmi_create_cnap_result_string(ciss_result_t *result, char *szResult)
 250 {
 251         switch (result->cli_type) {
 252         case CISS_CALLING_LINE_IDENTITY_PRESENTATION:
 253                 switch (result->szResult[0]) {
 254                 case CISS_STATUS_ACTIVE:
 255                         strncpy(szResult, CISS_STR_CALLER_ID_SHOWN, CISS_USSD_DATA_SIZE_MAX - 1);
 256                         break;
 257                 case CISS_STATUS_REGISTERED:
 258                 case CISS_STATUS_PROVISIONED:
 259                 case CISS_STATUS_QUIESCENT:
 260                 case CISS_STATUS_NOTHING:
 261                 default:
 262                         strncpy(szResult, CISS_STR_CALLER_ID_HIDDEN, CISS_USSD_DATA_SIZE_MAX - 1);
 263                         break;
 264                 }
 265                 break;
 266         case CISS_CALLING_LINE_IDENTITY_RESTRICTION:
 267                 switch (result->szResult[0]) {
 268                 case CISS_STATUS_ACTIVE:
 269                         strncpy(szResult, CISS_STR_MY_CALLER_ID_IS_NOT_SENT_WHEN_CALLING, CISS_USSD_DATA_SIZE_MAX - 1);
 270                         break;
 271                 case CISS_STATUS_REGISTERED:
 272                 case CISS_STATUS_PROVISIONED:
 273                 case CISS_STATUS_QUIESCENT:
 274                 case CISS_STATUS_NOTHING:
 275                 default:
 276                         strncpy(szResult, CISS_STR_MY_CALLER_ID_WILL_BE_SENT_WHEN_CALLING, CISS_USSD_DATA_SIZE_MAX - 1);
 277                         break;
 278                 }
 279                 break;
 280         case CISS_CONNECTED_LINE_IDENTITY_PRESENTATION:
 281                 switch (result->szResult[0]) {
 282                 case CISS_STATUS_ACTIVE:
 283                         strncpy(szResult, CISS_STR_ANSWERING_NUMBER_IS_SHOWN_WHEN_CALLING, CISS_USSD_DATA_SIZE_MAX - 1);
 284                         break;
 285                 case CISS_STATUS_REGISTERED:
 286                 case CISS_STATUS_PROVISIONED:
 287                 case CISS_STATUS_QUIESCENT:
 288                 case CISS_STATUS_NOTHING:
 289                 default:
 290                         strncpy(szResult, CISS_STR_ANSWERING_NUMBER_IS_NOT_SHOWN_WHEN_CALLING, CISS_USSD_DATA_SIZE_MAX - 1);
 291                         break;
 292                 }
 293                 break;
 294         case CISS_CONNECTED_LINE_IDENTITY_RESTRICTION:
 295                 switch (result->szResult[0]) {
 296                 case CISS_STATUS_ACTIVE:
 297                         strncpy(szResult, CISS_STR_MY_CALLER_ID_IS_NOT_SENT_WHEN_ANSWERING_CALLS, CISS_USSD_DATA_SIZE_MAX - 1);
 298                         break;
 299                 case CISS_STATUS_REGISTERED:
 300                 case CISS_STATUS_PROVISIONED:
 301                 case CISS_STATUS_QUIESCENT:
 302                 case CISS_STATUS_NOTHING:
 303                 default:
 304                         strncpy(szResult, CISS_STR_MY_CALLER_ID_WILL_BE_SENT_WHEN_ANSWERING_CALLS, CISS_USSD_DATA_SIZE_MAX - 1);
 305                         break;
 306                 }
 307                 break;
 308         case CISS_CALLING_NAME_PRESENTATION:
 309                 switch (result->szResult[0]) {
 310                 case CISS_STATUS_ACTIVE:
 311                         strncpy(szResult, CISS_STR_CALLER_ID_AVAILABLE, CISS_USSD_DATA_SIZE_MAX - 1);
 312                         break;
 313                 case CISS_STATUS_REGISTERED:
 314                 case CISS_STATUS_PROVISIONED:
 315                 case CISS_STATUS_QUIESCENT:
 316                 case CISS_STATUS_NOTHING:
 317                 default:
 318                         strncpy(szResult, CISS_STR_CALLER_ID_RESTRICTED, CISS_USSD_DATA_SIZE_MAX - 1);
 319                         break;
 320                 }
 321                 break;
 322         default:
 323                 strncpy(szResult, "Incorrect Service", CISS_USSD_DATA_SIZE_MAX - 1);
 324                 break;
 325         }
 326         DBG("\n \n [CISS-MMI] THe result String :%s\n", szResult);
 327 }
 328
 329 static void __ciss_ui_mmi_create_mmi_result_string(ciss_result_t *pSSResult, int index, char *result_string)
 330 {
 331         DBG("Enter");
 332         char mszBuffer[CISS_TEXT_LEN_MAX];
 333         char szBuffer[CISS_TEXT_LEN_MAX];
 334         char service[CISS_TEXT_LEN_MAX];
 335         char teleservice[CISS_TEXT_LEN_MAX];
 336         char flavor[CISS_TEXT_LEN_MAX];
 337         char status[CISS_TEXT_LEN_MAX];
 338
 339         _ciss_ui_mmi_get_service_name(pSSResult->szSsType, service);
 340         _ciss_ui_mmi_get_flavor_name(pSSResult->szFlavor, flavor);
 341         _ciss_ui_mmi_get_bearer_name(pSSResult->szSsType, pSSResult->szBearer[index], teleservice);
 342         _ciss_ui_mmi_get_result_status_type(pSSResult->szSsType, pSSResult->szResult[index], status);
 343
 344         strncpy(mszBuffer, service, CISS_TEXT_LEN_MAX - 1);
 345         mszBuffer[CISS_TEXT_LEN_MAX - 1] = '\0';
 346
 347         if (strlen(teleservice)) {
 348                 strncat(mszBuffer, "<br>", strlen("<br>"));
 349                 strncat(mszBuffer, " -", strlen(" -"));
 350                 strncat(mszBuffer, teleservice, strlen(teleservice));
 351         }
 352         DBG("create_result_string: Label Text(telecommSvc) = %d\n", pSSResult->szBearer[index]);
 353
 354         if (pSSResult->szSsType == CISS_SERVICE_DIVERTING) {
 355                 /*  if Flavor case is 'no reply' then add timer information */
 356                 if ((strcmp(flavor, CISS_STR_CALL_DIVERTING_ACTIVE_C_WHEN_NOREPLY) == 0) &&
 357                         (pSSResult->nDivertWaitingTime[index] != 0)) {
 358                         snprintf(szBuffer, CISS_TEXT_LEN_MAX, "%s %02ds", flavor, pSSResult->nDivertWaitingTime[index]);
 359                 } else {
 360                         strncpy(szBuffer, flavor, CISS_TEXT_LEN_MAX - 1);
 361                         szBuffer[CISS_TEXT_LEN_MAX - 1] = '\0';
 362                 }
 363
 364                 if (strlen(flavor) > 1) {
 365                         strncat(mszBuffer, "<br>", strlen("<br>"));
 366                         strncat(mszBuffer, " -", strlen(" -"));
 367                         strncat(mszBuffer, szBuffer, strlen(szBuffer));
 368                 }
 369                 DBG("\n [CISS-MMI] create_result_string: Label Text(flavor) = %s\n", flavor);
 370
 371                 /* 4) Display Status */
 372                 strncat(mszBuffer, "<br>", strlen("<br>"));
 373                 strncat(mszBuffer, " -", strlen(" -"));
 374                 strncat(mszBuffer, status, strlen(szBuffer));
 375
 376                 /* 5) Display telephone number */
 377                 if (strlen(pSSResult->szDivertNumber[index]) &&
 378                     (strcmp(status, CISS_STR_ACTIVATED) == 0)) {
 379                         DBG("\n [CISS-MMI] create_result_string: Call forwarding number = %s\n",
 380                                 pSSResult->szDivertNumber[index]);
 381
 382                         strncat(mszBuffer, "<br>", strlen("<br>"));
 383                         strncat(mszBuffer, " ", strlen(" "));
 384                         strncat(mszBuffer, pSSResult->szDivertNumber[index], strlen(pSSResult->szDivertNumber[index]));
 385                 } else
 386                         DBG("\n [CISS-MMI] create_result_string: Call forwarding number is not need");
 387         } else if (pSSResult->szSsType == CISS_SERVICE_BARRING) {
 388                 if (strlen(flavor) > 1) {
 389                         strncat(mszBuffer, "<br>", strlen("<br>"));
 390                         strncat(mszBuffer, " -", strlen(" -"));
 391                         strncat(mszBuffer, flavor, strlen(flavor));
 392                 }
 393
 394                 /* 4) Display Status */
 395                 strncat(mszBuffer, "<br>", strlen("<br>"));
 396                 strncat(mszBuffer, " -", strlen(" -"));
 397                 strncat(mszBuffer, status, strlen(status));
 398         } else if (pSSResult->szSsType == CISS_SERVICE_WAITING) {
 399                 /* 4) Display Status */
 400                 strncat(mszBuffer, "<br>", strlen("<br>"));
 401                 strncat(mszBuffer, " -", strlen("< ->"));
 402                 strncat(mszBuffer, status, strlen(status));
 403         }
 404         strncpy(result_string, mszBuffer, CISS_USSD_DATA_SIZE_MAX - 1);
 405
 406         DBG("Result String:%s\n", result_string);
 407         DBG("Leave");
 408 }
 409
 410 static int __ciss_tapi_handle_forward_cnf(ciss_result_t *ciss_result, TelSsInfo_t *ss_info)
 411 {
 412         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_forward_cnf: TAPI_EVENT_SS_FORWARD_XXX_CNF received\n");
 413         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_forward_cnf(Single): Bearer = %d, Flavor = %d, Status = %d \n",
 414                 ss_info->SsRecord.ForwardingRecord.rec_class[0].TeleCommService,
 415                 ss_info->SsRecord.ForwardingRecord.rec_class[0].ForwardCondition,
 416                 ss_info->SsRecord.ForwardingRecord.rec_class[0].Status);
 417
 418         memset(ciss_result, 0, sizeof(ciss_result_t));
 419         DBG("\n [CISS-ENGINE] ss_info.SsRecord.ForwardingRecord.rec_class[0].szCallForwardingNumber : %s %d",
 420                 ss_info->SsRecord.ForwardingRecord.rec_class[0].szCallForwardingNumber,
 421                 strlen((char *)ss_info->SsRecord.ForwardingRecord.rec_class[0].szCallForwardingNumber));
 422         _ciss_get_forward_flavor_type(ss_info->SsRecord.ForwardingRecord.rec_class[0].ForwardCondition,
 423                 &(ciss_result->szFlavor));
 424         __ciss_create_forward_result_string(ciss_result, ss_info);
 425
 426         DBG("\n [CISS-ENGINE] this->ss_req_data.flavor: %d\n", ciss_result->szFlavor);
 427         DBG("\n [CISS-ENGINE] this->ss_req_data.telecommSvc: %d\n, this->ss_req_data.action: %d \n",
 428                 ciss_result->szBearer[0], ciss_result->szResult[0]);
 429
 430         return TRUE;
 431 }
 432
 433 static int __ciss_tapi_handle_barring_cnf(ciss_result_t *ciss_result, TelSsInfo_t *ss_info)
 434 {
 435         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_barring_cnf: TAPI_EVENT_SS_BARRING_XXX_CNF received\n");
 436         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_barring_cnf(Single): Bearer = %d, Favor = %d, Status = %d\n",
 437                 ss_info->SsRecord.BarringRecord.rec_class[0].TeleCommService,
 438                 ss_info->SsRecord.BarringRecord.rec_class[0].Flavour,
 439                 ss_info->SsRecord.BarringRecord.rec_class[0].Status);
 440
 441         memset(ciss_result, 0, sizeof(ciss_result_t));
 442         _ciss_get_barring_flavor_type(ss_info->SsRecord.BarringRecord.rec_class[0].Flavour, &(ciss_result->szFlavor));
 443         __ciss_create_barring_result_string(ciss_result, ss_info);
 444
 445         return TRUE;
 446 }
 447
 448 static int __ciss_tapi_handle_waiting_cnf(ciss_result_t *ciss_result /*out */, TelSsInfo_t *ss_info /*in */)
 449 {
 450         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_waiting_cnf: TAPI_EVENT_SS_WAITING_XXX_CNF received\n");
 451         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_waiting_cnf(Single): Bearer = %d, Status = %d\n",
 452                 ss_info->SsRecord.WaitingRecord.rec_class[0].TeleCommService,
 453                 ss_info->SsRecord.WaitingRecord.rec_class[0].Status);
 454
 455         memset(ciss_result, 0, sizeof(ciss_result_t));
 456         __ciss_create_waiting_result_string(ciss_result, ss_info);
 457
 458         return TRUE;
 459 }
 460
 461 static int __ciss_tapi_handle_call_id(ciss_result_t *ciss_result, TelSsInfo_t *ss_info)
 462 {
 463         DBG("\n [CISS-ENGINE] __ciss_tapi_handle_call_id: TAPI_EVENT_SS_IDENTITY_IND received\n");
 464
 465         memset(ciss_result, 0, sizeof(ciss_result_t));
 466         __ciss_create_cli_result_string(ciss_result, &(ss_info->SsRecord.CliRecord));
 467         ciss_result->nRecordNum = 1;
 468
 469         return TRUE;
 470 }
 471
 472 static int __ciss_create_ss_result_sting(char *ss_result_string /*out */, TelSsInfo_t *ss_info /*in */)
 473 {
 474         DBG("Enter");
 475
 476         ciss_result_t ciss_result;
 477         switch (ss_info->SsType) {
 478         case TAPI_SS_TYPE_FORWARDING:
 479                 __ciss_tapi_handle_forward_cnf(&ciss_result, ss_info);
 480                 break;
 481
 482         case TAPI_SS_TYPE_BARRING:
 483                 __ciss_tapi_handle_barring_cnf(&ciss_result, ss_info);
 484                 break;
 485
 486         case TAPI_SS_TYPE_WAITING:
 487                 __ciss_tapi_handle_waiting_cnf(&ciss_result, ss_info);
 488                 break;
 489
 490         case TAPI_SS_TYPE_IDENTIFICATION:
 491                 __ciss_tapi_handle_call_id(&ciss_result, ss_info);
 492                 break;
 493
 494         default:
 495                 return -1;
 496         }
 497
 498         memset(resultstring, 0x0, sizeof(resultstring));
 499         if (ciss_result.szSsType == CISS_SERVICE_IDENTIFICATION) {
 500                 DBG("\n [CISS-MMI] CISS_SERVICE_IDENTIFICATION \n");
 501                 __ciss_ui_mmi_create_cnap_result_string(&ciss_result, resultstring[0]);
 502         } else if (ciss_result.nRecordNum == 0) {
 503                 DBG("\n [CISS-MMI] result.nRecordNum == 0  \n");
 504                 strncpy(resultstring[0], CISS_STR_SUCCESS, CISS_TEXT_LEN_MAX - 1);
 505         } else {
 506                 int g_count = 0;
 507                 for (g_count = 0; g_count < ciss_result.nRecordNum; g_count++) {
 508                         __ciss_ui_mmi_create_mmi_result_string(&ciss_result, g_count, resultstring[g_count]);
 509                         DBG("\n [CISS-MMI]  Copying data & parsing  Result string ::::::::::: %s \n", resultstring[g_count]);
 510                 }
 511         }
 512
 513         int count = 0;
 514
 515         for (count = 0; count < ciss_result.nRecordNum; count++) {
 516                 strncat(ss_result_string, "<br> ", strlen("<br> "));
 517                 strncat(ss_result_string, resultstring[count], strlen(resultstring[count]));
 518                 strncat(ss_result_string, "<br> ", strlen("<br> "));
 519         }
 520         DBG("Final Result string : %s ", ss_result_string);
 521         DBG("Leave");
 522
 523         return 0;
 524 }
 525
 526 static void __ciss_ssresp_view_quit_cb(void *data, Evas_Object *obj, void *event_info)
 527 {
 528         elm_exit();
 529 }
 530
 531 Evas_Object *_ciss_create_ss_resp_view(Evas_Object *parent, TelSsInfo_t *ss_info, void *data)
 532 {
 533         DBG("Enter");
 534         retv_if(parent == NULL, NULL);
 535         retv_if(data == NULL, NULL);
 536
 537         struct appdata *ad = (struct appdata *)data;
 538         Evas_Object *nf;
 539         Evas_Object *l_button;
 540
 541         char ss_result_string[CISS_MMI_MAX_SS_RESP_STRING] = { };
 542
 543         if (ss_info)
 544                 __ciss_create_ss_result_sting(ss_result_string, ss_info);
 545         else
 546                 snprintf(ss_result_string, CISS_MMI_MAX_SS_RESP_STRING, "%s", CISS_STR_SUCCESS);
 547
 548         nf = elm_naviframe_add(parent);
 549         retv_if(nf == NULL, NULL);
 550
 551         Evas_Object *genlist =
 552                 _ciss_create_result_genlist(ss_result_string, CISS_MMI_MAX_SS_RESP_STRING, nf, ad);
 553         retv_if(NULL == genlist, NULL);
 554
 555         l_button = elm_button_add(nf);
 556         evas_object_smart_callback_add(l_button, "clicked",
 557                 __ciss_ssresp_view_quit_cb, NULL);
 558
 559         elm_naviframe_item_push(nf, CISS_STR_INFORMATION,
 560                 l_button, NULL, genlist, NULL);
 561         elm_object_style_set(l_button, "naviframe/back_btn/default");
 562
 563         evas_object_show(nf);
 564
 565         DBG("Leave");
 566         return nf;
 567 }
 568