location/manager/location.c

   1 /*
   2  * libslp-location
   3  *
   4  * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Youngae Kang <youngae.kang@samsung.com>, Yunhan Kim <yhan.kim@samsung.com>,
   7  *          Genie Kim <daejins.kim@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <pthread.h>
  28 #include <dbus/dbus-glib.h>
  29
  30 #include "location.h"
  31 #include "location-log.h"
  32 #include "location-setting.h"
  33 #include "location-ielement.h"
  34 #include "location-hybrid.h"
  35 #include "location-gps.h"
  36 #include "location-wps.h"
  37 #include "location-cps.h"
  38 #include "location-position.h"
  39 #include "map-service.h"
  40 #include "module-internal.h"
  41 #include "location-common-util.h"
  42
  43 EXPORT_API
  44 int location_init (void)
  45 {
  46         LOCATION_LOGD("location_init");
  47         g_type_init ();
  48
  49 #if !GLIB_CHECK_VERSION (2, 31, 0)
  50         if (!g_thread_supported()) g_thread_init (NULL);
  51 #endif
  52         dbus_g_thread_init ();
  53         if( FALSE == module_init() )
  54                 return LOCATION_ERROR_NOT_AVAILABLE;
  55
  56         return LOCATION_ERROR_NONE;
  57 }
  58
  59 EXPORT_API LocationObject*
  60 location_new (LocationMethod method)
  61 {
  62         LocationObject *self = NULL;
  63
  64         switch (method) {
  65                 case LOCATION_METHOD_HYBRID:
  66                         self = g_object_new (LOCATION_TYPE_HYBRID, NULL);
  67                         break;
  68                 case LOCATION_METHOD_GPS:
  69                         self = g_object_new (LOCATION_TYPE_GPS, NULL);
  70                         break;
  71                 case LOCATION_METHOD_WPS:
  72                         self = g_object_new (LOCATION_TYPE_WPS, NULL);
  73                         break;
  74                 case LOCATION_METHOD_CPS:
  75                         self = g_object_new (LOCATION_TYPE_CPS, NULL);
  76                         break;
  77                 default:
  78                         break;
  79         }
  80         return self;
  81 }
  82
  83 EXPORT_API int
  84 location_free (LocationObject *obj)
  85 {
  86         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  87
  88         g_object_unref (obj);
  89         return LOCATION_ERROR_NONE;
  90 }
  91
  92 EXPORT_API int
  93 location_start (LocationObject *obj)
  94 {
  95         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  96         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
  97         if (FALSE == location_application_enabled()) {
  98                 LOCATION_LOGD("Application dose not have permission");
  99                 return LOCATION_ERROR_NOT_ALLOWED;
 100         }
 101         return location_ielement_start (LOCATION_IELEMENT(obj));
 102 }
 103
 104 EXPORT_API int
 105 location_stop (LocationObject *obj)
 106 {
 107         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 108         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 109         return location_ielement_stop (LOCATION_IELEMENT(obj));
 110 }
 111
 112 EXPORT_API gboolean
 113 location_is_supported_method(LocationMethod method)
 114 {
 115         gboolean is_supported = FALSE;
 116
 117         switch(method) {
 118         case LOCATION_METHOD_HYBRID:
 119                 if(module_is_supported("gps") || module_is_supported("wps"))
 120                         is_supported = TRUE;
 121                 break;
 122         case LOCATION_METHOD_GPS:
 123                 is_supported = module_is_supported("gps");
 124                 break;
 125         case LOCATION_METHOD_WPS:
 126                 is_supported = module_is_supported("wps");
 127                 break;
 128         case LOCATION_METHOD_CPS:
 129                 is_supported = module_is_supported("cps");
 130                 break;
 131         default:
 132                 break;
 133         }
 134
 135         return is_supported;
 136 }
 137
 138 EXPORT_API gboolean
 139 location_is_enabled_gps(LocationObject *obj)
 140 {
 141         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 142         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 143
 144         return (gboolean) location_setting_get_int(VCONFKEY_LOCATION_ENABLED);
 145 }
 146
 147 EXPORT_API int
 148 location_get_position (LocationObject *obj,
 149         LocationPosition **position,
 150         LocationAccuracy **accuracy)
 151 {
 152         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 153         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 154         g_return_val_if_fail (position, LOCATION_ERROR_PARAMETER);
 155         g_return_val_if_fail (accuracy, LOCATION_ERROR_PARAMETER);
 156         return location_ielement_get_position (LOCATION_IELEMENT(obj), position, accuracy);
 157 }
 158
 159 EXPORT_API int
 160 location_get_last_position (LocationObject *obj,
 161         LocationPosition **position,
 162         LocationAccuracy **accuracy)
 163 {
 164         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 165         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 166         g_return_val_if_fail (position, LOCATION_ERROR_PARAMETER);
 167         g_return_val_if_fail (accuracy, LOCATION_ERROR_PARAMETER);
 168         return location_ielement_get_last_position (LOCATION_IELEMENT(obj), position, accuracy);
 169 }
 170
 171 EXPORT_API int
 172 location_get_satellite (LocationObject *obj, LocationSatellite **satellite)
 173 {
 174         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 175         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 176         g_return_val_if_fail (satellite, LOCATION_ERROR_PARAMETER);
 177
 178         return location_ielement_get_satellite (LOCATION_IELEMENT(obj), satellite);
 179 }
 180
 181 EXPORT_API int
 182 location_get_last_satellite (LocationObject *obj, LocationSatellite **satellite)
 183 {
 184         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 185         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 186         g_return_val_if_fail (satellite, LOCATION_ERROR_PARAMETER);
 187
 188         return location_ielement_get_last_satellite (LOCATION_IELEMENT(obj), satellite);
 189 }
 190
 191 EXPORT_API int
 192 location_get_velocity (LocationObject *obj,
 193         LocationVelocity **velocity,
 194         LocationAccuracy **accuracy)
 195 {
 196         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 197         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 198         g_return_val_if_fail (velocity, LOCATION_ERROR_PARAMETER);
 199         g_return_val_if_fail (accuracy, LOCATION_ERROR_PARAMETER);
 200
 201         return location_ielement_get_velocity (LOCATION_IELEMENT(obj), velocity, accuracy);
 202 }
 203
 204 EXPORT_API int
 205 location_get_last_velocity (LocationObject *obj,
 206         LocationVelocity **velocity,
 207         LocationAccuracy **accuracy)
 208 {
 209         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 210         g_return_val_if_fail (G_OBJECT_TYPE(obj) != MAP_TYPE_SERVICE, LOCATION_ERROR_PARAMETER);
 211         g_return_val_if_fail (velocity, LOCATION_ERROR_PARAMETER);
 212         g_return_val_if_fail (accuracy, LOCATION_ERROR_PARAMETER);
 213
 214         return location_ielement_get_last_velocity (LOCATION_IELEMENT(obj), velocity, accuracy);
 215 }
 216
 217
 218 EXPORT_API int
 219 location_send_command(const char *cmd)
 220 {
 221         g_return_val_if_fail (cmd, LOCATION_ERROR_PARAMETER);
 222
 223         return LOCATION_ERROR_NONE;
 224 }
 225