@amafil/react-native-pdf-toolkit 1.1.2 → 1.1.17

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

@@ -24,20 +24,8 @@ import android.util.Log;
 import android.net.Uri;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
-import android.view.ViewConfiguration;
 import android.graphics.Canvas;
-import android.graphics.Color;
-import android.graphics.Paint;
-import android.graphics.Path;
-import android.graphics.PointF;
-import android.graphics.RectF;
 import android.graphics.pdf.PdfRenderer;
-import android.widget.EditText;
-import android.text.Editable;
-import android.text.TextWatcher;
-import android.text.TextUtils;
-import android.view.Gravity;
-import android.widget.FrameLayout;
 
 import io.legere.pdfiumandroid.util.Config;
 import io.legere.pdfiumandroid.util.ConfigKt;
@@ -67,10 +55,6 @@ import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
 
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
 import static java.lang.String.format;
 
 import java.io.FileNotFoundException;
@@ -92,14 +76,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     private boolean enableAntialiasing = true;
     private boolean enableAnnotationRendering = true;
     private boolean enableDoubleTapZoom = true;
-    private String annotations;
-    private boolean annotationMode = false;
-    private String annotationTool = "select";
-    private boolean annotationEditable = true;
-    private String annotationIdMode = "auto";
-    private String annotationInkColor = "#111111";
-    private float annotationInkThickness = 2f;
-    private AnnotationOverlayView annotationOverlayView;
 
     private boolean enablePaging = false;
     private boolean autoSpacing = false;
@@ -133,10 +109,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
         super(context, set);
         ConfigKt.setPdfiumConfig(new Config(new DefaultLogger(), AlreadyClosedBehavior.IGNORE));
         autoScrollResumeHandler = new Handler(Looper.getMainLooper());
-        annotationOverlayView = new AnnotationOverlayView(context);
-        addView(annotationOverlayView, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
-        bringChildToFront(annotationOverlayView);
-        updateAnnotationOverlayConfig();
     }
 
     @Override
@@ -178,10 +150,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
             new Handler(Looper.getMainLooper()).postDelayed(() -> dispatcher.dispatchEvent(tce), 10);
         }
 
-        if (annotationOverlayView != null) {
-            annotationOverlayView.invalidate();
-        }
-
 //        ReactContext reactContext = (ReactContext)this.getContext();
 //        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
 //            this.getId(),
@@ -271,21 +239,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 //         );
     }
 
-    private void notifyOnChangeWithMessage(String message) {
-        WritableMap event = Arguments.createMap();
-        event.putString("message", message);
-
-        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);
-        }
-    }
-
     @Override
     public void onPageScrolled(int page, float positionOffset){
 
@@ -293,10 +246,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
         Constants.Pinch.MINIMUM_ZOOM = this.minScale;
         Constants.Pinch.MAXIMUM_ZOOM = this.maxScale;
 
-        if (annotationOverlayView != null) {
-            annotationOverlayView.invalidate();
-        }
-
     }
 
     @Override
@@ -362,10 +311,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
         lastPageWidth = pageWidth;
         lastPageHeight = pageHeight;
-
-        if (annotationOverlayView != null) {
-            annotationOverlayView.invalidate();
-        }
     }
 
     @Override
@@ -457,55 +402,20 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
             }
 
             configurator.load();
-            updateAnnotationOverlayConfig();
-            if (annotationOverlayView != null) {
-                annotationOverlayView.invalidate();
-            }
         }
     }
 
     public void setEnableDoubleTapZoom(boolean enableDoubleTapZoom) {
         this.enableDoubleTapZoom = enableDoubleTapZoom;
-        updateAnnotationOverlayConfig();
     }
 
-    public void setAnnotations(String annotations) {
-        this.annotations = annotations;
-        if (annotationOverlayView != null) {
-            annotationOverlayView.replaceAnnotations(annotations);
+    public void cleanup() {
+        stopAutoScroll();
+        if (!this.isRecycled()) {
+            this.recycle();
         }
     }
 
-    public void setAnnotationMode(boolean annotationMode) {
-        this.annotationMode = annotationMode;
-        updateAnnotationOverlayConfig();
-    }
-
-    public void setAnnotationTool(String annotationTool) {
-        this.annotationTool = annotationTool;
-        updateAnnotationOverlayConfig();
-    }
-
-    public void setAnnotationEditable(boolean annotationEditable) {
-        this.annotationEditable = annotationEditable;
-        updateAnnotationOverlayConfig();
-    }
-
-    public void setAnnotationIdMode(String annotationIdMode) {
-        this.annotationIdMode = annotationIdMode;
-        updateAnnotationOverlayConfig();
-    }
-
-    public void setAnnotationInkColor(String annotationInkColor) {
-        this.annotationInkColor = TextUtils.isEmpty(annotationInkColor) ? "#111111" : annotationInkColor;
-        updateAnnotationOverlayConfig();
-    }
-
-    public void setAnnotationInkThickness(float annotationInkThickness) {
-        this.annotationInkThickness = annotationInkThickness > 0f ? annotationInkThickness : 2f;
-        updateAnnotationOverlayConfig();
-    }
-
     public void setPath(String path) {
         this.path = path;
     }
@@ -518,7 +428,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
     public void setEnableRTL(boolean enableRTL) {
         this.enableRTL = enableRTL;
-        updateAnnotationOverlayConfig();
     }
 
     public void setScale(float scale) {
@@ -535,7 +444,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
     public void setHorizontal(boolean horizontal) {
         this.horizontal = horizontal;
-        updateAnnotationOverlayConfig();
     }
 
     public void setScrollEnabled(boolean scrollEnabled) {
@@ -569,7 +477,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
             this.pageFling = false;
             this.pageSnap = false;
         }
-        updateAnnotationOverlayConfig();
     }
 
     public void setFitPolicy(int fitPolicy) {
@@ -592,1076 +499,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
     public void setSinglePage(boolean singlePage) {
         this.singlePage = singlePage;
-        updateAnnotationOverlayConfig();
-    }
-
-    private boolean isAnnotationEditingSupported() {
-        return !this.horizontal && !this.enablePaging && !this.enableRTL && !this.singlePage;
-    }
-
-    private void updateAnnotationOverlayConfig() {
-        if (annotationOverlayView != null) {
-            annotationOverlayView.setConfiguration(
-                this.annotationMode,
-                this.annotationTool,
-                this.annotationEditable,
-                this.annotationIdMode,
-                isAnnotationEditingSupported(),
-                this.annotationInkColor,
-                this.annotationInkThickness
-            );
-        }
-    }
-
-    private class AnnotationOverlayView extends FrameLayout {
-        private final java.util.ArrayList<JSONObject> draftAnnotations = new java.util.ArrayList<>();
-        private JSONObject activeInkAnnotation;
-        private JSONObject activeMarkupAnnotation;
-        private JSONObject activeTextAnnotation;
-        private PointF markupStartNormalized;
-        private EditText activeEditText;
-        private String selectedAnnotationId;
-        private JSONObject activeSelectionAnnotation;
-        private String activeSelectionHandle = "body";
-        private String activeSelectionMode = "none";
-        private RectF activeSelectionStartBounds;
-        private JSONArray activeSelectionStartPoints;
-        private int activeSelectionPageIndex = -1;
-        private float activeSelectionDownX;
-        private float activeSelectionDownY;
-        private boolean activeSelectionHasMoved;
-        private final float touchSlop;
-        private boolean annotationModeEnabled = false;
-        private String tool = "select";
-        private boolean editable = true;
-        private String idMode = "auto";
-        private boolean supported = true;
-        private String inkColor = "#111111";
-        private float inkThickness = 2f;
-
-        AnnotationOverlayView(Context context) {
-            super(context);
-            setWillNotDraw(false);
-            setBackgroundColor(Color.TRANSPARENT);
-            setClickable(true);
-            touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
-        }
-
-        void setConfiguration(boolean annotationMode, String annotationTool, boolean annotationEditable, String annotationIdMode, boolean annotationEditingSupported, String annotationInkColor, float annotationInkThickness) {
-            annotationModeEnabled = annotationMode;
-            tool = normalizeAnnotationType(annotationTool == null ? "select" : annotationTool);
-            editable = annotationEditable;
-            idMode = annotationIdMode == null ? "auto" : annotationIdMode;
-            supported = annotationEditingSupported;
-            inkColor = TextUtils.isEmpty(annotationInkColor) ? "#111111" : annotationInkColor;
-            inkThickness = annotationInkThickness > 0f ? annotationInkThickness : 2f;
-
-            if (!annotationModeEnabled || !editable || !supported) {
-                commitTextEditingIfNeeded();
-            }
-
-            if (!annotationModeEnabled || !editable || !supported) {
-                clearSelectionInteraction();
-            }
-
-            invalidate();
-        }
-
-        void deleteSelectedAnnotation() {
-            JSONObject selectedAnnotation = getSelectedAnnotation();
-            if (selectedAnnotation != null) {
-                deleteAnnotation(selectedAnnotation);
-            }
-        }
-
-        void deleteAllAnnotations() {
-            commitTextEditingIfNeeded();
-            draftAnnotations.clear();
-            selectedAnnotationId = null;
-            clearSelectionInteraction();
-            invalidate();
-        }
-
-        void replaceAnnotations(String json) {
-            draftAnnotations.clear();
-            clearSelectionInteraction();
-            if (TextUtils.isEmpty(json)) {
-                invalidate();
-                return;
-            }
-
-            try {
-                JSONArray annotationsArray;
-                try {
-                    JSONObject document = new JSONObject(json);
-                    annotationsArray = document.optJSONArray("annotations");
-                } catch (JSONException objectError) {
-                    annotationsArray = null;
-                }
-
-                if (annotationsArray == null) {
-                    annotationsArray = new JSONArray(json);
-                }
-
-                for (int i = 0; i < annotationsArray.length(); i++) {
-                    JSONObject source = annotationsArray.optJSONObject(i);
-                    if (source == null) {
-                        continue;
-                    }
-
-                    JSONObject annotation = new JSONObject(source.toString());
-                    String type = normalizeAnnotationType(annotation.optString("type", null));
-                    if (!TextUtils.isEmpty(type)) {
-                        annotation.put("type", type);
-                    }
-                    if (!annotation.has("id")) {
-                        annotation.put("id", nextLocalAnnotationId());
-                    }
-                    if (!annotation.has("page")) {
-                        annotation.put("page", 1);
-                    }
-                    draftAnnotations.add(annotation);
-                }
-            } catch (JSONException ignored) {
-            }
-
-            invalidate();
-        }
-
-        String serializeDocument() {
-            JSONObject document = new JSONObject();
-            try {
-                document.put("editable", editable);
-                document.put("idMode", idMode);
-                document.put("annotations", new JSONArray(draftAnnotations));
-                return document.toString();
-            } catch (JSONException e) {
-                return "{}";
-            }
-        }
-
-        @Override
-        public boolean dispatchTouchEvent(MotionEvent event) {
-            if (activeEditText != null && event.getActionMasked() == MotionEvent.ACTION_DOWN && !isPointInsideView(event.getX(), event.getY(), activeEditText)) {
-                commitTextEditingIfNeeded();
-            }
-
-            return super.dispatchTouchEvent(event);
-        }
-
-        @Override
-        public boolean onInterceptTouchEvent(MotionEvent ev) {
-            if (!annotationModeEnabled || !editable || !supported) {
-                return false;
-            }
-
-            if (ev.getPointerCount() > 1) {
-                return false;
-            }
-
-            String currentTool = tool == null ? "select" : tool;
-            if ("select".equals(currentTool)) {
-                return hitTestAnnotation(ev.getX(), ev.getY(), true) != null;
-            }
-
-            return !TextUtils.isEmpty(currentTool);
-        }
-
-        @Override
-        public boolean onTouchEvent(MotionEvent event) {
-            if (!annotationModeEnabled || !editable || !supported) {
-                return false;
-            }
-
-            if (event.getPointerCount() > 1) {
-                return false;
-            }
-
-            String currentTool = tool == null ? "select" : tool;
-            if ("select".equals(currentTool)) {
-                return handleSelectTouch(event);
-            }
-
-            int action = event.getActionMasked();
-            if ("ink".equals(currentTool)) {
-                if (action == MotionEvent.ACTION_DOWN) {
-                    AnnotationHit hit = hitTest(event.getX(), event.getY());
-                    if (hit == null) {
-                        return false;
-                    }
-                    beginInk(hit, event.getX(), event.getY());
-                    return true;
-                } else if (action == MotionEvent.ACTION_MOVE) {
-                    AnnotationHit hit = hitTest(event.getX(), event.getY());
-                    if (hit != null) {
-                        appendInkPoint(hit, event.getX(), event.getY());
-                    }
-                    return true;
-                } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
-                    endInk();
-                    return true;
-                }
-            } else if ("highlight".equals(currentTool)) {
-                if (action == MotionEvent.ACTION_DOWN) {
-                    AnnotationHit hit = hitTest(event.getX(), event.getY());
-                    if (hit == null) {
-                        return false;
-                    }
-                    beginMarkup(hit, event.getX(), event.getY(), currentTool);
-                    return true;
-                } else if (action == MotionEvent.ACTION_MOVE) {
-                    AnnotationHit hit = hitTest(event.getX(), event.getY());
-                    if (hit != null) {
-                        updateMarkup(hit, event.getX(), event.getY());
-                    }
-                    return true;
-                } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
-                    endMarkup();
-                    return true;
-                }
-            } else if ("text".equals(currentTool)) {
-                if (action == MotionEvent.ACTION_UP) {
-                    AnnotationHit hit = hitTest(event.getX(), event.getY());
-                    if (hit != null) {
-                        createTextAnnotation(hit, event.getX(), event.getY());
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        @Override
-        protected void onDraw(Canvas canvas) {
-            super.onDraw(canvas);
-
-            if (PdfView.this.getPageCount() <= 0) {
-                return;
-            }
-
-            Paint strokePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
-            Paint fillPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
-            Paint textPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
-
-            for (JSONObject annotation : draftAnnotations) {
-                int pageIndex = annotation.optInt("page", 1) - 1;
-                if (pageIndex < 0 || pageIndex >= PdfView.this.getPageCount()) {
-                    continue;
-                }
-
-                String type = normalizeAnnotationType(annotation.optString("type", ""));
-                RectF rect = viewRectForAnnotation(annotation, pageIndex);
-                if (rect == null && !"ink".equals(type)) {
-                    continue;
-                }
-
-                if ("ink".equals(type)) {
-                    JSONArray points = annotation.optJSONArray("points");
-                    if (points == null || points.length() < 2) {
-                        continue;
-                    }
-
-                    Path path = new Path();
-                    boolean first = true;
-                    for (int i = 0; i < points.length(); i++) {
-                        JSONObject point = points.optJSONObject(i);
-                        if (point == null) {
-                            continue;
-                        }
-
-                        float pageX = (float) point.optDouble("x", 0f);
-                        float pageY = (float) point.optDouble("y", 0f);
-                        PointF viewPoint = viewPointForNormalizedPoint(pageIndex, pageX, pageY);
-                        if (first) {
-                            path.moveTo(viewPoint.x, viewPoint.y);
-                            first = false;
-                        } else {
-                            path.lineTo(viewPoint.x, viewPoint.y);
-                        }
-                    }
-
-                    strokePaint.setStyle(Paint.Style.STROKE);
-                    strokePaint.setStrokeJoin(Paint.Join.ROUND);
-                    strokePaint.setStrokeCap(Paint.Cap.ROUND);
-                    strokePaint.setStrokeWidth(Math.max(1f, (float) styleFor(annotation).optDouble("thickness", 2.0)));
-                    strokePaint.setColor(annotationColor(annotation, Color.BLACK));
-                    canvas.drawPath(path, strokePaint);
-                } else if ("text".equals(type)) {
-                    fillPaint.setColor(Color.argb(200, 255, 255, 255));
-                    canvas.drawRoundRect(rect, 4f, 4f, fillPaint);
-
-                    strokePaint.setStyle(Paint.Style.STROKE);
-                    strokePaint.setStrokeWidth(1f);
-                    strokePaint.setColor(annotationColor(annotation, Color.rgb(34, 68, 170)));
-                    canvas.drawRoundRect(rect, 4f, 4f, strokePaint);
-
-                    textPaint.setColor(strokePaint.getColor());
-                    textPaint.setTextSize((float) styleFor(annotation).optDouble("fontSize", 15.0));
-                    textPaint.setTextAlign(Paint.Align.LEFT);
-                    String text = annotation.optString("text", "");
-                    canvas.drawText(text, rect.left + 8f, rect.top + Math.max(20f, textPaint.getTextSize() + 6f), textPaint);
-                } else if ("highlight".equals(type)) {
-                    fillPaint.setColor(annotationColor(annotation, annotationFillColor(type)));
-                    canvas.drawRect(rect, fillPaint);
-                }
-            }
-
-            drawSelectionDecorations(canvas);
-            updateEditTextFrame();
-        }
-
-        private boolean handleSelectTouch(MotionEvent event) {
-            int action = event.getActionMasked();
-            if (action == MotionEvent.ACTION_DOWN) {
-                clearSelectionInteraction();
-
-                AnnotationSelectionHit hit = hitTestAnnotation(event.getX(), event.getY(), true);
-                if (hit == null) {
-                    return false;
-                }
-
-                selectAnnotation(hit.annotation);
-                activeSelectionAnnotation = hit.annotation;
-                activeSelectionHandle = hit.hitPart;
-                activeSelectionMode = "resize".equals(hit.hitPart) ? "resize" : "move";
-                activeSelectionPageIndex = hit.pageIndex;
-                activeSelectionStartBounds = normalizedBoundsForAnnotation(hit.annotation);
-                activeSelectionStartPoints = copyPointsForAnnotation(hit.annotation);
-                activeSelectionDownX = event.getX();
-                activeSelectionDownY = event.getY();
-                activeSelectionHasMoved = false;
-
-                return true;
-            }
-
-            if (activeSelectionAnnotation == null) {
-                return false;
-            }
-
-            if (action == MotionEvent.ACTION_MOVE) {
-                float deltaX = event.getX() - activeSelectionDownX;
-                float deltaY = event.getY() - activeSelectionDownY;
-                if (!activeSelectionHasMoved) {
-                    if (Math.hypot(deltaX, deltaY) < touchSlop) {
-                        return true;
-                    }
-                    activeSelectionHasMoved = true;
-                }
-
-                if ("move".equals(activeSelectionMode)) {
-                    moveSelectedAnnotation(deltaX, deltaY);
-                } else if ("resize".equals(activeSelectionMode)) {
-                    resizeSelectedAnnotation(deltaX, deltaY);
-                }
-                return true;
-            }
-
-            if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
-                if (!activeSelectionHasMoved && "body".equals(activeSelectionHandle)) {
-                    // keep the annotation selected; tap selection is enough for now.
-                }
-
-                clearSelectionInteraction();
-                return true;
-            }
-
-            return true;
-        }
-
-        private void drawSelectionDecorations(Canvas canvas) {
-            JSONObject annotation = getSelectedAnnotation();
-            if (annotation == null) {
-                return;
-            }
-
-            int pageIndex = annotation.optInt("page", 1) - 1;
-            if (pageIndex < 0 || pageIndex >= PdfView.this.getPageCount()) {
-                return;
-            }
-
-            RectF rect = viewRectForAnnotation(annotation, pageIndex);
-            if (rect == null) {
-                return;
-            }
-
-            Paint outlinePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
-            outlinePaint.setStyle(Paint.Style.STROKE);
-            outlinePaint.setColor(Color.argb(220, 34, 68, 170));
-            outlinePaint.setStrokeWidth(2f);
-
-            Paint fillPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
-            fillPaint.setStyle(Paint.Style.FILL);
-
-            canvas.drawRoundRect(rect, 4f, 4f, outlinePaint);
-
-            if (annotationSupportsResize(annotation)) {
-                RectF resizeHandle = resizeHandleRect(rect);
-                fillPaint.setColor(Color.argb(235, 34, 68, 170));
-                canvas.drawRoundRect(resizeHandle, 2f, 2f, fillPaint);
-            }
-        }
-
-        private void clearSelectionInteraction() {
-            activeSelectionAnnotation = null;
-            activeSelectionHandle = "body";
-            activeSelectionMode = "none";
-            activeSelectionStartBounds = null;
-            activeSelectionStartPoints = null;
-            activeSelectionPageIndex = -1;
-            activeSelectionHasMoved = false;
-            activeSelectionDownX = 0f;
-            activeSelectionDownY = 0f;
-        }
-
-        private void selectAnnotation(JSONObject annotation) {
-            if (annotation == null) {
-                selectedAnnotationId = null;
-                invalidate();
-                return;
-            }
-
-            selectedAnnotationId = annotation.optString("id", null);
-            invalidate();
-        }
-
-        private JSONObject getSelectedAnnotation() {
-            if (TextUtils.isEmpty(selectedAnnotationId)) {
-                return null;
-            }
-
-            for (int i = draftAnnotations.size() - 1; i >= 0; i--) {
-                JSONObject annotation = draftAnnotations.get(i);
-                if (selectedAnnotationId.equals(annotation.optString("id", null))) {
-                    return annotation;
-                }
-            }
-
-            return null;
-        }
-
-        private void deleteAnnotation(JSONObject annotation) {
-            if (annotation == null) {
-                return;
-            }
-
-            String annotationId = annotation.optString("id", null);
-            for (int i = draftAnnotations.size() - 1; i >= 0; i--) {
-                JSONObject candidate = draftAnnotations.get(i);
-                if (annotationId != null && annotationId.equals(candidate.optString("id", null))) {
-                    draftAnnotations.remove(i);
-                    break;
-                }
-            }
-
-            if (annotationId != null && annotationId.equals(selectedAnnotationId)) {
-                selectedAnnotationId = null;
-            }
-
-            invalidate();
-        }
-
-        private RectF normalizedBoundsForAnnotation(JSONObject annotation) {
-            if (annotation == null) {
-                return null;
-            }
-
-            String type = annotation.optString("type", "");
-            if ("ink".equals(type)) {
-                JSONArray points = annotation.optJSONArray("points");
-                if (points == null || points.length() == 0) {
-                    return null;
-                }
-
-                float minX = Float.MAX_VALUE;
-                float minY = Float.MAX_VALUE;
-                float maxX = -Float.MAX_VALUE;
-                float maxY = -Float.MAX_VALUE;
-                for (int i = 0; i < points.length(); i++) {
-                    JSONObject point = points.optJSONObject(i);
-                    if (point == null) {
-                        continue;
-                    }
-
-                    float x = (float) point.optDouble("x", 0f);
-                    float y = (float) point.optDouble("y", 0f);
-                    minX = Math.min(minX, x);
-                    minY = Math.min(minY, y);
-                    maxX = Math.max(maxX, x);
-                    maxY = Math.max(maxY, y);
-                }
-
-                if (minX == Float.MAX_VALUE || minY == Float.MAX_VALUE || maxX == -Float.MAX_VALUE || maxY == -Float.MAX_VALUE) {
-                    return null;
-                }
-
-                return new RectF(minX, minY, maxX, maxY);
-            }
-
-            JSONObject bounds = annotation.optJSONObject("bounds");
-            if (bounds == null) {
-                return null;
-            }
-
-            float x = (float) bounds.optDouble("x", 0f);
-            float y = (float) bounds.optDouble("y", 0f);
-            float width = (float) bounds.optDouble("width", 0f);
-            float height = (float) bounds.optDouble("height", 0f);
-            return new RectF(x, y, x + width, y + height);
-        }
-
-        private JSONArray copyPointsForAnnotation(JSONObject annotation) {
-            if (annotation == null || !"ink".equals(annotation.optString("type", ""))) {
-                return null;
-            }
-
-            JSONArray points = annotation.optJSONArray("points");
-            if (points == null) {
-                return null;
-            }
-
-            try {
-                return new JSONArray(points.toString());
-            } catch (JSONException ignored) {
-                return null;
-            }
-        }
-
-        private void moveSelectedAnnotation(float deltaX, float deltaY) {
-            if (activeSelectionAnnotation == null || activeSelectionStartBounds == null || activeSelectionPageIndex < 0) {
-                return;
-            }
-
-            SizeF pageSize = PdfView.this.getPageSize(activeSelectionPageIndex);
-            if (pageSize == null) {
-                return;
-            }
-
-            float zoom = PdfView.this.getZoom();
-            float scaledPageWidth = Math.max(1f, pageSize.getWidth() * zoom);
-            float scaledPageHeight = Math.max(1f, pageSize.getHeight() * zoom);
-            float normalizedDeltaX = deltaX / scaledPageWidth;
-            float normalizedDeltaY = deltaY / scaledPageHeight;
-
-            RectF newBounds = new RectF(
-                activeSelectionStartBounds.left + normalizedDeltaX,
-                activeSelectionStartBounds.top + normalizedDeltaY,
-                activeSelectionStartBounds.right + normalizedDeltaX,
-                activeSelectionStartBounds.bottom + normalizedDeltaY
-            );
-
-            setAnnotationFromNormalizedBounds(activeSelectionAnnotation, activeSelectionStartBounds, activeSelectionStartPoints, newBounds);
-            invalidate();
-        }
-
-        private void resizeSelectedAnnotation(float deltaX, float deltaY) {
-            if (activeSelectionAnnotation == null || activeSelectionStartBounds == null || activeSelectionPageIndex < 0) {
-                return;
-            }
-
-            SizeF pageSize = PdfView.this.getPageSize(activeSelectionPageIndex);
-            if (pageSize == null) {
-                return;
-            }
-
-            float zoom = PdfView.this.getZoom();
-            float scaledPageWidth = Math.max(1f, pageSize.getWidth() * zoom);
-            float scaledPageHeight = Math.max(1f, pageSize.getHeight() * zoom);
-            float normalizedDeltaX = deltaX / scaledPageWidth;
-            float normalizedDeltaY = deltaY / scaledPageHeight;
-
-            RectF newBounds = new RectF(
-                activeSelectionStartBounds.left,
-                activeSelectionStartBounds.top,
-                Math.max(activeSelectionStartBounds.left + 0.01f, activeSelectionStartBounds.right + normalizedDeltaX),
-                Math.max(activeSelectionStartBounds.top + 0.01f, activeSelectionStartBounds.bottom + normalizedDeltaY)
-            );
-
-            setAnnotationFromNormalizedBounds(activeSelectionAnnotation, activeSelectionStartBounds, activeSelectionStartPoints, newBounds);
-            invalidate();
-        }
-
-        private void setAnnotationFromNormalizedBounds(JSONObject annotation, RectF startBounds, JSONArray startPoints, RectF newBounds) {
-            if (annotation == null || newBounds == null) {
-                return;
-            }
-
-            String type = annotation.optString("type", "");
-            if ("ink".equals(type)) {
-                if (startPoints == null || startBounds == null) {
-                    return;
-                }
-
-                try {
-                    JSONArray points = new JSONArray();
-                    float startWidth = Math.max(0.001f, startBounds.width());
-                    float startHeight = Math.max(0.001f, startBounds.height());
-                    float newWidth = Math.max(0.001f, newBounds.width());
-                    float newHeight = Math.max(0.001f, newBounds.height());
-
-                    for (int i = 0; i < startPoints.length(); i++) {
-                        JSONObject point = startPoints.optJSONObject(i);
-                        if (point == null) {
-                            continue;
-                        }
-
-                        float pointX = (float) point.optDouble("x", 0f);
-                        float pointY = (float) point.optDouble("y", 0f);
-                        float xRatio = (pointX - startBounds.left) / startWidth;
-                        float yRatio = (pointY - startBounds.top) / startHeight;
-
-                        JSONObject transformed = new JSONObject();
-                        transformed.put("x", Math.min(1f, Math.max(0f, newBounds.left + (xRatio * newWidth))));
-                        transformed.put("y", Math.min(1f, Math.max(0f, newBounds.top + (yRatio * newHeight))));
-                        points.put(transformed);
-                    }
-
-                    annotation.put("points", points);
-                } catch (JSONException ignored) {
-                }
-
-                return;
-            }
-
-            try {
-                annotation.put("bounds", new JSONObject()
-                    .put("x", Math.min(1f, Math.max(0f, newBounds.left)))
-                    .put("y", Math.min(1f, Math.max(0f, newBounds.top)))
-                    .put("width", Math.min(1f, Math.max(0.01f, newBounds.width())))
-                    .put("height", Math.min(1f, Math.max(0.01f, newBounds.height()))));
-            } catch (JSONException ignored) {
-            }
-        }
-
-        private RectF resizeHandleRect(RectF rect) {
-            float size = Math.max(18f, Math.min(rect.width(), rect.height()) * 0.18f);
-            return new RectF(rect.right - size, rect.bottom - size, rect.right, rect.bottom);
-        }
-
-        private AnnotationSelectionHit hitTestAnnotation(float x, float y, boolean includeHandles) {
-            if (PdfView.this.getPageCount() <= 0) {
-                return null;
-            }
-
-            for (int i = draftAnnotations.size() - 1; i >= 0; i--) {
-                JSONObject annotation = draftAnnotations.get(i);
-                int pageIndex = annotation.optInt("page", 1) - 1;
-                if (pageIndex < 0 || pageIndex >= PdfView.this.getPageCount()) {
-                    continue;
-                }
-
-                RectF rect = viewRectForAnnotation(annotation, pageIndex);
-                if (rect == null) {
-                    continue;
-                }
-
-                RectF hitRect = new RectF(rect);
-                hitRect.inset(-12f, -12f);
-                if (!hitRect.contains(x, y)) {
-                    continue;
-                }
-
-                String hitPart = "body";
-                if (includeHandles && selectedAnnotationId != null && selectedAnnotationId.equals(annotation.optString("id", null)) && annotationSupportsResize(annotation) && resizeHandleRect(rect).contains(x, y)) {
-                    hitPart = "resize";
-                }
-
-                return new AnnotationSelectionHit(annotation, pageIndex, rect, hitPart);
-            }
-
-            return null;
-        }
-
-        private final class AnnotationSelectionHit {
-            final JSONObject annotation;
-            final int pageIndex;
-            final RectF rect;
-            final String hitPart;
-
-            AnnotationSelectionHit(JSONObject annotation, int pageIndex, RectF rect, String hitPart) {
-                this.annotation = annotation;
-                this.pageIndex = pageIndex;
-                this.rect = rect;
-                this.hitPart = hitPart;
-            }
-        }
-
-        private void beginInk(AnnotationHit hit, float x, float y) {
-            try {
-                JSONObject annotation = new JSONObject();
-                annotation.put("id", nextLocalAnnotationId());
-                annotation.put("page", hit.pageIndex + 1);
-                annotation.put("type", "ink");
-                annotation.put("points", new JSONArray());
-                JSONObject style = new JSONObject();
-                style.put("color", inkColor);
-                style.put("thickness", inkThickness);
-                annotation.put("style", style);
-                draftAnnotations.add(annotation);
-                activeInkAnnotation = annotation;
-                appendInkPoint(hit, x, y);
-            } catch (JSONException ignored) {
-            }
-        }
-
-        private void appendInkPoint(AnnotationHit hit, float x, float y) {
-            if (activeInkAnnotation == null) {
-                return;
-            }
-
-            try {
-                JSONArray points = activeInkAnnotation.optJSONArray("points");
-                if (points == null) {
-                    points = new JSONArray();
-                    activeInkAnnotation.put("points", points);
-                }
-
-                PointF normalized = normalizedPointFor(hit, x, y);
-                JSONObject point = new JSONObject();
-                point.put("x", normalized.x);
-                point.put("y", normalized.y);
-                points.put(point);
-                invalidate();
-            } catch (JSONException ignored) {
-            }
-        }
-
-        private void endInk() {
-            activeInkAnnotation = null;
-            invalidate();
-        }
-
-        private void beginMarkup(AnnotationHit hit, float x, float y, String type) {
-            try {
-                markupStartNormalized = normalizedPointFor(hit, x, y);
-                JSONObject annotation = new JSONObject();
-                annotation.put("id", nextLocalAnnotationId());
-                annotation.put("page", hit.pageIndex + 1);
-                annotation.put("type", normalizeAnnotationType(type));
-                annotation.put("bounds", new JSONObject().put("x", markupStartNormalized.x).put("y", markupStartNormalized.y).put("width", 0).put("height", 0));
-                annotation.put("style", new JSONObject());
-                draftAnnotations.add(annotation);
-                activeMarkupAnnotation = annotation;
-                invalidate();
-            } catch (JSONException ignored) {
-            }
-        }
-
-        private void updateMarkup(AnnotationHit hit, float x, float y) {
-            if (activeMarkupAnnotation == null || markupStartNormalized == null) {
-                return;
-            }
-
-            try {
-                PointF normalized = normalizedPointFor(hit, x, y);
-                float minX = Math.min(markupStartNormalized.x, normalized.x);
-                float minY = Math.min(markupStartNormalized.y, normalized.y);
-                float maxX = Math.max(markupStartNormalized.x, normalized.x);
-                float maxY = Math.max(markupStartNormalized.y, normalized.y);
-                activeMarkupAnnotation.put("bounds", new JSONObject()
-                    .put("x", minX)
-                    .put("y", minY)
-                    .put("width", Math.max(0f, maxX - minX))
-                    .put("height", Math.max(0f, maxY - minY)));
-                invalidate();
-            } catch (JSONException ignored) {
-            }
-        }
-
-        private void endMarkup() {
-            activeMarkupAnnotation = null;
-            markupStartNormalized = null;
-            invalidate();
-        }
-
-        private void createTextAnnotation(AnnotationHit hit, float x, float y) {
-            if (!editable || !supported) {
-                return;
-            }
-
-            commitTextEditingIfNeeded();
-
-            try {
-                PointF normalized = normalizedPointFor(hit, x, y);
-                float width = 0.25f;
-                float height = 0.12f;
-                float clampedX = Math.min(Math.max(normalized.x, 0f), Math.max(0f, 1f - width));
-                float clampedY = Math.min(Math.max(normalized.y, 0f), Math.max(0f, 1f - height));
-
-                JSONObject bounds = new JSONObject();
-                bounds.put("x", clampedX);
-                bounds.put("y", clampedY);
-                bounds.put("width", width);
-                bounds.put("height", height);
-
-                JSONObject annotation = new JSONObject();
-                annotation.put("id", nextLocalAnnotationId());
-                annotation.put("page", hit.pageIndex + 1);
-                annotation.put("type", "text");
-                annotation.put("bounds", bounds);
-                annotation.put("text", "");
-                JSONObject style = new JSONObject();
-                style.put("color", "#2244aa");
-                style.put("fontSize", 15.0f);
-                style.put("textAlign", "left");
-                annotation.put("style", style);
-                draftAnnotations.add(annotation);
-                activeTextAnnotation = annotation;
-
-                activeEditText = new EditText(getContext());
-                activeEditText.setBackgroundColor(Color.argb(220, 255, 255, 255));
-                activeEditText.setTextColor(Color.rgb(34, 68, 170));
-                activeEditText.setPadding(12, 8, 12, 8);
-                activeEditText.setSingleLine(false);
-                activeEditText.setGravity(Gravity.TOP | Gravity.START);
-                activeEditText.setTextSize(15f);
-                activeEditText.addTextChangedListener(new TextWatcher() {
-                    @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { }
-                    @Override public void onTextChanged(CharSequence s, int start, int before, int count) { }
-                    @Override public void afterTextChanged(Editable s) {
-                        if (activeTextAnnotation != null) {
-                            try {
-                                activeTextAnnotation.put("text", s.toString());
-                            } catch (JSONException ignored) {
-                            }
-                            invalidate();
-                        }
-                    }
-                });
-
-                addView(activeEditText, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
-                activeEditText.requestFocus();
-                updateEditTextFrame();
-                invalidate();
-            } catch (JSONException ignored) {
-            }
-        }
-
-        void commitTextEditingIfNeeded() {
-            if (activeEditText == null || activeTextAnnotation == null) {
-                return;
-            }
-
-            try {
-                activeTextAnnotation.put("text", activeEditText.getText() == null ? "" : activeEditText.getText().toString());
-            } catch (JSONException ignored) {
-            }
-
-            activeEditText.clearFocus();
-            removeView(activeEditText);
-            activeEditText = null;
-            activeTextAnnotation = null;
-            invalidate();
-        }
-
-        private void updateEditTextFrame() {
-            if (activeEditText == null || activeTextAnnotation == null) {
-                return;
-            }
-
-            RectF rect = viewRectForAnnotation(activeTextAnnotation, activeTextAnnotation.optInt("page", 1) - 1);
-            if (rect == null) {
-                return;
-            }
-
-            ViewGroup.LayoutParams params = activeEditText.getLayoutParams();
-            params.width = Math.max(1, Math.round(rect.width()));
-            params.height = Math.max(1, Math.round(rect.height()));
-            activeEditText.setLayoutParams(params);
-            activeEditText.setX(rect.left);
-            activeEditText.setY(rect.top);
-        }
-
-        private boolean isPointInsideView(float x, float y, View view) {
-            if (view == null) {
-                return false;
-            }
-
-            return x >= view.getX() && x <= view.getX() + view.getWidth() && y >= view.getY() && y <= view.getY() + view.getHeight();
-        }
-
-        private AnnotationHit hitTest(float x, float y) {
-            if (PdfView.this.getPageCount() <= 0) {
-                return null;
-            }
-
-            float zoom = PdfView.this.getZoom();
-            float documentY = y - PdfView.this.getCurrentYOffset();
-            for (int i = 0; i < PdfView.this.getPageCount(); i++) {
-                SizeF pageSize = PdfView.this.getPageSize(i);
-                if (pageSize == null) {
-                    continue;
-                }
-
-                float scaledPageWidth = pageSize.getWidth() * zoom;
-                float scaledPageHeight = pageSize.getHeight() * zoom;
-                float horizontalMargin = Math.max(0f, (PdfView.this.getWidth() - scaledPageWidth) / 2f);
-                float pageTop = getPageTop(i, zoom);
-                if (documentY >= pageTop && documentY <= pageTop + scaledPageHeight) {
-                    float pageX = x - horizontalMargin;
-                    if (pageX >= 0f && pageX <= scaledPageWidth) {
-                        return new AnnotationHit(i, pageSize);
-                    }
-                }
-            }
-
-            return null;
-        }
-
-        private PointF normalizedPointFor(AnnotationHit hit, float x, float y) {
-            float zoom = PdfView.this.getZoom();
-            SizeF pageSize = hit.pageSize;
-            float scaledPageWidth = pageSize.getWidth() * zoom;
-            float scaledPageHeight = pageSize.getHeight() * zoom;
-            float horizontalMargin = Math.max(0f, (PdfView.this.getWidth() - scaledPageWidth) / 2f);
-            float pageTop = getPageTop(hit.pageIndex, zoom);
-            float pageX = x - horizontalMargin;
-            float documentY = y - PdfView.this.getCurrentYOffset();
-            float pageY = documentY - pageTop;
-            return new PointF(pageX / Math.max(1f, scaledPageWidth), pageY / Math.max(1f, scaledPageHeight));
-        }
-
-        private PointF viewPointForNormalizedPoint(int pageIndex, float normalizedX, float normalizedY) {
-            SizeF pageSize = PdfView.this.getPageSize(pageIndex);
-            float zoom = PdfView.this.getZoom();
-            float scaledPageWidth = pageSize.getWidth() * zoom;
-            float scaledPageHeight = pageSize.getHeight() * zoom;
-            float horizontalMargin = Math.max(0f, (PdfView.this.getWidth() - scaledPageWidth) / 2f);
-            float pageTop = getPageTop(pageIndex, zoom) + PdfView.this.getCurrentYOffset();
-            return new PointF(horizontalMargin + (normalizedX * scaledPageWidth), pageTop + (normalizedY * scaledPageHeight));
-        }
-
-        private RectF viewRectForAnnotation(JSONObject annotation, int pageIndex) {
-            JSONObject bounds = annotation.optJSONObject("bounds");
-            String type = annotation.optString("type", "");
-            if (bounds == null && !"ink".equals(type)) {
-                return null;
-            }
-
-            SizeF pageSize = PdfView.this.getPageSize(pageIndex);
-            if (pageSize == null) {
-                return null;
-            }
-
-            float zoom = PdfView.this.getZoom();
-            float scaledPageWidth = pageSize.getWidth() * zoom;
-            float scaledPageHeight = pageSize.getHeight() * zoom;
-            float horizontalMargin = Math.max(0f, (PdfView.this.getWidth() - scaledPageWidth) / 2f);
-            float pageTop = getPageTop(pageIndex, zoom) + PdfView.this.getCurrentYOffset();
-
-            if ("ink".equals(type)) {
-                JSONArray points = annotation.optJSONArray("points");
-                if (points == null || points.length() == 0) {
-                    return null;
-                }
-
-                float minX = Float.MAX_VALUE;
-                float minY = Float.MAX_VALUE;
-                float maxX = -Float.MAX_VALUE;
-                float maxY = -Float.MAX_VALUE;
-                for (int i = 0; i < points.length(); i++) {
-                    JSONObject point = points.optJSONObject(i);
-                    if (point == null) {
-                        continue;
-                    }
-
-                    float pointX = (float) point.optDouble("x", 0f);
-                    float pointY = (float) point.optDouble("y", 0f);
-                    minX = Math.min(minX, pointX);
-                    minY = Math.min(minY, pointY);
-                    maxX = Math.max(maxX, pointX);
-                    maxY = Math.max(maxY, pointY);
-                }
-
-                if (minX == Float.MAX_VALUE || minY == Float.MAX_VALUE || maxX == -Float.MAX_VALUE || maxY == -Float.MAX_VALUE) {
-                    return null;
-                }
-
-                float left = horizontalMargin + (minX * scaledPageWidth);
-                float top = pageTop + (minY * scaledPageHeight);
-                float right = horizontalMargin + (maxX * scaledPageWidth);
-                float bottom = pageTop + (maxY * scaledPageHeight);
-                return new RectF(Math.min(left, right), Math.min(top, bottom), Math.max(left, right), Math.max(top, bottom));
-            }
-
-            float x = (float) bounds.optDouble("x", 0f);
-            float y = (float) bounds.optDouble("y", 0f);
-            float width = (float) bounds.optDouble("width", 0f);
-            float height = (float) bounds.optDouble("height", 0f);
-
-            float left = horizontalMargin + (x * scaledPageWidth);
-            float top = pageTop + (y * scaledPageHeight);
-            float right = horizontalMargin + ((x + width) * scaledPageWidth);
-            float bottom = pageTop + ((y + height) * scaledPageHeight);
-
-            return new RectF(Math.min(left, right), Math.min(top, bottom), Math.max(left, right), Math.max(top, bottom));
-        }
-
-        private JSONObject styleFor(JSONObject annotation) {
-            JSONObject style = annotation.optJSONObject("style");
-            return style == null ? new JSONObject() : style;
-        }
-
-        private String normalizeAnnotationType(String type) {
-            if ("underline".equals(type) || "strikeout".equals(type)) {
-                return "highlight";
-            }
-
-            return type;
-        }
-
-        private boolean annotationSupportsResize(JSONObject annotation) {
-            String type = normalizeAnnotationType(annotation.optString("type", ""));
-            return "text".equals(type) || "highlight".equals(type);
-        }
-
-        private int annotationColor(JSONObject annotation, int fallback) {
-            String color = styleFor(annotation).optString("color", null);
-            if (TextUtils.isEmpty(color)) {
-                return fallback;
-            }
-
-            try {
-                return Color.parseColor(color);
-            } catch (IllegalArgumentException ex) {
-                return fallback;
-            }
-        }
-
-        private int annotationFillColor(String type) {
-            if ("highlight".equals(type) || "underline".equals(type) || "strikeout".equals(type)) {
-                return Color.argb(90, 255, 230, 60);
-            }
-
-            return Color.BLACK;
-        }
-
-        private String nextLocalAnnotationId() {
-            return "local-" + java.util.UUID.randomUUID().toString();
-        }
-
-        private float getPageTop(int pageIndex, float zoom) {
-            float pageTop = 0f;
-            for (int i = 0; i < pageIndex; i++) {
-                SizeF previousPageSize = PdfView.this.getPageSize(i);
-                if (previousPageSize == null) {
-                    continue;
-                }
-                pageTop += previousPageSize.getHeight() * zoom;
-                pageTop += PdfView.this.spacing * zoom;
-            }
-            return pageTop;
-        }
-
-        private final class AnnotationHit {
-            final int pageIndex;
-            final SizeF pageSize;
-
-            AnnotationHit(int pageIndex, SizeF pageSize) {
-                this.pageIndex = pageIndex;
-                this.pageSize = pageSize;
-            }
-        }
     }
 
     /**
@@ -1709,28 +546,6 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
         this.jumpTo(page);
     }
 
-    public void saveAnnotations() {
-        if (annotationOverlayView != null) {
-            annotationOverlayView.commitTextEditingIfNeeded();
-            notifyOnChangeWithMessage("annotationSaveComplete|" + annotationOverlayView.serializeDocument());
-            return;
-        }
-
-        notifyOnChangeWithMessage("annotationSaveError|Annotation overlay unavailable");
-    }
-
-    public void deleteSelectedAnnotation() {
-        if (annotationOverlayView != null) {
-            annotationOverlayView.deleteSelectedAnnotation();
-        }
-    }
-
-    public void deleteAllAnnotations() {
-        if (annotationOverlayView != null) {
-            annotationOverlayView.deleteAllAnnotations();
-        }
-    }
-
     private void showLog(final String str) {
         Log.d("PdfView", str);
     }