test/test_all_api.c

   1 /*
   2  * Copyright (c) 2011 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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <glib.h>
  20 #include <dlog.h>
  21
  22 #include <telephony.h>
  23
  24 #ifdef LOG_TAG
  25 #undef LOG_TAG
  26 #endif
  27 #define LOG_TAG "CAPI_TELEPHONY_TEST"
  28
  29 static GMainLoop *event_loop;
  30
  31 static int network_noti_tbl[] = {
  32         TELEPHONY_NOTI_NETWORK_SERVICE_STATE,
  33         TELEPHONY_NOTI_NETWORK_CELLID,
  34         TELEPHONY_NOTI_NETWORK_ROAMING_STATUS,
  35         TELEPHONY_NOTI_NETWORK_SIGNALSTRENGTH_LEVEL
  36 };
  37
  38 static int call_noti_tbl[] = {
  39         TELEPHONY_NOTI_VOICE_CALL_STATE,
  40         TELEPHONY_NOTI_VIDEO_CALL_STATE
  41 };
  42
  43 static const char *_mapping_sim_state(telephony_sim_state_e sim_state)
  44 {
  45         switch (sim_state) {
  46         case TELEPHONY_SIM_STATE_AVAILABLE:
  47                 return "Available";
  48         case TELEPHONY_SIM_STATE_LOCKED:
  49                 return "Locked";
  50         case TELEPHONY_SIM_STATE_UNKNOWN:
  51                 return "Unknown";
  52         default:
  53                 return "Unavailable";
  54         }
  55 }
  56
  57 static void sim_noti_cb(telephony_h handle, telephony_noti_e noti_id, void *data, void *user_data)
  58 {
  59         LOGI("Noti!! SIM status: [%d]", *(int *)data);
  60
  61 //      g_main_loop_quit(event_loop);
  62 }
  63
  64
  65 static const char *_mapping_service_state(telephony_network_service_state_e service_state)
  66 {
  67         switch (service_state) {
  68         case TELEPHONY_NETWORK_SERVICE_STATE_IN_SERVICE:
  69                 return "In service";
  70         case TELEPHONY_NETWORK_SERVICE_STATE_OUT_OF_SERVICE:
  71                 return "Out of service";
  72         case TELEPHONY_NETWORK_SERVICE_STATE_EMERGENCY_ONLY:
  73                 return "Emergency only";
  74         default:
  75                 return "Unknown state";
  76         }
  77 }
  78
  79 static const char *_mapping_network_type(telephony_network_type_e network_type)
  80 {
  81         switch (network_type) {
  82         case TELEPHONY_NETWORK_TYPE_GSM:
  83                 return "GSM";
  84         case TELEPHONY_NETWORK_TYPE_GPRS:
  85                 return "GPRS";
  86         case TELEPHONY_NETWORK_TYPE_EDGE:
  87                 return "EDGE";
  88         case TELEPHONY_NETWORK_TYPE_UMTS:
  89                 return "UMTS";
  90         case TELEPHONY_NETWORK_TYPE_HSDPA:
  91                 return "HSDPA";
  92         case TELEPHONY_NETWORK_TYPE_LTE:
  93                 return "LTE";
  94         default:
  95                 return "Unknown";
  96         }
  97 }
  98
  99 static void network_noti_cb(telephony_h handle, telephony_noti_e noti_id, void *data, void *user_data)
 100 {
 101         switch (noti_id) {
 102         case TELEPHONY_NOTI_NETWORK_SERVICE_STATE:
 103                 LOGI("Noti!!! Service state: [%s]", _mapping_service_state(*(int *)data));
 104                 break;
 105         case TELEPHONY_NOTI_NETWORK_CELLID:
 106                 LOGI("Noti!!! Cell ID: [%d]", *(int *)data);
 107                 break;
 108         case TELEPHONY_NOTI_NETWORK_ROAMING_STATUS:
 109                 LOGI("Noti!!! Roaming status: [%s]", *(int *)data ? "ON" : "OFF");
 110                 break;
 111         case TELEPHONY_NOTI_NETWORK_SIGNALSTRENGTH_LEVEL:
 112                 LOGI("Noti!!! Signal strength: [%d]", *(int *)data);
 113                 break;
 114         default:
 115                 LOGE("Unknown noti");
 116                 break;
 117         }
 118
 119 //      g_main_loop_quit(event_loop);
 120 }
 121
 122 static const char *_mapping_call_state(telephony_call_state_e call_state)
 123 {
 124         switch (call_state) {
 125         case TELEPHONY_CALL_STATE_IDLE:
 126                 return "Idle";
 127         case TELEPHONY_CALL_STATE_CONNECTING:
 128                 return "Connecting";
 129         case TELEPHONY_CALL_STATE_CONNECTED:
 130                 return "Active";
 131         default:
 132                 return "Unknown";
 133         }
 134 }
 135
 136 static void call_noti_cb(telephony_h handle, telephony_noti_e noti_id, void *data, void *user_data)
 137 {
 138         switch (noti_id) {
 139         case TELEPHONY_NOTI_VOICE_CALL_STATE:
 140                 LOGI("Noti!!! Voice Call state: [%s]", _mapping_call_state(*(int *)data));
 141                 break;
 142         case TELEPHONY_NOTI_VIDEO_CALL_STATE:
 143                 LOGI("Noti!!! Video Call state: [%s]", _mapping_call_state(*(int *)data));
 144                 break;
 145         default:
 146                 LOGE("Unknown noti");
 147                 break;
 148         }
 149
 150 //      g_main_loop_quit(event_loop);
 151 }
 152
 153 int main()
 154 {
 155         telephony_handle_list_s handle_list;
 156         int ret_value, i;
 157
 158         /* SIM value */
 159         char *operator = NULL;
 160         char *icc_id = NULL;
 161         char *msin = NULL;
 162         char *spn = NULL;
 163         telephony_sim_state_e sim_state = 0;
 164         char *subscriber_number = NULL;
 165
 166         /* Network value */
 167         int cell_id = 0;
 168         int lac = 0;
 169         char *mcc = NULL;
 170         char *mnc = NULL;
 171         char *network_name = NULL;
 172         bool roaming_status;
 173         telephony_network_rssi_e rssi = 0;
 174         telephony_network_service_state_e service_state = 0;
 175         telephony_network_type_e network_type = 0;
 176
 177         /* Call value */
 178         telephony_call_state_e call_state = 0;
 179
 180         /* Modem value */
 181         char *imei = NULL;
 182
 183         /* Initialize handle */
 184         ret_value = telephony_init(&handle_list);
 185         if (ret_value != TELEPHONY_ERROR_NONE) {
 186                 LOGE("Initialize failed!!!");
 187                 return 0;
 188         }
 189
 190         LOGI("handle count: [%d]", handle_list.count);
 191
 192         /* SIM API */
 193         ret_value = telephony_sim_get_operator(handle_list.handle[0], &operator);
 194         if (ret_value != TELEPHONY_ERROR_NONE) {
 195                 LOGE("telephony_sim_get_operator() failed!!! [%d]", ret_value);
 196         } else {
 197                 LOGI("Operator is [%s]", operator);
 198                 free(operator);
 199         }
 200
 201         ret_value = telephony_sim_get_icc_id(handle_list.handle[0], &icc_id);
 202         if (ret_value != TELEPHONY_ERROR_NONE) {
 203                 LOGE("telephony_sim_get_icc_id() failed!!! [%d]", ret_value);
 204         } else {
 205                 LOGI("ICC-ID is [%s]", icc_id);
 206                 free(icc_id);
 207         }
 208
 209         ret_value = telephony_sim_get_msin(handle_list.handle[0], &msin);
 210         if (ret_value != TELEPHONY_ERROR_NONE) {
 211                 LOGE("telephony_sim_get_msin() failed!!! [%d]", ret_value);
 212         } else {
 213                 LOGI("MSIN is [%s]", msin);
 214                 free(msin);
 215         }
 216
 217         ret_value = telephony_sim_get_spn(handle_list.handle[0], &spn);
 218         if (ret_value != TELEPHONY_ERROR_NONE) {
 219                 LOGE("telephony_sim_get_spn() failed!!! [%d]", ret_value);
 220         } else {
 221                 LOGI("SPN is [%s]", spn);
 222                 free(spn);
 223         }
 224
 225         ret_value = telephony_sim_get_state(handle_list.handle[0], &sim_state);
 226         if (ret_value != TELEPHONY_ERROR_NONE) {
 227                 LOGE("telephony_sim_get_state() failed!!! [%d]", ret_value);
 228         } else {
 229                 LOGI("SIM state is [%s]", _mapping_sim_state(sim_state));
 230         }
 231
 232         ret_value = telephony_sim_get_subscriber_number(handle_list.handle[0], &subscriber_number);
 233         if (ret_value != TELEPHONY_ERROR_NONE) {
 234                 LOGE("telephony_sim_get_subscriber_number() failed!!! [%d]", ret_value);
 235         } else {
 236                 LOGI("Subscriber number is [%s]", subscriber_number);
 237                 free(subscriber_number);
 238         }
 239
 240         /* Network API */
 241         ret_value = telephony_network_get_cell_id(handle_list.handle[0], &cell_id);
 242         if (ret_value != TELEPHONY_ERROR_NONE) {
 243                 LOGE("telephony_network_get_cell_id() failed!!! [%d]", ret_value);
 244         } else {
 245                 LOGI("Cell ID is [%d]", cell_id);
 246         }
 247
 248         ret_value = telephony_network_get_lac(handle_list.handle[0], &lac);
 249         if (ret_value != TELEPHONY_ERROR_NONE) {
 250                 LOGE("telephony_network_get_lac() failed!!! [%d]", ret_value);
 251         } else {
 252                 LOGI("Location Area Code is [%d]", lac);
 253         }
 254
 255         ret_value = telephony_network_get_mcc(handle_list.handle[0], &mcc);
 256         if (ret_value != TELEPHONY_ERROR_NONE) {
 257                 LOGE("telephony_network_get_mcc() failed!!! [%d]", ret_value);
 258         } else {
 259                 LOGI("Mobile Country Code is [%s]", mcc);
 260                 free(mcc);
 261         }
 262
 263         ret_value = telephony_network_get_mnc(handle_list.handle[0], &mnc);
 264         if (ret_value != TELEPHONY_ERROR_NONE) {
 265                 LOGE("telephony_network_get_mnc() failed!!! [%d]", ret_value);
 266         } else {
 267                 LOGI("Mobile Network Code is [%s]", mnc);
 268                 free(mnc);
 269         }
 270
 271         ret_value = telephony_network_get_network_name(handle_list.handle[0], &network_name);
 272         if (ret_value != TELEPHONY_ERROR_NONE) {
 273                 LOGE("telephony_network_get_network_name() failed!!! [%d]", ret_value);
 274         } else {
 275                 LOGI("Network name is [%s]", network_name);
 276                 free(network_name);
 277         }
 278
 279         ret_value = telephony_network_get_roaming_status(handle_list.handle[0], &roaming_status);
 280         if (ret_value != TELEPHONY_ERROR_NONE) {
 281                 LOGE("telephony_network_get_roaming_status() failed!!! [%d]", ret_value);
 282         } else {
 283                 LOGI("Network Roaming: [%s]", roaming_status ? "ON" : "OFF");
 284         }
 285
 286         ret_value = telephony_network_get_rssi(handle_list.handle[0], &rssi);
 287         if (ret_value != TELEPHONY_ERROR_NONE) {
 288                 LOGE("telephony_network_get_rssi() failed!!! [%d]", ret_value);
 289         } else {
 290                 LOGI("Received Signal Strength Indicator is [%d]", rssi);
 291         }
 292
 293         ret_value = telephony_network_get_service_state(handle_list.handle[0], &service_state);
 294         if (ret_value != TELEPHONY_ERROR_NONE) {
 295                 LOGE("telephony_network_get_service_state() failed!!! [%d]", ret_value);
 296         } else {
 297                 LOGI("Network service state is [%s]", _mapping_service_state(service_state));
 298         }
 299
 300         ret_value = telephony_network_get_type(handle_list.handle[0], &network_type);
 301         if (ret_value != TELEPHONY_ERROR_NONE) {
 302                 LOGE("telephony_network_get_type() failed!!! [%d]", ret_value);
 303         } else {
 304                 LOGI("Network type is [%s]", _mapping_network_type(network_type));
 305         }
 306
 307         /* Call API */
 308         ret_value = telephony_call_get_voice_call_state(handle_list.handle[0], &call_state);
 309         if (ret_value != TELEPHONY_ERROR_NONE) {
 310                 LOGE("telephony_call_get_voice_call_state() failed!!! [%d]", ret_value);
 311         } else {
 312                 LOGI("Voice Call state is [%s]", _mapping_call_state(call_state));
 313         }
 314
 315         ret_value = telephony_call_get_video_call_state(handle_list.handle[0], &call_state);
 316         if (ret_value != TELEPHONY_ERROR_NONE) {
 317                 LOGE("telephony_call_get_video_call_state() failed!!! [%d]", ret_value);
 318         } else {
 319                 LOGI("Video Call state is [%s]", _mapping_call_state(call_state));
 320         }
 321
 322         /* Modem API */
 323         ret_value = telephony_modem_get_imei(handle_list.handle[0], &imei);
 324         if (ret_value != TELEPHONY_ERROR_NONE) {
 325                 LOGE("telephony_modem_get_imei() failed!!! [%d]", ret_value);
 326         } else {
 327                 LOGI("IMEI is [%s]", imei);
 328                 free(imei);
 329         }
 330
 331         /* set_noti_cb */
 332         ret_value = telephony_set_noti_cb(handle_list.handle[0], TELEPHONY_NOTI_SIM_STATUS, sim_noti_cb, NULL);
 333         if (ret_value != TELEPHONY_ERROR_NONE)
 334                 LOGE("Set noti failed!!!");
 335
 336         for (i = 0; i < 4; i++) {
 337                 ret_value = telephony_set_noti_cb(handle_list.handle[0], network_noti_tbl[i], network_noti_cb, NULL);
 338                 if (ret_value != TELEPHONY_ERROR_NONE)
 339                         LOGE("Set noti failed!!!");
 340         }
 341
 342         for (i = 0; i < 2; i++) {
 343                 ret_value = telephony_set_noti_cb(handle_list.handle[0], call_noti_tbl[i], call_noti_cb, NULL);
 344                 if (ret_value != TELEPHONY_ERROR_NONE)
 345                         LOGE("Set noti failed!!!");
 346         }
 347
 348         LOGI("If telephony status is changed, then callback function will be called");
 349         event_loop = g_main_loop_new(NULL, FALSE);
 350         g_main_loop_run(event_loop);
 351
 352         ret_value = telephony_unset_noti_cb(handle_list.handle[0], TELEPHONY_NOTI_SIM_STATUS);
 353         if (ret_value != TELEPHONY_ERROR_NONE)
 354                 LOGE("Unset noti failed!!!");
 355
 356         for (i = 0; i < 4; i++) {
 357                 ret_value = telephony_unset_noti_cb(handle_list.handle[0], network_noti_tbl[i]);
 358                 if (ret_value != TELEPHONY_ERROR_NONE)
 359                         LOGE("Unset noti failed!!!");
 360         }
 361
 362         for (i = 0; i < 2; i++) {
 363                 ret_value = telephony_unset_noti_cb(handle_list.handle[0], call_noti_tbl[i]);
 364                 if (ret_value != TELEPHONY_ERROR_NONE)
 365                         LOGE("Unset noti failed!!!");
 366         }
 367
 368         ret_value = telephony_deinit(&handle_list);
 369         if (ret_value != TELEPHONY_ERROR_NONE) {
 370                 LOGE("Deinitialize failed!!!");
 371         }
 372
 373         return 0;
 374 }