rhodes 2.2.6 → 2.3.0.beta.1

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

@@ -0,0 +1,255 @@
+#ifndef _RHOESRIMAPENGINE_H_
+#define _RHOESRIMAPENGINE_H_
+
+#include "common/map/MapEngine.h"
+#include "common/RhoThread.h"
+#include "common/ThreadQueue.h"
+
+#include <list>
+
+namespace rho
+{
+namespace common
+{
+namespace map
+{
+
+class ESRIMapView : public IMapView
+{
+private:
+    // Non-copyable class
+    ESRIMapView(ESRIMapView const &);
+    ESRIMapView &operator=(ESRIMapView const &);
+
+    // Helper classes
+    class Tile
+    {
+    public:
+        Tile(IDrawingDevice *device, int z, uint64 lat, uint64 lon);
+        Tile(IDrawingDevice *device, int z, uint64 lat, uint64 lon, void *data, size_t datasize);
+        Tile(Tile const &c);
+        ~Tile();
+
+        Tile &operator=(Tile const &c);
+
+        int zoom() const {return m_zoom;}
+        uint64 latitude() const {return m_latitude;}
+        uint64 longitude() const {return m_longitude;}
+        IDrawingImage *image() const {return m_image;}
+
+    private:
+        void swap(Tile &tile);
+
+    private:
+        IDrawingDevice *m_device;
+        int m_zoom;
+        uint64 m_latitude;
+        uint64 m_longitude;
+        IDrawingImage *m_image;
+    };
+
+    class TilesCache
+    {
+    public:
+        typedef std::list<Tile> list;
+        typedef std::list<Tile>::const_iterator iterator;
+
+    public:
+        list clone() const;
+
+        bool empty() const {return m_tiles.empty();}
+
+        void put(Tile const &tile);
+        Tile const *get(int zoom, uint64 latitude, uint64 longitude) const;
+        std::map<String, Tile *>& get_by_coordinates(){ return m_by_coordinates; }
+        std::list<Tile>& get_tiles(){ return m_tiles; }
+
+    private:
+        static String makeKey(int zoom, uint64 latitude, uint64 longitude);
+
+    private:
+        std::list<Tile> m_tiles;
+        std::map<String, Tile *> m_by_coordinates;
+    };
+
+    class MapFetch : public CThreadQueue
+    {
+        DEFINE_LOGCLASS;
+
+    private:
+        MapFetch(MapFetch const &);
+        MapFetch &operator=(MapFetch const &);
+
+        struct Command : public IQueueCommand
+        {
+            Command(String const &u, int z, uint64 lat, uint64 lon)
+                :baseUrl(u), zoom(z), latitude(lat), longitude(lon)
+            {}
+
+            String baseUrl;
+            int zoom;
+            uint64 latitude;
+            uint64 longitude;
+
+            bool equals(IQueueCommand const &) {return false;}
+            String toString();
+        };
+
+    public:
+        MapFetch(ESRIMapView *view);
+        ~MapFetch();
+
+        void fetchTile(String const &baseUrl, int zoom, uint64 latitude, uint64 longitude);
+
+    private:
+        void processCommand(IQueueCommand *cmd);
+        bool fetchData(String const &url, void **data, size_t *datasize);
+
+    private:
+        ESRIMapView *m_mapview;
+        std::auto_ptr<net::INetRequest> m_net_request;
+    };
+
+    friend class CacheUpdate;
+    class CacheUpdate : public CThreadQueue
+    {
+        DEFINE_LOGCLASS;
+    private:
+        CacheUpdate(CacheUpdate const &);
+        CacheUpdate &operator=(CacheUpdate const &);
+
+        struct Command : public IQueueCommand
+        {
+            Command() {}
+
+            bool equals(IQueueCommand const &) {return false;}
+            String toString() {return "CACHE-UPDATE";}
+        };
+
+    public:
+        CacheUpdate(ESRIMapView *);
+        ~CacheUpdate();
+
+        void updateCache();
+
+    private:
+        void processCommand(IQueueCommand *cmd);
+
+    private:
+        ESRIMapView *m_mapview;
+    };
+
+public:
+    ESRIMapView(IDrawingDevice *device);
+    ~ESRIMapView();
+
+    void setSize(int width, int height);
+    int width() const {return m_width;}
+    int height() const {return m_height;}
+
+    void setZoomEnabled(bool v) {m_zoom_enabled = v;}
+    bool zoomEnabled() const {return m_zoom_enabled;}
+
+    void setScrollEnabled(bool v) {m_scroll_enabled = v;}
+    bool scrollEnabled() const {return m_scroll_enabled;}
+
+    void setMapType(String const &type);
+    String const &mapType() const {return m_maptype;}
+
+    void setZoom(int zoom);
+    void setZoom(double latDelta, double lonDelta);
+    int zoom() const {return m_zoom;}
+    int minZoom() const;
+    int maxZoom() const;
+
+    void moveTo(double latitude, double longitude);
+    void moveTo(String const &address);
+    void move(int dx, int dy);
+    double latitude() const;
+    uint64 latitudeInt() const {return m_latitude;}
+    double longitude() const;
+    uint64 longitudeInt() const {return m_longitude;}
+
+    void addAnnotation(Annotation const &ann);
+
+    bool handleClick(int x, int y);
+
+    void paint(IDrawingContext *context);
+
+    void setPinImage(IDrawingImage *pin, PIN_INFO pin_info);
+    void setPinCalloutImage(IDrawingImage *pinCallout, PIN_INFO pin_callout_info);
+    void setPinCalloutLinkImage(IDrawingImage *pinCallout, PIN_INFO pin_callout_info);
+
+private:
+    String const &getMapUrl();
+    void setCoordinates(int64 latitude, int64 longitude);
+
+    IDrawingDevice *drawingDevice() const {return m_drawing_device;}
+    void redraw();
+
+    void fetchTile(int zoom, uint64 latitude, uint64 longitude);
+    void updateCache();
+
+    void paintBackground(IDrawingContext *context);
+    void paintTile(IDrawingContext *context, Tile const &tile);
+    void paintAnnotation(IDrawingContext *context, Annotation const &ann);
+    void paintCallout(IDrawingContext *context, Annotation const &ann);
+
+    CMutex &tilesCacheLock() {return m_tiles_cache_mtx;}
+    TilesCache &tilesCache() {return m_tiles_cache;}
+
+    int getAnnotation(int x, int y);
+
+    int64 toScreenCoordinateX(double n);
+    int64 toScreenCoordinateY(double n);
+
+    bool isClickOnCallout(int x, int y, Annotation const &ann);
+private:
+    IDrawingDevice *m_drawing_device;
+
+    Hashtable<String, String> m_map_urls;
+
+    std::auto_ptr<IGeoCoding> m_geo_coding;
+
+    std::auto_ptr<MapFetch> m_map_fetch;
+    std::auto_ptr<CacheUpdate> m_cache_update;
+
+    int m_width;
+    int m_height;
+
+    bool m_zoom_enabled;
+    bool m_scroll_enabled;
+    String m_maptype;
+
+    int m_zoom;
+    uint64 m_latitude;
+    uint64 m_longitude;
+
+    typedef Vector<Annotation> annotations_list_t;
+    CMutex m_annotations_mtx;
+    annotations_list_t m_annotations;
+    int m_selected_annotation_index;
+
+    CMutex m_tiles_cache_mtx;
+    TilesCache m_tiles_cache;
+
+    IDrawingImage *m_pin;
+	PIN_INFO m_pin_info;
+    IDrawingImage *m_pinCallout;
+	PIN_INFO m_pin_callout_info;
+    IDrawingImage *m_pinCalloutLink;
+	PIN_INFO m_pin_calloutlink_info;
+};
+
+class ESRIMapEngine : public IMapEngine
+{
+public:
+    ESRIMapView *createMapView(IDrawingDevice *device);
+    void destroyMapView(IMapView *view);
+};
+
+} // namespace map
+} // namespace common
+} // namespace rho
+
+#endif

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

@@ -0,0 +1,160 @@
+#include "common/map/GoogleMapEngine.h"
+#include "common/IRhoClassFactory.h"
+#include "common/RhoThread.h"
+#include "net/URI.h"
+#include "json/JSONIterator.h"
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "GoogleMapEngine"
+
+extern "C" unsigned long rjson_tokener_parse(const char *str, char** pszError);
+
+namespace rho
+{
+namespace common
+{
+namespace map
+{
+
+String GoogleGeoCoding::Command::toString()
+{
+    return address;
+}
+
+IMPLEMENT_LOGCLASS(GoogleGeoCoding,"GGeoCoding");
+GoogleGeoCoding::GoogleGeoCoding()
+    :CThreadQueue(rho_impl_createClassFactory()),
+    m_net_request(getFactory()->createNetRequest())
+{
+    CThreadQueue::setLogCategory(getLogCategory());
+    RHO_MAP_TRACE("GoogleGeoCoding: ctor start");
+    start(epNormal);
+    RHO_MAP_TRACE("GoogleGeoCoding: ctor finish");
+}
+
+GoogleGeoCoding::~GoogleGeoCoding()
+{
+    RHO_MAP_TRACE("GoogleGeoCoding: dtor");
+    CThreadQueue::stop(200);
+}
+/*
+void GoogleGeoCoding::stop()
+{
+    RHO_MAP_TRACE("GoogleGeoCoding: stop");
+    CThreadQueue::stop(200);
+}*/
+
+bool GoogleGeoCoding::fetchData(String const &url, void **data, size_t *datasize)
+{
+    RHO_MAP_TRACE1("GoogleGeoCoding: fetchData: url=%s", url.c_str());
+    NetResponse(resp, m_net_request->doRequest("GET", url, "", 0, 0));
+    if (!resp.isOK())
+        return false;
+    *datasize = resp.getDataSize();
+    *data = malloc(*datasize);
+    if (!*data)
+        return false;
+    memcpy(*data, resp.getCharData(), *datasize);
+    return true;
+}
+
+void GoogleGeoCoding::resolve(String const &address, GeoCodingCallback *cb)
+{
+    RHO_MAP_TRACE1("GoogleGeoCoding: resolve address=%s", address.c_str());
+    addQueueCommand(new Command(address, cb));
+}
+
+static bool parse_json(const char *data, double *plat, double *plon)
+{
+    RHO_MAP_TRACE1("parse_json: data=%s", data);
+    json::CJSONEntry json(data);
+    const char *status = json.getString("status");
+    RHO_MAP_TRACE1("parse_json: status=%s", status);
+    if (strcasecmp(status, "OK") != 0)
+        return false;
+    for (json::CJSONArrayIterator results = json.getEntry("results"); !results.isEnd(); results.next())
+    {
+        json::CJSONEntry item = results.getCurItem();
+        if (!item.hasName("geometry"))
+            continue;
+
+        json::CJSONEntry geometry = item.getEntry("geometry");
+        json::CJSONEntry location = geometry.getEntry("location");
+        *plat = location.getDouble("lat");
+        *plon = location.getDouble("lng");
+        return true;
+    }
+
+    return false;
+}
+
+void GoogleGeoCoding::processCommand(IQueueCommand *pCmd)
+{
+    Command *cmd = (Command*)pCmd;
+    GeoCodingCallback &cb = *(cmd->callback);
+
+    String url = "http://maps.googleapis.com/maps/api/geocode/json?address=";
+    url += net::URI::urlEncode(cmd->address);
+    url += "&sensor=false";
+
+    RHO_MAP_TRACE1("GoogleGeoCoding: processCommand: url=%s", url.c_str());
+
+    void *data;
+    size_t datasize;
+    if (!fetchData(url, &data, &datasize))
+    {
+        RAWLOG_ERROR1("Can not fetch data by url=%s", url.c_str());
+        return;
+    }
+
+    RHO_MAP_TRACE("GoogleGeoCoding: processCommand: Parse received json...");
+
+    double latitude, longitude;
+    if (parse_json((const char *)data, &latitude, &longitude))
+    {
+        RHO_MAP_TRACE("GoogleGeoCoding: processCommand: json parsed successfully");
+        cb.onSuccess(latitude, longitude);
+    }
+    else
+    {
+        RHO_MAP_TRACE("GoogleGeoCoding: processCommand: can't parse json");
+        cb.onError("Can not parse JSON response");
+    }
+    /*
+    char *error = 0;
+    unsigned long json = rjson_tokener_parse((char const *)data, &error);
+    if (!rho_ruby_is_NIL(json))
+    {
+        RHO_MAP_TRACE("GoogleGeoCoding: processCommand: extract coordinates from json...");
+        unsigned long coords = rho_ruby_google_geocoding_get_coordinates(json);
+        if (rho_ruby_is_NIL(coords))
+        {
+            RHO_MAP_TRACE("GoogleGeoCoding: processCommand: rho_ruby_google_geocoding_get_coordinates return nil");
+            cb.onError("Cannot parse received JSON object");
+        }
+        else
+        {
+            RHO_MAP_TRACE("GoogleGeoCoding: processCommand: rho_ruby_google_geocoding_get_coordinates return coordinates");
+            double latitude = rho_ruby_google_geocoding_get_latitude(coords);
+            double longitude = rho_ruby_google_geocoding_get_longitude(coords);
+            RHO_MAP_TRACE2("GoogleGeoCoding: processCommand: latitude=%lf, longitude=%lf", latitude, longitude);
+            cb.onSuccess(latitude, longitude);
+        }
+    }
+    else
+    {
+        RHO_MAP_TRACE("GoogleGeoCoding: processCommand: rjson_tokener_parse return nil");
+        cb.onError(error);
+    }
+
+    if (error)
+        free (error);
+    */
+
+    free(data);
+}
+
+} // namespace map
+} // namespace common
+} // namespace rho
+

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

@@ -0,0 +1,52 @@
+#ifndef _RHOGOOGLEMAPENGINE_H_
+#define _RHOGOOGLEMAPENGINE_H_
+
+#include "common/map/MapEngine.h"
+#include "common/ThreadQueue.h"
+#include "net/INetRequest.h"
+
+namespace rho
+{
+namespace common
+{
+namespace map
+{
+
+class GoogleGeoCoding : public IGeoCoding, public CThreadQueue
+{
+    DEFINE_LOGCLASS;
+private:
+    struct Command : public IQueueCommand
+    {
+        String address;
+        std::auto_ptr<GeoCodingCallback> callback;
+
+        Command(String const &a, GeoCodingCallback *cb)
+            :address(a), callback(cb)
+        {}
+
+        bool equals(IQueueCommand const &) {return false;}
+        String toString();
+    };
+
+public:
+    GoogleGeoCoding();
+    ~GoogleGeoCoding();
+
+    //void stop();
+    void resolve(String const &address, GeoCodingCallback *cb);
+
+private:
+    bool fetchData(String const &url, void **data, size_t *datasize);
+
+    void processCommand(IQueueCommand* cmd);
+
+private:
+    std::auto_ptr<net::INetRequest> m_net_request;
+};
+
+} // namespace map
+} // namespace common
+} // namespace rho
+
+#endif