@onekeyfe/react-native-text-input 3.0.158 → 3.0.159

package/OneKeyTextInput.podspec

@@ -12,7 +12,12 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => "15.5" }
   s.source       = { :git => "https://github.com/OneKeyHQ/app-modules.git", :tag => "#{s.version}" }
   s.source_files = "ios/**/*.{h,m,mm}"
+  s.exclude_files = "ios/tests/**/*"
   s.frameworks   = "UIKit", "UniformTypeIdentifiers"
 
   s.dependency "React-Core"
+
+  s.test_spec "Tests" do |test_spec|
+    test_spec.source_files = "ios/tests/**/*.{m,mm}"
+  end
 end

package/android/build.gradle

@@ -100,6 +100,10 @@ android {
       }
     }
   }
+
+  testOptions {
+    unitTests.includeAndroidResources = true
+  }
 }
 
 repositories {
@@ -115,6 +119,8 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.robolectric:robolectric:4.17"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/test/java/com/textinput/TextInputViewPasteTest.kt

@@ -0,0 +1,116 @@
+package com.textinput
+
+import android.R
+import android.content.ClipData
+import android.content.ClipDescription
+import android.content.ClipboardManager
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import com.facebook.react.bridge.BridgeReactContext
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.uimanager.DisplayMetricsHolder
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+import org.robolectric.shadows.ShadowContentResolver
+import so.onekey.app.wallet.pasteinput.PasteWatcher
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class TextInputViewPasteTest {
+  @Test
+  fun textPasteReportsAndRunsNativePasteForBothMenuActions() {
+    for (action in listOf(R.id.paste, R.id.pasteAsPlainText)) {
+      val context = context()
+      clipboard(context).setPrimaryClip(ClipData.newPlainText("text", "copied"))
+      val events = mutableListOf<Pair<String, String>>()
+      val view = view(context, events)
+
+      assertTrue(view.onTextContextMenuItem(action))
+      assertEquals(listOf(ClipDescription.MIMETYPE_TEXT_PLAIN to "copied"), events)
+      assertEquals("copied", view.text.toString())
+    }
+  }
+
+  @Test
+  fun uriPasteReportsResolvedMime() {
+    val context = context()
+    val uri = Uri.parse("content://text-input-image/item")
+    ShadowContentResolver.registerProviderInternal("text-input-image", MimeProvider("image/png"))
+    clipboard(context).setPrimaryClip(uriClip(uri))
+    val events = mutableListOf<Pair<String, String>>()
+    val view = view(context, events)
+
+    assertTrue(view.onTextContextMenuItem(R.id.paste))
+    assertEquals(listOf("image/png" to uri.toString()), events)
+  }
+
+  @Test
+  fun uriWithoutResolvedMimeDoesNotReport() {
+    val context = context()
+    val uri = Uri.parse("content://text-input-no-mime/item")
+    ShadowContentResolver.registerProviderInternal("text-input-no-mime", MimeProvider(null))
+    clipboard(context).setPrimaryClip(uriClip(uri))
+    val events = mutableListOf<Pair<String, String>>()
+    val view = view(context, events)
+
+    assertTrue(view.onTextContextMenuItem(R.id.paste))
+    assertTrue(events.isEmpty())
+  }
+
+  @Test
+  fun removedWatcherDoesNotReportButStillRunsNativePaste() {
+    val context = context()
+    clipboard(context).setPrimaryClip(ClipData.newPlainText("text", "copied"))
+    val events = mutableListOf<Pair<String, String>>()
+    val view = view(context, events)
+    view.setPasteWatcher(null)
+
+    assertTrue(view.onTextContextMenuItem(R.id.paste))
+    assertTrue(events.isEmpty())
+    assertEquals("copied", view.text.toString())
+  }
+
+  private fun context(): TestReactContext {
+    val application = RuntimeEnvironment.getApplication()
+    DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(application)
+    return TestReactContext(application)
+  }
+
+  private fun clipboard(context: Context) =
+    context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+
+  private fun view(context: Context, events: MutableList<Pair<String, String>>) =
+    TextInputView(context).apply {
+      setPasteWatcher(object : PasteWatcher {
+        override fun onPaste(type: String, data: String) {
+          events += type to data
+        }
+      })
+    }
+
+  private fun uriClip(uri: Uri) =
+    ClipData(ClipDescription("uri", arrayOf("text/uri-list")), ClipData.Item(uri))
+
+  private class TestReactContext(base: Context) : BridgeReactContext(base) {
+    override fun <T : NativeModule?> getNativeModule(nativeModuleInterface: Class<T>): T? = null
+  }
+
+  private class MimeProvider(private val mime: String?) : ContentProvider() {
+    override fun onCreate() = true
+    override fun getType(uri: Uri): String? = mime
+    override fun query(uri: Uri, projection: Array<out String>?, selection: String?,
+      selectionArgs: Array<out String>?, sortOrder: String?): Cursor? = null
+    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
+    override fun update(uri: Uri, values: ContentValues?, selection: String?,
+      selectionArgs: Array<out String>?): Int = 0
+  }
+}

package/ios/OneKeyTextInputPasteObserver.mm

@@ -7,11 +7,80 @@
 #import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
 #import <objc/runtime.h>
 
+#include <atomic>
+
 static NSString *const OneKeyTextInputPasteEvent = @"OneKeyTextInputPaste";
 static __weak OneKeyTextInputPasteObserver *OneKeyPasteObserver = nil;
 static BOOL OneKeyPasteObserverHasListeners = NO;
 static const void *OneKeyPasteInFlightKey = &OneKeyPasteInFlightKey;
 
+// canPerformAction: runs on the main thread, and iOS 27 also calls it from
+// system command validation without any user action. Reading UIPasteboard
+// there is a synchronous XPC call that can block until the watchdog kills the
+// app, so the image check reads this cache and refreshes it off the main thread.
+enum class OneKeyPasteboardImageState { Unknown, NoImages, HasImages };
+enum class OneKeyPasteboardRefreshState { Idle, Scheduled, Dirty };
+static std::atomic<OneKeyPasteboardImageState> OneKeyPasteboardImageCache{OneKeyPasteboardImageState::Unknown};
+static std::atomic<OneKeyPasteboardRefreshState> OneKeyPasteboardRefresh{OneKeyPasteboardRefreshState::Idle};
+
+static void OneKeyRefreshPasteboardImageState(void)
+{
+  for (;;) {
+    OneKeyPasteboardRefreshState state = OneKeyPasteboardRefresh.load();
+    if (state == OneKeyPasteboardRefreshState::Dirty) {
+      return;
+    }
+    if (state == OneKeyPasteboardRefreshState::Scheduled) {
+      if (OneKeyPasteboardRefresh.compare_exchange_weak(state, OneKeyPasteboardRefreshState::Dirty)) {
+        return;
+      }
+    } else if (OneKeyPasteboardRefresh.compare_exchange_weak(state, OneKeyPasteboardRefreshState::Scheduled)) {
+      break;
+    }
+  }
+  static dispatch_queue_t queue;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    queue = dispatch_queue_create("so.onekey.textinput.pasteboard", DISPATCH_QUEUE_SERIAL);
+  });
+  dispatch_async(queue, ^{
+    for (;;) {
+      BOOL hasImages = UIPasteboard.generalPasteboard.hasImages;
+      OneKeyPasteboardImageCache.store(hasImages ? OneKeyPasteboardImageState::HasImages
+                                                : OneKeyPasteboardImageState::NoImages);
+      OneKeyPasteboardRefreshState expected = OneKeyPasteboardRefreshState::Scheduled;
+      if (OneKeyPasteboardRefresh.compare_exchange_strong(expected, OneKeyPasteboardRefreshState::Idle)) {
+        return;
+      }
+      // A notification arrived during the read. Keep Paste available until
+      // another read observes the latest clipboard state.
+      OneKeyPasteboardRefresh.store(OneKeyPasteboardRefreshState::Scheduled);
+    }
+  });
+}
+
+static void OneKeyStartObservingPasteboard(void)
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSNotificationCenter *center = NSNotificationCenter.defaultCenter;
+    for (NSNotificationName name in @[
+           UIPasteboardChangedNotification,
+           UIApplicationDidBecomeActiveNotification,
+           UITextFieldTextDidBeginEditingNotification,
+           UITextViewTextDidBeginEditingNotification,
+         ]) {
+      [center addObserverForName:name
+                          object:nil
+                           queue:nil
+                      usingBlock:^(__unused NSNotification *note) {
+                        OneKeyRefreshPasteboardImageState();
+                      }];
+    }
+    OneKeyRefreshPasteboardImageState();
+  });
+}
+
 @implementation OneKeyTextInputPasteObserver
 
 RCT_EXPORT_MODULE(OneKeyTextInputPasteObserver)
@@ -145,6 +214,7 @@ static void OneKeySwizzle(Class cls, SEL originalSelector, SEL replacementSelect
   dispatch_once(&onceToken, ^{
     OneKeySwizzle(self, @selector(paste:), @selector(onekey_paste:));
     OneKeySwizzle(self, @selector(canPerformAction:withSender:), @selector(onekey_canPerformAction:withSender:));
+    OneKeyStartObservingPasteboard();
   });
 }
 
@@ -162,7 +232,9 @@ static void OneKeySwizzle(Class cls, SEL originalSelector, SEL replacementSelect
 
 - (BOOL)onekey_canPerformAction:(SEL)action withSender:(id)sender
 {
-  if (action == @selector(paste:) && UIPasteboard.generalPasteboard.hasImages) {
+  if (action == @selector(paste:) &&
+      (OneKeyPasteboardRefresh.load() != OneKeyPasteboardRefreshState::Idle ||
+       OneKeyPasteboardImageCache.load() != OneKeyPasteboardImageState::NoImages)) {
     return YES;
   }
   return [self onekey_canPerformAction:action withSender:sender];
@@ -178,6 +250,7 @@ static void OneKeySwizzle(Class cls, SEL originalSelector, SEL replacementSelect
   dispatch_once(&onceToken, ^{
     OneKeySwizzle(self, @selector(paste:), @selector(onekey_paste:));
     OneKeySwizzle(self, @selector(canPerformAction:withSender:), @selector(onekey_canPerformAction:withSender:));
+    OneKeyStartObservingPasteboard();
   });
 }
 
@@ -195,7 +268,9 @@ static void OneKeySwizzle(Class cls, SEL originalSelector, SEL replacementSelect
 
 - (BOOL)onekey_canPerformAction:(SEL)action withSender:(id)sender
 {
-  if (action == @selector(paste:) && UIPasteboard.generalPasteboard.hasImages) {
+  if (action == @selector(paste:) &&
+      (OneKeyPasteboardRefresh.load() != OneKeyPasteboardRefreshState::Idle ||
+       OneKeyPasteboardImageCache.load() != OneKeyPasteboardImageState::NoImages)) {
     return YES;
   }
   return [self onekey_canPerformAction:action withSender:sender];

package/ios/tests/OneKeyTextInputPasteObserverTests.mm

@@ -0,0 +1,96 @@
+#import <React/RCTUITextField.h>
+#import <XCTest/XCTest.h>
+#import <objc/runtime.h>
+
+static dispatch_semaphore_t OneKeyTestReadStarted;
+static dispatch_semaphore_t OneKeyTestReleaseRead;
+
+@interface UIPasteboard (OneKeyPasteCacheTests)
+- (BOOL)onekey_test_hasImages;
+@end
+
+@implementation UIPasteboard (OneKeyPasteCacheTests)
+
+- (BOOL)onekey_test_hasImages
+{
+  dispatch_semaphore_t releaseRead;
+  dispatch_semaphore_t readStarted;
+  @synchronized (UIPasteboard.class) {
+    releaseRead = OneKeyTestReleaseRead;
+    readStarted = OneKeyTestReadStarted;
+  }
+  if (!NSThread.isMainThread && releaseRead != nil) {
+    dispatch_semaphore_signal(readStarted);
+    dispatch_semaphore_wait(releaseRead, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC));
+  }
+  return [self onekey_test_hasImages];
+}
+
+@end
+
+@interface OneKeyTextInputPasteObserverTests : XCTestCase
+@end
+
+@implementation OneKeyTextInputPasteObserverTests
+
+- (void)assertImagePasteAvailableWhileRefreshingAfterNotification:(NSNotificationName)name
+{
+  UIPasteboard *pasteboard = UIPasteboard.generalPasteboard;
+  NSArray<NSDictionary<NSString *, id> *> *previousItems = pasteboard.items;
+  RCTUITextField *field = [[RCTUITextField alloc] initWithFrame:CGRectZero];
+  SEL paste = @selector(paste:);
+
+  @try {
+    pasteboard.items = @[];
+    NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:5];
+    while ([field canPerformAction:paste withSender:nil] && [deadline timeIntervalSinceNow] > 0) {
+      [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+    }
+    XCTAssertFalse([field canPerformAction:paste withSender:nil]);
+
+    @synchronized (UIPasteboard.class) {
+      OneKeyTestReadStarted = dispatch_semaphore_create(0);
+      OneKeyTestReleaseRead = dispatch_semaphore_create(0);
+    }
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      Method original = class_getInstanceMethod(object_getClass(pasteboard), @selector(hasImages));
+      Method replacement = class_getInstanceMethod(UIPasteboard.class, @selector(onekey_test_hasImages));
+      method_exchangeImplementations(original, replacement);
+    });
+
+    UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:CGSizeMake(1, 1)];
+    pasteboard.image = [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+      [UIColor.blackColor setFill];
+      UIRectFill(CGRectMake(0, 0, 1, 1));
+    }];
+    [NSNotificationCenter.defaultCenter postNotificationName:UIPasteboardChangedNotification object:pasteboard];
+    XCTAssertEqual(dispatch_semaphore_wait(OneKeyTestReadStarted, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)), 0L);
+
+    [NSNotificationCenter.defaultCenter postNotificationName:name object:field];
+    XCTAssertTrue([field canPerformAction:paste withSender:nil]);
+  } @finally {
+    dispatch_semaphore_t releaseRead;
+    @synchronized (UIPasteboard.class) {
+      releaseRead = OneKeyTestReleaseRead;
+      OneKeyTestReleaseRead = nil;
+      OneKeyTestReadStarted = nil;
+    }
+    if (releaseRead != nil) {
+      dispatch_semaphore_signal(releaseRead);
+    }
+    pasteboard.items = previousItems;
+  }
+}
+
+- (void)testFirstFocusKeepsImagePasteAvailableDuringRefresh
+{
+  [self assertImagePasteAvailableWhileRefreshingAfterNotification:UITextFieldTextDidBeginEditingNotification];
+}
+
+- (void)testForegroundResumeKeepsImagePasteAvailableDuringRefresh
+{
+  [self assertImagePasteAvailableWhileRefreshingAfterNotification:UIApplicationDidBecomeActiveNotification];
+}
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-text-input",
-  "version": "3.0.158",
+  "version": "3.0.159",
   "description": "React Native TextInput with native paste events",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",