src/tapi_modem.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "tapi_common.h"
  26 #include "TapiUtility.h"
  27
  28 #include "TelMisc.h"
  29 #include "TelPower.h"
  30 #include "ITapiModem.h"
  31
  32 #include "common.h"
  33 #include "tapi_log.h"
  34
  35 static void on_response_default_set(GObject *source_object, GAsyncResult *res, gpointer user_data)
  36 {
  37         GError *error = NULL;
  38         GDBusConnection *conn = NULL;
  39         struct tapi_resp_data *evt_cb_data = user_data;
  40         int result = -1;
  41
  42         GVariant *dbus_result;
  43
  44         conn = G_DBUS_CONNECTION (source_object);
  45         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  46         CHECK_ERROR(error);
  47
  48         g_variant_get (dbus_result, "(i)", &result);
  49
  50         if (evt_cb_data->cb_fn) {
  51                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
  52         }
  53
  54         g_free(evt_cb_data);
  55         g_variant_unref(dbus_result);
  56 }
  57
  58 static void on_response_get_version(GObject *source_object, GAsyncResult *res, gpointer user_data)
  59 {
  60         GError *error = NULL;
  61         GDBusConnection *conn = NULL;
  62         struct tapi_resp_data *evt_cb_data = user_data;
  63         int result = -1;
  64         TelMiscVersionInformation data;
  65         char *sw = NULL, *hw = NULL, *rf = NULL, *product = NULL;
  66
  67         GVariant *dbus_result;
  68
  69         memset(&data, 0, sizeof(TelMiscVersionInformation));
  70
  71         conn = G_DBUS_CONNECTION (source_object);
  72         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  73         CHECK_ERROR(error);
  74
  75         g_variant_get (dbus_result, "(issss)", &result,
  76                         &sw, &hw, &rf, &product);
  77
  78         dbg("product code [%s]", product);
  79
  80         g_strlcpy((gchar *)data.szSwVersion, sw, MAX_VERSION_LEN);
  81         g_strlcpy((gchar *)data.szHwVersion, hw, MAX_VERSION_LEN);
  82         g_strlcpy((gchar *)data.szRfCalDate, rf, MAX_VERSION_LEN);
  83         g_strlcpy((gchar *)data.szProductCode, product, TAPI_MISC_PRODUCT_CODE_LEN_MAX);
  84
  85         g_free(sw);
  86         g_free(hw);
  87         g_free(rf);
  88         g_free(product);
  89
  90         if (evt_cb_data->cb_fn) {
  91                 if (result != 0)
  92                         evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
  93                 else
  94                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
  95         }
  96         g_free(evt_cb_data);
  97         g_variant_unref(dbus_result);
  98 }
  99
 100 static void on_response_get_serial_number(GObject *source_object, GAsyncResult *res, gpointer user_data)
 101 {
 102         GError *error = NULL;
 103         GDBusConnection *conn = NULL;
 104         struct tapi_resp_data *evt_cb_data = user_data;
 105         int result = -1;
 106         TelMiscSNInformation data;
 107         char *sn = NULL, *meid = NULL, *imei = NULL, *imeisv = NULL;
 108
 109         GVariant *dbus_result;
 110
 111         conn = G_DBUS_CONNECTION (source_object);
 112         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 113         CHECK_ERROR(error);
 114
 115         g_variant_get (dbus_result, "(issss)", &result,
 116                         &sn, &meid, &imei, &imeisv);
 117
 118         g_strlcpy((gchar *)data.szEsn, sn, TAPI_MISC_ME_SN_LEN_MAX);
 119         g_strlcpy((gchar *)data.szMeid, meid, TAPI_MISC_ME_SN_LEN_MAX);
 120         g_strlcpy((gchar *)data.szImei, imei, TAPI_MISC_ME_SN_LEN_MAX);
 121         g_strlcpy((gchar *)data.szImeiSv, imeisv, TAPI_MISC_ME_SN_LEN_MAX);
 122
 123
 124         g_free(sn);
 125         g_free(meid);
 126         g_free(imei);
 127         g_free(imeisv);
 128
 129         if (evt_cb_data->cb_fn) {
 130                 if (result != 0)
 131                         evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 132                 else
 133                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 134         }
 135
 136         g_free(evt_cb_data);
 137         g_variant_unref(dbus_result);
 138 }
 139
 140 static void on_response_get_imei(GObject *source_object, GAsyncResult *res, gpointer user_data)
 141 {
 142         GError *error = NULL;
 143         GDBusConnection *conn = NULL;
 144         struct tapi_resp_data *evt_cb_data = user_data;
 145         int result = -1;
 146         char *imei = NULL;
 147
 148         GVariant *dbus_result;
 149
 150         conn = G_DBUS_CONNECTION (source_object);
 151         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 152         CHECK_ERROR(error);
 153
 154         g_variant_get (dbus_result, "(is)", &result, &imei);
 155
 156         if (evt_cb_data->cb_fn) {
 157                 if (result != 0)
 158                         evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 159                 else
 160                         evt_cb_data->cb_fn(evt_cb_data->handle, result, imei, evt_cb_data->user_data);
 161         }
 162         g_free(imei);
 163
 164         g_free(evt_cb_data);
 165         g_variant_unref(dbus_result);
 166 }
 167
 168 static void on_response_get_flight_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 169 {
 170         GError *error = NULL;
 171         GDBusConnection *conn = NULL;
 172         struct tapi_resp_data *evt_cb_data = user_data;
 173         int result = -1;
 174         gboolean mode = FALSE;
 175
 176         GVariant *dbus_result;
 177
 178         conn = G_DBUS_CONNECTION (source_object);
 179         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 180         CHECK_ERROR(error);
 181
 182         g_variant_get (dbus_result, "(bi)", &mode, &result);
 183
 184         if (evt_cb_data->cb_fn) {
 185                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 186         }
 187
 188         g_free(evt_cb_data);
 189         g_variant_unref(dbus_result);
 190 }
 191
 192 /**
 193  *
 194  * Turn Off or Turn On the Modem.
 195  *
 196  * @param[in]   tapi_power_phone_cmd_t  Turn ON or OFF.
 197  * @param[out]  NONE
 198  * @return              TapiResult_t API result code. Either Success or some Error Code.
 199  * @exception   In case of exceptions return value contains appropriate error code.
 200  * @remarks             None.
 201  * @see                 tapi_power_phone_cmd_t, TapiResult_t.
 202  */
 203 EXPORT_API int tel_process_power_command(TapiHandle *handle, tapi_power_phone_cmd_t cmd, tapi_response_cb callback, void *user_data)
 204 {
 205         struct tapi_resp_data *evt_cb_data = NULL;
 206         GVariant *param;
 207
 208         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 209
 210         msg("[%s] tel_process_power_command:[%d] (0:ON,1:OFF,2:RST,3:LOW)", handle->cp_name, cmd);
 211
 212         if (cmd > TAPI_PHONE_POWER_MAX)
 213                 return TAPI_API_INVALID_INPUT;
 214         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 215
 216         param = g_variant_new("(i)", cmd);
 217
 218         g_dbus_connection_call(handle->dbus_connection,
 219                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 220                         "SetPower", param, NULL,
 221                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 222                         on_response_default_set, evt_cb_data);
 223
 224         return TAPI_API_SUCCESS;
 225 }
 226
 227 /**
 228  *
 229  * Enter in to or Leave from Flight Mode.
 230  *
 231  * @param[in]   Enable (if 1, Enable and if 0, Disable)
 232  * @param[out]  NONE
 233  * @return              TapiResult_t API result code. Either Success or some Error Code.
 234  * @exception   In case of exceptions return value contains appropriate error code.
 235  * @remarks             None
 236  * @see                 None.
 237  */
 238 EXPORT_API int tel_set_flight_mode(TapiHandle *handle, tapi_power_flight_mode_type_t mode, tapi_response_cb callback, void *user_data)
 239 {
 240         struct tapi_resp_data *evt_cb_data = NULL;
 241         GVariant *param;
 242         gboolean b_mode;
 243
 244         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 245
 246         msg("[%s] requested flight mode:[%d] (1:enter, 2:leave)", handle->cp_name, mode);
 247
 248         if (mode == TAPI_POWER_FLIGHT_MODE_ENTER) {
 249                 b_mode = TRUE;
 250         }
 251         else if (mode == TAPI_POWER_FLIGHT_MODE_LEAVE) {
 252                 b_mode = FALSE;
 253         }
 254         else {
 255                 return TAPI_API_INVALID_INPUT;
 256         };
 257
 258         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 259
 260         param = g_variant_new("(b)", b_mode);
 261
 262         g_dbus_connection_call(handle->dbus_connection,
 263                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 264                         "SetFlightMode", param, NULL,
 265                         G_DBUS_CALL_FLAGS_NONE, 180000, handle->ca,
 266                         on_response_default_set, evt_cb_data);
 267
 268         return TAPI_API_SUCCESS;
 269 }
 270
 271 EXPORT_API int tel_get_flight_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 272 {
 273         struct tapi_resp_data *evt_cb_data = NULL;
 274
 275         dbg("Func Entrance");
 276
 277         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 278         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 279
 280         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 281
 282         g_dbus_connection_call(handle->dbus_connection,
 283                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 284                         "GetFlightMode", NULL, NULL,
 285                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 286                         on_response_get_flight_mode, evt_cb_data);
 287
 288         return TAPI_API_SUCCESS;
 289 }
 290
 291 EXPORT_API int tel_get_misc_me_version(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 292 {
 293         struct tapi_resp_data *evt_cb_data = NULL;
 294
 295         dbg("Func Entrance");
 296
 297         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 298         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 299
 300         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 301
 302         g_dbus_connection_call(handle->dbus_connection,
 303                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 304                         "GetVersion", NULL, NULL,
 305                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 306                         on_response_get_version, evt_cb_data);
 307
 308         return TAPI_API_SUCCESS;
 309 }
 310
 311 EXPORT_API TelMiscVersionInformation *tel_get_misc_me_version_sync(TapiHandle *handle)
 312 {
 313         GVariant *dbus_result;
 314         GError *error = NULL;
 315         int result = -1;
 316         TelMiscVersionInformation *data = NULL;
 317         char *sw = NULL, *hw = NULL, *rf = NULL, *product = NULL;
 318
 319         dbg("Func Entrance");
 320
 321         TAPI_RET_ERR_NUM_IF_FAIL(handle, NULL);
 322
 323         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 324                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 325                         "GetVersion", NULL, NULL,
 326                         G_DBUS_CALL_FLAGS_NONE, TAPI_SHORT_TIMEOUT, handle->ca, &error);
 327
 328         if (error) {
 329                 warn("dbus error = %d (%s)", error->code, error->message);
 330                 g_error_free(error);
 331         }
 332
 333         if (!dbus_result)
 334                 return NULL;
 335
 336         g_variant_get (dbus_result, "(issss)", &result,
 337                         &sw, &hw, &rf, &product);
 338         g_variant_unref(dbus_result);
 339
 340         if (result != 0)
 341                 goto OUT;
 342
 343         dbg("product code[%s]", product);
 344
 345         data = calloc(1, sizeof(TelMiscVersionInformation));
 346         if (!data)
 347                 goto OUT;
 348
 349         g_strlcpy((gchar *)data->szSwVersion, sw, MAX_VERSION_LEN);
 350         g_strlcpy((gchar *)data->szHwVersion, hw, MAX_VERSION_LEN);
 351         g_strlcpy((gchar *)data->szRfCalDate, rf, MAX_VERSION_LEN);
 352         g_strlcpy((gchar *)data->szProductCode, product, TAPI_MISC_PRODUCT_CODE_LEN_MAX);
 353 OUT:
 354         g_free(sw);
 355         g_free(hw);
 356         g_free(rf);
 357         g_free(product);
 358
 359         return data;
 360 }
 361
 362 EXPORT_API int tel_get_misc_me_imei(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 363 {
 364         struct tapi_resp_data *evt_cb_data = NULL;
 365
 366         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 367         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 368
 369         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 370
 371         sdbg("[%s] Func Entrance", handle->cp_name);
 372
 373         g_dbus_connection_call(handle->dbus_connection,
 374                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 375                         "GetIMEI", NULL, NULL,
 376                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 377                         on_response_get_imei, evt_cb_data);
 378
 379         return TAPI_API_SUCCESS;
 380 }
 381
 382 EXPORT_API char *tel_get_misc_me_imei_sync(TapiHandle *handle)
 383 {
 384         GVariant *dbus_result;
 385         GError *error = NULL;
 386         char *imei = NULL;
 387         int result = 0;
 388
 389         TAPI_RET_ERR_NUM_IF_FAIL(handle, NULL);
 390
 391         sdbg("[%s] Func Entrance", handle->cp_name);
 392
 393         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 394                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 395                         "GetIMEI", NULL, NULL,
 396                         G_DBUS_CALL_FLAGS_NONE, TAPI_SHORT_TIMEOUT, handle->ca, &error);
 397
 398         if (error) {
 399                 warn("dbus error = %d (%s)", error->code, error->message);
 400                 g_error_free(error);
 401         }
 402
 403         if (!dbus_result)
 404                 return NULL;
 405
 406         g_variant_get (dbus_result, "(is)", &result, &imei);
 407         g_variant_unref(dbus_result);
 408
 409         if (result != 0) {
 410                 g_free(imei);
 411                 return NULL;
 412         }
 413
 414         return imei;
 415 }
 416
 417 EXPORT_API int tel_get_misc_me_sn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 418 {
 419         struct tapi_resp_data *evt_cb_data = NULL;
 420
 421         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 422         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 423
 424         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 425
 426         sdbg("[%s] Func Entrance", handle->cp_name);
 427
 428         g_dbus_connection_call(handle->dbus_connection,
 429                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 430                         "GetSerialNumber", NULL, NULL,
 431                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 432                         on_response_get_serial_number, evt_cb_data);
 433
 434         return TAPI_API_SUCCESS;
 435 }
 436
 437 EXPORT_API TelMiscSNInformation *tel_get_misc_me_sn_sync(TapiHandle *handle)
 438 {
 439         GVariant *dbus_result;
 440         GError *error = NULL;
 441         char *sn = NULL, *meid = NULL,*imei = NULL, *imeisv = NULL;
 442         TelMiscSNInformation *data = NULL;
 443         int result = 0;
 444
 445         TAPI_RET_ERR_NUM_IF_FAIL(handle, NULL);
 446
 447         sdbg("[%s] Func Entrance", handle->cp_name);
 448
 449         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 450                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 451                         "GetSerialNumber", NULL, NULL,
 452                         G_DBUS_CALL_FLAGS_NONE, TAPI_SHORT_TIMEOUT, handle->ca, &error);
 453         if (error) {
 454                 warn("dbus error = %d (%s)", error->code, error->message);
 455                 g_error_free(error);
 456         }
 457
 458         if (!dbus_result)
 459                 return NULL;
 460
 461         g_variant_get (dbus_result, "(issss)", &result, &sn, &meid, &imei, &imeisv);
 462         g_variant_unref(dbus_result);
 463
 464         if (result != 0)
 465                 goto OUT;
 466
 467         data = calloc(1, sizeof(TelMiscSNInformation));
 468         if (!data)
 469                 goto OUT;
 470
 471         g_strlcpy((gchar *)data->szEsn, sn, TAPI_MISC_ME_SN_LEN_MAX);
 472         g_strlcpy((gchar *)data->szMeid, meid, TAPI_MISC_ME_SN_LEN_MAX);
 473         g_strlcpy((gchar *)data->szImei, imei, TAPI_MISC_ME_SN_LEN_MAX);
 474         g_strlcpy((gchar *)data->szImeiSv, imeisv, TAPI_MISC_ME_SN_LEN_MAX);
 475
 476 OUT:
 477         g_free(sn);
 478         g_free(meid);
 479         g_free(imei);
 480         g_free(imeisv);
 481
 482         return data;
 483 }
 484
 485 EXPORT_API int tel_check_modem_power_status(TapiHandle *handle, int *result)
 486 {
 487         int ret = TAPI_API_SUCCESS;
 488
 489         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 490         TAPI_RET_ERR_NUM_IF_FAIL(result, TAPI_API_INVALID_PTR);
 491
 492         ret = tel_get_property_int(handle, TAPI_PROP_MODEM_POWER, result);
 493         if (ret == TAPI_API_ACCESS_DENIED) {
 494                 err("Access denied");
 495                 return ret;
 496         } else if (ret != TAPI_API_SUCCESS) {
 497                 err("failed. (ret=%d)", ret);
 498                 return ret;
 499         }
 500
 501         msg("[%s] modem_power_status = %d (0=on,1=off,2=rst,3=low)", handle->cp_name, *result);
 502
 503         return ret;
 504 }