Add emscripten support

all/native/graphics/BitmapCanvas.cpp

@@ -9,6 +9,9 @@
 #elif defined(__ANDROID__)
 #define CARTO_BITMAP_CANVAS_IMPL AndroidImpl
 #include "graphics/BitmapCanvasAndroidImpl.h"
+#elif defined(__EMSCRIPTEN__)
+#define CARTO_BITMAP_CANVAS_IMPL EmscriptenImpl
+#include "graphics/BitmapCanvasEmscriptenImpl.h"
 #else
 #error "Unsupported platform"
 #endif

all/native/graphics/BitmapCanvas.h

@@ -71,6 +71,7 @@ namespace carto {
         class AndroidImpl;
         class IOSImpl;
         class UWPImpl;
+        class EmscriptenImpl;
 
         std::unique_ptr<Impl> _impl;
     };

all/native/network/HTTPClient.cpp

@@ -19,6 +19,9 @@
 #elif defined(__ANDROID__)
 #define CARTO_HTTP_SOCKET_IMPL AndroidImpl
 #include "network/HTTPClientAndroidImpl.h"
+#elif defined(__EMSCRIPTEN__)
+#define CARTO_HTTP_SOCKET_IMPL EmscriptenImpl
+#include "network/HTTPClientEmscriptenImpl.h"
 #else
 #define CARTO_HTTP_SOCKET_IMPL PionImpl
 #include "HTTPClientPionImpl.h"

all/native/network/HTTPClient.h

@@ -78,6 +78,7 @@ namespace carto {
         class AndroidImpl;
         class IOSImpl;
         class WinSockImpl;
+        class EmscriptenImpl;
 
         int makeRequest(Request request, Response& response, HandlerFunc handlerFn, std::uint64_t offset) const;
 

all/native/utils/Log.cpp

@@ -39,6 +39,15 @@ namespace carto {
         OutputDebugStringA("\n");
     }
 #endif
+#ifdef __EMSCRIPTEN__
+    enum LogType { LOG_TYPE_FATAL = 0, LOG_TYPE_ERROR = 1, LOG_TYPE_WARNING = 2, LOG_TYPE_INFO = 3, LOG_TYPE_DEBUG = 4 };
+
+    static void OutputLog(LogType logType, const std::string& tag, const char* text) {
+        if ((int)logType <= 1) {
+            printf("LogType: %d, tag: %s, message: %s\n", logType, tag.c_str(), text);
+        }
+    }
+#endif
 
     bool Log::IsShowError() {
         std::lock_guard<std::mutex> lock(_Mutex);

all/native/utils/PlatformUtils.h

@@ -20,7 +20,8 @@ namespace carto {
             PLATFORM_TYPE_WINDOWS,
             PLATFORM_TYPE_WINDOWS_PHONE,
             PLATFORM_TYPE_XAMARIN_IOS,
-            PLATFORM_TYPE_XAMARIN_ANDROID
+            PLATFORM_TYPE_XAMARIN_ANDROID,
+            PLATFORM_TYPE_WEB
         };
     }
 

emscripten/modules/ui/MapView.i

@@ -0,0 +1,29 @@
+#ifndef _MAPVIEW_I
+#define _MAPVIEW_I
+
+%module MAPVIEW
+
+!proxy_imports(carto::MapView, ui.MapView)
+
+%{
+#include "ui/MapView.h"
+#include "ui/BaseMapView.h"
+#include "ui/MapEventListener.h"
+#include "ui/MapRedrawRequestListener.h"
+#include "ui/EmscriptenInput.h"
+#include "components/Options.h"
+#include "components/Layers.h"
+#include "core/MapBounds.h"
+#include "core/MapPos.h"
+#include "core/MapVec.h"
+#include "core/ScreenPos.h"
+#include "core/ScreenBounds.h"
+#include "utils/Const.h"
+#include "renderers/MapRenderer.h"
+%}
+
+%include <std_string.i>
+
+%include "ui/MapView.h"
+
+#endif

emscripten/modules/utils/AssetUtils.i

@@ -0,0 +1,18 @@
+#ifndef _ASSETUTILS_I
+#define _ASSETUTILS_I
+
+%module AssetUtils
+
+!proxy_imports(carto::AssetUtils, core.BinaryData)
+
+%{
+#include "utils/AssetUtils.h"
+%}
+
+%include <std_string.i>
+
+%import "core/BinaryData.i"
+
+%include "utils/AssetUtils.h"
+
+#endif

emscripten/modules/utils/BitmapUtils.i

@@ -0,0 +1,24 @@
+#ifndef _BITMAPUTILS_I
+#define _BITMAPUTILS_I
+
+%module BitmapUtils
+
+!proxy_imports(carto::BitmapUtils, graphics.Bitmap)
+
+%{
+#include "utils/BitmapUtils.h"
+#include "components/Exceptions.h"
+%}
+
+%include <std_shared_ptr.i>
+%include <std_string.i>
+%include <cartoswig.i>
+
+%import "graphics/Bitmap.i"
+
+%std_exceptions(carto::BitmapUtils::CreateBitmapFromUIImage)
+%std_exceptions(carto::BitmapUtils::CreateUIImageFromBitmap)
+
+%include "utils/BitmapUtils.h"
+
+#endif

emscripten/native/components/Task.cpp

@@ -0,0 +1,9 @@
+#include "components/Task.h"
+
+namespace carto {
+
+    void Task::operator()() {
+        run();
+    }
+
+}

emscripten/native/graphics/BitmapCanvasEmscriptenImpl.cpp

@@ -0,0 +1,63 @@
+#include "graphics/BitmapCanvasEmscriptenImpl.h"
+#include "components/Exceptions.h"
+#include "utils/BitmapUtils.h"
+
+#include <cmath>
+
+namespace carto {
+    BitmapCanvas::EmscriptenImpl::EmscriptenImpl(int width, int height)
+    {
+
+    }
+
+    BitmapCanvas::EmscriptenImpl::~EmscriptenImpl() {
+    }
+
+    void BitmapCanvas::EmscriptenImpl::setDrawMode(DrawMode mode) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::setColor(const Color& color) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::setStrokeWidth(float width) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::setFont(const std::string& name, float size) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::pushClipRect(const ScreenBounds& clipRect) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::popClipRect() {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::drawText(std::string text, const ScreenPos& pos, int maxWidth, bool breakLines) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::drawRoundRect(const ScreenBounds& rect, float radius) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::drawPolygon(const std::vector<ScreenPos>& poses) {
+
+    }
+
+    void BitmapCanvas::EmscriptenImpl::drawBitmap(const ScreenBounds& rect, const std::shared_ptr<Bitmap>& bitmap) {
+
+    }
+
+    ScreenBounds BitmapCanvas::EmscriptenImpl::measureTextSize(std::string text, int maxWidth, bool breakLines) const {
+        return ScreenBounds(ScreenPos(0, 0), ScreenPos(0, 0));
+    }
+
+    std::shared_ptr<Bitmap> BitmapCanvas::EmscriptenImpl::buildBitmap() const {
+        return std::shared_ptr<Bitmap>();
+    }
+}

emscripten/native/graphics/BitmapCanvasEmscriptenImpl.h

@@ -0,0 +1,33 @@
+#ifndef _CARTO_BITMAPCANVASEMSCRIPTENIMPL_H_
+#define _CARTO_BITMAPCANVASEMSCRIPTENIMPL_H_
+
+#include "graphics/BitmapCanvas.h"
+
+namespace carto {
+
+    class BitmapCanvas::EmscriptenImpl : public BitmapCanvas::Impl {
+    public:
+        EmscriptenImpl(int width, int height);
+        virtual ~EmscriptenImpl();
+
+        virtual void setDrawMode(DrawMode mode);
+        virtual void setColor(const Color& color);
+        virtual void setStrokeWidth(float width);
+        virtual void setFont(const std::string& name, float size);
+
+        virtual void pushClipRect(const ScreenBounds& clipRect);
+        virtual void popClipRect();
+
+        virtual void drawText(std::string text, const ScreenPos& pos, int maxWidth, bool breakLines);
+        virtual void drawPolygon(const std::vector<ScreenPos>& poses);
+        virtual void drawRoundRect(const ScreenBounds& rect, float radius);
+        virtual void drawBitmap(const ScreenBounds& rect, const std::shared_ptr<Bitmap>& bitmap);
+
+        virtual ScreenBounds measureTextSize(std::string text, int maxWidth, bool breakLines) const;
+
+        virtual std::shared_ptr<Bitmap> buildBitmap() const;
+    };
+
+}
+
+#endif

emscripten/native/network/HTTPClientEmscriptenImpl.cpp

@@ -0,0 +1,45 @@
+#include "HTTPClientEmscriptenImpl.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <iostream>
+#include <emscripten/fetch.h>
+
+namespace carto {
+    HTTPClient::EmscriptenImpl::EmscriptenImpl(bool log) :
+        _log(log),
+        _timeout(-1)
+    {
+    }
+
+    void HTTPClient::EmscriptenImpl::setTimeout(int milliseconds) {
+        _timeout = milliseconds;
+    }
+
+    bool HTTPClient::EmscriptenImpl::makeRequest(const HTTPClient::Request& request, HeadersFunc headersFn, DataFunc dataFn) const {
+        emscripten_fetch_attr_t attr;
+        emscripten_fetch_attr_init(&attr);
+        strcpy(attr.requestMethod, "GET");
+        attr.attributes = EMSCRIPTEN_FETCH_LOAD_TO_MEMORY | EMSCRIPTEN_FETCH_SYNCHRONOUS;
+        attr.timeoutMSecs = _timeout;
+        emscripten_fetch_t *fetch = emscripten_fetch(&attr, request.url.c_str());
+
+        bool cancel = false;
+        std::map<std::string, std::string> headers;
+
+        if (!headersFn(fetch->status, headers)) {
+            cancel = true;
+        }
+
+        if (!cancel) {
+            if(!dataFn((const unsigned char *)fetch->data, fetch->numBytes)) {
+                cancel = true;
+            }
+        }
+
+        emscripten_fetch_close(fetch);
+
+        return !cancel;
+    }
+}

emscripten/native/network/HTTPClientEmscriptenImpl.h

@@ -0,0 +1,21 @@
+#ifndef _CARTO_HTTPCLIENTEMSCRIPTENImpl_H_
+#define _CARTO_HTTPCLIENTEMSCRIPTENImpl_H_
+
+#include "network/HTTPClient.h"
+
+namespace carto {
+    class HTTPClient::EmscriptenImpl : public HTTPClient::Impl {
+    public:
+        explicit EmscriptenImpl(bool log);
+
+        virtual void setTimeout(int milliseconds);
+        virtual bool makeRequest(const HTTPClient::Request& request, HeadersFunc headersFn, DataFunc dataFn) const;
+
+    private:
+        bool _log;
+        int _timeout;
+    };
+
+}
+
+#endif