react-native-pdf-jsi 1.0.1

package/android/src/main/java/org/wonday/pdf/PdfView.java

@@ -0,0 +1,505 @@
+/**
+ * Copyright (c) 2017-present, Wonday (@wonday.org)
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package org.wonday.pdf;
+
+import java.io.File;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.util.SizeF;
+import android.view.View;
+import android.view.ViewGroup;
+import android.util.Log;
+import android.net.Uri;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.graphics.Canvas;
+
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.github.barteksc.pdfviewer.PDFView;
+import com.github.barteksc.pdfviewer.listener.OnPageChangeListener;
+import com.github.barteksc.pdfviewer.listener.OnLoadCompleteListener;
+import com.github.barteksc.pdfviewer.listener.OnErrorListener;
+import com.github.barteksc.pdfviewer.listener.OnTapListener;
+import com.github.barteksc.pdfviewer.listener.OnDrawListener;
+import com.github.barteksc.pdfviewer.listener.OnPageScrollListener;
+import com.github.barteksc.pdfviewer.util.FitPolicy;
+import com.github.barteksc.pdfviewer.util.Constants;
+import com.github.barteksc.pdfviewer.link.LinkHandler;
+import com.github.barteksc.pdfviewer.model.LinkTapEvent;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+
+import static java.lang.String.format;
+
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+
+import com.google.gson.Gson;
+
+import org.wonday.pdf.events.TopChangeEvent;
+
+public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompleteListener,OnErrorListener,OnTapListener,OnDrawListener,OnPageScrollListener, LinkHandler {
+    private int page = 1;               // start from 1
+    private boolean horizontal = false;
+    private float scale = 1;
+    private float minScale = 1;
+    private float maxScale = 3;
+    private String path;
+    private int spacing = 10;
+    private String password = "";
+    private boolean enableAntialiasing = true;
+    private boolean enableAnnotationRendering = true;
+    private boolean enableDoubleTapZoom = true;
+
+    private boolean enablePaging = false;
+    private boolean autoSpacing = false;
+    private boolean pageFling = false;
+    private boolean pageSnap = false;
+    private FitPolicy fitPolicy = FitPolicy.WIDTH;
+    private boolean singlePage = false;
+    private boolean scrollEnabled = true;
+
+    private float originalWidth = 0;
+    private float lastPageWidth = 0;
+    private float lastPageHeight = 0;
+
+    // used to store the parameters for `super.onSizeChanged`
+    private int oldW = 0;
+    private int oldH = 0;
+
+    public PdfView(Context context, AttributeSet set){
+        super(context, set);
+    }
+
+    @Override
+    public void onPageChanged(int page, int numberOfPages) {
+        // pdf lib page start from 0, convert it to our page (start from 1)
+        page = page+1;
+        this.page = page;
+        showLog(format("%s %s / %s", path, page, numberOfPages));
+
+        WritableMap event = Arguments.createMap();
+        event.putString("message", "pageChanged|"+page+"|"+numberOfPages);
+
+        ThemedReactContext context = (ThemedReactContext) getContext();
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, getId());
+        int surfaceId = UIManagerHelper.getSurfaceId(this);
+
+        TopChangeEvent tce = new TopChangeEvent(surfaceId, getId(), event);
+
+        if (dispatcher != null) {
+            dispatcher.dispatchEvent(tce);
+        }
+
+//        ReactContext reactContext = (ReactContext)this.getContext();
+//        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+//            this.getId(),
+//            "topChange",
+//            event
+//         );
+    }
+
+    // In some cases Yoga (I think) will measure the view only along one axis first, resulting in
+    // onSizeChanged being called with either w or h set to zero. This in turn starts the rendering
+    // of the pdf under the hood with one dimension being set to zero and the follow-up call to
+    // onSizeChanged with the correct dimensions doesn't have any effect on the already started process.
+    // The offending class is DecodingAsyncTask, which tries to get width and height of the pdfView
+    // in the constructor, and is created as soon as the measurement is complete, which in some cases
+    // may be incomplete as described above.
+    // By delaying calling super.onSizeChanged until the size in both dimensions is correct we are able
+    // to prevent this from happening.
+    //
+    // I'm not sure whether the second condition is necessary, but without it, it would be impossible
+    // to set the dimensions to zero after first measurement.
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        if ((w > 0 && h > 0) || this.oldW > 0 || this.oldH > 0) {
+            super.onSizeChanged(w, h, this.oldW, this.oldH);
+            this.oldW = w;
+            this.oldH = h;
+        }
+    }
+
+    @Override
+    public void loadComplete(int numberOfPages) {
+        SizeF pageSize = getPageSize(0);
+        float width = pageSize.getWidth();
+        float height = pageSize.getHeight();
+
+        this.zoomTo(this.scale);
+        WritableMap event = Arguments.createMap();
+
+        //create a new json Object for the TableOfContents
+        Gson gson = new Gson();
+        event.putString("message", "loadComplete|"+numberOfPages+"|"+width+"|"+height+"|"+gson.toJson(this.getTableOfContents()));
+
+        ThemedReactContext context = (ThemedReactContext) getContext();
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, getId());
+        int surfaceId = UIManagerHelper.getSurfaceId(this);
+
+        TopChangeEvent tce = new TopChangeEvent(surfaceId, getId(), event);
+
+        if (dispatcher != null) {
+            dispatcher.dispatchEvent(tce);
+        }
+        //        ReactContext reactContext = (ReactContext)this.getContext();
+//        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+//            this.getId(),
+//            "topChange",
+//            event
+//         );
+
+        //Log.e("ReactNative", gson.toJson(this.getTableOfContents()));
+
+    }
+
+    @Override
+    public void onError(Throwable t){
+        WritableMap event = Arguments.createMap();
+        if (t.getMessage().contains("Password required or incorrect password")) {
+            event.putString("message", "error|Password required or incorrect password.");
+        } else {
+            event.putString("message", "error|"+t.getMessage());
+        }
+
+        ThemedReactContext context = (ThemedReactContext) getContext();
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, getId());
+        int surfaceId = UIManagerHelper.getSurfaceId(this);
+
+        TopChangeEvent tce = new TopChangeEvent(surfaceId, getId(), event);
+
+        if (dispatcher != null) {
+            dispatcher.dispatchEvent(tce);
+        }
+
+//        ReactContext reactContext = (ReactContext)this.getContext();
+//        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+//            this.getId(),
+//            "topChange",
+//            event
+//         );
+    }
+
+    @Override
+    public void onPageScrolled(int page, float positionOffset){
+
+        // maybe change by other instance, restore zoom setting
+        Constants.Pinch.MINIMUM_ZOOM = this.minScale;
+        Constants.Pinch.MAXIMUM_ZOOM = this.maxScale;
+
+    }
+
+    @Override
+    public boolean onTap(MotionEvent e){
+
+        // maybe change by other instance, restore zoom setting
+        //Constants.Pinch.MINIMUM_ZOOM = this.minScale;
+        //Constants.Pinch.MAXIMUM_ZOOM = this.maxScale;
+
+        WritableMap event = Arguments.createMap();
+        event.putString("message", "pageSingleTap|"+page+"|"+e.getX()+"|"+e.getY());
+
+        ThemedReactContext context = (ThemedReactContext) getContext();
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, getId());
+        int surfaceId = UIManagerHelper.getSurfaceId(this);
+
+        TopChangeEvent tce = new TopChangeEvent(surfaceId, getId(), event);
+
+        if (dispatcher != null) {
+            dispatcher.dispatchEvent(tce);
+        }
+//        ReactContext reactContext = (ReactContext)this.getContext();
+//        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+//            this.getId(),
+//            "topChange",
+//            event
+//         );
+
+        // process as tap
+         return true;
+
+    }
+
+    @Override
+    public void onLayerDrawn(Canvas canvas, float pageWidth, float pageHeight, int displayedPage){
+        if (originalWidth == 0) {
+            originalWidth = pageWidth;
+        }
+        
+        if (lastPageWidth>0 && lastPageHeight>0 && (pageWidth!=lastPageWidth || pageHeight!=lastPageHeight)) {
+            // maybe change by other instance, restore zoom setting
+            Constants.Pinch.MINIMUM_ZOOM = this.minScale;
+            Constants.Pinch.MAXIMUM_ZOOM = this.maxScale;
+
+            WritableMap event = Arguments.createMap();
+            event.putString("message", "scaleChanged|"+(pageWidth/originalWidth));
+            ThemedReactContext context = (ThemedReactContext) getContext();
+            EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, getId());
+            int surfaceId = UIManagerHelper.getSurfaceId(this);
+
+            TopChangeEvent tce = new TopChangeEvent(surfaceId, getId(), event);
+
+            if (dispatcher != null) {
+                dispatcher.dispatchEvent(tce);
+            }
+//            ReactContext reactContext = (ReactContext)this.getContext();
+//            reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+//                this.getId(),
+//                "topChange",
+//                event
+//             );
+        }
+
+        lastPageWidth = pageWidth;
+        lastPageHeight = pageHeight;
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        if (this.isRecycled())
+            this.drawPdf();
+    }
+
+    public void drawPdf() {
+        showLog(format("drawPdf path:%s %s", this.path, this.page));
+
+        if (this.path != null){
+
+            // set scale
+            this.setMinZoom(this.minScale);
+            this.setMaxZoom(this.maxScale);
+            this.setMidZoom((this.maxScale+this.minScale)/2);
+            Constants.Pinch.MINIMUM_ZOOM = this.minScale;
+            Constants.Pinch.MAXIMUM_ZOOM = this.maxScale;
+
+            Configurator configurator;
+
+            if (this.path.startsWith("content://")) {
+                ContentResolver contentResolver = getContext().getContentResolver();
+                InputStream inputStream = null;
+                Uri uri = Uri.parse(this.path);
+                try {
+                    inputStream = contentResolver.openInputStream(uri);
+                } catch (FileNotFoundException e) {
+                    throw new RuntimeException(e.getMessage());
+                }
+                configurator = this.fromStream(inputStream);
+            } else {
+                configurator = this.fromUri(getURI(this.path));
+            }
+
+            configurator.defaultPage(this.page-1)
+                .swipeHorizontal(this.horizontal)
+                .onPageChange(this)
+                .onLoad(this)
+                .onError(this)
+                .onDraw(this)
+                .onPageScroll(this)
+                .spacing(this.spacing)
+                .password(this.password)
+                .enableAntialiasing(this.enableAntialiasing)
+                .pageFitPolicy(this.fitPolicy)
+                .pageSnap(this.pageSnap)
+                .autoSpacing(this.autoSpacing)
+                .pageFling(this.pageFling)
+                .enableSwipe(!this.singlePage && this.scrollEnabled)
+                .enableDoubletap(!this.singlePage && this.enableDoubleTapZoom)
+                .enableAnnotationRendering(this.enableAnnotationRendering)
+                .linkHandler(this);
+
+            if (this.singlePage) {
+                configurator.pages(this.page-1);
+                setTouchesEnabled(false);
+            } else {
+                configurator.onTap(this);
+            }
+
+            configurator.load();
+        }
+    }
+
+    public void setEnableDoubleTapZoom(boolean enableDoubleTapZoom) {
+        this.enableDoubleTapZoom = enableDoubleTapZoom;
+    }
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    // page start from 1
+    public void setPage(int page) {
+        this.page = page>1?page:1;
+    }
+
+    public void setScale(float scale) {
+        this.scale = scale;
+    }
+
+    public void setMinScale(float minScale) {
+        this.minScale = minScale;
+    }
+
+    public void setMaxScale(float maxScale) {
+        this.maxScale = maxScale;
+    }
+
+    public void setHorizontal(boolean horizontal) {
+        this.horizontal = horizontal;
+    }
+
+    public void setScrollEnabled(boolean scrollEnabled) {
+        this.scrollEnabled = scrollEnabled;
+    }
+
+    public void setSpacing(int spacing) {
+        this.spacing = spacing;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public void setEnableAntialiasing(boolean enableAntialiasing) {
+        this.enableAntialiasing = enableAntialiasing;
+    }
+
+    public void setEnableAnnotationRendering(boolean enableAnnotationRendering) {
+        this.enableAnnotationRendering = enableAnnotationRendering;
+    }
+
+    public void setEnablePaging(boolean enablePaging) {
+        this.enablePaging = enablePaging;
+        if (this.enablePaging) {
+            this.autoSpacing = true;
+            this.pageFling = true;
+            this.pageSnap = true;
+        } else {
+            this.autoSpacing = false;
+            this.pageFling = false;
+            this.pageSnap = false;
+        }
+    }
+
+    public void setFitPolicy(int fitPolicy) {
+        switch(fitPolicy){
+            case 0:
+                this.fitPolicy = FitPolicy.WIDTH;
+                break;
+            case 1:
+                this.fitPolicy = FitPolicy.HEIGHT;
+                break;
+            case 2:
+            default:
+            {
+                this.fitPolicy = FitPolicy.BOTH;
+                break;
+            }
+        }
+
+    }
+
+    public void setSinglePage(boolean singlePage) {
+        this.singlePage = singlePage;
+    }
+
+    /**
+     * @see https://github.com/barteksc/AndroidPdfViewer/blob/master/android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/link/DefaultLinkHandler.java
+     */
+    public void handleLinkEvent(LinkTapEvent event) {
+        String uri = event.getLink().getUri();
+        Integer page = event.getLink().getDestPageIdx();
+        if (uri != null && !uri.isEmpty()) {
+            handleUri(uri);
+        } else if (page != null) {
+            handlePage(page);
+        }
+    }
+
+    /**
+     * @see https://github.com/barteksc/AndroidPdfViewer/blob/master/android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/link/DefaultLinkHandler.java
+     */
+    private void handleUri(String uri) {
+        WritableMap event = Arguments.createMap();
+        event.putString("message", "linkPressed|"+uri);
+
+        ThemedReactContext context = (ThemedReactContext) getContext();
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, getId());
+        int surfaceId = UIManagerHelper.getSurfaceId(this);
+
+        TopChangeEvent tce = new TopChangeEvent(surfaceId, getId(), event);
+
+        if (dispatcher != null) {
+            dispatcher.dispatchEvent(tce);
+        }
+
+//        ReactContext reactContext = (ReactContext)this.getContext();
+//        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
+//            this.getId(),
+//            "topChange",
+//            event
+//        );
+    }
+
+    /**
+     * @see https://github.com/barteksc/AndroidPdfViewer/blob/master/android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/link/DefaultLinkHandler.java
+     */
+    private void handlePage(int page) {
+        this.jumpTo(page);
+    }
+
+    private void showLog(final String str) {
+        Log.d("PdfView", str);
+    }
+
+    private Uri getURI(final String uri) {
+        Uri parsed = Uri.parse(uri);
+
+        if (parsed.getScheme() == null || parsed.getScheme().isEmpty()) {
+          return Uri.fromFile(new File(uri));
+        }
+        return parsed;
+    }
+
+    private void setTouchesEnabled(final boolean enabled) {
+        setTouchesEnabled(this, enabled);
+    }
+
+    private static void setTouchesEnabled(View v, final boolean enabled) {
+        if (enabled) {
+            v.setOnTouchListener(null);
+        } else {
+            v.setOnTouchListener(new View.OnTouchListener() {
+                @Override
+                public boolean onTouch(View v, MotionEvent event) {
+                    return true;
+                }
+            });
+        }
+
+        if (v instanceof ViewGroup) {
+            ViewGroup vg = (ViewGroup) v;
+            for (int i = 0; i < vg.getChildCount(); i++) {
+                View child = vg.getChildAt(i);
+                setTouchesEnabled(child, enabled);
+            }
+        }
+    }
+}

package/android/src/main/java/org/wonday/pdf/RNPDFPackage.java

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2017-present, Wonday (@wonday.org)
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package org.wonday.pdf;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.ArrayList;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+public class RNPDFPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        // Add JSI modules for enhanced PDF performance
+        modules.add(new PDFJSIManager(reactContext));
+        modules.add(new EnhancedPdfJSIBridge(reactContext));
+        return modules;
+    }
+
+    // Deprecated as of RN 0.47.0
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        List<ViewManager> modules = new ArrayList<>();
+        modules.add(new PdfManager(reactContext));
+        return modules;
+    }
+}

package/android/src/main/java/org/wonday/pdf/events/TopChangeEvent.java

@@ -0,0 +1,26 @@
+package org.wonday.pdf.events;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+
+public class TopChangeEvent extends Event<TopChangeEvent> {
+    private WritableMap eventData;
+
+    public TopChangeEvent(int surfaceId, int viewTag, WritableMap data) {
+        super(surfaceId, viewTag);
+        eventData = data;
+    }
+
+    @Override
+    public String getEventName() {
+        return "topChange";
+    }
+
+    @Nullable
+    @Override
+    protected WritableMap getEventData() {
+        return eventData;
+    }
+}

package/android/src/paper/java/com/facebook/react/viewmanagers/RNPDFPdfViewManagerDelegate.java

@@ -0,0 +1,92 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaDelegate.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class RNPDFPdfViewManagerDelegate<T extends View, U extends BaseViewManager<T, ? extends LayoutShadowNode> & RNPDFPdfViewManagerInterface<T>> extends BaseViewManagerDelegate<T, U> {
+  public RNPDFPdfViewManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    switch (propName) {
+      case "path":
+        mViewManager.setPath(view, value == null ? null : (String) value);
+        break;
+      case "page":
+        mViewManager.setPage(view, value == null ? 0 : ((Double) value).intValue());
+        break;
+      case "scale":
+        mViewManager.setScale(view, value == null ? 0f : ((Double) value).floatValue());
+        break;
+      case "minScale":
+        mViewManager.setMinScale(view, value == null ? 0f : ((Double) value).floatValue());
+        break;
+      case "maxScale":
+        mViewManager.setMaxScale(view, value == null ? 0f : ((Double) value).floatValue());
+        break;
+      case "horizontal":
+        mViewManager.setHorizontal(view, value == null ? false : (boolean) value);
+        break;
+      case "showsHorizontalScrollIndicator":
+        mViewManager.setShowsHorizontalScrollIndicator(view, value == null ? false : (boolean) value);
+        break;
+      case "showsVerticalScrollIndicator":
+        mViewManager.setShowsVerticalScrollIndicator(view, value == null ? false : (boolean) value);
+        break;
+      case "scrollEnabled":
+        mViewManager.setScrollEnabled(view, value == null ? false : (boolean) value);
+        break;
+      case "enablePaging":
+        mViewManager.setEnablePaging(view, value == null ? false : (boolean) value);
+        break;
+      case "enableRTL":
+        mViewManager.setEnableRTL(view, value == null ? false : (boolean) value);
+        break;
+      case "enableAnnotationRendering":
+        mViewManager.setEnableAnnotationRendering(view, value == null ? false : (boolean) value);
+        break;
+      case "enableDoubleTapZoom":
+        mViewManager.setEnableDoubleTapZoom(view, value == null ? false : (boolean) value);
+        break;
+      case "enableAntialiasing":
+        mViewManager.setEnableAntialiasing(view, value == null ? false : (boolean) value);
+        break;
+      case "fitPolicy":
+        mViewManager.setFitPolicy(view, value == null ? 0 : ((Double) value).intValue());
+        break;
+      case "spacing":
+        mViewManager.setSpacing(view, value == null ? 0 : ((Double) value).intValue());
+        break;
+      case "password":
+        mViewManager.setPassword(view, value == null ? null : (String) value);
+        break;
+      case "singlePage":
+        mViewManager.setSinglePage(view, value == null ? false : (boolean) value);
+        break;
+      default:
+        super.setProperty(view, propName, value);
+    }
+  }
+
+  public void receiveCommand(T view, String commandName, ReadableArray args) {
+    switch (commandName) {
+      case "setNativePage":
+        mViewManager.setNativePage(view, args.getInt(0));
+        break;
+    }
+  }
+}