@papyrus-sdk/engine-native 0.2.9 → 0.2.11

package/android/src/main/cpp/papyrus_outline_loader_test.cpp

@@ -0,0 +1,240 @@
+#include "papyrus_outline_loader.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+
+namespace {
+
+using PdfiumSymbol = OutlineLoaderDeps::PdfiumSymbol;
+
+struct FakeLoaderEnv {
+  void *library_handle = reinterpret_cast<void *>(0x1);
+  int dlopen_calls = 0;
+  int dlsym_calls = 0;
+  int dlclose_calls = 0;
+  std::unordered_map<std::string, PdfiumSymbol> symbols;
+};
+
+FPDF_DOCUMENT FakeLoadDocument(const char *, const char *) {
+  return nullptr;
+}
+
+void FakeCloseDocument(FPDF_DOCUMENT) {}
+
+FPDF_BOOKMARK FakeBookmarkGetFirstChild(FPDF_DOCUMENT, FPDF_BOOKMARK) {
+  return nullptr;
+}
+
+FPDF_BOOKMARK FakeBookmarkGetNextSibling(FPDF_DOCUMENT, FPDF_BOOKMARK) {
+  return nullptr;
+}
+
+unsigned long FakeBookmarkGetTitle(FPDF_BOOKMARK, void *, unsigned long) {
+  return 0;
+}
+
+FPDF_DEST FakeBookmarkGetDest(FPDF_DOCUMENT, FPDF_BOOKMARK) {
+  return nullptr;
+}
+
+int FakeDestGetPageIndex(FPDF_DOCUMENT, FPDF_DEST) {
+  return -1;
+}
+
+template <typename FnType>
+PdfiumSymbol ToPdfiumSymbol(FnType fn) {
+  PdfiumSymbol symbol = nullptr;
+  static_assert(sizeof(symbol) == sizeof(fn),
+                "Expected function pointers to share the same size");
+  std::memcpy(&symbol, &fn, sizeof(symbol));
+  return symbol;
+}
+
+PdfiumOutlineFns MakeCompleteOutlineFns() {
+  PdfiumOutlineFns fns = {};
+  fns.loadDocument = &FakeLoadDocument;
+  fns.closeDocument = &FakeCloseDocument;
+  fns.bookmarkGetFirstChild = &FakeBookmarkGetFirstChild;
+  fns.bookmarkGetNextSibling = &FakeBookmarkGetNextSibling;
+  fns.bookmarkGetTitle = &FakeBookmarkGetTitle;
+  fns.bookmarkGetDest = &FakeBookmarkGetDest;
+  fns.destGetPageIndex = &FakeDestGetPageIndex;
+  return fns;
+}
+
+FakeLoaderEnv *GetEnv(void *user_data) {
+  return static_cast<FakeLoaderEnv *>(user_data);
+}
+
+void *FakeDlopen(void *user_data, const char *, int) {
+  FakeLoaderEnv *env = GetEnv(user_data);
+  env->dlopen_calls += 1;
+  return env->library_handle;
+}
+
+PdfiumSymbol FakeDlsym(void *user_data, void *, const char *symbol_name) {
+  FakeLoaderEnv *env = GetEnv(user_data);
+  env->dlsym_calls += 1;
+
+  const auto it = env->symbols.find(symbol_name);
+  if (it == env->symbols.end()) {
+    return nullptr;
+  }
+
+  return it->second;
+}
+
+int FakeDlclose(void *user_data, void *) {
+  FakeLoaderEnv *env = GetEnv(user_data);
+  env->dlclose_calls += 1;
+  return 0;
+}
+
+OutlineLoaderDeps MakeDeps(FakeLoaderEnv *env) {
+  OutlineLoaderDeps deps = {};
+  deps.user_data = env;
+  deps.dlopen_fn = &FakeDlopen;
+  deps.dlsym_fn = &FakeDlsym;
+  deps.dlclose_fn = &FakeDlclose;
+  deps.library_name = "libmodpdfium.so";
+  deps.dlopen_flags = 0;
+  return deps;
+}
+
+void InstallSymbols(FakeLoaderEnv *env, const PdfiumOutlineFns &fns) {
+  env->symbols["FPDF_LoadDocument"] = ToPdfiumSymbol(fns.loadDocument);
+  env->symbols["FPDF_CloseDocument"] = ToPdfiumSymbol(fns.closeDocument);
+  env->symbols["FPDFBookmark_GetFirstChild"] = ToPdfiumSymbol(fns.bookmarkGetFirstChild);
+  env->symbols["FPDFBookmark_GetNextSibling"] = ToPdfiumSymbol(fns.bookmarkGetNextSibling);
+  env->symbols["FPDFBookmark_GetTitle"] = ToPdfiumSymbol(fns.bookmarkGetTitle);
+  env->symbols["FPDFBookmark_GetDest"] = ToPdfiumSymbol(fns.bookmarkGetDest);
+  env->symbols["FPDFDest_GetPageIndex"] = ToPdfiumSymbol(fns.destGetPageIndex);
+}
+
+[[noreturn]] void Fail(const char *expression, const char *file, int line) {
+  std::cerr << file << ":" << line << ": assertion failed: " << expression << std::endl;
+  std::exit(1);
+}
+
+#define EXPECT_TRUE(condition) \
+  do { \
+    if (!(condition)) { \
+      Fail(#condition, __FILE__, __LINE__); \
+    } \
+  } while (false)
+
+#define EXPECT_FALSE(condition) EXPECT_TRUE(!(condition))
+
+#define EXPECT_EQ(expected, actual) \
+  do { \
+    const auto expected_value = (expected); \
+    const auto actual_value = (actual); \
+    if (!(expected_value == actual_value)) { \
+      std::cerr << __FILE__ << ":" << __LINE__ \
+                << ": expected equality for " << #expected << " and " << #actual << std::endl; \
+      std::exit(1); \
+    } \
+  } while (false)
+
+void TestFullSymbolTableReturnsSupported() {
+  FakeLoaderEnv env = {};
+  const PdfiumOutlineFns complete_fns = MakeCompleteOutlineFns();
+  InstallSymbols(&env, complete_fns);
+
+  OutlineLoaderState state = {};
+  const OutlineLoaderDeps deps = MakeDeps(&env);
+
+  const OutlineLoadAttemptResult result = EnsureOutlinePdfiumLoaded(&state, &deps);
+
+  EXPECT_TRUE(result.loaded);
+  EXPECT_FALSE(result.transitioned_to_unsupported);
+  EXPECT_EQ(OutlineLoadState::kSupported, state.load_state);
+  EXPECT_TRUE(state.handle != nullptr);
+  EXPECT_TRUE(HasCompleteOutlineFns(state.fns));
+  EXPECT_EQ(1, env.dlopen_calls);
+  EXPECT_EQ(7, env.dlsym_calls);
+  EXPECT_EQ(0, env.dlclose_calls);
+}
+
+void TestMissingLibraryReturnsUnsupported() {
+  FakeLoaderEnv env = {};
+  env.library_handle = nullptr;
+
+  OutlineLoaderState state = {};
+  const OutlineLoaderDeps deps = MakeDeps(&env);
+
+  const OutlineLoadAttemptResult result = EnsureOutlinePdfiumLoaded(&state, &deps);
+
+  EXPECT_FALSE(result.loaded);
+  EXPECT_TRUE(result.transitioned_to_unsupported);
+  EXPECT_EQ(OutlineLoadState::kUnsupported, state.load_state);
+  EXPECT_TRUE(state.handle == nullptr);
+  EXPECT_FALSE(HasCompleteOutlineFns(state.fns));
+  EXPECT_EQ(1, env.dlopen_calls);
+  EXPECT_EQ(0, env.dlsym_calls);
+  EXPECT_EQ(0, env.dlclose_calls);
+}
+
+void TestMissingSymbolReturnsUnsupportedAndClosesHandle() {
+  FakeLoaderEnv env = {};
+  const PdfiumOutlineFns partial_fns = MakeCompleteOutlineFns();
+  InstallSymbols(&env, partial_fns);
+  env.symbols.erase("FPDFBookmark_GetDest");
+
+  OutlineLoaderState state = {};
+  const OutlineLoaderDeps deps = MakeDeps(&env);
+
+  const OutlineLoadAttemptResult result = EnsureOutlinePdfiumLoaded(&state, &deps);
+
+  EXPECT_FALSE(result.loaded);
+  EXPECT_TRUE(result.transitioned_to_unsupported);
+  EXPECT_EQ(OutlineLoadState::kUnsupported, state.load_state);
+  EXPECT_TRUE(state.handle == nullptr);
+  EXPECT_FALSE(HasCompleteOutlineFns(state.fns));
+  EXPECT_EQ(1, env.dlopen_calls);
+  EXPECT_EQ(7, env.dlsym_calls);
+  EXPECT_EQ(1, env.dlclose_calls);
+}
+
+void TestRepeatedCallsAfterFailureStayUnsupported() {
+  FakeLoaderEnv env = {};
+  const PdfiumOutlineFns partial_fns = MakeCompleteOutlineFns();
+  InstallSymbols(&env, partial_fns);
+  env.symbols.erase("FPDFDest_GetPageIndex");
+
+  OutlineLoaderState state = {};
+  const OutlineLoaderDeps deps = MakeDeps(&env);
+
+  const OutlineLoadAttemptResult first = EnsureOutlinePdfiumLoaded(&state, &deps);
+  EXPECT_FALSE(first.loaded);
+  EXPECT_TRUE(first.transitioned_to_unsupported);
+  EXPECT_EQ(OutlineLoadState::kUnsupported, state.load_state);
+  EXPECT_TRUE(state.handle == nullptr);
+  EXPECT_FALSE(HasCompleteOutlineFns(state.fns));
+  EXPECT_EQ(1, env.dlopen_calls);
+  EXPECT_EQ(7, env.dlsym_calls);
+  EXPECT_EQ(1, env.dlclose_calls);
+
+  const OutlineLoadAttemptResult second = EnsureOutlinePdfiumLoaded(&state, &deps);
+  EXPECT_FALSE(second.loaded);
+  EXPECT_FALSE(second.transitioned_to_unsupported);
+  EXPECT_EQ(OutlineLoadState::kUnsupported, state.load_state);
+  EXPECT_TRUE(state.handle == nullptr);
+  EXPECT_FALSE(HasCompleteOutlineFns(state.fns));
+  EXPECT_EQ(1, env.dlopen_calls);
+  EXPECT_EQ(7, env.dlsym_calls);
+  EXPECT_EQ(1, env.dlclose_calls);
+}
+
+}  // namespace
+
+int main() {
+  TestFullSymbolTableReturnsSupported();
+  TestMissingLibraryReturnsUnsupported();
+  TestMissingSymbolReturnsUnsupportedAndClosesHandle();
+  TestRepeatedCallsAfterFailureStayUnsupported();
+  return 0;
+}

package/android/src/main/java/com/papyrus/engine/PapyrusOutline.java

@@ -1,19 +1,33 @@
 package com.papyrus.engine;
 
 final class PapyrusOutline {
+  interface LibraryLoader {
+    void load() throws Throwable;
+  }
+
+  interface OutlineSupportProbe {
+    boolean isSupported() throws Throwable;
+  }
+
   static final boolean AVAILABLE;
 
   static {
-    boolean available = false;
+    AVAILABLE = computeAvailability(
+        () -> System.loadLibrary("papyrus_text"),
+        PapyrusOutline::nativeIsOutlineSupported);
+  }
+
+  static boolean computeAvailability(LibraryLoader loader, OutlineSupportProbe probe) {
     try {
-      System.loadLibrary("papyrus_text");
-      available = true;
+      loader.load();
+      return probe.isSupported();
     } catch (Throwable ignored) {
-      available = false;
+      return false;
     }
-    AVAILABLE = available;
   }
 
+  static native boolean nativeIsOutlineSupported();
+
   static native PapyrusOutlineItem[] nativeGetOutline(long docPtr);
 
   static native PapyrusOutlineItem[] nativeGetOutlineFile(String filePath);

package/android/src/main/java/com/papyrus/engine/PapyrusPageView.java

@@ -6,6 +6,7 @@ import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.util.AttributeSet;
+import android.util.Log;
 import android.view.View;
 
 import com.shockwave.pdfium.PdfDocument;
@@ -14,6 +15,9 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public class PapyrusPageView extends View {
+  static final long MAX_RENDER_PIXELS = 8L * 1024L * 1024L;
+  static final int MAX_RENDER_EDGE = 4096;
+  private static final String TAG = "PapyrusPageView";
   private static final ExecutorService RENDER_EXECUTOR = Executors.newSingleThreadExecutor();
 
   private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
@@ -43,8 +47,12 @@ public class PapyrusPageView extends View {
     final int viewHeight = getHeight();
     final float clampedZoom = Math.max(0.1f, Math.min(5.0f, zoom));
     final float targetScale = Math.max(0.1f, scale) * clampedZoom;
-    final int renderWidth = Math.max(1, (int) (viewWidth * targetScale));
-    final int renderHeight = Math.max(1, (int) (viewHeight * targetScale));
+    final int[] renderSize = constrainRenderSize(
+      Math.max(1, (int) (viewWidth * targetScale)),
+      Math.max(1, (int) (viewHeight * targetScale))
+    );
+    final int renderWidth = renderSize[0];
+    final int renderHeight = renderSize[1];
 
     RENDER_EXECUTOR.execute(() -> {
       PdfDocument doc = state.document;
@@ -81,6 +89,40 @@ public class PapyrusPageView extends View {
     super.onDraw(canvas);
     if (bitmap == null) return;
     Rect dest = new Rect(0, 0, getWidth(), getHeight());
-    canvas.drawBitmap(bitmap, null, dest, paint);
+    try {
+      canvas.drawBitmap(bitmap, null, dest, paint);
+    } catch (RuntimeException error) {
+      Log.w(TAG, "Failed to draw rendered page bitmap safely", error);
+      if (bitmap != null && !bitmap.isRecycled()) {
+        bitmap.recycle();
+      }
+      bitmap = null;
+    }
+  }
+
+  static int[] constrainRenderSize(int requestedWidth, int requestedHeight) {
+    int width = Math.max(1, requestedWidth);
+    int height = Math.max(1, requestedHeight);
+    double scale = 1.0d;
+
+    if (width > MAX_RENDER_EDGE || height > MAX_RENDER_EDGE) {
+      scale = Math.min(
+        scale,
+        Math.min((double) MAX_RENDER_EDGE / width, (double) MAX_RENDER_EDGE / height)
+      );
+    }
+
+    long pixels = (long) width * (long) height;
+    if (pixels > MAX_RENDER_PIXELS) {
+      scale = Math.min(scale, Math.sqrt((double) MAX_RENDER_PIXELS / (double) pixels));
+    }
+
+    if (scale >= 1.0d) {
+      return new int[] { width, height };
+    }
+
+    int safeWidth = Math.max(1, (int) Math.floor(width * scale));
+    int safeHeight = Math.max(1, (int) Math.floor(height * scale));
+    return new int[] { safeWidth, safeHeight };
   }
 }

package/android/src/test/java/com/papyrus/engine/PapyrusOutlineTest.java

@@ -0,0 +1,40 @@
+package com.papyrus.engine;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class PapyrusOutlineTest {
+  @Test
+  public void computeAvailabilityReturnsTrueWhenLoaderAndProbeSucceed() {
+    boolean available = PapyrusOutline.computeAvailability(() -> {}, () -> true);
+
+    assertTrue(available);
+  }
+
+  @Test
+  public void computeAvailabilityReturnsFalseWhenProbeReturnsFalse() {
+    boolean available = PapyrusOutline.computeAvailability(() -> {}, () -> false);
+
+    assertFalse(available);
+  }
+
+  @Test
+  public void computeAvailabilityReturnsFalseWhenProbeThrows() {
+    boolean available = PapyrusOutline.computeAvailability(() -> {}, () -> {
+      throw new UnsatisfiedLinkError("missing probe");
+    });
+
+    assertFalse(available);
+  }
+
+  @Test
+  public void computeAvailabilityReturnsFalseWhenLibraryLoadThrows() {
+    boolean available = PapyrusOutline.computeAvailability(() -> {
+      throw new UnsatisfiedLinkError("missing lib");
+    }, () -> true);
+
+    assertFalse(available);
+  }
+}

package/android/src/test/java/com/papyrus/engine/PapyrusPageViewTest.java

@@ -0,0 +1,30 @@
+package com.papyrus.engine;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class PapyrusPageViewTest {
+  @Test
+  public void constrainRenderSizeKeepsSafeSizesUntouched() {
+    int[] size = PapyrusPageView.constrainRenderSize(1200, 1600);
+
+    assertArrayEquals(new int[] {1200, 1600}, size);
+  }
+
+  @Test
+  public void constrainRenderSizeCapsOversizedBitmapsPreservingAspectRatio() {
+    int[] size = PapyrusPageView.constrainRenderSize(6000, 8000);
+
+    assertTrue(size[0] > 0);
+    assertTrue(size[1] > 0);
+    assertTrue(size[0] <= PapyrusPageView.MAX_RENDER_EDGE);
+    assertTrue(size[1] <= PapyrusPageView.MAX_RENDER_EDGE);
+    assertTrue(
+      ((long) size[0] * (long) size[1]) <= PapyrusPageView.MAX_RENDER_PIXELS
+    );
+    assertTrue(size[0] < 6000);
+    assertTrue(size[1] < 8000);
+  }
+}