@pompadour/react-native-skia 1.4.0

package/android/src/main/java/com/shopify/reactnative/skia/PlatformContext.java

@@ -0,0 +1,195 @@
+package com.shopify.reactnative.skia;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.view.Choreographer;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactContext;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLConnection;
+
+public class PlatformContext {
+    @DoNotStrip
+    private final HybridData mHybridData;
+
+    private final ReactContext mContext;
+
+    private boolean _drawLoopActive = false;
+    private boolean _isPaused = false;
+
+    private final String TAG = "PlatformContext";
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+
+    public PlatformContext(ReactContext reactContext) {
+        mContext = reactContext;
+        mHybridData = initHybrid(reactContext.getResources().getDisplayMetrics().density);
+    }
+
+    @DoNotStrip
+    public Object createVideo(String url) {
+        return new RNSkVideo(mContext, url);
+    }
+
+    private byte[] getStreamAsBytes(InputStream is) throws IOException {
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        int nRead;
+        byte[] data = new byte[4 * 0x400];
+        while ((nRead = is.read(data, 0, data.length)) != -1) {
+            buffer.write(data, 0, nRead);
+        }
+        return buffer.toByteArray();
+    }
+
+    private void postFrameLoop() {
+        Choreographer.FrameCallback frameCallback = new Choreographer.FrameCallback() {
+            @Override
+            public void doFrame(long frameTimeNanos) {
+                if (_drawLoopActive) {
+                    Choreographer.getInstance().postFrameCallback(this);
+                }
+                if (_isPaused) {
+                    return;
+                }
+                notifyDrawLoop();
+            }
+        };
+        Choreographer.getInstance().postFrameCallback(frameCallback);
+    }
+
+
+    @DoNotStrip
+    public void notifyTaskReadyOnMainThread() {
+        mainHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                notifyTaskReady();
+            }
+        });
+    }
+
+    @DoNotStrip
+    Object takeScreenshotFromViewTag(int tag) {
+        return ViewScreenshotService.makeViewScreenshotFromTag(mContext, tag);
+    }
+
+    @DoNotStrip
+    public void raise(final String message) {
+        mainHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                mContext.handleException(new Exception(message));
+            }
+        });
+    }
+
+    @DoNotStrip
+    public void beginDrawLoop() {
+        if (_drawLoopActive) {
+            return;
+        }
+        _drawLoopActive = true;
+        mainHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                postFrameLoop();
+            }
+        });
+    }
+
+    @DoNotStrip
+    public void endDrawLoop() {
+        if (_drawLoopActive) {
+            _drawLoopActive = false;
+        }
+    }
+
+    @DoNotStrip
+    public byte[] getJniStreamFromSource(String sourceUri) throws IOException {
+        // First try loading the input as a resource directly
+        int resourceId = mContext.getResources().getIdentifier(sourceUri, "drawable", mContext.getPackageName());
+
+        // Test to see if we have a raw resource (for SVG)
+        if (resourceId == 0) {
+            resourceId = mContext.getResources().getIdentifier(sourceUri, "raw", mContext.getPackageName());
+        }
+
+        if (resourceId != 0) {
+            // We can just return the input stream directly
+            return getStreamAsBytes(mContext.getResources().openRawResource(resourceId));
+        }
+
+        // We should try to open a connection and return a stream to download this
+        // object
+        URI uri = null;
+        try {
+            uri = new URI(sourceUri);
+
+            String scheme = uri.getScheme();
+
+            if (scheme == null)
+                throw new Exception("Invalid URI scheme");
+
+            // TODO: Base64??
+
+            URL url = uri.toURL();
+            URLConnection connection = url.openConnection();
+            connection.connect();
+
+            BufferedInputStream b = new BufferedInputStream(url.openStream(), 8192);
+            return getStreamAsBytes(b);
+
+        } catch (URISyntaxException e) {
+            e.printStackTrace();
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    void onPause() {
+        Log.i(TAG, "Paused");
+        _isPaused = true;
+    }
+
+    void onResume() {
+        _isPaused = false;
+        Log.i(TAG, "Resume");
+        if(_drawLoopActive) {
+            // Restart draw loop
+            mainHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    postFrameLoop();
+                }
+            });
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        mHybridData.resetNative();
+        super.finalize();
+    }
+
+    // Private c++ native methods
+    private native HybridData initHybrid(float pixelDensity);
+    private native void notifyDrawLoop();
+    private native void notifyTaskReady();
+}

package/android/src/main/java/com/shopify/reactnative/skia/RNSkVideo.java

@@ -0,0 +1,266 @@
+package com.shopify.reactnative.skia;
+
+import android.content.Context;
+import android.graphics.ImageFormat;
+import android.hardware.HardwareBuffer;
+import android.media.AudioAttributes;
+import android.media.AudioManager;
+import android.media.MediaCodec;
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.media.MediaPlayer;
+import android.media.MediaSync;
+import android.media.Image;
+import android.media.ImageReader;
+import android.net.Uri;
+import android.os.Build;
+import android.view.Surface;
+import android.graphics.Point;
+
+import androidx.annotation.RequiresApi;
+
+import com.facebook.jni.annotations.DoNotStrip;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+public class RNSkVideo {
+    private final Uri uri;
+    private final Context context;
+
+    private MediaExtractor extractor;
+    private MediaCodec decoder;
+    private ImageReader imageReader;
+    private Surface outputSurface;
+    private MediaPlayer mediaPlayer;
+    private MediaSync mediaSync;
+    private double durationMs;
+    private double frameRate;
+    private int rotationDegrees = 0;
+    private int width = 0;
+    private int height = 0;
+
+    private boolean isPlaying = false;
+
+    RNSkVideo(Context context, String localUri) {
+        this.uri = Uri.parse(localUri);
+        this.context = context;
+        this.initializeReader();
+    }
+
+    private void initializeReader() {
+        extractor = new MediaExtractor();
+        try {
+            extractor.setDataSource(context, this.uri, null);
+            int trackIndex = selectVideoTrack(extractor);
+            if (trackIndex < 0) {
+                throw new RuntimeException("No video track found in " + this.uri);
+            }
+            extractor.selectTrack(trackIndex);
+            MediaFormat format = extractor.getTrackFormat(trackIndex);
+
+            // Initialize MediaPlayer
+            mediaPlayer = new MediaPlayer();
+            mediaPlayer.setDataSource(context, uri);
+            mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
+            mediaPlayer.setOnPreparedListener(mp -> {
+                durationMs = mp.getDuration();
+                mp.start();
+                isPlaying = true;
+            });
+            mediaPlayer.prepareAsync();
+
+            // Retrieve and store video properties
+            if (format.containsKey(MediaFormat.KEY_DURATION)) {
+                durationMs = format.getLong(MediaFormat.KEY_DURATION) / 1000;  // Convert microseconds to milliseconds
+            }
+            if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) {
+                frameRate = format.getInteger(MediaFormat.KEY_FRAME_RATE);
+            }
+            if (format.containsKey(MediaFormat.KEY_ROTATION)) {
+                rotationDegrees = format.getInteger(MediaFormat.KEY_ROTATION);
+            }
+            width = format.getInteger(MediaFormat.KEY_WIDTH);
+            height = format.getInteger(MediaFormat.KEY_HEIGHT);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                imageReader = ImageReader.newInstance(
+                        width,
+                        height,
+                        ImageFormat.PRIVATE,
+                        2,
+                        HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE
+                );
+            } else {
+                imageReader = ImageReader.newInstance(width, height,
+                        ImageFormat.PRIVATE, 2);
+            }
+            outputSurface = imageReader.getSurface();
+
+            // Create a decoder for the format
+            String mime = format.getString(MediaFormat.KEY_MIME);
+            decoder = MediaCodec.createDecoderByType(mime);
+
+            // Note: Use an output Surface for rendering if necessary, otherwise handle buffers
+            decoder.configure(format, outputSurface, null, 0);
+            decoder.start();
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to initialize extractor or decoder", e);
+        }
+    }
+
+    @DoNotStrip
+    public double getDuration() {
+        return durationMs;
+    }
+
+    @DoNotStrip
+    public double getFrameRate() {
+        return frameRate;
+    }
+
+    @DoNotStrip
+    public int getRotationDegrees() {
+        return rotationDegrees;
+    }
+
+    @DoNotStrip
+    public HardwareBuffer nextImage() {
+        if (!decoderOutputAvailable()) {
+            decodeFrame();
+        }
+
+        Image image = imageReader.acquireLatestImage();
+        if (image != null) {
+            HardwareBuffer hardwareBuffer = image.getHardwareBuffer();
+            image.close();  // Make sure to close the Image to free up the buffer
+            return hardwareBuffer;
+        }
+        return null;
+    }
+
+    @DoNotStrip
+    public void seek(double timestamp) {
+        // Log the values for debugging
+
+        long timestampUs = (long)(timestamp * 1000); // Convert milliseconds to microseconds
+
+        extractor.seekTo(timestampUs, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
+        if (mediaPlayer != null) {
+            int timestampMs = (int) timestamp; // Convert to milliseconds
+            mediaPlayer.seekTo(timestampMs, MediaPlayer.SEEK_CLOSEST);
+        }
+
+        // Flush the codec to reset internal state and buffers
+        if (decoder != null) {
+            decoder.flush();
+
+            // Decode frames until reaching the exact timestamp
+            boolean isSeeking = true;
+            while (isSeeking) {
+                decodeFrame();
+                long currentTimestampUs = extractor.getSampleTime();
+                if (currentTimestampUs >= timestampUs) {
+                    isSeeking = false;
+                }
+            }
+        }
+    }
+
+    @DoNotStrip
+    public Point getSize() {
+        return new Point(width, height);
+    }
+
+    private int selectVideoTrack(MediaExtractor extractor) {
+        int numTracks = extractor.getTrackCount();
+        for (int i = 0; i < numTracks; i++) {
+            MediaFormat format = extractor.getTrackFormat(i);
+            String mime = format.getString(MediaFormat.KEY_MIME);
+            if (mime.startsWith("video/")) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private boolean decoderOutputAvailable() {
+        MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
+        int outputBufferId = decoder.dequeueOutputBuffer(info, 0);
+        if (outputBufferId >= 0) {
+            // If a buffer is available, release it immediately back since we are just checking
+            decoder.releaseOutputBuffer(outputBufferId, true);
+            return true;
+        }
+        return false;
+    }
+
+    private void decodeFrame() {
+        MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
+        long timeoutUs = 10000;
+        boolean isEOS = false;
+
+        int inputBufferId = decoder.dequeueInputBuffer(timeoutUs);
+        if (inputBufferId >= 0) {
+            ByteBuffer inputBuffer = decoder.getInputBuffer(inputBufferId);
+            int sampleSize = extractor.readSampleData(inputBuffer, 0);
+            if (sampleSize < 0) {
+                // End of stream, make sure to send this information to the decoder
+                decoder.queueInputBuffer(inputBufferId, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
+                isEOS = true;
+            } else {
+                long presentationTimeUs = extractor.getSampleTime();
+                decoder.queueInputBuffer(inputBufferId, 0, sampleSize, presentationTimeUs, 0);
+                extractor.advance();
+            }
+        }
+
+        int outputBufferId = decoder.dequeueOutputBuffer(info, timeoutUs);
+        if (outputBufferId >= 0) {
+            // If we have a valid buffer, release it to make it available to the ImageReader's surface
+            decoder.releaseOutputBuffer(outputBufferId, true);
+
+            if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                isEOS = true;
+            }
+        }
+    }
+
+    @DoNotStrip
+    public void play() {
+        if (mediaPlayer != null && !isPlaying) {
+            mediaPlayer.start();
+            isPlaying = true;
+        }
+    }
+
+    @DoNotStrip
+    public void pause() {
+        if (mediaPlayer != null && isPlaying) {
+            mediaPlayer.pause();
+            isPlaying = false;
+        }
+    }
+
+    @DoNotStrip
+    public void setVolume(float volume) {
+        if (mediaPlayer != null) {
+            mediaPlayer.setVolume(volume, volume);
+        }
+    }
+
+    public void release() {
+        if (mediaPlayer != null) {
+            mediaPlayer.release();
+            mediaPlayer = null;
+        }
+        if (decoder != null) {
+            decoder.stop();
+            decoder.release();
+            decoder = null;
+        }
+        if (extractor != null) {
+            extractor.release();
+            extractor = null;
+        }
+    }
+}

package/android/src/main/java/com/shopify/reactnative/skia/RNSkiaModule.java

@@ -0,0 +1,87 @@
+// RnskiaModule.java
+
+package com.shopify.reactnative.skia;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+import java.lang.ref.WeakReference;
+
+@ReactModule(name="RNSkiaModule")
+public class RNSkiaModule extends NativeSkiaModuleSpec implements LifecycleEventListener {
+    public static final String NAME = "RNSkiaModule";
+
+    private final WeakReference<ReactApplicationContext> weakReactContext;
+    private SkiaManager skiaManager;
+
+    public RNSkiaModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.weakReactContext = new WeakReference<>(reactContext);
+        reactContext.addLifecycleEventListener(this);
+    }
+
+    @Override
+    public void invalidate() {
+        super.invalidate();
+
+        if (getReactApplicationContext() != null) {
+            getReactApplicationContext().removeLifecycleEventListener(this);
+        }
+
+        if (this.skiaManager != null) {
+            this.skiaManager.invalidate();
+            this.skiaManager.destroy();
+            this.skiaManager = null;
+        }
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    public SkiaManager getSkiaManager() {
+        return skiaManager;
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public boolean install() {
+        if (skiaManager != null) {
+            // Already initialized, ignore call.
+            return true;
+        }
+
+        try {
+            System.loadLibrary("rnskia");
+            ReactApplicationContext context = weakReactContext.get();
+            if (context == null) {
+                Log.e(NAME, "React Application Context was null!");
+                return false;
+            }
+            skiaManager = new SkiaManager(context);
+            return true;
+        } catch (Exception exception) {
+            Log.e(NAME, "Failed to initialize Skia Manager!", exception);
+            return false;
+        }
+    }
+
+    @Override
+    public void onHostResume() {
+        if(skiaManager != null) skiaManager.onHostResume();
+    }
+
+    @Override
+    public void onHostPause() {
+        if(skiaManager != null) skiaManager.onHostPause();
+    }
+
+    @Override
+    public void onHostDestroy() {
+
+    }
+}

package/android/src/main/java/com/shopify/reactnative/skia/RNSkiaPackage.java

@@ -0,0 +1,77 @@
+// RnskiaPackage.java
+
+package com.shopify.reactnative.skia;
+
+import androidx.annotation.Nullable;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.module.annotations.ReactModuleList;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import com.facebook.react.uimanager.ViewManager;
+
+@ReactModuleList(
+        nativeModules = {
+                RNSkiaModule.class,
+        })
+public class RNSkiaPackage extends TurboReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(new RNSkiaModule(reactContext));
+    }
+
+    @Nullable
+    @Override
+    public NativeModule getModule(String s, ReactApplicationContext reactApplicationContext) {
+        switch (s) {
+            case RNSkiaModule.NAME:
+                return new RNSkiaModule(reactApplicationContext);
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Arrays.<ViewManager>asList(new SkiaPictureViewManager(), new SkiaDomViewManager());
+    }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return new ReactModuleInfoProvider() {
+            @Override
+            public Map<String, ReactModuleInfo> getReactModuleInfos() {
+                final Map<String, ReactModuleInfo> reactModuleInfoMap = new HashMap<>();
+                Class<? extends NativeModule>[] moduleList =
+                        new Class[] {
+                                RNSkiaModule.class,
+                        };
+
+                for (Class<? extends NativeModule> moduleClass : moduleList) {
+                    ReactModule reactModule = moduleClass.getAnnotation(ReactModule.class);
+
+                    reactModuleInfoMap.put(
+                            reactModule.name(),
+                            new ReactModuleInfo(
+                                    reactModule.name(),
+                                    moduleClass.getName(),
+                                    reactModule.canOverrideExistingModule(),
+                                    reactModule.needsEagerInit(),
+                                    reactModule.hasConstants(),
+                                    reactModule.isCxxModule(),
+                                    TurboModule.class.isAssignableFrom(moduleClass)));
+                }
+                return reactModuleInfoMap;
+            }
+        };
+    }
+}