src/telephony_network.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 <string.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <glib.h>
  21 #include <dlog.h>
  22 #include <tapi_common.h>
  23 #include <TapiUtility.h>
  24 #include <TelNetwork.h>
  25 #include "telephony_network.h"
  26 #include "telephony_common.h"
  27 #include "telephony_private.h"
  28
  29 #include <sys/types.h>
  30 #include <unistd.h>
  31
  32 #ifdef LOG_TAG
  33 #undef LOG_TAG
  34 #endif
  35 #define LOG_TAG "CAPI_TELEPHONY"
  36
  37 #define CHECK_INPUT_PARAMETER(arg) \
  38         if (arg == NULL) { \
  39                 LOGE("INVALID_PARAMETER"); \
  40                 return TELEPHONY_ERROR_INVALID_PARAMETER; \
  41         }
  42
  43 int telephony_network_get_lac(telephony_h handle, int *lac)
  44 {
  45         int ret;
  46         TapiHandle *tapi_h;
  47
  48         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
  49         CHECK_INPUT_PARAMETER(handle);
  50         tapi_h = ((telephony_data *)handle)->tapi_h;
  51         CHECK_INPUT_PARAMETER(tapi_h);
  52         CHECK_INPUT_PARAMETER(lac);
  53
  54         ret = tel_get_property_int(tapi_h, TAPI_PROP_NETWORK_LAC, lac);
  55         if (ret == TAPI_API_SUCCESS) {
  56                 LOGI("lac:[%d]", *lac);
  57                 ret = TELEPHONY_ERROR_NONE;
  58         } else if (ret == TAPI_API_ACCESS_DENIED) {
  59                 LOGE("PERMISSION_DENIED");
  60                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
  61         } else {
  62                 LOGE("OPERATION_FAILED");
  63                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
  64         }
  65
  66         return ret;
  67 }
  68
  69 int telephony_network_get_cell_id(telephony_h handle, int *cell_id)
  70 {
  71         int ret;
  72         TapiHandle *tapi_h;
  73
  74         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
  75         CHECK_INPUT_PARAMETER(handle);
  76         tapi_h = ((telephony_data *)handle)->tapi_h;
  77         CHECK_INPUT_PARAMETER(tapi_h);
  78         CHECK_INPUT_PARAMETER(cell_id);
  79
  80         ret = tel_get_property_int(tapi_h, TAPI_PROP_NETWORK_CELLID, cell_id);
  81         if (ret == TAPI_API_SUCCESS) {
  82                 LOGI("cell_id:[%d]", *cell_id);
  83                 ret = TELEPHONY_ERROR_NONE;
  84         } else if (ret == TAPI_API_ACCESS_DENIED) {
  85                 LOGE("PERMISSION_DENIED");
  86                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
  87         } else {
  88                 LOGE("OPERATION_FAILED");
  89                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
  90         }
  91
  92         return ret;
  93 }
  94
  95 int telephony_network_get_rssi(telephony_h handle, telephony_network_rssi_e *rssi)
  96 {
  97         int ret;
  98         TapiHandle *tapi_h;
  99
 100         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
 101         CHECK_INPUT_PARAMETER(handle);
 102         tapi_h = ((telephony_data *)handle)->tapi_h;
 103         CHECK_INPUT_PARAMETER(tapi_h);
 104         CHECK_INPUT_PARAMETER(rssi);
 105
 106         ret = tel_get_property_int(tapi_h, TAPI_PROP_NETWORK_SIGNALSTRENGTH_LEVEL, (int *)rssi);
 107         if (ret == TAPI_API_SUCCESS) {
 108                 LOGI("rssi:[%d]", *rssi);
 109                 ret = TELEPHONY_ERROR_NONE;
 110         } else if (ret == TAPI_API_ACCESS_DENIED) {
 111                 LOGE("PERMISSION_DENIED");
 112                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
 113         } else {
 114                 LOGE("OPERATION_FAILED");
 115                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
 116         }
 117
 118         return ret;
 119 }
 120
 121 int telephony_network_get_roaming_status(telephony_h handle, bool *status)
 122 {
 123         int ret;
 124         int temp = 0;
 125         TapiHandle *tapi_h;
 126
 127         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
 128         CHECK_INPUT_PARAMETER(handle);
 129         tapi_h = ((telephony_data *)handle)->tapi_h;
 130         CHECK_INPUT_PARAMETER(tapi_h);
 131         CHECK_INPUT_PARAMETER(status);
 132
 133         ret = tel_get_property_int(tapi_h, TAPI_PROP_NETWORK_ROAMING_STATUS, &temp);
 134         if (ret == TAPI_API_SUCCESS) {
 135                 if (temp == 1)
 136                         *status = true;
 137                 else
 138                         *status = false;
 139                 LOGI("status:[%d]", *status);
 140                 ret = TELEPHONY_ERROR_NONE;
 141         } else if (ret == TAPI_API_ACCESS_DENIED) {
 142                 LOGE("PERMISSION_DENIED");
 143                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
 144         } else {
 145                 LOGE("OPERATION_FAILED");
 146                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
 147         }
 148
 149         return ret;
 150 }
 151
 152 int telephony_network_get_mcc(telephony_h handle, char **mcc)
 153 {
 154         int ret;
 155         char *plmn_str = NULL;
 156         int mcc_length = 3;
 157         TapiHandle *tapi_h;
 158
 159         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
 160         CHECK_INPUT_PARAMETER(handle);
 161         tapi_h = ((telephony_data *)handle)->tapi_h;
 162         CHECK_INPUT_PARAMETER(tapi_h);
 163         CHECK_INPUT_PARAMETER(mcc);
 164
 165         ret = tel_get_property_string(tapi_h, TAPI_PROP_NETWORK_PLMN, &plmn_str);
 166         if (ret == TAPI_API_SUCCESS) {
 167                 *mcc = malloc (sizeof(char) * (mcc_length + 1));
 168                 if (*mcc == NULL) {
 169                         LOGE("OUT_OF_MEMORY");
 170                         ret = TELEPHONY_ERROR_OUT_OF_MEMORY;
 171                 } else {
 172                         memset (*mcc, 0x00, mcc_length + 1);
 173                         strncpy (*mcc, plmn_str, mcc_length);
 174                         free (plmn_str);
 175
 176                         LOGI("mcc:[%s]", *mcc);
 177                         ret = TELEPHONY_ERROR_NONE;
 178                 }
 179         } else if (ret == TAPI_API_ACCESS_DENIED) {
 180                 LOGE("PERMISSION_DENIED");
 181                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
 182         } else {
 183                 LOGE("OPERATION_FAILED");
 184                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
 185         }
 186
 187         return ret;
 188 }
 189
 190 int telephony_network_get_mnc(telephony_h handle, char **mnc)
 191 {
 192         int ret;
 193         char *plmn_str = NULL;
 194         int plmn_length;
 195         TapiHandle *tapi_h;
 196
 197         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
 198         CHECK_INPUT_PARAMETER(handle);
 199         tapi_h = ((telephony_data *)handle)->tapi_h;
 200         CHECK_INPUT_PARAMETER(tapi_h);
 201         CHECK_INPUT_PARAMETER(mnc);
 202
 203         ret = tel_get_property_string(tapi_h, TAPI_PROP_NETWORK_PLMN, &plmn_str);
 204         if (ret == TAPI_API_SUCCESS) {
 205                 plmn_length = strlen(plmn_str);
 206                 LOGI("plmn:[%s], length:[%d]", plmn_str, plmn_length);
 207
 208                 *mnc = malloc (sizeof(char) * (plmn_length -3 + 1));
 209                 if (*mnc == NULL) {
 210                         LOGE("OUT_OF_MEMORY");
 211                         ret = TELEPHONY_ERROR_OUT_OF_MEMORY;
 212                 } else {
 213                         memset (*mnc, 0x00, (plmn_length -3 + 1));
 214                         strncpy (*mnc, plmn_str + 3, (plmn_length -3 + 1));
 215                         free (plmn_str);
 216
 217                         LOGI("mnc:[%s]", *mnc);
 218                         ret = TELEPHONY_ERROR_NONE;
 219                 }
 220         } else if (ret == TAPI_API_ACCESS_DENIED) {
 221                 LOGE("PERMISSION_DENIED");
 222                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
 223         } else {
 224                 LOGE("OPERATION_FAILED");
 225                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
 226         }
 227
 228         return ret;
 229 }
 230
 231 int telephony_network_get_network_name(telephony_h handle, char **network_name)
 232 {
 233         int ret;
 234         TapiHandle *tapi_h;
 235
 236         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
 237         CHECK_INPUT_PARAMETER(handle);
 238         tapi_h = ((telephony_data *)handle)->tapi_h;
 239         CHECK_INPUT_PARAMETER(tapi_h);
 240         CHECK_INPUT_PARAMETER(network_name);
 241
 242         ret = tel_get_property_string(tapi_h, TAPI_PROP_NETWORK_NETWORK_NAME, network_name);
 243         if (ret == TAPI_API_SUCCESS) {
 244                 LOGI("network_name:[%s]", *network_name);
 245                 ret = TELEPHONY_ERROR_NONE;
 246         } else if (ret == TAPI_API_ACCESS_DENIED) {
 247                 LOGE("PERMISSION_DENIED");
 248                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
 249         } else {
 250                 LOGE("OPERATION_FAILED");
 251                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
 252         }
 253
 254         return ret;
 255 }
 256
 257 int telephony_network_get_type(telephony_h handle, telephony_network_type_e *network_type)
 258 {
 259         int ret;
 260         int service_type = 0;
 261         TapiHandle *tapi_h;
 262
 263         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
 264         CHECK_INPUT_PARAMETER(handle);
 265         tapi_h = ((telephony_data *)handle)->tapi_h;
 266         CHECK_INPUT_PARAMETER(tapi_h);
 267         CHECK_INPUT_PARAMETER(network_type);
 268
 269         ret = tel_get_property_int(tapi_h, TAPI_PROP_NETWORK_SERVICE_TYPE, &service_type);
 270         if (ret == TAPI_API_SUCCESS) {
 271                 switch (service_type) {
 272                 case TAPI_NETWORK_SERVICE_TYPE_2G:
 273                         *network_type = TELEPHONY_NETWORK_TYPE_GSM;
 274                         break;
 275                 case TAPI_NETWORK_SERVICE_TYPE_2_5G:
 276                         *network_type = TELEPHONY_NETWORK_TYPE_GPRS;
 277                         break;
 278                 case TAPI_NETWORK_SERVICE_TYPE_2_5G_EDGE:
 279                         *network_type = TELEPHONY_NETWORK_TYPE_EDGE;
 280                         break;
 281                 case TAPI_NETWORK_SERVICE_TYPE_3G:
 282                         *network_type = TELEPHONY_NETWORK_TYPE_UMTS;
 283                         break;
 284                 case TAPI_NETWORK_SERVICE_TYPE_HSDPA:
 285                         *network_type = TELEPHONY_NETWORK_TYPE_HSDPA;
 286                         break;
 287                 case TAPI_NETWORK_SERVICE_TYPE_LTE:
 288                         *network_type = TELEPHONY_NETWORK_TYPE_LTE;
 289                         break;
 290                 default:
 291                         *network_type = TELEPHONY_NETWORK_TYPE_UNKNOWN;
 292                         break;
 293                 }
 294
 295                 LOGI("network_type:[%d]", *network_type);
 296                 ret = TELEPHONY_ERROR_NONE;
 297         } else if (ret == TAPI_API_ACCESS_DENIED) {
 298                 LOGE("PERMISSION_DENIED");
 299                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
 300         } else {
 301                 LOGE("OPERATION_FAILED");
 302                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
 303         }
 304
 305         return ret;
 306 }
 307
 308 int telephony_network_get_service_state(telephony_h handle, telephony_network_service_state_e *network_service_state)
 309 {
 310         int ret;
 311         int service_type = 0;
 312         TapiHandle *tapi_h;
 313
 314         CHECK_TELEPHONY_SUPPORTED(TELEPHONY_FEATURE);
 315         CHECK_INPUT_PARAMETER(handle);
 316         tapi_h = ((telephony_data *)handle)->tapi_h;
 317         CHECK_INPUT_PARAMETER(tapi_h);
 318         CHECK_INPUT_PARAMETER(network_service_state);
 319
 320         ret = tel_get_property_int(tapi_h, TAPI_PROP_NETWORK_SERVICE_TYPE, &service_type);
 321         if (ret == TAPI_API_SUCCESS) {
 322                 switch (service_type) {
 323                 case TAPI_NETWORK_SERVICE_TYPE_UNKNOWN:
 324                 case TAPI_NETWORK_SERVICE_TYPE_NO_SERVICE:
 325                 case TAPI_NETWORK_SERVICE_TYPE_SEARCH:
 326                         *network_service_state = TELEPHONY_NETWORK_SERVICE_STATE_OUT_OF_SERVICE;
 327                         break;
 328                 case TAPI_NETWORK_SERVICE_TYPE_EMERGENCY:
 329                         *network_service_state = TELEPHONY_NETWORK_SERVICE_STATE_EMERGENCY_ONLY;
 330                         break;
 331                 default:
 332                         *network_service_state = TELEPHONY_NETWORK_SERVICE_STATE_IN_SERVICE;
 333                         break;
 334                 }
 335                 LOGI("network_service_state:[%d]", *network_service_state);
 336                 ret = TELEPHONY_ERROR_NONE;
 337         } else if (ret == TAPI_API_ACCESS_DENIED) {
 338                 LOGE("PERMISSION_DENIED");
 339                 ret = TELEPHONY_ERROR_PERMISSION_DENIED;
 340         } else {
 341                 LOGE("OPERATION_FAILED");
 342                 ret = TELEPHONY_ERROR_OPERATION_FAILED;
 343         }
 344
 345         return ret;
 346 }