@amafil/react-native-pdf-toolkit 1.0.15 → 1.1.1

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

@@ -24,8 +24,20 @@ 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;
@@ -55,6 +67,10 @@ 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;
@@ -76,6 +92,14 @@ 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;
@@ -109,6 +133,10 @@ 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
@@ -150,6 +178,10 @@ 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(),
@@ -239,6 +271,21 @@ 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){
 
@@ -246,6 +293,10 @@ 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
@@ -311,6 +362,10 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
         lastPageWidth = pageWidth;
         lastPageHeight = pageHeight;
+
+        if (annotationOverlayView != null) {
+            annotationOverlayView.invalidate();
+        }
     }
 
     @Override
@@ -402,11 +457,53 @@ 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 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) {
@@ -421,6 +518,7 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
     public void setEnableRTL(boolean enableRTL) {
         this.enableRTL = enableRTL;
+        updateAnnotationOverlayConfig();
     }
 
     public void setScale(float scale) {
@@ -437,6 +535,7 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
     public void setHorizontal(boolean horizontal) {
         this.horizontal = horizontal;
+        updateAnnotationOverlayConfig();
     }
 
     public void setScrollEnabled(boolean scrollEnabled) {
@@ -470,6 +569,7 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
             this.pageFling = false;
             this.pageSnap = false;
         }
+        updateAnnotationOverlayConfig();
     }
 
     public void setFitPolicy(int fitPolicy) {
@@ -492,6 +592,1076 @@ 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;
+            }
+        }
     }
 
     /**
@@ -539,6 +1709,28 @@ 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);
     }