@aguacerowx/react-native 0.0.42 → 0.0.44

package/android/src/main/java/com/aguacerowx/reactnative/SatelliteLayer.java

@@ -0,0 +1,576 @@
+package com.aguacerowx.reactnative;
+
+import android.opengl.GLES20;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.mapbox.maps.CustomLayerHost;
+import com.mapbox.maps.CustomLayerRenderParameters;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Mapbox Android custom layer port of mapsgl {@code SatelliteShaderManager} (GOES KTX2 → GL).
+ */
+public class SatelliteLayer implements CustomLayerHost {
+
+    private static final String TAG = "AguaceroSatellite";
+    private static final int MAX_GPU_CACHED_FRAMES = 16;
+
+    private static final int GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0;
+    private static final int GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
+
+    private final Object lock = new Object();
+
+    private int program;
+    private int uMatrix;
+    private int uTexture;
+    private int uColormap;
+    private int uIsTrueColor;
+    private int uUseColormap;
+    private int uOpacity;
+    private int uUvTransform;
+    private int aPos;
+    private int aTexCoord;
+
+    private int defaultIrColormapTex;
+    private int defaultWvColormapTex;
+    private int userColormapTex;
+
+    private volatile boolean visible = true;
+    private volatile float opacity = 1f;
+    private volatile int fillSmoothing = 0;
+
+    /** Access-ordered LRU — eldest iterator entry is LRU. */
+    private final LinkedHashMap<Long, GpuSlot> cache =
+            new LinkedHashMap<Long, GpuSlot>(MAX_GPU_CACHED_FRAMES + 1, 0.75f, true);
+
+    private final List<GpuSlot> pendingDelete = new ArrayList<>();
+
+    @Nullable private Long activeUnix;
+    @Nullable private Long targetUnix;
+
+    static final class PendingGpuUpload {
+        final long unix;
+        final SatelliteMeshBuilder.MeshResult mesh;
+        final SatelliteKtxDecoder.Parsed decoded;
+        final boolean trueColor;
+        @NonNull final String colormapKind;
+        final boolean useColormap;
+
+        PendingGpuUpload(
+                long unix,
+                SatelliteMeshBuilder.MeshResult mesh,
+                SatelliteKtxDecoder.Parsed decoded,
+                boolean trueColor,
+                @NonNull String colormapKind,
+                boolean useColormap) {
+            this.unix = unix;
+            this.mesh = mesh;
+            this.decoded = decoded;
+            this.trueColor = trueColor;
+            this.colormapKind = colormapKind;
+            this.useColormap = useColormap;
+        }
+    }
+
+    private final ArrayDeque<PendingGpuUpload> pendingGpuQueue = new ArrayDeque<>();
+
+    private byte[] pendingUserColormap;
+    private volatile boolean pendingUserColormapDirty;
+
+    private static final class GpuSlot {
+        final long unix;
+        final int textureId;
+        final int vbo;
+        final int ibo;
+        final int indexCount;
+        final boolean trueColor;
+        final boolean useColormap;
+        @NonNull final String colormapKind;
+
+        GpuSlot(
+                long unix,
+                int textureId,
+                int vbo,
+                int ibo,
+                int indexCount,
+                boolean trueColor,
+                boolean useColormap,
+                @NonNull String colormapKind) {
+            this.unix = unix;
+            this.textureId = textureId;
+            this.vbo = vbo;
+            this.ibo = ibo;
+            this.indexCount = indexCount;
+            this.trueColor = trueColor;
+            this.useColormap = useColormap;
+            this.colormapKind = colormapKind;
+        }
+    }
+
+    private static int compileShader(int type, String src) {
+        int sh = GLES20.glCreateShader(type);
+        GLES20.glShaderSource(sh, src);
+        GLES20.glCompileShader(sh);
+        int[] ok = new int[1];
+        GLES20.glGetShaderiv(sh, GLES20.GL_COMPILE_STATUS, ok, 0);
+        if (ok[0] == 0) {
+            Log.e(TAG, "shader compile failed: " + GLES20.glGetShaderInfoLog(sh));
+            GLES20.glDeleteShader(sh);
+            return 0;
+        }
+        return sh;
+    }
+
+    @Override
+    public void initialize() {
+        String vs =
+                "attribute vec2 a_pos;\n"
+                        + "attribute vec2 a_texCoord;\n"
+                        + "uniform mat4 u_matrix;\n"
+                        + "uniform vec4 u_uv_transform;\n"
+                        + "varying vec2 v_texCoord;\n"
+                        + "void main() {\n"
+                        + "  gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);\n"
+                        + "  v_texCoord = a_texCoord * u_uv_transform.xy + u_uv_transform.zw;\n"
+                        + "}\n";
+
+        String fs =
+                "precision mediump float;\n"
+                        + "varying vec2 v_texCoord;\n"
+                        + "uniform sampler2D u_texture;\n"
+                        + "uniform sampler2D u_colormap;\n"
+                        + "uniform bool u_is_true_color;\n"
+                        + "uniform bool u_use_colormap;\n"
+                        + "uniform float u_opacity;\n"
+                        + "void main() {\n"
+                        + "  vec4 texColor = texture2D(u_texture, v_texCoord);\n"
+                        + "  vec3 rawColor = texColor.rgb;\n"
+                        + "  if (u_is_true_color) {\n"
+                        + "    gl_FragColor = vec4(rawColor, texColor.a * u_opacity);\n"
+                        + "  } else {\n"
+                        + "    float luminance = rawColor.r;\n"
+                        + "    if (u_use_colormap) {\n"
+                        + "      float intensity = clamp(luminance, 0.0, 1.0);\n"
+                        + "      vec3 colorMapped = texture2D(u_colormap, vec2(intensity, 0.5)).rgb;\n"
+                        + "      gl_FragColor = vec4(colorMapped, u_opacity);\n"
+                        + "    } else {\n"
+                        + "      float val = clamp(luminance * 1.7, 0.0, 1.0);\n"
+                        + "      gl_FragColor = vec4(val, val, val, u_opacity);\n"
+                        + "    }\n"
+                        + "  }\n"
+                        + "}\n";
+
+        int v = compileShader(GLES20.GL_VERTEX_SHADER, vs);
+        int f = compileShader(GLES20.GL_FRAGMENT_SHADER, fs);
+        program = GLES20.glCreateProgram();
+        GLES20.glAttachShader(program, v);
+        GLES20.glAttachShader(program, f);
+        GLES20.glLinkProgram(program);
+        GLES20.glDeleteShader(v);
+        GLES20.glDeleteShader(f);
+
+        uMatrix = GLES20.glGetUniformLocation(program, "u_matrix");
+        uTexture = GLES20.glGetUniformLocation(program, "u_texture");
+        uColormap = GLES20.glGetUniformLocation(program, "u_colormap");
+        uIsTrueColor = GLES20.glGetUniformLocation(program, "u_is_true_color");
+        uUseColormap = GLES20.glGetUniformLocation(program, "u_use_colormap");
+        uOpacity = GLES20.glGetUniformLocation(program, "u_opacity");
+        uUvTransform = GLES20.glGetUniformLocation(program, "u_uv_transform");
+        aPos = GLES20.glGetAttribLocation(program, "a_pos");
+        aTexCoord = GLES20.glGetAttribLocation(program, "a_texCoord");
+
+        byte[] ir = SatelliteColormap.defaultIrColormapRgba();
+        byte[] wv = SatelliteColormap.defaultWvColormapRgba();
+        defaultIrColormapTex = uploadColormapTexture(ir);
+        defaultWvColormapTex = uploadColormapTexture(wv);
+        userColormapTex = 0;
+    }
+
+    private int uploadColormapTexture(byte[] rgba) {
+        int[] t = new int[1];
+        GLES20.glGenTextures(1, t, 0);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, t[0]);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+        ByteBuffer buf = ByteBuffer.allocateDirect(rgba.length).order(ByteOrder.nativeOrder());
+        buf.put(rgba);
+        buf.flip();
+        GLES20.glTexImage2D(
+                GLES20.GL_TEXTURE_2D,
+                0,
+                GLES20.GL_RGBA,
+                256,
+                1,
+                0,
+                GLES20.GL_RGBA,
+                GLES20.GL_UNSIGNED_BYTE,
+                buf);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+        return t[0];
+    }
+
+    public void setVisible(boolean v) {
+        this.visible = v;
+    }
+
+    public void setOpacity(float o) {
+        this.opacity = Math.max(0f, Math.min(1f, o));
+    }
+
+    public void setFillSmoothing(int s) {
+        this.fillSmoothing = s != 0 ? 1 : 0;
+    }
+
+    public void setUserColormapRgba(@Nullable byte[] rgba256x1) {
+        synchronized (lock) {
+            pendingUserColormap = rgba256x1 != null ? rgba256x1.clone() : null;
+            pendingUserColormapDirty = true;
+        }
+    }
+
+    public void clearUserColormap() {
+        setUserColormapRgba(null);
+    }
+
+    public void setActiveUnix(@Nullable Long unix) {
+        synchronized (lock) {
+            targetUnix = unix;
+            if (unix != null && cache.containsKey(unix)) {
+                activeUnix = unix;
+            } else if (unix != null) {
+                activeUnix = null;
+            } else {
+                activeUnix = null;
+            }
+        }
+    }
+
+    /** Instant scrub when {@code unix} is already decoded — no decode work (parity with NEXRAD LRU activate). */
+    public void activateCachedUnix(long unix) {
+        synchronized (lock) {
+            targetUnix = unix;
+            if (cache.containsKey(unix)) {
+                activeUnix = unix;
+            }
+        }
+    }
+
+    public boolean isFrameCached(long unix) {
+        synchronized (lock) {
+            return cache.containsKey(unix);
+        }
+    }
+
+    /** Enqueue upload — must be called from the process main thread (after decode). GL work runs in {@link #render}. */
+    public void queueGpuUpload(@NonNull PendingGpuUpload upload) {
+        synchronized (lock) {
+            pendingGpuQueue.addLast(upload);
+        }
+    }
+
+    public void clearAll() {
+        synchronized (lock) {
+            pendingGpuQueue.clear();
+            for (GpuSlot s : cache.values()) {
+                pendingDelete.add(s);
+            }
+            cache.clear();
+            activeUnix = null;
+            targetUnix = null;
+        }
+    }
+
+    private void putSlotEvictLru(@NonNull GpuSlot slot) {
+        GpuSlot prev = cache.put(slot.unix, slot);
+        if (prev != null) {
+            pendingDelete.add(prev);
+        }
+        while (cache.size() > MAX_GPU_CACHED_FRAMES) {
+            Iterator<Map.Entry<Long, GpuSlot>> it = cache.entrySet().iterator();
+            if (!it.hasNext()) {
+                break;
+            }
+            GpuSlot victim = it.next().getValue();
+            it.remove();
+            pendingDelete.add(victim);
+        }
+    }
+
+    private void drainDeletesOnGl() {
+        for (GpuSlot s : pendingDelete) {
+            int[] tx = new int[] {s.textureId};
+            GLES20.glDeleteTextures(1, tx, 0);
+            int[] bufs = new int[] {s.vbo, s.ibo};
+            GLES20.glDeleteBuffers(2, bufs, 0);
+        }
+        pendingDelete.clear();
+    }
+
+    private void applyUserColormapGlIfNeeded() {
+        if (!pendingUserColormapDirty) return;
+        pendingUserColormapDirty = false;
+        byte[] rgba = pendingUserColormap;
+        if (userColormapTex != 0) {
+            GLES20.glDeleteTextures(1, new int[] {userColormapTex}, 0);
+            userColormapTex = 0;
+        }
+        if (rgba != null && rgba.length >= 256 * 4) {
+            userColormapTex = uploadColormapTexture(rgba);
+        }
+    }
+
+    private GpuSlot uploadPendingOnGl(@NonNull PendingGpuUpload p) {
+        SatelliteKtxDecoder.Parsed decoded = p.decoded;
+        int fmt = decoded.basisFormatOrdinal;
+        byte[] payload = decoded.payload;
+        int w = decoded.width;
+        int h = decoded.height;
+
+        int[] texArr = new int[1];
+        GLES20.glGenTextures(1, texArr, 0);
+        int texId = texArr[0];
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texId);
+        int filter = fillSmoothing != 0 ? GLES20.GL_LINEAR : GLES20.GL_NEAREST;
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, filter);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, filter);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+
+        if (fmt == SatelliteKtxDecoder.TF_RGBA32) {
+            GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 4);
+            ByteBuffer bb = ByteBuffer.allocateDirect(payload.length).order(ByteOrder.nativeOrder());
+            bb.put(payload);
+            bb.flip();
+            GLES20.glTexImage2D(
+                    GLES20.GL_TEXTURE_2D,
+                    0,
+                    GLES20.GL_RGBA,
+                    w,
+                    h,
+                    0,
+                    GLES20.GL_RGBA,
+                    GLES20.GL_UNSIGNED_BYTE,
+                    bb);
+        } else if (fmt == SatelliteKtxDecoder.TF_ASTC_LDR_4x4_RGBA) {
+            GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
+            ByteBuffer bb = ByteBuffer.allocateDirect(payload.length).order(ByteOrder.nativeOrder());
+            bb.put(payload);
+            bb.flip();
+            GLES20.glCompressedTexImage2D(
+                    GLES20.GL_TEXTURE_2D,
+                    0,
+                    GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+                    w,
+                    h,
+                    0,
+                    payload.length,
+                    bb);
+        } else if (fmt == SatelliteKtxDecoder.TF_ETC2_RGBA) {
+            GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
+            ByteBuffer bb = ByteBuffer.allocateDirect(payload.length).order(ByteOrder.nativeOrder());
+            bb.put(payload);
+            bb.flip();
+            GLES20.glCompressedTexImage2D(
+                    GLES20.GL_TEXTURE_2D,
+                    0,
+                    GL_COMPRESSED_RGBA8_ETC2_EAC,
+                    w,
+                    h,
+                    0,
+                    payload.length,
+                    bb);
+        } else {
+            Log.w(TAG, "Unknown basis format ordinal " + fmt + ", skipping texture");
+            GLES20.glDeleteTextures(1, texArr, 0);
+            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+            return null;
+        }
+
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+
+        FloatBuffer vb = p.mesh.vertexBuffer;
+        vb.position(0);
+        IntBuffer ib = p.mesh.indexBuffer;
+        ib.position(0);
+
+        int[] bufs = new int[2];
+        GLES20.glGenBuffers(2, bufs, 0);
+        int vbo = bufs[0];
+        int ibo = bufs[1];
+
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vbo);
+        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vb.remaining() * 4, vb, GLES20.GL_STATIC_DRAW);
+        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, ibo);
+        GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, ib.remaining() * 4, ib, GLES20.GL_STATIC_DRAW);
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
+        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
+
+        return new GpuSlot(
+                p.unix,
+                texId,
+                vbo,
+                ibo,
+                p.mesh.indexCount,
+                p.trueColor,
+                p.useColormap,
+                p.colormapKind);
+    }
+
+    @Override
+    public void render(@NonNull CustomLayerRenderParameters params) {
+        if (program == 0) return;
+
+        synchronized (lock) {
+            drainDeletesOnGl();
+
+            while (!pendingGpuQueue.isEmpty()) {
+                PendingGpuUpload pu = pendingGpuQueue.pollFirst();
+                GpuSlot uploaded = uploadPendingOnGl(pu);
+                if (uploaded != null) {
+                    putSlotEvictLru(uploaded);
+                    drainDeletesOnGl();
+                    if (targetUnix != null && targetUnix.equals(uploaded.unix)) {
+                        activeUnix = uploaded.unix;
+                    }
+                }
+            }
+
+            applyUserColormapGlIfNeeded();
+        }
+
+        if (!visible || opacity <= 0f) return;
+
+        GpuSlot draw;
+        synchronized (lock) {
+            draw = activeUnix != null ? cache.get(activeUnix) : null;
+        }
+        if (draw == null || draw.indexCount <= 0) return;
+
+        GLES20.glUseProgram(program);
+
+        List<Double> matrixList = params.getProjectionMatrix();
+        float[] floatMatrix = new float[16];
+        for (int i = 0; i < 16; i++) {
+            floatMatrix[i] = matrixList.get(i).floatValue();
+        }
+        double zoom = params.getZoom();
+        double scale = Math.pow(2.0, zoom);
+        floatMatrix[0] *= scale;
+        floatMatrix[1] *= scale;
+        floatMatrix[2] *= scale;
+        floatMatrix[3] *= scale;
+        floatMatrix[4] *= scale;
+        floatMatrix[5] *= scale;
+        floatMatrix[6] *= scale;
+        floatMatrix[7] *= scale;
+        floatMatrix[8] *= scale;
+        floatMatrix[9] *= scale;
+        floatMatrix[10] *= scale;
+        floatMatrix[11] *= scale;
+
+        GLES20.glUniformMatrix4fv(uMatrix, 1, false, floatMatrix, 0);
+
+        GLES20.glUniform1i(uIsTrueColor, draw.trueColor ? 1 : 0);
+        GLES20.glUniform1i(uUseColormap, draw.useColormap ? 1 : 0);
+        GLES20.glUniform1f(uOpacity, opacity);
+        GLES20.glUniform4f(uUvTransform, 1f, 1f, 0f, 0f);
+
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, draw.textureId);
+        GLES20.glUniform1i(uTexture, 0);
+
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
+        int cmapId = defaultIrColormapTex;
+        if (draw.useColormap) {
+            if (userColormapTex != 0) {
+                cmapId = userColormapTex;
+            } else if ("wv".equals(draw.colormapKind)) {
+                cmapId = defaultWvColormapTex;
+            } else if ("ir".equals(draw.colormapKind)) {
+                cmapId = defaultIrColormapTex;
+            }
+        }
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, cmapId);
+        GLES20.glUniform1i(uColormap, 1);
+
+        GLES20.glEnable(GLES20.GL_BLEND);
+        GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
+        GLES20.glDisable(GLES20.GL_DEPTH_TEST);
+
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, draw.vbo);
+        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, draw.ibo);
+
+        GLES20.glEnableVertexAttribArray(aPos);
+        GLES20.glVertexAttribPointer(aPos, 2, GLES20.GL_FLOAT, false, 16, 0);
+
+        GLES20.glEnableVertexAttribArray(aTexCoord);
+        GLES20.glVertexAttribPointer(aTexCoord, 2, GLES20.GL_FLOAT, false, 16, 8);
+
+        GLES20.glDrawElements(GLES20.GL_TRIANGLES, draw.indexCount, GLES20.GL_UNSIGNED_INT, 0);
+
+        GLES20.glDisableVertexAttribArray(aPos);
+        GLES20.glDisableVertexAttribArray(aTexCoord);
+
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
+        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
+
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+    }
+
+    @Override
+    public void deinitialize() {
+        synchronized (lock) {
+            pendingGpuQueue.clear();
+            for (GpuSlot s : cache.values()) {
+                pendingDelete.add(s);
+            }
+            cache.clear();
+            activeUnix = null;
+            targetUnix = null;
+        }
+        drainDeletesOnGl();
+        if (defaultIrColormapTex != 0) {
+            GLES20.glDeleteTextures(1, new int[] {defaultIrColormapTex}, 0);
+            defaultIrColormapTex = 0;
+        }
+        if (defaultWvColormapTex != 0) {
+            GLES20.glDeleteTextures(1, new int[] {defaultWvColormapTex}, 0);
+            defaultWvColormapTex = 0;
+        }
+        if (userColormapTex != 0) {
+            GLES20.glDeleteTextures(1, new int[] {userColormapTex}, 0);
+            userColormapTex = 0;
+        }
+        if (program != 0) {
+            GLES20.glDeleteProgram(program);
+            program = 0;
+        }
+    }
+
+    @Override
+    public void contextLost() {
+        synchronized (lock) {
+            pendingGpuQueue.clear();
+            cache.clear();
+            program = 0;
+        }
+    }
+}

package/android/src/main/java/com/aguacerowx/reactnative/SatelliteLayerManager.java

@@ -0,0 +1,79 @@
+package com.aguacerowx.reactnative;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SatelliteLayerManager extends SimpleViewManager<SatelliteLayerView> {
+
+    private static final String REACT_CLASS = "SatelliteLayer";
+    private static final int CMD_SYNC = 1;
+    private static final int CMD_CLEAR = 2;
+    private static final int CMD_ACTIVATE_CACHED = 3;
+    private static final int CMD_STYLE = 4;
+
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @NonNull
+    @Override
+    protected SatelliteLayerView createViewInstance(@NonNull ThemedReactContext reactContext) {
+        return new SatelliteLayerView(reactContext);
+    }
+
+    @ReactProp(name = "belowID")
+    public void setBelowID(SatelliteLayerView view, @Nullable String belowID) {
+        view.setBelowID(belowID);
+    }
+
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        Map<String, Integer> m = new HashMap<>();
+        m.put("syncSatellite", CMD_SYNC);
+        m.put("clearSatellite", CMD_CLEAR);
+        m.put("activateSatelliteCachedUnix", CMD_ACTIVATE_CACHED);
+        m.put("updateSatelliteStyle", CMD_STYLE);
+        return m;
+    }
+
+    @Override
+    public void receiveCommand(
+            @NonNull SatelliteLayerView view, int commandId, @Nullable ReadableArray args) {
+        switch (commandId) {
+            case CMD_CLEAR:
+                view.clearSatellite();
+                return;
+            case CMD_SYNC:
+                if (args != null && args.size() > 0) {
+                    view.syncFromJson(args.getString(0));
+                }
+                return;
+            case CMD_ACTIVATE_CACHED:
+                if (args != null && args.size() > 0) {
+                    try {
+                        double u = args.getDouble(0);
+                        view.activateSatelliteCachedUnix((long) u);
+                    } catch (Exception ignored) {
+                    }
+                }
+                return;
+            case CMD_STYLE:
+                if (args != null && args.size() > 0) {
+                    view.updateStyleFromJson(args.getString(0));
+                }
+                return;
+            default:
+                break;
+        }
+    }
+}