rhodes 2.2.6 → 2.3.0.beta.1

data/platform/shared/common/map/MapEngine.cpp

@@ -0,0 +1,304 @@
+#include "common/map/MapEngine.h"
+#include "common/map/GoogleMapEngine.h"
+#include "common/map/ESRIMapEngine.h"
+
+#include <algorithm>
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "MapEngine"
+
+namespace rho
+{
+namespace common
+{
+namespace map
+{
+
+MapProvider &MapProvider::getInstance()
+{
+    static MapProvider instance;
+    return instance;
+}
+
+MapProvider::MapProvider()
+{
+    // Initialize predefined engines
+    //registerMapEngine("google", new GoogleMapEngine());
+    registerMapEngine("esri", new ESRIMapEngine());
+}
+
+void MapProvider::registerMapEngine(String const &id, IMapEngine *engine)
+{
+    RAWTRACE2("Register map engine: id=%s, engine=%p", id.c_str(), engine);
+    IMapEngine *old = m_engines.get(id);
+    if (old)
+        delete old;
+    m_engines.put(id, engine);
+}
+
+void MapProvider::unregisterMapEngine(String const &id)
+{
+    RAWTRACE1("Unregister map engine: id=%s", id.c_str());
+    IMapEngine *engine = m_engines.get(id);
+    if (engine)
+        delete engine;
+    m_engines.remove(id);
+}
+
+IMapView *MapProvider::createMapView(String const &id, IDrawingDevice *device)
+{
+    IMapEngine *engine = m_engines.get(id);
+    if (!engine)
+        return 0;
+    IMapView *view = engine->createMapView(device);
+    if (!view)
+        return 0;
+    m_cache.put(view, engine);
+    return view;
+}
+
+void MapProvider::destroyMapView(IMapView *view)
+{
+    if (!view)
+        return;
+    IMapEngine *engine = m_cache.get(view);
+    if (!engine)
+        return;
+    m_cache.remove(view);
+    engine->destroyMapView(view);
+}
+
+String Annotation::make_address(double latitude, double longitude)
+{
+    char buf[128];
+    snprintf(buf, sizeof(buf), "%.5lf,%.5lf", latitude, longitude);
+    return buf;
+}
+
+} // namespace map
+} // namespace common
+} // namespace rho
+
+namespace rhomap = rho::common::map;
+
+rhomap::IMapView *rho_map_create(rho_param *p, rhomap::IDrawingDevice *device, int width, int height)
+{
+    if (!p || p->type != RHO_PARAM_HASH)
+        rho_ruby_raise_argerror("Wrong input parameter (expect Hash)");
+
+    rho_param *provider = NULL;
+    rho_param *settings = NULL;
+    rho_param *annotations = NULL;
+    for (int i = 0, lim = p->v.hash->size; i < lim; ++i)
+    {
+        char *name = p->v.hash->name[i];
+        rho_param *value = p->v.hash->value[i];
+        if (!name || !value)
+            continue;
+
+        if (strcasecmp(name, "provider") == 0)
+            provider = value;
+        else if (strcasecmp(name, "settings") == 0)
+            settings = value;
+        else if (strcasecmp(name, "annotations") == 0)
+            annotations = value;
+    }
+
+    std::string providerId = "google";
+    if (provider)
+    {
+        if (provider->type != RHO_PARAM_STRING)
+            rho_ruby_raise_argerror("Wrong 'provider' value (expect String)");
+        providerId = provider->v.string;
+    }
+    std::transform(providerId.begin(), providerId.end(), providerId.begin(), &::tolower);
+
+    char *map_type = NULL;
+    bool use_center_radius = false;
+    double latitude = 0;
+    double longitude = 0;
+    double latitudeSpan = 0;
+    double longitudeSpan = 0;
+    char *center = NULL;
+    double radius = 0;
+    bool zoom_enabled = true;
+    bool scroll_enabled = true;
+
+    if (settings)
+    {
+        if (settings->type != RHO_PARAM_HASH)
+            rho_ruby_raise_argerror("Wrong 'settings' value (expect Hash)");
+
+        for (int i = 0, lim = settings->v.hash->size; i < lim; ++i)
+        {
+            char *name = settings->v.hash->name[i];
+            rho_param *value = settings->v.hash->value[i];
+            if (!name || !value)
+                continue;
+
+            if (strcasecmp(name, "map_type") == 0)
+            {
+                if (value->type != RHO_PARAM_STRING)
+                    rho_ruby_raise_argerror("Wrong 'map_type' value (expect String)");
+                map_type = value->v.string;
+            }
+            else if (strcasecmp(name, "region") == 0)
+            {
+                if (value->type == RHO_PARAM_ARRAY)
+                {
+                    if (value->v.array->size != 4)
+                        rho_ruby_raise_argerror("'region' array should contain exactly 4 items");
+
+                    rho_param *lat = value->v.array->value[0];
+                    if (!lat) continue;
+                    rho_param *lon = value->v.array->value[1];
+                    if (!lon) continue;
+                    rho_param *latSpan = value->v.array->value[2];
+                    if (!latSpan) continue;
+                    rho_param *lonSpan = value->v.array->value[3];
+                    if (!lonSpan) continue;
+
+                    latitude = lat->type == RHO_PARAM_STRING ? strtod(lat->v.string, NULL) : 0;
+                    longitude = lon->type == RHO_PARAM_STRING ? strtod(lon->v.string, NULL) : 0;
+                    latitudeSpan = latSpan->type == RHO_PARAM_STRING ? strtod(latSpan->v.string, NULL) : 0;
+                    longitudeSpan = lonSpan->type == RHO_PARAM_STRING ? strtod(lonSpan->v.string, NULL) : 0;
+
+                    use_center_radius = false;
+                }
+                else if (value->type == RHO_PARAM_HASH)
+                {
+                    for (int j = 0, limm = value->v.hash->size; j < limm; ++j)
+                    {
+                        char *rname = value->v.hash->name[i];
+                        rho_param *rvalue = value->v.hash->value[i];
+                        if (!rname || !rvalue)
+                            continue;
+                        if (strcasecmp(rname, "center") == 0)
+                        {
+                            if (rvalue->type != RHO_PARAM_STRING)
+                                rho_ruby_raise_argerror("Wrong 'center' value (expect String)");
+                            center = rvalue->v.string;
+                        }
+                        else if (strcasecmp(rname, "radius") == 0)
+                        {
+                            if (rvalue->type != RHO_PARAM_STRING)
+                                rho_ruby_raise_argerror("Wrong 'radius' value (expect String or Float)");
+                            radius = strtod(rvalue->v.string, NULL);
+                        }
+                    }
+
+                    use_center_radius = true;
+                }
+                else
+                    rho_ruby_raise_argerror("Wrong 'region' value (expect Array or Hash");
+            }
+            else if (strcasecmp(name, "zoom_enabled") == 0)
+            {
+                if (value->type != RHO_PARAM_STRING)
+                    rho_ruby_raise_argerror("Wrong 'zoom_enabled' value (expect boolean)");
+                zoom_enabled = strcasecmp(value->v.string, "true") == 0;
+            }
+            else if (strcasecmp(name, "scroll_enabled") == 0)
+            {
+                if (value->type != RHO_PARAM_STRING)
+                    rho_ruby_raise_argerror("Wrong 'scroll_enabled' value (expect boolean)");
+                scroll_enabled = strcasecmp(value->v.string, "true") == 0;
+            }
+        }
+    }
+
+    typedef rhomap::Annotation ann_t;
+    typedef std::vector<ann_t> ann_list_t;
+    ann_list_t ann_list;
+    if (annotations)
+    {
+        if (annotations->type != RHO_PARAM_ARRAY)
+            rho_ruby_raise_argerror("Wrong 'annotations' value (expect Array)");
+        for (int i = 0, lim = annotations->v.array->size; i < lim; ++i)
+        {
+            rho_param *ann = annotations->v.array->value[i];
+            if (!ann)
+                continue;
+            if (ann->type != RHO_PARAM_HASH)
+                rho_ruby_raise_argerror("Wrong annotation value found (expect Hash)");
+
+            bool latitude_set = false;
+            double latitude = 0;
+            bool longitude_set = false;
+            double longitude = 0;
+            char const *address = "";
+            char const *title = "";
+            char const *subtitle = "";
+            char const *url = "";
+
+            for (int j = 0, limm = ann->v.hash->size; j < limm; ++j)
+            {
+                char *name = ann->v.hash->name[j];
+                rho_param *value = ann->v.hash->value[j];
+                if (!name || !value)
+                    continue;
+
+                if (value->type != RHO_PARAM_STRING)
+                    rho_ruby_raise_argerror("Wrong annotation value");
+
+                char *v = value->v.string;
+                if (strcasecmp(name, "latitude") == 0)
+                {
+                    latitude = strtod(v, NULL);
+                    latitude_set = true;
+                }
+                else if (strcasecmp(name, "longitude") == 0)
+                {
+                    longitude = strtod(v, NULL);
+                    longitude_set = true;
+                }
+                else if (strcasecmp(name, "street_address") == 0)
+                    address = v;
+                else if (strcasecmp(name, "title") == 0)
+                    title = v;
+                else if (strcasecmp(name, "subtitle") == 0)
+                    subtitle = v;
+                else if (strcasecmp(name, "url") == 0)
+                    url = v;
+            }
+
+            if (latitude_set && longitude_set)
+                ann_list.push_back(ann_t(title, subtitle, latitude, longitude, url));
+            else
+                ann_list.push_back(ann_t(title, subtitle, address, url));
+        }
+    }
+
+    rhomap::IMapView *mapview = RHOMAPPROVIDER().createMapView(providerId, device);
+    if (!mapview)
+        return NULL;
+
+    mapview->setSize(width, height);
+
+    if (map_type)
+        mapview->setMapType(map_type);
+
+    if (use_center_radius)
+    {
+        mapview->moveTo(center);
+        mapview->setZoom(radius, radius);
+    }
+    else
+    {
+        mapview->moveTo(latitude, longitude);
+        mapview->setZoom(latitudeSpan, longitudeSpan);
+    }
+
+    mapview->setZoomEnabled(zoom_enabled);
+    mapview->setScrollEnabled(scroll_enabled);
+
+    for (ann_list_t::const_iterator it = ann_list.begin(), lim = ann_list.end(); it != lim; ++it)
+        mapview->addAnnotation(*it);
+
+    return mapview;
+}
+
+void rho_map_destroy(rho::common::map::IMapView *mapview)
+{
+    RHOMAPPROVIDER().destroyMapView(mapview);
+}

data/platform/shared/common/map/MapEngine.h

@@ -0,0 +1,214 @@
+#ifndef _RHOMAPVIEW_H_
+#define _RHOMAPVIEW_H_
+
+#include "logging/RhoLog.h"
+#include "common/rhoparams.h"
+
+//#define RHO_MAP_DEBUG
+
+#ifdef RHO_MAP_DEBUG
+#   define RHO_MAP_TRACE(fmt) RAWTRACE(fmt)
+#   define RHO_MAP_TRACE1(fmt, arg1) RAWTRACE1(fmt, arg1)
+#   define RHO_MAP_TRACE2(fmt, arg1, arg2) RAWTRACE2(fmt, arg1, arg2)
+#   define RHO_MAP_TRACE3(fmt, arg1, arg2, arg3) RAWTRACE3(fmt, arg1, arg2, arg3)
+#   define RHO_MAP_TRACE4(fmt, arg1, arg2, arg3, arg4) RAWTRACE4(fmt, arg1, arg2, arg3, arg4)
+#else
+#   define RHO_MAP_TRACE(fmt)
+#   define RHO_MAP_TRACE1(fmt, arg1)
+#   define RHO_MAP_TRACE2(fmt, arg1, arg2)
+#   define RHO_MAP_TRACE3(fmt, arg1, arg2, arg3)
+#   define RHO_MAP_TRACE4(fmt, arg1, arg2, arg3, arg4)
+#endif
+
+namespace rho
+{
+namespace common
+{
+namespace map
+{
+
+class IDrawingImage
+{
+public:
+    virtual ~IDrawingImage() {}
+
+    virtual int width() const = 0;
+    virtual int height() const = 0;
+};
+
+class IDrawingDevice
+{
+public:
+    virtual ~IDrawingDevice(){}
+
+    virtual IDrawingImage* createImage(String const &path, bool useAlpha) = 0;
+    virtual IDrawingImage* createImage(void const *p, size_t s, bool useAlpha) = 0;
+    virtual IDrawingImage* cloneImage(IDrawingImage *image) = 0;
+    virtual void destroyImage(IDrawingImage* image) = 0;
+
+    virtual void requestRedraw() = 0;
+};
+
+class IDrawingContext
+{
+public:
+    virtual ~IDrawingContext(){}
+
+    virtual void drawImage(int x, int y, IDrawingImage *image) = 0;
+    virtual void drawText(int x, int y, int width, int height, String const &text, int color) = 0;
+	virtual void fillRect(int x, int y, int width, int height, int color) = 0;
+};
+
+typedef struct {
+	int x_offset;
+	int y_offset;
+	int click_rect_x;
+	int click_rect_y;
+	int click_rect_width;
+	int click_rect_height;
+}PIN_INFO;
+
+
+class Annotation
+{
+public:
+    Annotation(String const &title, String const &subtitle,
+        double latitude, double longitude, String const &address,
+        String const &url)
+        :m_title(title), m_subtitle(subtitle), m_resolved(true),
+        m_latitude(latitude), m_longitude(longitude),
+        m_address(address), m_url(url)
+    {}
+
+    Annotation(String const &title, String const &subtitle,
+        double latitude, double longitude, String const &url)
+        :m_title(title), m_subtitle(subtitle), m_resolved(true),
+        m_latitude(latitude), m_longitude(longitude),
+        m_address(make_address(latitude, longitude)), m_url(url)
+    {}
+
+    Annotation(String const &title, String const &subtitle,
+        String const &address, String const &url)
+        :m_title(title), m_subtitle(subtitle), m_resolved(false),
+        m_latitude(0), m_longitude(0),
+        m_address(address), m_url(url)
+    {}
+
+    String const &title() const {return m_title;}
+    String const &subtitle() const {return m_subtitle;}
+    bool resolved() const {return m_resolved;}
+    double latitude() const {return m_latitude;}
+    double longitude() const {return m_longitude;}
+    String const &address() const {return m_address;}
+    String const &url() const {return m_url;}
+
+private:
+    static String make_address(double latitude, double longitude);
+
+private:
+    String m_title;
+    String m_subtitle;
+    bool m_resolved;
+    double m_latitude;
+    double m_longitude;
+    String m_address;
+    String m_url;
+};
+
+class IMapView
+{
+public:
+    virtual ~IMapView() {}
+
+    virtual void setSize(int width, int height) = 0;
+    virtual int width() const = 0;
+    virtual int height() const = 0;
+
+    virtual void setZoomEnabled(bool v) = 0;
+    virtual bool zoomEnabled() const = 0;
+
+    virtual void setScrollEnabled(bool v) = 0;
+    virtual bool scrollEnabled() const = 0;
+
+    virtual void setMapType(String const &type) = 0;
+    virtual String const &mapType() const = 0;
+
+    virtual void setZoom(int zoom) = 0;
+    virtual void setZoom(double latDelta, double lonDelta) = 0;
+    virtual int zoom() const = 0;
+    virtual int minZoom() const = 0;
+    virtual int maxZoom() const = 0;
+
+    virtual void moveTo(double latitude, double longitude) = 0;
+    virtual void moveTo(String const &address) = 0;
+    virtual void move(int dx, int dy) = 0;
+    virtual double latitude() const = 0;
+    virtual double longitude() const = 0;
+
+    virtual void addAnnotation(Annotation const &ann) = 0;
+
+    // Return true if this MapView need to be closed
+    virtual bool handleClick(int x, int y) = 0;
+
+    virtual void paint(IDrawingContext *device) = 0;
+
+    virtual void setPinImage(IDrawingImage *pin, PIN_INFO pin_info) = 0;
+    virtual void setPinCalloutImage(IDrawingImage *pinCallout, PIN_INFO pin_callout_info) = 0;
+    virtual void setPinCalloutLinkImage(IDrawingImage *pinCallout, PIN_INFO pin_callout_info) = 0;
+
+};
+
+class GeoCodingCallback
+{
+public:
+    virtual void onError(String const &description) = 0;
+    virtual void onSuccess(double latitude, double longitude) = 0;
+};
+
+class IGeoCoding
+{
+public:
+    virtual ~IGeoCoding() {}
+
+    //virtual void stop() = 0;
+
+    virtual void resolve(String const &address, GeoCodingCallback *callback) = 0;
+};
+
+class IMapEngine
+{
+public:
+    virtual IMapView *createMapView(IDrawingDevice *drawingDevice) = 0;
+    virtual void destroyMapView(IMapView *view) = 0;
+};
+
+class MapProvider
+{
+private:
+    MapProvider();
+
+public:
+    static MapProvider &getInstance();
+
+    void registerMapEngine(String const &id, IMapEngine *engine);
+    void unregisterMapEngine(String const &id);
+
+    IMapView *createMapView(String const &id, IDrawingDevice *device);
+    void destroyMapView(IMapView *view);
+
+private:
+    Hashtable<String, IMapEngine *> m_engines;
+    Hashtable<IMapView *, IMapEngine *> m_cache;
+};
+
+} // namespace map
+} // namespace common
+} // namespace rho
+
+inline rho::common::map::MapProvider &RHOMAPPROVIDER() {return rho::common::map::MapProvider::getInstance();}
+
+rho::common::map::IMapView *rho_map_create(rho_param *p, rho::common::map::IDrawingDevice *device, int width, int height);
+void rho_map_destroy(rho::common::map::IMapView *mapview);
+
+#endif
+