mobile/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                 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         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                 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                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 111         }
 112
 113         free(evt_cb_data);
 114 }
 115
 116 static void on_response_get_serial_number(GObject *source_object, GAsyncResult *res, gpointer user_data)
 117 {
 118         GError *error = NULL;
 119         GDBusConnection *conn = NULL;
 120         struct tapi_resp_data *evt_cb_data = user_data;
 121         int result = -1;
 122         char *sn = NULL;
 123
 124         GVariant *dbus_result;
 125
 126         conn = G_DBUS_CONNECTION (source_object);
 127         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 128         CHECK_DEINIT(error);
 129
 130         if (!dbus_result) {
 131                 if (evt_cb_data->cb_fn) {
 132                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 133                 }
 134
 135                 if (error)
 136                         g_error_free(error);
 137
 138                 free(evt_cb_data);
 139                 return;
 140         }
 141
 142         g_variant_get (dbus_result, "(is)", &result, &sn);
 143
 144         if (evt_cb_data->cb_fn) {
 145                 evt_cb_data->cb_fn(evt_cb_data->handle, result, sn, evt_cb_data->user_data);
 146         }
 147
 148         free(evt_cb_data);
 149 }
 150
 151 static void on_response_get_imei(GObject *source_object, GAsyncResult *res, gpointer user_data)
 152 {
 153         GError *error = NULL;
 154         GDBusConnection *conn = NULL;
 155         struct tapi_resp_data *evt_cb_data = user_data;
 156         int result = -1;
 157         char *imei = NULL;
 158
 159         GVariant *dbus_result;
 160
 161         conn = G_DBUS_CONNECTION (source_object);
 162         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 163         CHECK_DEINIT(error);
 164
 165         if (!dbus_result) {
 166                 if (evt_cb_data->cb_fn) {
 167                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 168                 }
 169
 170                 if (error)
 171                         g_error_free(error);
 172
 173                 free(evt_cb_data);
 174                 return;
 175         }
 176
 177         g_variant_get (dbus_result, "(is)", &result, &imei);
 178
 179         if (evt_cb_data->cb_fn) {
 180                 evt_cb_data->cb_fn(evt_cb_data->handle, result, imei, evt_cb_data->user_data);
 181         }
 182
 183         free(evt_cb_data);
 184 }
 185
 186 static void on_response_set_dun_pin_ctrl(GObject *source_object, GAsyncResult *res, gpointer user_data)
 187 {
 188         GError *error = NULL;
 189         GDBusConnection *conn = NULL;
 190         struct tapi_resp_data *evt_cb_data = user_data;
 191         int result = -1;
 192
 193         GVariant *dbus_result;
 194
 195         conn = G_DBUS_CONNECTION (source_object);
 196         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 197         CHECK_DEINIT(error);
 198
 199         if (!dbus_result) {
 200                 if (evt_cb_data->cb_fn) {
 201                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 202                 }
 203
 204                 if (error)
 205                         g_error_free(error);
 206
 207                 free(evt_cb_data);
 208                 return;
 209         }
 210
 211         g_variant_get (dbus_result, "(i)", &result);
 212         dbg("dun pin ctrl result(%d)", result);
 213
 214         if (evt_cb_data->cb_fn) {
 215                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 216         }
 217
 218         free(evt_cb_data);
 219 }
 220
 221 static void on_response_get_flight_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 222 {
 223         GError *error = NULL;
 224         GDBusConnection *conn = NULL;
 225         struct tapi_resp_data *evt_cb_data = user_data;
 226         int result = -1;
 227         gboolean mode = FALSE;
 228
 229         GVariant *dbus_result;
 230
 231         conn = G_DBUS_CONNECTION (source_object);
 232         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 233         CHECK_DEINIT(error);
 234
 235         if (!dbus_result) {
 236                 if (evt_cb_data->cb_fn) {
 237                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 238                 }
 239
 240                 if (error)
 241                         g_error_free(error);
 242
 243                 free(evt_cb_data);
 244                 return;
 245         }
 246
 247         g_variant_get (dbus_result, "(bi)", &mode, &result);
 248
 249         if (evt_cb_data->cb_fn) {
 250                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 251         }
 252
 253         free(evt_cb_data);
 254 }
 255
 256 /**
 257  *
 258  * Turn Off or Turn On the Modem.
 259  *
 260  * @param[in]   tapi_power_phone_cmd_t  Turn ON or OFF.
 261  * @param[out]  NONE
 262  * @return              TapiResult_t API result code. Either Success or some Error Code.
 263  * @exception   In case of exceptions return value contains appropriate error code.
 264  * @remarks             None.
 265  * @see                 tapi_power_phone_cmd_t, TapiResult_t.
 266  */
 267 EXPORT_API int tel_process_power_command(TapiHandle *handle, tapi_power_phone_cmd_t cmd, tapi_response_cb callback, void *user_data)
 268 {
 269         struct tapi_resp_data *evt_cb_data = NULL;
 270         GVariant *param;
 271
 272         dbg("Func Entrance");
 273
 274         if (cmd > TAPI_PHONE_POWER_RESET)
 275                 return TAPI_API_INVALID_INPUT;
 276
 277         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 278
 279         param = g_variant_new("(i)", cmd);
 280
 281         g_dbus_connection_call(handle->dbus_connection,
 282                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 283                         "SetPower", param, NULL,
 284                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 285                         on_response_default_set, evt_cb_data);
 286
 287         return TAPI_API_SUCCESS;
 288 }
 289
 290 /**
 291  *
 292  * Enter in to or Leave from Flight Mode.
 293  *
 294  * @param[in]   Enable (if 1, Enable and if 0, Disable)
 295  * @param[out]  NONE
 296  * @return              TapiResult_t API result code. Either Success or some Error Code.
 297  * @exception   In case of exceptions return value contains appropriate error code.
 298  * @remarks             None
 299  * @see                 None.
 300  */
 301 EXPORT_API int tel_set_flight_mode(TapiHandle *handle, tapi_power_flight_mode_type_t mode, tapi_response_cb callback, void *user_data)
 302 {
 303         struct tapi_resp_data *evt_cb_data = NULL;
 304         GVariant *param;
 305         gboolean b_mode;
 306
 307         dbg("Func Entrance");
 308
 309         if (mode == TAPI_POWER_FLIGHT_MODE_ENTER) {
 310                 b_mode = TRUE;
 311         }
 312         else if (mode == TAPI_POWER_FLIGHT_MODE_LEAVE) {
 313                 b_mode = FALSE;
 314         }
 315         else {
 316                 return TAPI_API_INVALID_INPUT;
 317         };
 318
 319         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 320
 321         param = g_variant_new("(b)", b_mode);
 322
 323         g_dbus_connection_call(handle->dbus_connection,
 324                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 325                         "SetFlightMode", param, NULL,
 326                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 327                         on_response_default_set, evt_cb_data);
 328
 329         return TAPI_API_SUCCESS;
 330 }
 331
 332 EXPORT_API int tel_get_flight_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 333 {
 334         struct tapi_resp_data *evt_cb_data = NULL;
 335
 336         dbg("Func Entrance");
 337
 338         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 339
 340         g_dbus_connection_call(handle->dbus_connection,
 341                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 342                         "GetFlightMode", NULL, NULL,
 343                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 344                         on_response_get_flight_mode, evt_cb_data);
 345
 346         return TAPI_API_SUCCESS;
 347 }
 348
 349 EXPORT_API int tel_get_misc_me_version(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 350 {
 351         struct tapi_resp_data *evt_cb_data = NULL;
 352
 353         dbg("Func Entrance");
 354
 355         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 356
 357         g_dbus_connection_call(handle->dbus_connection,
 358                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 359                         "GetVersion", NULL, NULL,
 360                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 361                         on_response_get_version, evt_cb_data);
 362
 363         return TAPI_API_SUCCESS;
 364 }
 365
 366 EXPORT_API TelMiscVersionInformation *tel_get_misc_me_version_sync(TapiHandle *handle)
 367 {
 368         GVariant *dbus_result;
 369         int result = -1;
 370         TelMiscVersionInformation *data = NULL;
 371         char *sw = NULL, *hw = NULL, *rf = NULL, *product = NULL;
 372
 373         dbg("Func Entrance");
 374
 375         if (!handle)
 376                 return NULL;
 377
 378         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 379                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 380                         "GetVersion", NULL, NULL,
 381                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
 382
 383         g_variant_get (dbus_result, "(issss)", &result,
 384                         &sw, &hw, &rf, &product);
 385
 386         dbg("product code[%s]", product);
 387
 388         data = calloc(sizeof(TelMiscVersionInformation), 1);
 389         if (!data)
 390                 return NULL;
 391
 392         g_strlcpy((gchar *)data->szSwVersion, sw, MAX_VERSION_LEN);
 393         g_strlcpy((gchar *)data->szHwVersion, hw, MAX_VERSION_LEN);
 394         g_strlcpy((gchar *)data->szRfCalDate, rf, MAX_VERSION_LEN);
 395         g_strlcpy((gchar *)data->szProductCode, product, TAPI_MISC_PRODUCT_CODE_LEN_MAX);
 396
 397         return data;
 398 }
 399
 400 EXPORT_API int tel_get_misc_me_imei(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 401 {
 402         struct tapi_resp_data *evt_cb_data = NULL;
 403
 404         dbg("Func Entrance");
 405
 406         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 407
 408         g_dbus_connection_call(handle->dbus_connection,
 409                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 410                         "GetIMEI", NULL, NULL,
 411                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 412                         on_response_get_imei, evt_cb_data);
 413
 414         return TAPI_API_SUCCESS;
 415 }
 416
 417 EXPORT_API char *tel_get_misc_me_imei_sync(TapiHandle *handle)
 418 {
 419         GVariant *dbus_result;
 420         char *imei = NULL;
 421         int result = 0;
 422
 423         dbg("Func Entrance");
 424
 425         if (!handle)
 426                 return NULL;
 427
 428         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 429                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 430                         "GetIMEI", NULL, NULL,
 431                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
 432
 433         g_variant_get (dbus_result, "(is)", &result, &imei);
 434
 435         return imei;
 436 }
 437
 438 EXPORT_API int tel_get_misc_me_sn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 439 {
 440         struct tapi_resp_data *evt_cb_data = NULL;
 441
 442         dbg("Func Entrance");
 443
 444         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 445
 446         g_dbus_connection_call(handle->dbus_connection,
 447                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 448                         "GetSerialNumber", NULL, NULL,
 449                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 450                         on_response_get_serial_number, evt_cb_data);
 451
 452         return TAPI_API_SUCCESS;
 453 }
 454
 455 EXPORT_API char *tel_get_misc_me_sn_sync(TapiHandle *handle)
 456 {
 457         GVariant *dbus_result;
 458         char *sn = NULL;
 459         int result = 0;
 460
 461         dbg("Func Entrance");
 462
 463         if (!handle)
 464                 return NULL;
 465
 466         dbus_result = g_dbus_connection_call_sync(handle->dbus_connection,
 467                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 468                         "GetSerialNumber", NULL, NULL,
 469                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
 470
 471         g_variant_get (dbus_result, "(is)", &result, &sn);
 472
 473         return sn;
 474 }
 475
 476 EXPORT_API int tel_check_modem_power_status(TapiHandle *handle, int *result)
 477 {
 478         return tel_get_property_int(handle, TAPI_PROP_MODEM_POWER, result);
 479 }
 480
 481 EXPORT_API int tel_control_modem_dun_pin_ctrl(TapiHandle *handle, tapi_ps_btdun_pincontrol *pincontrol, tapi_response_cb callback, void *user_data)
 482 {
 483         struct tapi_resp_data *evt_cb_data = NULL;
 484         GVariant *param;
 485
 486         dbg("Func Entrance ");
 487
 488         if (!handle || !handle->dbus_connection || !pincontrol){
 489                 dbg("invalid parameter");
 490                 return TAPI_API_INVALID_INPUT;
 491         }
 492
 493         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 494
 495         param = g_variant_new("(ib)", pincontrol->signal, pincontrol->status);
 496
 497         g_dbus_connection_call(handle->dbus_connection,
 498                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_MODEM_INTERFACE,
 499                         "SetDunPinCtrl", param, NULL,
 500                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 501                         on_response_set_dun_pin_ctrl, evt_cb_data);
 502
 503         return TAPI_API_SUCCESS;
 504 }