wearable/src/tapi_modem.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 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 #include "ITapiPS.h"
  32
  33 #include "common.h"
  34 #include "tapi_log.h"
  35
  36 static void on_response_default_set(GObject *source_object, GAsyncResult *res, gpointer user_data)
  37 {
  38         GError *error = NULL;
  39         GDBusConnection *conn = NULL;
  40         struct tapi_resp_data *evt_cb_data = user_data;
  41         int result = -1;
  42
  43         GVariant *dbus_result;
  44
  45         conn = G_DBUS_CONNECTION (source_object);
  46         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  47         CHECK_DEINIT(error);
  48
  49         if (!dbus_result) {
  50                 if (evt_cb_data->cb_fn) {
  51                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  52                 }
  53
  54                 if (error)
  55                         g_error_free(error);
  56
  57                 g_free(evt_cb_data);
  58                 return;
  59         }
  60
  61         g_variant_get (dbus_result, "(i)", &result);
  62
  63         if (evt_cb_data->cb_fn) {
  64                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
  65         }
  66
  67         g_free(evt_cb_data);
  68 }
  69
  70 static void on_response_get_version(GObject *source_object, GAsyncResult *res, gpointer user_data)
  71 {
  72         GError *error = NULL;
  73         GDBusConnection *conn = NULL;
  74         struct tapi_resp_data *evt_cb_data = user_data;
  75         int result = -1;
  76         TelMiscVersionInformation data;
  77         char *sw = NULL, *hw = NULL, *rf = NULL, *product = NULL;
  78
  79         GVariant *dbus_result;
  80
  81         memset(&data, 0, sizeof(TelMiscVersionInformation));
  82
  83         conn = G_DBUS_CONNECTION (source_object);
  84         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  85         CHECK_DEINIT(error);
  86
  87         if (!dbus_result) {
  88                 if (evt_cb_data->cb_fn) {
  89                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  90                 }
  91
  92                 if (error)
  93                         g_error_free(error);
  94
  95                 g_free(evt_cb_data);
  96                 return;
  97         }
  98
  99         g_variant_get (dbus_result, "(issss)", &result,
 100                         &sw, &hw, &rf, &product);
 101
 102         dbg("product code [%s]", product);
 103
 104         g_strlcpy((gchar *)data.szSwVersion, sw, MAX_VERSION_LEN);
 105         g_strlcpy((gchar *)data.szHwVersion, hw, MAX_VERSION_LEN);
 106         g_strlcpy((gchar *)data.szRfCalDate, rf, MAX_VERSION_LEN);
 107         g_strlcpy((gchar *)data.szProductCode, product, TAPI_MISC_PRODUCT_CODE_LEN_MAX);
 108
 109         if (evt_cb_data->cb_fn) {
 110                 if (result != 0)
 111                         evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 112                 else
 113                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 114         }
 115         g_free(evt_cb_data);
 116 }
 117
 118 static void on_response_get_serial_number(GObject *source_object, GAsyncResult *res, gpointer user_data)
 119 {
 120         GError *error = NULL;
 121         GDBusConnection *conn = NULL;
 122         struct tapi_resp_data *evt_cb_data = user_data;
 123         int result = -1;
 124         char *sn = NULL;
 125
 126         GVariant *dbus_result;
 127
 128         conn = G_DBUS_CONNECTION (source_object);
 129         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 130         CHECK_DEINIT(error);
 131
 132         if (!dbus_result) {
 133                 if (evt_cb_data->cb_fn) {
 134                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 135                 }
 136
 137                 if (error)
 138                         g_error_free(error);
 139
 140                 g_free(evt_cb_data);
 141                 return;
 142         }
 143
 144         g_variant_get (dbus_result, "(is)", &result, &sn);
 145
 146         if (evt_cb_data->cb_fn) {
 147                 if (result != 0)
 148                         evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 149                 else
 150                         evt_cb_data->cb_fn(evt_cb_data->handle, result, sn, evt_cb_data->user_data);
 151         }
 152
 153         g_free(evt_cb_data);
 154 }
 155
 156 static void on_response_get_imei(GObject *source_object, GAsyncResult *res, gpointer user_data)
 157 {
 158         GError *error = NULL;
 159         GDBusConnection *conn = NULL;
 160         struct tapi_resp_data *evt_cb_data = user_data;
 161         int result = -1;
 162         char *imei = NULL;
 163
 164         GVariant *dbus_result;
 165
 166         conn = G_DBUS_CONNECTION (source_object);
 167         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 168         CHECK_DEINIT(error);
 169
 170         if (!dbus_result) {
 171                 if (evt_cb_data->cb_fn) {
 172                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 173                 }
 174
 175                 if (error)
 176                         g_error_free(error);
 177
 178                 g_free(evt_cb_data);
 179                 return;
 180         }
 181
 182         g_variant_get (dbus_result, "(is)", &result, &imei);
 183
 184         if (evt_cb_data->cb_fn) {
 185                 if (result != 0)
 186                         evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 187                 else
 188                         evt_cb_data->cb_fn(evt_cb_data->handle, result, imei, evt_cb_data->user_data);
 189         }
 190
 191         g_free(evt_cb_data);
 192 }
 193
 194 static void on_response_set_dun_pin_ctrl(GObject *source_object, GAsyncResult *res, gpointer user_data)
 195 {
 196         GError *error = NULL;
 197         GDBusConnection *conn = NULL;
 198         struct tapi_resp_data *evt_cb_data = user_data;
 199         int result = -1;
 200
 201         GVariant *dbus_result;
 202
 203         conn = G_DBUS_CONNECTION (source_object);
 204         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 205         CHECK_DEINIT(error);
 206
 207         if (!dbus_result) {
 208                 if (evt_cb_data->cb_fn) {
 209                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 210                 }
 211
 212                 if (error)
 213                         g_error_free(error);
 214
 215                 g_free(evt_cb_data);
 216                 return;
 217         }
 218
 219         g_variant_get (dbus_result, "(i)", &result);
 220         dbg("dun pin ctrl result(%d)", result);
 221
 222         if (evt_cb_data->cb_fn) {
 223                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 224         }
 225
 226         g_free(evt_cb_data);
 227 }
 228
 229 static void on_response_get_flight_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 230 {
 231         GError *error = NULL;
 232         GDBusConnection *conn = NULL;
 233         struct tapi_resp_data *evt_cb_data = user_data;
 234         int result = -1;
 235         gboolean mode = FALSE;
 236
 237         GVariant *dbus_result;
 238
 239         conn = G_DBUS_CONNECTION (source_object);
 240         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 241         CHECK_DEINIT(error);
 242
 243         if (!dbus_result) {
 244                 if (evt_cb_data->cb_fn) {
 245                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 246                 }
 247
 248                 if (error)
 249                         g_error_free(error);
 250
 251                 g_free(evt_cb_data);
 252                 return;
 253         }
 254
 255         g_variant_get (dbus_result, "(bi)", &mode, &result);
 256
 257         if (evt_cb_data->cb_fn) {
 258                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 259         }
 260
 261         g_free(evt_cb_data);
 262 }
 263
 264 /**
 265  *
 266  * Turn Off or Turn On the Modem.
 267  *
 268  * @param[in]   tapi_power_phone_cmd_t  Turn ON or OFF.
 269  * @param[out]  NONE
 270  * @return              TapiResult_t API result code. Either Success or some Error Code.
 271  * @exception   In case of exceptions return value contains appropriate error code.
 272  * @remarks             None.
 273  * @see                 tapi_power_phone_cmd_t, TapiResult_t.
 274  */
 275 EXPORT_API int tel_process_power_command(TapiHandle *handle, tapi_power_phone_cmd_t cmd, tapi_response_cb callback, void *user_data)
 276 {
 277         struct tapi_resp_data *evt_cb_data = NULL;
 278         GVariant *param;
 279
 280         dbg("Func Entrance");
 281
 282         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 283
 284         if (cmd > TAPI_PHONE_POWER_RESET)
 285                 return TAPI_API_INVALID_INPUT;
 286
 287         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 288
 289         param = g_variant_new("(i)", cmd);
 290
 291         g_dbus_connection_call(handle->dbus_connection,
 292                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 293                         "SetPower", param, NULL,
 294                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 295                         on_response_default_set, evt_cb_data);
 296
 297         return TAPI_API_SUCCESS;
 298 }
 299
 300 /**
 301  *
 302  * Enter in to or Leave from Flight Mode.
 303  *
 304  * @param[in]   Enable (if 1, Enable and if 0, Disable)
 305  * @param[out]  NONE
 306  * @return              TapiResult_t API result code. Either Success or some Error Code.
 307  * @exception   In case of exceptions return value contains appropriate error code.
 308  * @remarks             None
 309  * @see                 None.
 310  */
 311 EXPORT_API int tel_set_flight_mode(TapiHandle *handle, tapi_power_flight_mode_type_t mode, tapi_response_cb callback, void *user_data)
 312 {
 313         struct tapi_resp_data *evt_cb_data = NULL;
 314         GVariant *param;
 315         gboolean b_mode;
 316
 317         dbg("Func Entrance");
 318
 319         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 320
 321         if (mode == TAPI_POWER_FLIGHT_MODE_ENTER) {
 322                 b_mode = TRUE;
 323         }
 324         else if (mode == TAPI_POWER_FLIGHT_MODE_LEAVE) {
 325                 b_mode = FALSE;
 326         }
 327         else {
 328                 return TAPI_API_INVALID_INPUT;
 329         };
 330
 331         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 332
 333         param = g_variant_new("(b)", b_mode);
 334
 335         g_dbus_connection_call(handle->dbus_connection,
 336                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 337                         "SetFlightMode", param, NULL,
 338                         G_DBUS_CALL_FLAGS_NONE, 180000, handle->ca,
 339                         on_response_default_set, evt_cb_data);
 340
 341         return TAPI_API_SUCCESS;
 342 }
 343
 344 EXPORT_API int tel_get_flight_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 345 {
 346         struct tapi_resp_data *evt_cb_data = NULL;
 347
 348         dbg("Func Entrance");
 349
 350         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 351         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 352
 353         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 354
 355         g_dbus_connection_call(handle->dbus_connection,
 356                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 357                         "GetFlightMode", NULL, NULL,
 358                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 359                         on_response_get_flight_mode, evt_cb_data);
 360
 361         return TAPI_API_SUCCESS;
 362 }
 363
 364 EXPORT_API int tel_get_misc_me_version(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 365 {
 366         struct tapi_resp_data *evt_cb_data = NULL;
 367
 368         dbg("Func Entrance");
 369
 370         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 371         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 372
 373         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 374
 375         g_dbus_connection_call(handle->dbus_connection,
 376                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 377                         "GetVersion", NULL, NULL,
 378                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 379                         on_response_get_version, evt_cb_data);
 380
 381         return TAPI_API_SUCCESS;
 382 }
 383
 384 EXPORT_API TelMiscVersionInformation *tel_get_misc_me_version_sync(TapiHandle *handle)
 385 {
 386         GVariant *dbus_result;
 387         GError *error = NULL;
 388         int result = -1;
 389         TelMiscVersionInformation *data = NULL;
 390         char *sw = NULL, *hw = NULL, *rf = NULL, *product = NULL;
 391
 392         dbg("Func Entrance");
 393
 394         TAPI_RET_ERR_NUM_IF_FAIL(handle, NULL);
 395
 396         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 397                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 398                         "GetVersion", NULL, NULL,
 399                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &error);
 400
 401         if (error) {
 402                 warn("dbus error = %d (%s)", error->code, error->message);
 403                 g_error_free(error);
 404         }
 405
 406         if (!dbus_result)
 407                 return NULL;
 408
 409         g_variant_get (dbus_result, "(issss)", &result,
 410                         &sw, &hw, &rf, &product);
 411
 412         if (result != 0)
 413                 return NULL;
 414
 415         dbg("product code[%s]", product);
 416
 417         data = calloc(1, sizeof(TelMiscVersionInformation));
 418         if (!data)
 419                 return NULL;
 420
 421         g_strlcpy((gchar *)data->szSwVersion, sw, MAX_VERSION_LEN);
 422         g_strlcpy((gchar *)data->szHwVersion, hw, MAX_VERSION_LEN);
 423         g_strlcpy((gchar *)data->szRfCalDate, rf, MAX_VERSION_LEN);
 424         g_strlcpy((gchar *)data->szProductCode, product, TAPI_MISC_PRODUCT_CODE_LEN_MAX);
 425
 426         return data;
 427 }
 428
 429 EXPORT_API int tel_get_misc_me_imei(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 430 {
 431         struct tapi_resp_data *evt_cb_data = NULL;
 432
 433         sdbg("Func Entrance");
 434
 435         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 436         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 437
 438         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 439
 440         g_dbus_connection_call(handle->dbus_connection,
 441                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 442                         "GetIMEI", NULL, NULL,
 443                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 444                         on_response_get_imei, evt_cb_data);
 445
 446         return TAPI_API_SUCCESS;
 447 }
 448
 449 EXPORT_API char *tel_get_misc_me_imei_sync(TapiHandle *handle)
 450 {
 451         GVariant *dbus_result;
 452         GError *error = NULL;
 453         char *imei = NULL;
 454         int result = 0;
 455
 456         sdbg("Func Entrance");
 457
 458         TAPI_RET_ERR_NUM_IF_FAIL(handle, NULL);
 459
 460         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 461                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 462                         "GetIMEI", NULL, NULL,
 463                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &error);
 464
 465         if (error) {
 466                 warn("dbus error = %d (%s)", error->code, error->message);
 467                 g_error_free(error);
 468         }
 469
 470         if (!dbus_result)
 471                 return NULL;
 472
 473         g_variant_get (dbus_result, "(is)", &result, &imei);
 474
 475         if (result != 0)
 476                 return NULL;
 477
 478         return imei;
 479 }
 480
 481 EXPORT_API int tel_get_misc_me_sn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 482 {
 483         struct tapi_resp_data *evt_cb_data = NULL;
 484
 485         sdbg("Func Entrance");
 486
 487         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 488         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 489
 490         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 491
 492         g_dbus_connection_call(handle->dbus_connection,
 493                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 494                         "GetSerialNumber", NULL, NULL,
 495                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 496                         on_response_get_serial_number, evt_cb_data);
 497
 498         return TAPI_API_SUCCESS;
 499 }
 500
 501 EXPORT_API char *tel_get_misc_me_sn_sync(TapiHandle *handle)
 502 {
 503         GVariant *dbus_result;
 504         GError *error = NULL;
 505         char *sn = NULL;
 506         int result = 0;
 507
 508         sdbg("Func Entrance");
 509
 510         TAPI_RET_ERR_NUM_IF_FAIL(handle, NULL);
 511
 512         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 513                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 514                         "GetSerialNumber", NULL, NULL,
 515                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &error);
 516
 517         if (error) {
 518                 warn("dbus error = %d (%s)", error->code, error->message);
 519                 g_error_free(error);
 520         }
 521
 522         if (!dbus_result)
 523                 return NULL;
 524
 525         g_variant_get (dbus_result, "(is)", &result, &sn);
 526
 527         if (result != 0)
 528                 return NULL;
 529
 530         return sn;
 531 }
 532
 533 EXPORT_API int tel_check_modem_power_status(TapiHandle *handle, int *result)
 534 {
 535         int ret = TAPI_API_SUCCESS;
 536
 537         dbg("Func Entrance");
 538
 539         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 540         TAPI_RET_ERR_NUM_IF_FAIL(result, TAPI_API_INVALID_PTR);
 541
 542         ret = tel_get_property_int(handle, TAPI_PROP_MODEM_POWER, result);
 543         if (ret != TAPI_API_SUCCESS) {
 544                 warn("failed. (ret=0x%x)", ret);
 545                 return ret;
 546         }
 547
 548         dbg("power status = %d (0=on,1=off,2=err)", *result);
 549
 550         return ret;
 551 }
 552
 553 EXPORT_API int tel_control_modem_dun_pin_ctrl(TapiHandle *handle, tapi_ps_btdun_pincontrol *pincontrol, tapi_response_cb callback, void *user_data)
 554 {
 555         struct tapi_resp_data *evt_cb_data = NULL;
 556         GVariant *param;
 557
 558         dbg("Func Entrance ");
 559
 560         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 561         TAPI_RET_ERR_NUM_IF_FAIL(handle->dbus_connection, TAPI_API_INVALID_PTR);
 562         TAPI_RET_ERR_NUM_IF_FAIL(pincontrol, TAPI_API_INVALID_PTR);
 563
 564         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 565
 566         param = g_variant_new("(ib)", pincontrol->signal, pincontrol->status);
 567
 568         g_dbus_connection_call(handle->dbus_connection,
 569                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 570                         "SetDunPinCtrl", param, NULL,
 571                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 572                         on_response_set_dun_pin_ctrl, evt_cb_data);
 573
 574         return TAPI_API_SUCCESS;
 575 }