wearable/src/tapi_gps.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2012 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 "common.h"
  29 #include "tapi_log.h"
  30 #include "ITapiGps.h"
  31
  32 static void on_response_default_set(GObject *source_object, GAsyncResult *res, gpointer user_data)
  33 {
  34         GError *error = NULL;
  35         GDBusConnection *conn = NULL;
  36         struct tapi_resp_data *evt_cb_data = user_data;
  37         int result = -1;
  38
  39         GVariant *dbus_result;
  40
  41         conn = G_DBUS_CONNECTION (source_object);
  42         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  43         CHECK_DEINIT(error);
  44
  45         if (!dbus_result) {
  46                 if (evt_cb_data->cb_fn) {
  47                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  48                 }
  49
  50                 if (error)
  51                         g_error_free(error);
  52
  53                 g_free(evt_cb_data);
  54                 return;
  55         }
  56
  57
  58         g_variant_get (dbus_result, "(i)", &result);
  59
  60         if (evt_cb_data->cb_fn) {
  61                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
  62         }
  63
  64         g_free(evt_cb_data);
  65 }
  66
  67
  68 EXPORT_API int tel_set_gps_frequency_aiding(TapiHandle *handle, unsigned char state, tapi_response_cb callback, void *user_data)
  69 {
  70         struct tapi_resp_data *evt_cb_data = NULL;
  71         GVariant *param;
  72
  73         dbg("Func Entrance");
  74
  75         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
  76
  77         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
  78
  79         param = g_variant_new("(y)", state);
  80
  81         g_dbus_connection_call(handle->dbus_connection,
  82                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
  83                         "SetFrequencyAiding", param, NULL,
  84                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
  85                         on_response_default_set, evt_cb_data);
  86
  87         return TAPI_API_SUCCESS;
  88 }
  89
  90 EXPORT_API int tel_confirm_gps_measure_pos(TapiHandle *handle, unsigned char *data, unsigned int data_len)
  91 {
  92         GVariant *param = NULL;
  93         GVariant *rst = NULL;
  94         GError *gerr = 0;
  95         gchar *encoded_data = NULL;
  96         gint result;
  97
  98         dbg("Func Entrance");
  99
 100         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 101         TAPI_RET_ERR_NUM_IF_FAIL(handle->dbus_connection, TAPI_API_INVALID_INPUT);
 102         TAPI_RET_ERR_NUM_IF_FAIL(data, TAPI_API_INVALID_PTR);
 103
 104         msg("call tel_confirm_gps_measure_pos(). data_len=%d", data_len);
 105         encoded_data = g_base64_encode((const guchar*)data, data_len);
 106
 107         param = g_variant_new("(s)", encoded_data);
 108
 109         rst = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE , handle->path,
 110                         DBUS_TELEPHONY_GPS_INTERFACE, "ConfirmMeasurePos", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
 111
 112         g_free(encoded_data);
 113
 114         if(!rst){
 115                 dbg( "error to gps measure pos confirm(%s)", gerr->message);
 116                 g_error_free (gerr);
 117                 return TAPI_API_OPERATION_FAILED;
 118         }
 119         dbg("send gps user confirm format(%s)", g_variant_get_type_string(rst));
 120
 121         g_variant_get(rst, "(i)", &result);
 122         dbg("result (%d)", result);
 123
 124         return TAPI_API_SUCCESS;
 125 }
 126
 127 EXPORT_API int tel_enable_smart_assistant(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 128 {
 129         struct tapi_resp_data *evt_cb_data = NULL;
 130
 131         dbg("Func Entrance");
 132
 133         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 134
 135         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 136
 137         g_dbus_connection_call(handle->dbus_connection,
 138                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
 139                         "EnableSmartAssistant", NULL, NULL,
 140                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 141                         on_response_default_set, evt_cb_data);
 142
 143         return TAPI_API_SUCCESS;
 144 }
 145
 146 EXPORT_API int tel_disable_smart_assistant(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 147 {
 148         struct tapi_resp_data *evt_cb_data = NULL;
 149
 150         dbg("Func Entrance");
 151
 152         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 153
 154         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 155
 156         g_dbus_connection_call(handle->dbus_connection,
 157                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
 158                         "DisableSmartAssistant", NULL, NULL,
 159                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 160                         on_response_default_set, evt_cb_data);
 161
 162         return TAPI_API_SUCCESS;
 163 }
 164
 165 EXPORT_API int tel_sync_smart_assistant_area_list(TapiHandle *handle, TelSmartAssistantAreaList_t *area_list, tapi_response_cb callback, void *user_data)
 166 {
 167         struct tapi_resp_data *evt_cb_data = NULL;
 168         GVariant *param = NULL, *inparam = NULL;
 169         GVariantBuilder *b;
 170         unsigned int i;
 171
 172         TAPI_RET_ERR_NUM_IF_FAIL(area_list, TAPI_API_INVALID_PTR);
 173         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 174
 175         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 176         dbg("count:%d", area_list->count);
 177
 178         b = g_variant_builder_new(G_VARIANT_TYPE ("a(ii)"));
 179
 180         for (i = 0; i < area_list->count; i++) {
 181                 g_variant_builder_add(b, "(ii)", area_list->area[i].index, area_list->area[i].mode_state);
 182         }
 183
 184         inparam = g_variant_builder_end(b);
 185         param = g_variant_new("(iv)", area_list->count, inparam);
 186
 187         g_dbus_connection_call(handle->dbus_connection,
 188                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
 189                         "SyncSmartAssistantAreaList", param, NULL,
 190                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 191                         on_response_default_set, evt_cb_data);
 192
 193         return TAPI_API_SUCCESS;
 194 }
 195
 196 EXPORT_API int tel_del_smart_assistant_area_list(TapiHandle *handle, TelSmartAssistantAreaList_t *area_list, tapi_response_cb callback, void *user_data)
 197 {
 198         struct tapi_resp_data *evt_cb_data = NULL;
 199         GVariant *param = NULL, *inparam = NULL;
 200         GVariantBuilder *b;
 201         unsigned int i;
 202
 203         TAPI_RET_ERR_NUM_IF_FAIL(area_list, TAPI_API_INVALID_PTR);
 204         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 205
 206         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 207         dbg("count:%d", area_list->count);
 208
 209         b = g_variant_builder_new(G_VARIANT_TYPE ("a(ii)"));
 210
 211         for (i = 0; i < area_list->count; i++) {
 212                 g_variant_builder_add(b, "(ii)", area_list->area[i].index, area_list->area[i].mode_state);
 213         }
 214
 215         inparam = g_variant_builder_end(b);
 216         param = g_variant_new("(iv)", area_list->count, inparam);
 217
 218         g_dbus_connection_call(handle->dbus_connection,
 219                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
 220                         "DelSmartAssistantAreaList", 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 EXPORT_API int tel_add_smart_assistant_area(TapiHandle *handle, TelSmartAssistantArea_t *area, tapi_response_cb callback, void *user_data)
 228 {
 229         struct tapi_resp_data *evt_cb_data = NULL;
 230         GVariant *param;
 231
 232         TAPI_RET_ERR_NUM_IF_FAIL(area, TAPI_API_INVALID_PTR);
 233         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 234
 235         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 236
 237         param = g_variant_new("(ii)",
 238                         area->index,
 239                         area->mode_state);
 240
 241         g_dbus_connection_call(handle->dbus_connection,
 242                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
 243                         "AddSmartAssistantArea", param, NULL,
 244                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 245                         on_response_default_set, evt_cb_data);
 246
 247         return TAPI_API_SUCCESS;
 248 }
 249
 250 EXPORT_API int tel_modify_smart_assistant_area(TapiHandle *handle, TelSmartAssistantArea_t *area, tapi_response_cb callback, void *user_data)
 251 {
 252         struct tapi_resp_data *evt_cb_data = NULL;
 253         GVariant *param;
 254
 255         TAPI_RET_ERR_NUM_IF_FAIL(area, TAPI_API_INVALID_PTR);
 256         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 257
 258         dbg("index:%d, mode_state:%d", area->index, area->mode_state);
 259
 260         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 261
 262         param = g_variant_new("(ii)",
 263                         area->index,
 264                         area->mode_state);
 265
 266         g_dbus_connection_call(handle->dbus_connection,
 267                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
 268                         "ModifySmartAssistantArea", param, NULL,
 269                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 270                         on_response_default_set, evt_cb_data);
 271
 272         return TAPI_API_SUCCESS;
 273 }
 274
 275 EXPORT_API int tel_set_smart_assistant_info(TapiHandle *handle, TelSmartAssistantInfo_t *info, tapi_response_cb callback, void *user_data)
 276 {
 277         struct tapi_resp_data *evt_cb_data = NULL;
 278         GVariant *param;
 279
 280         TAPI_RET_ERR_NUM_IF_FAIL(info, TAPI_API_INVALID_PTR);
 281         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 282
 283         dbg("index:%d, lpp_state:%d", info->index, info->lpp_state);
 284
 285         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 286
 287         param = g_variant_new("(ii)",
 288                         info->index,
 289                         info->lpp_state);
 290
 291         g_dbus_connection_call(handle->dbus_connection,
 292                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_GPS_INTERFACE,
 293                         "SetSmartAssistantInfo", 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