@apollohg/react-native-rich-text-editor 2.0.0

package/android/build.gradle

@@ -0,0 +1,188 @@
+import groovy.json.JsonSlurper
+
+plugins {
+    id 'com.android.library'
+    id 'com.facebook.react'
+}
+
+def expoModulesCorePlugin = new File(project(':expo-modules-core').projectDir, 'ExpoModulesCorePlugin.gradle')
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+
+def packageJson = new JsonSlurper().parse(file('../package.json'))
+def repositoryRoot = file('..').canonicalFile
+def hostOsName = System.getProperty('os.name').toLowerCase(java.util.Locale.ROOT)
+def hostEditorCoreLibraryName = hostOsName.contains('mac') ? 'libeditor_core.dylib' :
+    hostOsName.contains('linux') ? 'libeditor_core.so' :
+    hostOsName.contains('windows') ? 'editor_core.dll' :
+    'libeditor_core.so'
+def hostRustTargetDirectory = file("$buildDir/host-editor-core")
+def hostEditorCoreLibrary = file("$hostRustTargetDirectory/release/$hostEditorCoreLibraryName")
+def pinnedCargoScript = new File(repositoryRoot, 'rust/toolchain-cargo.sh').absolutePath
+// Native Windows needs a Bash host for the checked-in pinned-Cargo wrapper;
+// macOS and Linux execute that wrapper directly.
+def hostCargoCommand = hostOsName.contains('windows') ? ['bash', pinnedCargoScript] : [pinnedCargoScript]
+
+def newArchEnabled = project.findProperty('newArchEnabled')?.toString() == 'true'
+if (!newArchEnabled) {
+    throw new GradleException(
+        'ReactNativeProseEditor requires the React Native New Architecture. Set newArchEnabled=true.'
+    )
+}
+
+group = 'com.apollohg'
+version = packageJson.version
+
+// The Android AAR is the only production JNA artifact. Robolectric runs the
+// generated UniFFI binding on the host JVM, which instead needs JNA's ordinary
+// JAR and its bundled host jnidispatch resource. Resolve that artifact outside
+// the Android runtime graph so Gradle cannot select the AAR for host tests.
+configurations {
+    hostTestJna {
+        canBeConsumed = false
+        canBeResolved = true
+        transitive = false
+    }
+}
+
+configurations.configureEach {
+    if (name.endsWith('UnitTestRuntimeClasspath')) {
+        // The direct host JAR below supplies JNA classes and host native
+        // resources. Do not let the Android AAR's component variant collapse
+        // that runtime back to Android-only jnidispatch binaries.
+        exclude group: 'net.java.dev.jna', module: 'jna'
+    }
+}
+
+// The generated UniFFI Kotlin binding loads a host dynamic library while
+// Robolectric executes. Keep that artifact under Gradle's build directory and
+// outside Android source sets, instrumentation, and publication.
+tasks.register('buildHostEditorCore', Exec) {
+    inputs.files(
+        fileTree(new File(repositoryRoot, 'rust/editor-core')) {
+            include 'Cargo.toml', 'Cargo.lock', 'build.rs', 'src/**/*.rs'
+        },
+        new File(pinnedCargoScript),
+        new File(repositoryRoot, 'rust/toolchain.sh'),
+    )
+    outputs.file(hostEditorCoreLibrary)
+    workingDir repositoryRoot
+    environment 'CARGO_TARGET_DIR', hostRustTargetDirectory.absolutePath
+    commandLine(*(hostCargoCommand + [
+        'build',
+        '--manifest-path', new File(repositoryRoot, 'rust/editor-core/Cargo.toml').absolutePath,
+        '--release',
+    ]))
+}
+
+// Bypass AGP's Android artifact transform: it strips the raw JAR's host
+// jnidispatch resource. These are JVM Test tasks only; neither Android
+// instrumentation nor any production/public configuration receives them.
+//
+// AGP finalizes each unit-test runtime classpath after task configuration. Add
+// the raw JAR in a doFirst action so it is the first entry seen by the forked
+// JVM, after AGP has completed that construction, rather than being replaced
+// by a transformed Android artifact.
+def hostTestJnaClasspath = files(configurations.hostTestJna)
+tasks.withType(Test).configureEach {
+    dependsOn tasks.named('buildHostEditorCore')
+    inputs.files(hostTestJnaClasspath).withPropertyName('hostTestJnaClasspath')
+    systemProperty 'uniffi.component.editor_core.libraryOverride', hostEditorCoreLibrary.absolutePath
+    doFirst {
+        classpath = hostTestJnaClasspath.plus(classpath)
+    }
+}
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', 35)
+    namespace = "com.apollohg.editor"
+    lint {
+        abortOnError true
+        xmlReport true
+        xmlOutput file("$buildDir/reports/lint-results-debug.xml")
+        lintConfig file('lint.xml')
+    }
+    buildFeatures {
+        // The performance collector uses this explicit build-type constant;
+        // no implicit/generated DEBUG field is relied on by release drawing.
+        buildConfig = true
+    }
+    buildTypes {
+        debug {
+            buildConfigField "boolean", "PREPARED_PROSE_INSTRUMENTATION", "true"
+        }
+        release {
+            buildConfigField "boolean", "PREPARED_PROSE_INSTRUMENTATION", "false"
+        }
+    }
+    testOptions {
+        unitTests.includeAndroidResources = true
+        unitTests.all { test ->
+            if (project.findProperty("apollohgShowPerfTestOutput") == "true") {
+                test.testLogging {
+                    events "passed", "failed"
+                    showStandardStreams = true
+                }
+            }
+        }
+    }
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 24)
+        targetSdkVersion safeExtGet('targetSdkVersion', 35)
+        versionCode = 1
+        versionName = packageJson.version
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles "consumer-rules.pro"
+    }
+
+    sourceSets {
+        main {
+            jniLibs.srcDirs = [
+                "${project.projectDir}/../rust/android"
+            ]
+            java.srcDirs += [
+                "${project.projectDir}/../rust/bindings/kotlin"
+            ]
+        }
+        test {
+            java.srcDirs += [
+                "${project.projectDir}/src/sharedTest/java"
+            ]
+            assets.srcDirs += [
+                "${project.projectDir}/../scripts/tests"
+            ]
+        }
+        androidTest {
+            java.srcDirs += [
+                "${project.projectDir}/src/sharedTest/java"
+            ]
+            assets.srcDirs += [
+                "${project.projectDir}/../scripts/tests"
+            ]
+        }
+    }
+}
+
+dependencies {
+    implementation "androidx.recyclerview:recyclerview:1.3.2"
+    implementation "com.facebook.react:react-android"
+    implementation "androidx.appcompat:appcompat:1.7.0"
+    implementation "com.google.android.material:material:1.12.0"
+    implementation "com.squareup.okhttp3:okhttp:4.9.2"
+    implementation "com.caverock:androidsvg-aar:1.4"
+
+    api "net.java.dev.jna:jna:5.18.1@aar"
+    // Do not add this JAR to any Android or published configuration. The
+    // separate artifact request is intentionally consumed only by JVM tests.
+    hostTestJna "net.java.dev.jna:jna:5.18.1@jar"
+
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.robolectric:robolectric:4.14.1"
+    testImplementation "com.squareup.okhttp3:mockwebserver:4.9.2"
+
+    androidTestImplementation "androidx.test:core-ktx:1.6.1"
+    androidTestImplementation "androidx.test:runner:1.6.2"
+    androidTestImplementation "androidx.test.ext:junit:1.2.1"
+    androidTestImplementation "com.squareup.okhttp3:mockwebserver:4.9.2"
+}

package/android/consumer-rules.pro

@@ -0,0 +1,18 @@
+# JNA includes desktop AWT helpers that are not available on Android. The editor
+# bindings do not call those APIs, but R8 still validates the references.
+-dontwarn java.awt.**
+
+# UniFFI uses JNA reflection/proxies to bind Kotlin method and structure field
+# names to the Rust library. Keep these names stable in consuming release builds.
+-keep class com.sun.jna.** { *; }
+-keep class uniffi.editor_core.** { *; }
+-keepattributes Signature,InnerClasses,EnclosingMethod,*Annotation*
+
+# Preserve native editor View class names in consuming release builds so Android
+# framework ViewGroup crashes identify the owning component in crash reporters.
+-keepnames class com.apollohg.editor.** extends android.view.View
+
+# JNA inspects Library interfaces and Structure fields reflectively. These
+# member rules make that contract explicit for ProGuard/R8 consumers.
+-keepclassmembers class * implements com.sun.jna.Library { *; }
+-keepclassmembers class * extends com.sun.jna.Structure { *; }

package/android/expo/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id 'com.android.library'
+}
+
+android {
+    compileSdkVersion rootProject.ext.has('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    namespace = 'com.apollohg.editor.expo'
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.has('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion rootProject.ext.has('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+    }
+}
+
+dependencies {
+    api project(':apollohg_react-native-rich-text-editor')
+}

package/android/src/debug/java/com/apollohg/editor/viewer/PreparedProseDrawInstrumentation.kt

@@ -0,0 +1,7 @@
+package com.apollohg.editor.viewer
+
+/** Debug/androidTest-only draw timing, inlined into [PreparedProseDrawingView]. */
+internal inline fun recordPreparedProseDraw(draw: () -> Int) {
+    val started = PreparedProseInstrumentation.now()
+    PreparedProseInstrumentation.drew(started, draw())
+}