src/mapzen/mapzen_api.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   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 extern "C" {
  18 #include "mapzen_queue.h"
  19 #include "mapzen_debug.h"
  20 #include "mapzen_util.h"
  21 }
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include "mapzen_api.hpp"
  26 #include "mapzen_server_private.h"
  27 #include "tangram_view.hpp"
  28
  29 int mapzen_init()
  30 {
  31         int ret = mapzen_init_queue();
  32
  33         return ret;
  34 }
  35
  36 int mapzen_shutdown()
  37 {
  38         int ret = mapzen_deinit_queue();
  39
  40         return ret;
  41 }
  42
  43 int mapzen_geocode(mapzen_geocode_req_s *req_details, mapzen_geocode_cb callback, int request_id, void *user_data)
  44 {
  45         int ret = MAPZEN_ERROR_NONE;
  46         ret = start_geocode_service(req_details, callback, request_id, user_data);
  47
  48         return ret;
  49 }
  50
  51 int mapzen_cancel_request(int request_id)
  52 {
  53         int ret = remove_from_request_list(request_id);
  54
  55         return ret;
  56 }
  57
  58 int mapzen_reverse_geocode(mapzen_revgeocode_req_s *req_details, mapzen_reverse_geocode_cb callback, int request_id, void *user_data)
  59 {
  60         int ret = MAPZEN_ERROR_NONE;
  61         ret = start_reversegeocode_service(req_details, callback, request_id, user_data);
  62
  63         return ret;
  64 }
  65
  66 int mapzen_search_place(mapzen_search_req_s *req_details, mapzen_place_search_cb callback, int request_id, void *user_data)
  67 {
  68         int ret = MAPZEN_ERROR_NONE;
  69         ret = start_place_service(req_details, callback, request_id, user_data);
  70
  71         return ret;
  72 }
  73
  74 int mapzen_get_place_details(mapzen_get_details_req_s *req_details, mapzen_get_place_details_cb callback, int request_id, void *user_data)
  75 {
  76         int ret = MAPZEN_ERROR_NONE;
  77         ret = start_place_details_service(req_details, callback, request_id, user_data);
  78
  79         return ret;
  80 }
  81
  82 int mapzen_search_place_list(mapzen_search_req_s *req_details, mapzen_place_list_search_cb callback, int request_id, void *user_data)
  83 {
  84         int ret = MAPZEN_ERROR_NONE;
  85         ret = start_places_list_service(req_details, callback, request_id, user_data);
  86
  87         return ret;
  88 }
  89
  90 int mapzen_start_route(mapzen_route_req_s *req_details, mapzen_route_cb callback, int request_id, void *user_data)
  91 {
  92         int ret = MAPZEN_ERROR_NONE;
  93         ret = start_route_service(req_details, callback, request_id, user_data);
  94
  95         return ret;
  96 }
  97
  98 int mapzen_create_map_view(maps_view_h hView, maps_plugin_map_view_ready_cb pCbFunc, const char* providerKey)
  99 {
 100         TangramView* tv = new TangramView();
 101         if (!tv) {
 102                 return MAPZEN_ERROR_OUT_OF_MEMORY;
 103         }
 104         TangramView* old_tv = nullptr;
 105         maps_view_get_maps_plugin_view_handle(hView, (void**)&old_tv);
 106         maps_view_set_maps_plugin_view_handle(hView, tv);
 107         if (old_tv) {
 108                 delete old_tv;
 109         }
 110         return tv->create(hView, pCbFunc, providerKey);
 111 }
 112
 113 int mapzen_destroy_map_view(maps_view_h hView)
 114 {
 115         TangramView* tv = nullptr;
 116         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 117         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 118         if (error == MAPZEN_ERROR_NONE && tv) {
 119                 maps_view_set_maps_plugin_view_handle(hView, nullptr);
 120                 error = tv->destroy(hView);
 121         }
 122         return error;
 123 }
 124
 125 int mapzen_render_map(maps_view_h hView, const maps_coordinates_h coordinates, double zoom_factor, double rotation_angle)
 126 {
 127         TangramView* tv = nullptr;
 128         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 129         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 130         if (error == MAPZEN_ERROR_NONE && tv) {
 131                 error = tv->render(hView, coordinates, zoom_factor, rotation_angle);
 132         }
 133         return error;
 134 }
 135
 136 int mapzen_move_center(maps_view_h hView, int delta_x, int delta_y)
 137 {
 138         TangramView* tv = nullptr;
 139         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 140         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 141         if (error == MAPZEN_ERROR_NONE && tv) {
 142                 error = tv->moveCenter(hView, delta_x, delta_y);
 143         }
 144         return error;
 145 }
 146
 147 int mapzen_set_scalebar(maps_view_h hView, bool enable)
 148 {
 149         TangramView* tv = nullptr;
 150         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 151         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 152         if (error == MAPZEN_ERROR_NONE && tv) {
 153                 error = tv->setScalebarEnabled(hView, enable);
 154         }
 155         return error;
 156 }
 157
 158 int mapzen_get_scalebar(maps_view_h hView, bool *enabled)
 159 {
 160         TangramView* tv = nullptr;
 161         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 162         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 163         if (error == MAPZEN_ERROR_NONE && tv) {
 164                 error = tv->getScalebarEnabled(hView, enabled);
 165         }
 166         return error;
 167 }
 168
 169 int mapzen_on_view_object(maps_view_h hView, const maps_view_object_h object, maps_view_object_operation_e operation)
 170 {
 171         TangramView* tv = nullptr;
 172         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 173         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 174         if (error == MAPZEN_ERROR_NONE && tv) {
 175                 error = tv->onViewObject(hView, object, operation);
 176         }
 177         return error;
 178 }
 179
 180 int mapzen_screen_to_geography(maps_view_h hView, int x, int y, maps_coordinates_h *mapsCoord)
 181 {
 182         TangramView* tv = nullptr;
 183         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 184         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 185         if (error == MAPZEN_ERROR_NONE && tv) {
 186                 error = tv->convertScreenToGeolocation(hView, x, y, mapsCoord);
 187         }
 188         return error;
 189 }
 190
 191 int mapzen_geography_to_screen(maps_view_h hView, const maps_coordinates_h mapsCoord, int* x, int* y)
 192 {
 193         TangramView* tv = nullptr;
 194         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 195         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 196         if (error == MAPZEN_ERROR_NONE && tv) {
 197                 error = tv->convertGeolocationToScreen(hView, mapsCoord, x, y);
 198         }
 199         return error;
 200 }
 201
 202 int mapzen_get_min_zoom_level(maps_view_h hView, int *min_zoom_level)
 203 {
 204         TangramView* tv = nullptr;
 205         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 206         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 207         if (error == MAPZEN_ERROR_NONE && tv) {
 208                 error = tv->getMinZoomLevel(hView, min_zoom_level);
 209         }
 210         return error;
 211 }
 212
 213 int mapzen_get_max_zoom_level(maps_view_h hView, int *max_zoom_level)
 214 {
 215         TangramView* tv = nullptr;
 216         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 217         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 218         if (error == MAPZEN_ERROR_NONE && tv) {
 219                 error = tv->getMaxZoomLevel(hView, max_zoom_level);
 220         }
 221         return error;
 222 }
 223
 224 int mapzen_get_center(maps_view_h hView, maps_coordinates_h *center)
 225 {
 226         TangramView* tv = nullptr;
 227         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 228         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 229         if (error == MAPZEN_ERROR_NONE && tv) {
 230                 error = tv->getCenter(hView, center);
 231         }
 232         return error;
 233 }
 234
 235 int mapzen_capture_snapshot(maps_view_h hView, void **data, int *width, int *height, maps_view_colorspace_type_e *cs)
 236 {
 237         TangramView* tv = nullptr;
 238         int maps_error = maps_view_get_maps_plugin_view_handle(hView, (void**)&tv);
 239         mapzen_error_e error = (mapzen_error_e)convert_maps_error_to_mapzen_error(maps_error);
 240         if (error == MAPZEN_ERROR_NONE && tv) {
 241                 error = tv->captureSnapshot(hView, data, width, height, cs);
 242         }
 243         return error;
 244 }
 245