test/dummy_plugin/dummy_plugin.cpp

   1 /* Copyright (c) 2010-2014 Samsung Electronics Co., Ltd. All rights reserved.
   2  *
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <maps_service.h>
  18 #include <maps_error.h>
  19 #include <maps_plugin.h>
  20 #include <maps_address.h>
  21 #include <maps_place_plugin.h>
  22 #include <maps_route_plugin.h>
  23 #include <glib.h>
  24
  25 #include <maps_object.h>
  26 using namespace maps;
  27
  28 static int dummy_geocode_request_id = 101;
  29 static char __provider_key[1024] = { 0 };
  30
  31 /*----------------------------------------------------------------------------*/
  32 /* Service API */
  33
  34 EXPORT_API int maps_plugin_init(maps_plugin_h *plugin)
  35 {
  36         return MAPS_ERROR_NONE;
  37 }
  38
  39 EXPORT_API int maps_plugin_shutdown(maps_plugin_h plugin)
  40 {
  41         return MAPS_ERROR_NONE;
  42 }
  43
  44 EXPORT_API int maps_plugin_get_info(maps_plugin_info_h *info)
  45 {
  46         /*g_print("\n\nplugin maps_plugin_get_info\n\n"); */
  47         maps_plugin_info_create(info);
  48         maps_plugin_info_set_provider_name(*info, "Maps Provider");
  49         return MAPS_ERROR_NONE;
  50 }
  51
  52 /*----------------------------------------------------------------------------*/
  53 /*
  54  * Maps API
  55  */
  56
  57 EXPORT_API int maps_plugin_set_provider_key(const char *map_key)
  58 {
  59         g_return_val_if_fail(map_key, MAPS_ERROR_INVALID_PARAMETER);
  60         g_snprintf(__provider_key, 1024, "%s", map_key);
  61         return MAPS_ERROR_NONE;
  62 }
  63
  64 EXPORT_API int maps_plugin_get_provider_key(char **map_key)
  65 {
  66         g_return_val_if_fail(map_key, MAPS_ERROR_INVALID_PARAMETER);
  67         *map_key = g_strndup(__provider_key, 1024);
  68         return MAPS_ERROR_NONE;
  69 }
  70
  71 EXPORT_API int maps_plugin_get_preference(maps_item_hashtable_h *preference)
  72 {
  73         return MAPS_ERROR_NONE;
  74 }
  75
  76 EXPORT_API int maps_plugin_set_preference(maps_item_hashtable_h preference)
  77 {
  78         return MAPS_ERROR_NONE;
  79 }
  80
  81 EXPORT_API int maps_plugin_is_service_supported(maps_service_e service,
  82                                                 bool *supported)
  83 {
  84         switch (service) {
  85         case MAPS_SERVICE_GEOCODE:
  86         case MAPS_SERVICE_GEOCODE_INSIDE_AREA:
  87         case MAPS_SERVICE_GEOCODE_BY_STRUCTURED_ADDRESS:
  88         case MAPS_SERVICE_REVERSE_GEOCODE:
  89         case MAPS_SERVICE_SEARCH_PLACE:
  90         case MAPS_SERVICE_SEARCH_PLACE_BY_AREA:
  91         case MAPS_SERVICE_SEARCH_PLACE_BY_ADDRESS:
  92         case MAPS_SERVICE_SEARCH_ROUTE:
  93         case MAPS_SERVICE_SEARCH_ROUTE_WAYPOINTS:
  94         case MAPS_SERVICE_CANCEL_REQUEST:
  95                 *supported = true;
  96                 return MAPS_ERROR_NONE;
  97         default:
  98                 *supported = false;
  99                 return MAPS_ERROR_NOT_SUPPORTED;
 100         }
 101 }
 102
 103 EXPORT_API int maps_plugin_is_data_supported(maps_service_data_e data,
 104                                              bool *supported)
 105 {
 106         switch (data) {
 107         case MAPS_PLACE_ADDRESS:
 108         case MAPS_PLACE_RATING:
 109         case MAPS_PLACE_CATEGORIES:
 110         case MAPS_PLACE_ATTRIBUTES:
 111         case MAPS_PLACE_CONTACTS:
 112         case MAPS_PLACE_EDITORIALS:
 113         case MAPS_PLACE_REVIEWS:
 114         case MAPS_PLACE_IMAGE:
 115         case MAPS_PLACE_SUPPLIER:
 116         case MAPS_PLACE_RELATED:
 117         case MAPS_ROUTE_PATH:
 118         case MAPS_ROUTE_SEGMENTS_PATH:
 119         case MAPS_ROUTE_SEGMENTS_MANEUVERS:
 120                 *supported = true;
 121                 return MAPS_ERROR_NONE;
 122         default:
 123                 *supported = false;
 124                 return MAPS_ERROR_NOT_SUPPORTED;
 125         }
 126 }
 127
 128
 129 EXPORT_API int maps_plugin_geocode(const char *address,
 130                                    const maps_item_hashtable_h preference,
 131                                    maps_service_geocode_cb callback,
 132                                    void *user_data, int *request_id)
 133 {
 134         g_return_val_if_fail(address, MAPS_ERROR_INVALID_PARAMETER);
 135         g_return_val_if_fail(callback, MAPS_ERROR_INVALID_PARAMETER);
 136         g_return_val_if_fail(request_id, MAPS_ERROR_INVALID_PARAMETER);
 137         /*g_return_val_if_fail(preference, MAPS_ERROR_INVALID_PARAMETER);*/
 138
 139         *request_id = dummy_geocode_request_id++;
 140
 141         /* For testing purposes */
 142         bool no_need_callback = false;
 143         maps_item_hashtable_contains(preference, "no_need_callback",
 144                 &no_need_callback);
 145         if (no_need_callback)
 146                 return MAPS_ERROR_NONE;
 147
 148         coordinates c(11.1, 22.2);
 149         callback(MAPS_ERROR_NONE, *request_id, 0, 1, c.clone(), user_data);
 150         return MAPS_ERROR_NONE;
 151 }
 152
 153 EXPORT_API int maps_plugin_geocode_inside_area(const char *address,
 154                                                const maps_area_h bounds,
 155                                                const maps_item_hashtable_h
 156                                                preference,
 157                                                maps_service_geocode_cb callback,
 158                                                void *user_data, int *request_id)
 159 {
 160         g_return_val_if_fail(address, MAPS_ERROR_INVALID_PARAMETER);
 161         g_return_val_if_fail(bounds, MAPS_ERROR_INVALID_PARAMETER);
 162         g_return_val_if_fail(callback, MAPS_ERROR_INVALID_PARAMETER);
 163         g_return_val_if_fail(request_id, MAPS_ERROR_INVALID_PARAMETER);
 164         /*g_return_val_if_fail(preference, MAPS_ERROR_INVALID_PARAMETER);*/
 165
 166         *request_id = dummy_geocode_request_id++;
 167
 168         /* For testing purposes */
 169         bool no_need_callback = false;
 170         maps_item_hashtable_contains(preference, "no_need_callback",
 171                 &no_need_callback);
 172         if (no_need_callback)
 173                 return MAPS_ERROR_NONE;
 174
 175         coordinates c(11.1, 22.2);
 176         callback(MAPS_ERROR_NONE, *request_id, 0, 1, c.clone(), user_data);
 177         return MAPS_ERROR_NONE;
 178 }
 179
 180 EXPORT_API int maps_plugin_geocode_by_structured_address(const maps_address_h
 181                                                          address,
 182                                                          const maps_preference_h
 183                                                          preference,
 184                                                         maps_service_geocode_cb
 185                                                         callback,
 186                                                         void *user_data,
 187                                                         int *request_id)
 188 {
 189         g_return_val_if_fail(address, MAPS_ERROR_INVALID_PARAMETER);
 190         g_return_val_if_fail(callback, MAPS_ERROR_INVALID_PARAMETER);
 191         g_return_val_if_fail(request_id, MAPS_ERROR_INVALID_PARAMETER);
 192         g_return_val_if_fail(preference, MAPS_ERROR_INVALID_PARAMETER);
 193
 194         *request_id = dummy_geocode_request_id++;
 195
 196         /* For testing purposes */
 197         bool no_need_callback = false;
 198         maps_item_hashtable_contains(preference, "no_need_callback",
 199                 &no_need_callback);
 200         if (no_need_callback)
 201                 return MAPS_ERROR_NONE;
 202
 203         coordinates c(11.1, 22.2);
 204         callback(MAPS_ERROR_NONE, *request_id, 0, 1, c.clone(), user_data);
 205         return MAPS_ERROR_NONE;
 206 }
 207
 208 EXPORT_API int maps_plugin_reverse_geocode(double latitude, double longitude,
 209                                            const maps_item_hashtable_h
 210                                            preference,
 211                                            maps_service_reverse_geocode_cb
 212                                            callback,
 213                                            void *user_data,
 214                                            int *request_id)
 215 {
 216         g_return_val_if_fail(request_id, MAPS_ERROR_INVALID_PARAMETER);
 217         g_return_val_if_fail(preference, MAPS_ERROR_INVALID_PARAMETER);
 218
 219         *request_id = dummy_geocode_request_id++;
 220
 221         /* For testing purposes */
 222         bool no_need_callback = false;
 223         maps_item_hashtable_contains(preference, "no_need_callback",
 224                 &no_need_callback);
 225         if (no_need_callback)
 226                 return MAPS_ERROR_NONE;
 227
 228         address a;
 229         maps_address_set_building_number(a, "12");
 230         maps_address_set_street(a, "Na Boyishti");
 231         callback(MAPS_ERROR_NONE, *request_id, 0, 1, a.clone(), user_data);
 232         return MAPS_ERROR_NONE;
 233 }
 234
 235 EXPORT_API int maps_plugin_search_place(const maps_coordinates_h position,
 236                                         int distance,
 237                                         const maps_place_filter_h filter,
 238                                         maps_preference_h preference,
 239                                         maps_service_search_place_cb callback,
 240                                         void *user_data, int *request_id)
 241 {
 242
 243         *request_id = dummy_geocode_request_id++;
 244
 245         /* For testing purposes */
 246         bool no_need_callback = false;
 247         maps_item_hashtable_contains(preference, "no_need_callback",
 248                 &no_need_callback);
 249         if (no_need_callback)
 250                 return MAPS_ERROR_NONE;
 251
 252         place p;
 253         maps_place_set_id(p, "1722/12");
 254         maps_place_set_name(p, "U Kalicha");
 255         callback(MAPS_ERROR_NONE, *request_id, 0, 1, p.clone(), user_data);
 256
 257         return MAPS_ERROR_NONE;
 258 }
 259
 260 EXPORT_API int maps_plugin_search_place_by_area(const maps_area_h boundary,
 261                                                 const maps_place_filter_h
 262                                                 filter,
 263                                                 maps_preference_h preference,
 264                                                 maps_service_search_place_cb
 265                                                 callback,
 266                                                 void *user_data,
 267                                                 int *request_id)
 268 {
 269
 270         *request_id = dummy_geocode_request_id++;
 271
 272         /* For testing purposes */
 273         bool no_need_callback = false;
 274         maps_item_hashtable_contains(preference, "no_need_callback",
 275                 &no_need_callback);
 276         if (no_need_callback)
 277                 return MAPS_ERROR_NONE;
 278
 279         place p;
 280         maps_place_set_id(p, "1722/12");
 281         maps_place_set_name(p, "U Kalicha");
 282         callback(MAPS_ERROR_NONE, *request_id, 0, 1, p.clone(), user_data);
 283         return MAPS_ERROR_NONE;
 284 }
 285
 286 EXPORT_API int maps_plugin_search_place_by_address(const char *address,
 287                                                    const maps_area_h boundary,
 288                                                    const maps_place_filter_h
 289                                                    filter,
 290                                                    maps_preference_h preference,
 291                                                    maps_service_search_place_cb
 292                                                    callback,
 293                                                    void *user_data,
 294                                                    int *request_id)
 295 {
 296
 297         *request_id = dummy_geocode_request_id++;
 298
 299         /* For testing purposes */
 300         bool no_need_callback = false;
 301         maps_item_hashtable_contains(preference, "no_need_callback",
 302                 &no_need_callback);
 303         if (no_need_callback)
 304                 return MAPS_ERROR_NONE;
 305
 306         place p;
 307         maps_place_set_id(p, "1722/12");
 308         maps_place_set_name(p, "U Kalicha");
 309         callback(MAPS_ERROR_NONE, *request_id, 0, 1, p.clone(), user_data);
 310         return MAPS_ERROR_NONE;
 311 }
 312
 313 EXPORT_API int maps_plugin_search_route(const maps_coordinates_h origin,
 314                                         const maps_coordinates_h destination,
 315                                         maps_preference_h preference,
 316                                         maps_service_search_route_cb callback,
 317                                         void *user_data,
 318                                         int *request_id)
 319 {
 320
 321         /*g_print("Maps Plugin Search Route\n\n"); */
 322         *request_id = dummy_geocode_request_id++;
 323
 324         /* For testing purposes */
 325         bool no_need_callback = false;
 326         maps_item_hashtable_contains(preference, "no_need_callback",
 327                 &no_need_callback);
 328         if (no_need_callback)
 329                 return MAPS_ERROR_NONE;
 330
 331         route route;
 332
 333         item_list <route_maneuver> maneuvers;
 334         route_maneuver m1, m2;
 335         maneuvers.add(m1);
 336         maneuvers.add(m2);
 337
 338         item_list <route_segment> segments;
 339         route_segment s1, s2;
 340
 341         maps_route_segment_set_origin(s1, coordinates(11.1, 12.1));
 342         maps_route_segment_set_destination(s1, coordinates(21.1, 22.1));
 343
 344         maps_route_segment_set_origin(s2, coordinates(11.1, 12.1));
 345         maps_route_segment_set_destination(s2, coordinates(21.1, 22.1));
 346
 347         maps_route_segment_set_maneuvers(s1, maneuvers);
 348         maps_route_segment_set_maneuvers(s2, maneuvers);
 349
 350         segments.add(s1);
 351         segments.add(s2);
 352         maps_route_set_segments(route, segments);
 353
 354         callback(MAPS_ERROR_NONE, *request_id, 0, 1, route.clone(), user_data);
 355         return MAPS_ERROR_NONE;
 356 }
 357
 358 EXPORT_API int maps_plugin_search_route_waypoints(const maps_coordinates_h *
 359                                                   waypoint_list,
 360                                                   int waypoint_num,
 361                                                   maps_preference_h preference,
 362                                                   maps_service_search_route_cb
 363                                                   callback,
 364                                                   void *user_data,
 365                                                   int *request_id)
 366 {
 367         *request_id = dummy_geocode_request_id++;
 368
 369         /* For testing purposes */
 370         bool no_need_callback = false;
 371         maps_item_hashtable_contains(preference, "no_need_callback",
 372                 &no_need_callback);
 373         if (no_need_callback)
 374                 return MAPS_ERROR_NONE;
 375
 376         route route;
 377
 378         item_list <route_maneuver> maneuvers;
 379         route_maneuver m1, m2;
 380         maneuvers.add(m1);
 381         maneuvers.add(m2);
 382
 383         item_list <route_segment> segments;
 384         route_segment s1, s2;
 385
 386         maps_route_segment_set_origin(s1, coordinates(11.1, 12.1));
 387         maps_route_segment_set_destination(s1, coordinates(21.1, 22.1));
 388
 389         maps_route_segment_set_origin(s2, coordinates(11.1, 12.1));
 390         maps_route_segment_set_destination(s2, coordinates(21.1, 22.1));
 391
 392         maps_route_segment_set_maneuvers(s1, maneuvers);
 393         maps_route_segment_set_maneuvers(s2, maneuvers);
 394
 395         segments.add(s1);
 396         segments.add(s2);
 397         maps_route_set_segments(route, segments);
 398
 399         callback(MAPS_ERROR_NONE, *request_id, 0, 1, route.clone(), user_data);
 400         return MAPS_ERROR_NONE;
 401 }
 402
 403 EXPORT_API int maps_plugin_cancel_request(int request_id)
 404 {
 405         return MAPS_ERROR_NONE;
 406 }