@papyrus-sdk/engine-native 0.2.9 → 0.2.10

package/README.md

@@ -1,38 +1,38 @@
-# Papyrus Engine Native
-
-React Native native engine for PDF rendering (PDFKit on iOS, PDFium on Android),
-plus a WebView runtime for EPUB/TXT via `MobileDocumentEngine`.
-
-## Install
-
-```bash
-npm install @papyrus-sdk/engine-native @papyrus-sdk/core @papyrus-sdk/types
-```
-
-`@papyrus-sdk/core` and `@papyrus-sdk/types` are required peer dependencies.
-
-For EPUB/TXT on mobile, also install:
-
-```bash
-npm install react-native-webview
-```
-
-## Usage
-
-```ts
-import { MobileDocumentEngine, PapyrusPageView } from '@papyrus-sdk/engine-native';
-import { findNodeHandle } from 'react-native';
-
-const engine = new MobileDocumentEngine();
-await engine.load({ type: 'pdf', source: { uri: 'https://example.com/book.pdf' } });
-
-// Render the first page into a native view
-const viewTag = findNodeHandle(pageViewRef.current);
-if (viewTag) {
-  await engine.renderPage(0, viewTag, 2);
-}
-```
-
-Notes:
-- Requires a native build (not Expo Go).
-- Use `PapyrusPageView` for native PDF rendering.
+# Papyrus Engine Native
+
+React Native native engine for PDF rendering (PDFKit on iOS, PDFium on Android),
+plus a WebView runtime for EPUB/TXT via `MobileDocumentEngine`.
+
+## Install
+
+```bash
+npm install @papyrus-sdk/engine-native @papyrus-sdk/core @papyrus-sdk/types
+```
+
+`@papyrus-sdk/core` and `@papyrus-sdk/types` are required peer dependencies.
+
+For EPUB/TXT on mobile, also install:
+
+```bash
+npm install react-native-webview
+```
+
+## Usage
+
+```ts
+import { MobileDocumentEngine, PapyrusPageView } from '@papyrus-sdk/engine-native';
+import { findNodeHandle } from 'react-native';
+
+const engine = new MobileDocumentEngine();
+await engine.load({ type: 'pdf', source: { uri: 'https://example.com/book.pdf' } });
+
+// Render the first page into a native view
+const viewTag = findNodeHandle(pageViewRef.current);
+if (viewTag) {
+  await engine.renderPage(0, viewTag, 2);
+}
+```
+
+Notes:
+- Requires a native build (not Expo Go).
+- Use `PapyrusPageView` for native PDF rendering.

package/android/build.gradle

@@ -1,41 +1,42 @@
-apply plugin: 'com.android.library'
-
-def safeExtGet(prop, fallback) {
-  return rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-}
-
-android {
-  compileSdkVersion safeExtGet('compileSdkVersion', 35)
-  ndkVersion safeExtGet('ndkVersion', '26.1.10909125')
-  namespace 'com.papyrus.engine'
-
-  defaultConfig {
-    minSdkVersion safeExtGet('minSdkVersion', 21)
-    targetSdkVersion safeExtGet('targetSdkVersion', 35)
-    consumerProguardFiles 'consumer-rules.pro'
-    externalNativeBuild {
-      cmake {
-        cppFlags "-std=c++17"
-      }
-    }
-  }
-
-  sourceSets {
-    main {
-      java.srcDirs = ['src/main/java']
-    }
-  }
-
-  externalNativeBuild {
-    cmake {
-      path "src/main/cpp/CMakeLists.txt"
-    }
-  }
-}
-
-dependencies {
-  implementation 'com.facebook.react:react-android'
-  implementation('io.github.oothp:pdfium-android:1.9.5-beta01') {
-    exclude group: 'com.android.support'
-  }
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+  return rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  compileSdkVersion safeExtGet('compileSdkVersion', 35)
+  ndkVersion safeExtGet('ndkVersion', '26.1.10909125')
+  namespace 'com.papyrus.engine'
+
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 21)
+    targetSdkVersion safeExtGet('targetSdkVersion', 35)
+    consumerProguardFiles 'consumer-rules.pro'
+    externalNativeBuild {
+      cmake {
+        cppFlags "-std=c++17"
+      }
+    }
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs = ['src/main/java']
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "src/main/cpp/CMakeLists.txt"
+    }
+  }
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-android'
+  implementation('io.github.oothp:pdfium-android:1.9.5-beta01') {
+    exclude group: 'com.android.support'
+  }
+  testImplementation 'junit:junit:4.13.2'
 }

package/android/consumer-rules.pro

@@ -1 +1 @@
-# Keep rules can be added here if needed.
+# Keep rules can be added here if needed.

package/android/src/main/cpp/CMakeLists.txt

@@ -1,24 +1,45 @@
 cmake_minimum_required(VERSION 3.18.1)
 project(papyrus_text)
 
-add_library(papyrus_text SHARED
-  papyrus_text_search.cpp
-  papyrus_outline.cpp
-)
-
-target_compile_options(papyrus_text PRIVATE -Wall -Werror)
-target_link_options(papyrus_text PRIVATE "-Wl,-z,max-page-size=16384")
-set_target_properties(papyrus_text PROPERTIES
-  CXX_STANDARD 17
-  CXX_STANDARD_REQUIRED YES
-)
-
-find_library(log-lib log)
-find_library(android-lib android)
-find_library(dl-lib dl)
-
-target_link_libraries(papyrus_text
-  ${log-lib}
-  ${android-lib}
-  ${dl-lib}
-)
+option(PAPYRUS_OUTLINE_HOST_TESTS "Build host tests for the outline loader" OFF)
+
+function(papyrus_set_cxx17 target_name)
+  set_target_properties(${target_name} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED YES
+  )
+endfunction()
+
+if(ANDROID)
+  add_library(papyrus_text SHARED
+    papyrus_text_search.cpp
+    papyrus_outline.cpp
+    papyrus_outline_loader.cpp
+  )
+
+  papyrus_set_cxx17(papyrus_text)
+  target_compile_options(papyrus_text PRIVATE -Wall -Werror)
+  target_link_options(papyrus_text PRIVATE "-Wl,-z,max-page-size=16384")
+
+  find_library(log-lib log)
+  find_library(android-lib android)
+  find_library(dl-lib dl)
+
+  target_link_libraries(papyrus_text
+    ${log-lib}
+    ${android-lib}
+    ${dl-lib}
+  )
+endif()
+
+if(PAPYRUS_OUTLINE_HOST_TESTS)
+  enable_testing()
+
+  add_executable(papyrus_outline_loader_test
+    papyrus_outline_loader.cpp
+    papyrus_outline_loader_test.cpp
+  )
+
+  papyrus_set_cxx17(papyrus_outline_loader_test)
+  add_test(NAME papyrus_outline_loader_test COMMAND papyrus_outline_loader_test)
+endif()

package/android/src/main/cpp/papyrus_outline.cpp

@@ -1,71 +1,68 @@
+#include "papyrus_outline_loader.h"
+
 #include <jni.h>
 #include <android/log.h>
 #include <dlfcn.h>
 
-#include <algorithm>
-#include <string>
+#include <cstring>
 #include <vector>
 
 #define LOG_TAG "PapyrusOutline"
 #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
 
-typedef void *FPDF_DOCUMENT;
-typedef void *FPDF_BOOKMARK;
-typedef void *FPDF_DEST;
-
-struct PdfiumFns {
-  FPDF_DOCUMENT (*loadDocument)(const char *, const char *);
-  void (*closeDocument)(FPDF_DOCUMENT);
-  FPDF_BOOKMARK (*bookmarkGetFirstChild)(FPDF_DOCUMENT, FPDF_BOOKMARK);
-  FPDF_BOOKMARK (*bookmarkGetNextSibling)(FPDF_DOCUMENT, FPDF_BOOKMARK);
-  unsigned long (*bookmarkGetTitle)(FPDF_BOOKMARK, void *, unsigned long);
-  FPDF_DEST (*bookmarkGetDest)(FPDF_DOCUMENT, FPDF_BOOKMARK);
-  int (*destGetPageIndex)(FPDF_DOCUMENT, FPDF_DEST);
-};
+namespace {
 
-static void *g_pdfium = nullptr;
-static PdfiumFns g_fns = {};
-static bool g_loaded = false;
+OutlineLoaderState g_outline_loader = {};
 
-static bool LoadPdfium() {
-  if (g_loaded) return g_pdfium != nullptr;
+void *OutlineDlopen(void *, const char *filename, int flags) {
+  return dlopen(filename, flags);
+}
 
-  g_pdfium = dlopen("libmodpdfium.so", RTLD_LAZY);
-  if (!g_pdfium) {
-    LOGE("Failed to load libmodpdfium.so");
-    g_loaded = true;
-    return false;
-  }
+OutlineLoaderDeps::PdfiumSymbol OutlineDlsym(void *, void *handle, const char *symbol_name) {
+  void *raw_symbol = dlsym(handle, symbol_name);
+  OutlineLoaderDeps::PdfiumSymbol symbol = nullptr;
+  static_assert(sizeof(symbol) == sizeof(raw_symbol),
+                "Expected dlsym results to match function pointer size");
+  std::memcpy(&symbol, &raw_symbol, sizeof(symbol));
+  return symbol;
+}
+
+int OutlineDlclose(void *, void *handle) {
+  return dlclose(handle);
+}
 
-  g_fns.loadDocument = reinterpret_cast<FPDF_DOCUMENT (*)(const char *, const char *)>(dlsym(g_pdfium, "FPDF_LoadDocument"));
-  g_fns.closeDocument = reinterpret_cast<void (*)(FPDF_DOCUMENT)>(dlsym(g_pdfium, "FPDF_CloseDocument"));
-  g_fns.bookmarkGetFirstChild = reinterpret_cast<FPDF_BOOKMARK (*)(FPDF_DOCUMENT, FPDF_BOOKMARK)>(dlsym(g_pdfium, "FPDFBookmark_GetFirstChild"));
-  g_fns.bookmarkGetNextSibling = reinterpret_cast<FPDF_BOOKMARK (*)(FPDF_DOCUMENT, FPDF_BOOKMARK)>(dlsym(g_pdfium, "FPDFBookmark_GetNextSibling"));
-  g_fns.bookmarkGetTitle = reinterpret_cast<unsigned long (*)(FPDF_BOOKMARK, void *, unsigned long)>(dlsym(g_pdfium, "FPDFBookmark_GetTitle"));
-  g_fns.bookmarkGetDest = reinterpret_cast<FPDF_DEST (*)(FPDF_DOCUMENT, FPDF_BOOKMARK)>(dlsym(g_pdfium, "FPDFBookmark_GetDest"));
-  g_fns.destGetPageIndex = reinterpret_cast<int (*)(FPDF_DOCUMENT, FPDF_DEST)>(dlsym(g_pdfium, "FPDFDest_GetPageIndex"));
-
-  if (!g_fns.loadDocument || !g_fns.closeDocument || !g_fns.bookmarkGetFirstChild ||
-      !g_fns.bookmarkGetNextSibling || !g_fns.bookmarkGetTitle || !g_fns.bookmarkGetDest ||
-      !g_fns.destGetPageIndex) {
+const OutlineLoaderDeps kOutlineLoaderDeps = {
+    nullptr,
+    &OutlineDlopen,
+    &OutlineDlsym,
+    &OutlineDlclose,
+    "libmodpdfium.so",
+    RTLD_LAZY,
+};
+
+bool LoadPdfium() {
+  const OutlineLoadAttemptResult result =
+      EnsureOutlinePdfiumLoaded(&g_outline_loader, &kOutlineLoaderDeps);
+  if (!result.loaded && result.transitioned_to_unsupported) {
     LOGE("Failed to load required PDFium symbols for outline");
-    g_loaded = true;
-    return false;
   }
+  return result.loaded;
+}
 
-  g_loaded = true;
-  return true;
+PdfiumOutlineFns &OutlineFns() {
+  return g_outline_loader.fns;
 }
 
-static jstring GetBookmarkTitle(JNIEnv *env, FPDF_BOOKMARK bookmark) {
-  unsigned long length = g_fns.bookmarkGetTitle(bookmark, nullptr, 0);
+jstring GetBookmarkTitle(JNIEnv *env, FPDF_BOOKMARK bookmark) {
+  unsigned long length = OutlineFns().bookmarkGetTitle(bookmark, nullptr, 0);
   if (length <= 2) {
     return env->NewStringUTF("");
   }
 
   std::vector<unsigned short> buffer((length / 2) + 1, 0);
-  unsigned long written = g_fns.bookmarkGetTitle(bookmark, buffer.data(), length);
-  int chars = written > 0 ? static_cast<int>(written / 2) - 1 : static_cast<int>(length / 2) - 1;
+  unsigned long written = OutlineFns().bookmarkGetTitle(bookmark, buffer.data(), length);
+  int chars = written > 0 ? static_cast<int>(written / 2) - 1
+                          : static_cast<int>(length / 2) - 1;
   if (chars <= 0) {
     return env->NewStringUTF("");
   }
@@ -73,30 +70,39 @@ static jstring GetBookmarkTitle(JNIEnv *env, FPDF_BOOKMARK bookmark) {
   return env->NewString(reinterpret_cast<const jchar *>(buffer.data()), chars);
 }
 
-static jobjectArray BuildOutlineItems(JNIEnv *env, FPDF_DOCUMENT doc, FPDF_BOOKMARK parent, jclass itemClass, jmethodID ctor) {
+jobjectArray BuildOutlineItems(JNIEnv *env,
+                               FPDF_DOCUMENT doc,
+                               FPDF_BOOKMARK parent,
+                               jclass item_class,
+                               jmethodID ctor) {
   std::vector<jobject> items;
 
-  for (FPDF_BOOKMARK child = g_fns.bookmarkGetFirstChild(doc, parent); child;
-       child = g_fns.bookmarkGetNextSibling(doc, child)) {
+  for (FPDF_BOOKMARK child = OutlineFns().bookmarkGetFirstChild(doc, parent); child;
+       child = OutlineFns().bookmarkGetNextSibling(doc, child)) {
     jstring title = GetBookmarkTitle(env, child);
-    int pageIndex = -1;
-    FPDF_DEST dest = g_fns.bookmarkGetDest(doc, child);
-    if (dest) {
-      pageIndex = g_fns.destGetPageIndex(doc, dest);
+    int page_index = -1;
+    FPDF_DEST dest = OutlineFns().bookmarkGetDest(doc, child);
+    if (dest != nullptr) {
+      page_index = OutlineFns().destGetPageIndex(doc, dest);
     }
 
-    jobjectArray children = BuildOutlineItems(env, doc, child, itemClass, ctor);
-    jobject item = env->NewObject(itemClass, ctor, title, pageIndex, children);
+    jobjectArray children = BuildOutlineItems(env, doc, child, item_class, ctor);
+    jobject item = env->NewObject(item_class, ctor, title, page_index, children);
 
-    if (title) env->DeleteLocalRef(title);
-    if (children) env->DeleteLocalRef(children);
+    if (title != nullptr) {
+      env->DeleteLocalRef(title);
+    }
+    if (children != nullptr) {
+      env->DeleteLocalRef(children);
+    }
 
-    if (item) {
+    if (item != nullptr) {
       items.push_back(item);
     }
   }
 
-  jobjectArray array = env->NewObjectArray(static_cast<jsize>(items.size()), itemClass, nullptr);
+  jobjectArray array =
+      env->NewObjectArray(static_cast<jsize>(items.size()), item_class, nullptr);
   for (jsize i = 0; i < static_cast<jsize>(items.size()); i++) {
     env->SetObjectArrayElement(array, i, items[i]);
   }
@@ -104,36 +110,64 @@ static jobjectArray BuildOutlineItems(JNIEnv *env, FPDF_DOCUMENT doc, FPDF_BOOKM
   return array;
 }
 
-static jobjectArray BuildOutline(JNIEnv *env, FPDF_DOCUMENT doc) {
-  jclass itemClass = env->FindClass("com/papyrus/engine/PapyrusOutlineItem");
-  if (!itemClass) return nullptr;
-  jmethodID ctor = env->GetMethodID(itemClass, "<init>", "(Ljava/lang/String;I[Lcom/papyrus/engine/PapyrusOutlineItem;)V");
-  if (!ctor) return nullptr;
-  return BuildOutlineItems(env, doc, nullptr, itemClass, ctor);
+jobjectArray BuildOutline(JNIEnv *env, FPDF_DOCUMENT doc) {
+  jclass item_class = env->FindClass("com/papyrus/engine/PapyrusOutlineItem");
+  if (item_class == nullptr) {
+    return nullptr;
+  }
+
+  jmethodID ctor = env->GetMethodID(
+      item_class, "<init>", "(Ljava/lang/String;I[Lcom/papyrus/engine/PapyrusOutlineItem;)V");
+  if (ctor == nullptr) {
+    return nullptr;
+  }
+
+  return BuildOutlineItems(env, doc, nullptr, item_class, ctor);
+}
+
+}  // namespace
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_papyrus_engine_PapyrusOutline_nativeIsOutlineSupported(JNIEnv *, jclass) {
+  return LoadPdfium() ? JNI_TRUE : JNI_FALSE;
 }
 
 extern "C" JNIEXPORT jobjectArray JNICALL
 Java_com_papyrus_engine_PapyrusOutline_nativeGetOutline(JNIEnv *env, jclass, jlong docPtr) {
-  if (!LoadPdfium()) return nullptr;
-  if (!docPtr) return nullptr;
+  if (!LoadPdfium()) {
+    return nullptr;
+  }
+  if (!docPtr) {
+    return nullptr;
+  }
 
   FPDF_DOCUMENT doc = reinterpret_cast<FPDF_DOCUMENT>(docPtr);
   return BuildOutline(env, doc);
 }
 
 extern "C" JNIEXPORT jobjectArray JNICALL
-Java_com_papyrus_engine_PapyrusOutline_nativeGetOutlineFile(JNIEnv *env, jclass, jstring filePath) {
-  if (!LoadPdfium()) return nullptr;
-  if (!filePath) return nullptr;
+Java_com_papyrus_engine_PapyrusOutline_nativeGetOutlineFile(JNIEnv *env,
+                                                            jclass,
+                                                            jstring filePath) {
+  if (!LoadPdfium()) {
+    return nullptr;
+  }
+  if (filePath == nullptr) {
+    return nullptr;
+  }
 
   const char *path = env->GetStringUTFChars(filePath, nullptr);
-  if (!path) return nullptr;
+  if (path == nullptr) {
+    return nullptr;
+  }
 
-  FPDF_DOCUMENT doc = g_fns.loadDocument(path, nullptr);
+  FPDF_DOCUMENT doc = OutlineFns().loadDocument(path, nullptr);
   env->ReleaseStringUTFChars(filePath, path);
-  if (!doc) return nullptr;
+  if (doc == nullptr) {
+    return nullptr;
+  }
 
   jobjectArray result = BuildOutline(env, doc);
-  g_fns.closeDocument(doc);
+  OutlineFns().closeDocument(doc);
   return result;
-}
+}

package/android/src/main/cpp/papyrus_outline_loader.cpp

@@ -0,0 +1,125 @@
+#include "papyrus_outline_loader.h"
+
+#include <cstring>
+
+namespace {
+
+void ClearOutlineFns(PdfiumOutlineFns *fns) {
+  if (fns == nullptr) {
+    return;
+  }
+
+  *fns = {};
+}
+
+void CloseHandleIfPresent(OutlineLoaderState *state, const OutlineLoaderDeps *deps) {
+  if (state == nullptr || state->handle == nullptr) {
+    return;
+  }
+
+  if (deps != nullptr && deps->dlclose_fn != nullptr) {
+    deps->dlclose_fn(deps->user_data, state->handle);
+  }
+
+  state->handle = nullptr;
+}
+
+void TransitionToUnsupported(OutlineLoaderState *state, const OutlineLoaderDeps *deps) {
+  if (state == nullptr) {
+    return;
+  }
+
+  ClearOutlineFns(&state->fns);
+  CloseHandleIfPresent(state, deps);
+  state->load_state = OutlineLoadState::kUnsupported;
+}
+
+template <typename FnType>
+FnType ResolveOutlineSymbol(const OutlineLoaderDeps *deps, void *handle, const char *symbol_name) {
+  const OutlineLoaderDeps::PdfiumSymbol raw_symbol =
+      deps->dlsym_fn(deps->user_data, handle, symbol_name);
+
+  FnType resolved_symbol = nullptr;
+  static_assert(sizeof(resolved_symbol) == sizeof(raw_symbol),
+                "Expected function pointers to share the same size");
+  std::memcpy(&resolved_symbol, &raw_symbol, sizeof(resolved_symbol));
+  return resolved_symbol;
+}
+
+PdfiumOutlineFns LoadOutlineFns(void *handle, const OutlineLoaderDeps *deps) {
+  PdfiumOutlineFns fns = {};
+  fns.loadDocument =
+      ResolveOutlineSymbol<decltype(fns.loadDocument)>(deps, handle, "FPDF_LoadDocument");
+  fns.closeDocument =
+      ResolveOutlineSymbol<decltype(fns.closeDocument)>(deps, handle, "FPDF_CloseDocument");
+  fns.bookmarkGetFirstChild = ResolveOutlineSymbol<decltype(fns.bookmarkGetFirstChild)>(
+      deps, handle, "FPDFBookmark_GetFirstChild");
+  fns.bookmarkGetNextSibling = ResolveOutlineSymbol<decltype(fns.bookmarkGetNextSibling)>(
+      deps, handle, "FPDFBookmark_GetNextSibling");
+  fns.bookmarkGetTitle =
+      ResolveOutlineSymbol<decltype(fns.bookmarkGetTitle)>(deps, handle, "FPDFBookmark_GetTitle");
+  fns.bookmarkGetDest =
+      ResolveOutlineSymbol<decltype(fns.bookmarkGetDest)>(deps, handle, "FPDFBookmark_GetDest");
+  fns.destGetPageIndex =
+      ResolveOutlineSymbol<decltype(fns.destGetPageIndex)>(deps, handle, "FPDFDest_GetPageIndex");
+  return fns;
+}
+
+bool HasRequiredDeps(const OutlineLoaderDeps *deps) {
+  return deps != nullptr && deps->dlopen_fn != nullptr && deps->dlsym_fn != nullptr &&
+         deps->dlclose_fn != nullptr && deps->library_name != nullptr;
+}
+
+}  // namespace
+
+bool HasCompleteOutlineFns(const PdfiumOutlineFns &fns) {
+  return fns.loadDocument != nullptr && fns.closeDocument != nullptr &&
+         fns.bookmarkGetFirstChild != nullptr && fns.bookmarkGetNextSibling != nullptr &&
+         fns.bookmarkGetTitle != nullptr && fns.bookmarkGetDest != nullptr &&
+         fns.destGetPageIndex != nullptr;
+}
+
+OutlineLoadAttemptResult EnsureOutlinePdfiumLoaded(OutlineLoaderState *state,
+                                                   const OutlineLoaderDeps *deps) {
+  if (state == nullptr) {
+    return {};
+  }
+
+  if (state->load_state == OutlineLoadState::kSupported) {
+    return {true, false};
+  }
+
+  if (state->load_state == OutlineLoadState::kUnsupported) {
+    return {false, false};
+  }
+
+  if (!HasRequiredDeps(deps)) {
+    TransitionToUnsupported(state, deps);
+    return {false, true};
+  }
+
+  state->handle = deps->dlopen_fn(deps->user_data, deps->library_name, deps->dlopen_flags);
+  if (state->handle == nullptr) {
+    TransitionToUnsupported(state, deps);
+    return {false, true};
+  }
+
+  state->fns = LoadOutlineFns(state->handle, deps);
+  if (!HasCompleteOutlineFns(state->fns)) {
+    TransitionToUnsupported(state, deps);
+    return {false, true};
+  }
+
+  state->load_state = OutlineLoadState::kSupported;
+  return {true, false};
+}
+
+void ResetOutlineLoaderState(OutlineLoaderState *state, const OutlineLoaderDeps *deps) {
+  if (state == nullptr) {
+    return;
+  }
+
+  ClearOutlineFns(&state->fns);
+  CloseHandleIfPresent(state, deps);
+  state->load_state = OutlineLoadState::kUninitialized;
+}

package/android/src/main/cpp/papyrus_outline_loader.h

@@ -0,0 +1,48 @@
+#pragma once
+
+using FPDF_DOCUMENT = void *;
+using FPDF_BOOKMARK = void *;
+using FPDF_DEST = void *;
+
+enum class OutlineLoadState {
+  kUninitialized,
+  kSupported,
+  kUnsupported,
+};
+
+struct PdfiumOutlineFns {
+  FPDF_DOCUMENT (*loadDocument)(const char *, const char *) = nullptr;
+  void (*closeDocument)(FPDF_DOCUMENT) = nullptr;
+  FPDF_BOOKMARK (*bookmarkGetFirstChild)(FPDF_DOCUMENT, FPDF_BOOKMARK) = nullptr;
+  FPDF_BOOKMARK (*bookmarkGetNextSibling)(FPDF_DOCUMENT, FPDF_BOOKMARK) = nullptr;
+  unsigned long (*bookmarkGetTitle)(FPDF_BOOKMARK, void *, unsigned long) = nullptr;
+  FPDF_DEST (*bookmarkGetDest)(FPDF_DOCUMENT, FPDF_BOOKMARK) = nullptr;
+  int (*destGetPageIndex)(FPDF_DOCUMENT, FPDF_DEST) = nullptr;
+};
+
+struct OutlineLoaderDeps {
+  using PdfiumSymbol = void (*)();
+
+  void *user_data = nullptr;
+  void *(*dlopen_fn)(void *user_data, const char *filename, int flags) = nullptr;
+  PdfiumSymbol (*dlsym_fn)(void *user_data, void *handle, const char *symbol_name) = nullptr;
+  int (*dlclose_fn)(void *user_data, void *handle) = nullptr;
+  const char *library_name = nullptr;
+  int dlopen_flags = 0;
+};
+
+struct OutlineLoaderState {
+  void *handle = nullptr;
+  PdfiumOutlineFns fns = {};
+  OutlineLoadState load_state = OutlineLoadState::kUninitialized;
+};
+
+struct OutlineLoadAttemptResult {
+  bool loaded = false;
+  bool transitioned_to_unsupported = false;
+};
+
+bool HasCompleteOutlineFns(const PdfiumOutlineFns &fns);
+OutlineLoadAttemptResult EnsureOutlinePdfiumLoaded(OutlineLoaderState *state,
+                                                   const OutlineLoaderDeps *deps);
+void ResetOutlineLoaderState(OutlineLoaderState *state, const OutlineLoaderDeps *deps);