@onekeyfe/react-native-text-input 3.0.157-alpha.251 → 3.0.157-alpha.253

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/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,95 @@
+#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(UIPasteboard.class, @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));
+    }];
+    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.157-alpha.251",
+  "version": "3.0.157-alpha.253",
   "description": "React Native TextInput with native paste events",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",