@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/modules/MLRNStaticMapModule.kt

@@ -0,0 +1,121 @@
+package io.github.mapvina.reactnative.modules
+
+import android.graphics.Bitmap
+import android.util.Log
+import android.util.TypedValue
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.github.mapvina.android.camera.CameraPosition
+import io.github.mapvina.android.maps.Style
+import io.github.mapvina.android.snapshotter.MapSnapshot
+import io.github.mapvina.android.snapshotter.MapSnapshotter
+import io.github.mapvina.reactnative.NativeStaticMapModuleSpec
+import io.github.mapvina.reactnative.utils.BitmapUtils
+import io.github.mapvina.reactnative.utils.ConvertUtils
+import io.github.mapvina.reactnative.utils.GeoJSONUtils
+import java.util.UUID
+
+class MLRNStaticMapModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeStaticMapModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNStaticMapModule"
+    }
+
+    override fun getName() = NAME
+
+    // Prevent garbage collection
+    private val snapshotterMap: MutableMap<String, MapSnapshotter> = HashMap()
+
+    override fun createImage(
+        readableMap: ReadableMap,
+        promise: Promise,
+    ) {
+        io.github.mapvina.android.storage.FileSource
+            .getInstance(reactContext)
+            .activate()
+
+        reactContext.runOnUiQueueThread {
+            val snapshotterID = UUID.randomUUID().toString()
+            val snapshotter = MapSnapshotter(reactContext, getOptions(readableMap))
+            snapshotterMap[snapshotterID] = snapshotter
+            snapshotter.start(
+                object : MapSnapshotter.SnapshotReadyCallback {
+                    override fun onSnapshotReady(snapshot: MapSnapshot) {
+                        val bitmap: Bitmap = snapshot.bitmap
+                        val result: String? =
+                            if (readableMap.getString("output") == "file") {
+                                BitmapUtils.createTempFile(
+                                    reactContext,
+                                    bitmap,
+                                )
+                            } else if (readableMap.getString("output") == "base64") {
+                                BitmapUtils.createBase64(bitmap)
+                            } else {
+                                null
+                            }
+
+                        if (result == null) {
+                            promise.reject(
+                                NAME,
+                                "Could not generate snapshot, please check Android logs for more info.",
+                            )
+                            return
+                        }
+
+                        promise.resolve(result)
+                        snapshotterMap.remove(snapshotterID)
+                    }
+                },
+            ) { error ->
+                Log.w(NAME, error)
+                snapshotterMap.remove(snapshotterID)
+            }
+        }
+    }
+
+    private fun getOptions(readableMap: ReadableMap): MapSnapshotter.Options {
+        val options: MapSnapshotter.Options =
+            MapSnapshotter.Options(
+                readableMap.getDouble("width").toInt(),
+                readableMap.getDouble("height").toInt(),
+            )
+
+        val showLogo = if (readableMap.hasKey("logo")) readableMap.getBoolean("logo") else false
+        options.withLogo(showLogo)
+        readableMap.getString("mapStyle")?.let { mapStyle ->
+            options.withStyleBuilder(
+                if (ConvertUtils.isJSONValid(mapStyle)) {
+                    Style.Builder().fromJson(mapStyle)
+                } else {
+                    Style.Builder().fromUri(mapStyle)
+                },
+            )
+        }
+        options.withPixelRatio(
+            TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_DIP,
+                1f,
+                reactContext.resources.displayMetrics,
+            ),
+        )
+
+        if (readableMap.hasKey("center")) {
+            val center = GeoJSONUtils.toLatLng(readableMap.getArray("center"))
+            val cameraPosition: CameraPosition =
+                CameraPosition
+                    .Builder()
+                    .target(center)
+                    .tilt(ConvertUtils.getDouble("pitch", readableMap, 0.0))
+                    .bearing(ConvertUtils.getDouble("bearing", readableMap, 0.0))
+                    .zoom(ConvertUtils.getDouble("zoom", readableMap, 0.0))
+                    .build()
+            options.withCameraPosition(cameraPosition)
+        } else if (readableMap.hasKey("bounds")) {
+            options.withRegion(GeoJSONUtils.toLatLngBounds(readableMap.getArray("bounds")))
+        }
+
+        return options
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/modules/MLRNTransformRequestModule.kt

@@ -0,0 +1,144 @@
+package io.github.mapvina.reactnative.modules
+
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import okhttp3.Dispatcher
+import okhttp3.OkHttpClient
+import io.github.mapvina.android.module.http.HttpRequestUtil
+import io.github.mapvina.reactnative.NativeTransformRequestModuleSpec
+
+@ReactModule(name = MLRNTransformRequestModule.NAME)
+class MLRNTransformRequestModule(
+    reactContext: ReactApplicationContext,
+) : NativeTransformRequestModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNTransformRequestModule"
+
+        private var transformRequestInterceptorAdded = false
+    }
+
+    override fun getName() = NAME
+
+    override fun initialize() {
+        reactApplicationContext.getNativeModule(MLRNLogModule::class.java)?.let { logModule ->
+            TransformRequestInterceptor.INSTANCE.jsLogger = { level, tag, message ->
+                logModule.onLog(level, tag, message)
+            }
+        }
+    }
+
+    private fun ensureInterceptorAdded() {
+        if (!transformRequestInterceptorAdded) {
+            Log.i(NAME, "Add interceptor")
+            val httpClient =
+                OkHttpClient
+                    .Builder()
+                    .addInterceptor(TransformRequestInterceptor.INSTANCE)
+                    .dispatcher(getDispatcher())
+                    .build()
+            HttpRequestUtil.setOkHttpClient(httpClient)
+            transformRequestInterceptorAdded = true
+        }
+    }
+
+    override fun addUrlTransform(
+        id: String,
+        match: String?,
+        find: String,
+        replace: String,
+    ) {
+        requireValidRegex(match, "addUrlTransform", "match")
+        requireValidRegex(find, "addUrlTransform", "find")
+        reactApplicationContext.runOnUiQueueThread {
+            ensureInterceptorAdded()
+            TransformRequestInterceptor.INSTANCE.addUrlTransform(id, match, find, replace)
+        }
+    }
+
+    override fun removeUrlTransform(id: String) {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.removeUrlTransform(id)
+        }
+    }
+
+    override fun clearUrlTransforms() {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.clearUrlTransforms()
+        }
+    }
+
+    override fun addUrlSearchParam(
+        id: String,
+        match: String?,
+        key: String,
+        value: String,
+    ) {
+        requireValidRegex(match, "addUrlSearchParam", "match")
+        reactApplicationContext.runOnUiQueueThread {
+            ensureInterceptorAdded()
+            TransformRequestInterceptor.INSTANCE.addUrlSearchParam(id, match, key, value)
+        }
+    }
+
+    override fun removeUrlSearchParam(id: String) {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.removeUrlSearchParam(id)
+        }
+    }
+
+    override fun clearUrlSearchParams() {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.clearUrlSearchParams()
+        }
+    }
+
+    override fun addHeader(
+        id: String,
+        match: String?,
+        name: String,
+        value: String,
+    ) {
+        requireValidRegex(match, "addHeader", "match")
+        reactApplicationContext.runOnUiQueueThread {
+            ensureInterceptorAdded()
+            TransformRequestInterceptor.INSTANCE.addHeader(id, match, name, value)
+        }
+    }
+
+    override fun removeHeader(id: String) {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.removeHeader(id)
+        }
+    }
+
+    override fun clearHeaders() {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.clearHeaders()
+        }
+    }
+
+    private fun requireValidRegex(
+        pattern: String?,
+        methodName: String,
+        fieldName: String,
+    ) {
+        if (pattern != null) {
+            try {
+                Regex(pattern)
+            } catch (e: Exception) {
+                throw IllegalArgumentException(
+                    "[$NAME] $methodName: invalid $fieldName regex '$pattern': ${e.message}",
+                )
+            }
+        }
+    }
+
+    private fun getDispatcher(): Dispatcher {
+        val dispatcher = Dispatcher()
+        // Matches core limit set on
+        // https://github.com/mapbox/mapbox-gl-native/blob/master/platform/android/src/http_file_source.cpp#L192
+        dispatcher.maxRequestsPerHost = 20
+        return dispatcher
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/modules/TransformRequestInterceptor.kt

@@ -0,0 +1,184 @@
+package io.github.mapvina.reactnative.modules
+
+import android.util.Log
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.Interceptor
+import okhttp3.Response
+import java.io.IOException
+import kotlin.collections.iterator
+
+data class UrlTransformConfig(
+    val matchRegex: Regex?,
+    val findRegex: Regex,
+    val replace: String,
+)
+
+data class UrlSearchParamConfig(
+    val matchRegex: Regex?,
+    val name: String,
+    val value: String,
+)
+
+data class HeaderConfig(
+    val matchRegex: Regex?,
+    val name: String,
+    val value: String,
+)
+
+class TransformRequestInterceptor : Interceptor {
+    private val urlTransforms: LinkedHashMap<String, UrlTransformConfig> = LinkedHashMap()
+    private val urlSearchParams: LinkedHashMap<String, UrlSearchParamConfig> = LinkedHashMap()
+    private val headers: LinkedHashMap<String, HeaderConfig> = LinkedHashMap()
+
+    @Volatile
+    var jsLogger: ((level: String, tag: String, message: String) -> Unit)? = null
+
+    private fun debugLog(message: String) {
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, message)
+        }
+        jsLogger?.invoke("debug", TAG, message)
+    }
+
+    private fun errorLog(message: String) {
+        Log.e(TAG, message)
+        jsLogger?.invoke("error", TAG, message)
+    }
+
+    fun addUrlTransform(
+        id: String,
+        match: String?,
+        find: String,
+        replace: String,
+    ) {
+        urlTransforms[id] = UrlTransformConfig(match?.let { Regex(it) }, Regex(find), replace)
+    }
+
+    fun removeUrlTransform(id: String) {
+        urlTransforms.remove(id)
+    }
+
+    fun clearUrlTransforms() {
+        urlTransforms.clear()
+    }
+
+    fun addUrlSearchParam(
+        id: String,
+        match: String?,
+        name: String,
+        value: String,
+    ) {
+        urlSearchParams[id] = UrlSearchParamConfig(match?.let { Regex(it) }, name, value)
+    }
+
+    fun removeUrlSearchParam(id: String) {
+        urlSearchParams.remove(id)
+    }
+
+    fun clearUrlSearchParams() {
+        urlSearchParams.clear()
+    }
+
+    fun addHeader(
+        id: String,
+        match: String?,
+        name: String,
+        value: String,
+    ) {
+        headers[id] = HeaderConfig(match?.let { Regex(it) }, name, value)
+    }
+
+    fun removeHeader(id: String) {
+        headers.remove(id)
+    }
+
+    fun clearHeaders() {
+        headers.clear()
+    }
+
+    @Throws(IOException::class)
+    override fun intercept(chain: Interceptor.Chain): Response {
+        var request = chain.request()
+
+        val hasConfig = urlTransforms.isNotEmpty() || urlSearchParams.isNotEmpty() || headers.isNotEmpty()
+        if (hasConfig) {
+            debugLog("Request: ${request.url}")
+        }
+
+        // 1. URL transforms
+        var currentUrl = request.url.toString()
+        for ((transformId, config) in urlTransforms) {
+            val urlBeforeTransform = currentUrl
+            val shouldApply = config.matchRegex == null || config.matchRegex.containsMatchIn(currentUrl)
+
+            if (!shouldApply) {
+                debugLog("  URL Transform [$transformId]${matchDescription(config.matchRegex)}: SKIPPED (no match)")
+                continue
+            }
+
+            val result = config.findRegex.replace(currentUrl, config.replace)
+            if (result.toHttpUrlOrNull() == null) {
+                errorLog(
+                    "URL Transform [$transformId]${matchDescription(config.matchRegex)}: produced invalid URL '$result', " +
+                        "using pre-transform URL",
+                )
+            } else {
+                debugLog(
+                    "  URL Transform [$transformId]${matchDescription(config.matchRegex)}: APPLIED '$urlBeforeTransform' → '$result'",
+                )
+                currentUrl = result
+            }
+        }
+
+        // 2. URL search params
+        var modifiedUrl: HttpUrl = currentUrl.toHttpUrlOrNull() ?: request.url
+        for (entry in urlSearchParams.entries) {
+            val config = entry.value
+            val shouldApply =
+                config.matchRegex == null || config.matchRegex.containsMatchIn(modifiedUrl.toString())
+
+            if (shouldApply) {
+                debugLog(
+                    "  URL Search Param [${entry.key}]${matchDescription(config.matchRegex)}: APPLIED '${config.name}=${config.value}'",
+                )
+                modifiedUrl =
+                    modifiedUrl
+                        .newBuilder()
+                        .setQueryParameter(config.name, config.value)
+                        .build()
+            } else {
+                debugLog("  URL Search Param [${entry.key}]${matchDescription(config.matchRegex)}: SKIPPED (no match)")
+            }
+        }
+
+        // 3. Headers
+        val requestBuilder = request.newBuilder().url(modifiedUrl)
+        for (entry in headers.entries) {
+            val config = entry.value
+            val shouldApply =
+                config.matchRegex == null || config.matchRegex.containsMatchIn(modifiedUrl.toString())
+
+            if (shouldApply) {
+                debugLog("  Header [${entry.key}]${matchDescription(config.matchRegex)}: APPLIED '${config.name}: ${config.value}'")
+                requestBuilder.header(config.name, config.value)
+            } else {
+                debugLog("  Header [${entry.key}]${matchDescription(config.matchRegex)}: SKIPPED (no match)")
+            }
+        }
+
+        if (hasConfig) {
+            debugLog("Final URL: $modifiedUrl")
+        }
+
+        request = requestBuilder.build()
+        return chain.proceed(request)
+    }
+
+    companion object {
+        val INSTANCE: TransformRequestInterceptor = TransformRequestInterceptor()
+        private const val TAG = "TransformRequestInterceptor"
+
+        private fun matchDescription(matchRegex: Regex?) = if (matchRegex != null) " (match='${matchRegex.pattern}')" else ""
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/BitmapUtils.java

@@ -0,0 +1,125 @@
+package io.github.mapvina.reactnative.utils;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.net.Uri;
+import android.util.Base64;
+import android.util.Log;
+import android.util.LruCache;
+import android.view.View;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+
+public class BitmapUtils {
+    public static final String LOG_TAG = "BitmapUtils";
+
+    private  static int CACHE_SIZE = 1024 * 1024;
+    private static LruCache<String, Bitmap> mCache = new LruCache<String, Bitmap>(CACHE_SIZE) {
+        protected int sizeOf(String key, Bitmap bitmap) {
+            return bitmap.getByteCount();
+        }
+    };
+
+    public static Bitmap getBitmapFromURL(String url) {
+        return BitmapUtils.getBitmapFromURL(url, null);
+    }
+
+    public static Bitmap getBitmapFromURL(String url, BitmapFactory.Options options) {
+        Bitmap bitmap = getImage(url);
+
+        if (bitmap != null) {
+            return  bitmap;
+        }
+
+        try {
+            InputStream bitmapStream = new URL(url).openStream();
+            bitmap = BitmapFactory.decodeStream(bitmapStream, null, options);
+            bitmapStream.close();
+            addImage(url, bitmap);
+        } catch (Exception e) {
+            Log.w(LOG_TAG, e.getLocalizedMessage());
+            bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ALPHA_8); // Returns a transparent bitmap
+        }
+
+        return bitmap;
+    }
+
+    public static Bitmap getBitmapFromResource(Context context, String resourceName, BitmapFactory.Options options) {
+        Resources resources = context.getResources();
+        int resID = resources.getIdentifier(resourceName, "drawable", context.getPackageName());
+        return BitmapFactory.decodeResource(resources, resID, options);
+    }
+
+    public static String createTempFile(Context context, Bitmap bitmap) {
+        File tempFile = null;
+        FileOutputStream outputStream = null;
+
+        try {
+            tempFile = File.createTempFile(LOG_TAG, ".png", context.getCacheDir());
+            outputStream = new FileOutputStream(tempFile);
+        } catch (IOException e) {
+            Log.w(LOG_TAG, e.getLocalizedMessage());
+        }
+
+        if (tempFile == null) {
+            return null;
+        }
+
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
+        closeSnapshotOutputStream(outputStream);
+        return Uri.fromFile(tempFile).toString();
+    }
+
+    public static String createBase64(Bitmap bitmap) {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
+        byte[] bitmapBytes = outputStream.toByteArray();
+        closeSnapshotOutputStream(outputStream);
+        String base64Prefix = "data:image/png;base64,";
+        return base64Prefix + Base64.encodeToString(bitmapBytes, Base64.NO_WRAP);
+    }
+
+    public static Bitmap viewToBitmap(View v, int left, int top, int right, int bottom) {
+        Bitmap bitmap = null;
+        if (v != null) {
+            int w = right - left;
+            int h = bottom - top;
+            if (w > 0 && h > 0) {
+                bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
+                bitmap.eraseColor(Color.TRANSPARENT);
+                Canvas canvas = new Canvas(bitmap);
+                v.draw(canvas);
+            }
+        }
+        return bitmap;
+    }
+
+    private static void addImage(String imageURL, Bitmap bitmap) {
+        mCache.put(imageURL, bitmap);
+    }
+
+    private static Bitmap getImage(String imageURL) {
+        return mCache.get(imageURL);
+    }
+
+    private static void closeSnapshotOutputStream(OutputStream outputStream) {
+        if (outputStream == null) {
+            return;
+        }
+        try {
+            outputStream.close();
+        } catch (IOException e) {
+            Log.w(LOG_TAG, e.getLocalizedMessage());
+        }
+    }
+}