| // Copyright 2017 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #import "components/open_from_clipboard/clipboard_recent_content_impl_ios.h" |
| |
| #import <MobileCoreServices/MobileCoreServices.h> |
| #import <UIKit/UIKit.h> |
| |
| #import "base/apple/foundation_util.h" |
| #import "base/functional/bind.h" |
| #include "base/notreached.h" |
| #include "base/strings/sys_string_conversions.h" |
| #include "base/system/sys_info.h" |
| #include "components/open_from_clipboard/clipboard_async_wrapper_ios.h" |
| |
| ContentType const ContentTypeURL = @"ContentTypeURL"; |
| ContentType const ContentTypeText = @"ContentTypeString"; |
| ContentType const ContentTypeImage = @"ContentTypeImage"; |
| |
| namespace { |
| // Key used to store the pasteboard's current change count. If when resuming |
| // chrome the pasteboard's change count is different from the stored one, then |
| // it means that the pasteboard's content has changed. |
| NSString* const kPasteboardChangeCountKey = @"PasteboardChangeCount"; |
| // Key used to store the last date at which it was detected that the pasteboard |
| // changed. It is used to evaluate the age of the pasteboard's content. |
| NSString* const kPasteboardChangeDateKey = @"PasteboardChangeDate"; |
| // Default Scheme to use for urls with no scheme. |
| NSString* const kDefaultScheme = @"https"; |
| |
| } // namespace |
| |
| @interface ClipboardRecentContentImplIOS () |
| |
| // The user defaults from the app group used to optimize the pasteboard change |
| // detection. |
| @property(nonatomic, strong) NSUserDefaults* sharedUserDefaults; |
| // The pasteboard's change count. Increases everytime the pasteboard changes. |
| @property(nonatomic) NSInteger lastPasteboardChangeCount; |
| // Contains the authorized schemes for URLs. |
| @property(nonatomic, readonly) NSSet* authorizedSchemes; |
| // Delegate for metrics. |
| @property(nonatomic, strong) id<ClipboardRecentContentDelegate> delegate; |
| // Maximum age of clipboard in seconds. |
| @property(nonatomic, readonly) NSTimeInterval maximumAgeOfClipboard; |
| // Whether the clipboard should only be accessed asynchronously. |
| @property(nonatomic, assign) BOOL onlyUseClipboardAsync; |
| |
| // A cached version of an already-retrieved URL. This prevents subsequent URL |
| // requests from triggering the iOS 14 pasteboard notification. |
| @property(nonatomic, strong) NSURL* cachedURL; |
| // A cached version of an already-retrieved string. This prevents subsequent |
| // string requests from triggering the iOS 14 pasteboard notification. |
| @property(nonatomic, copy) NSString* cachedText; |
| // A cached version of an already-retrieved image. This prevents subsequent |
| // image requests from triggering the iOS 14 pasteboard notification. |
| @property(nonatomic, strong) UIImage* cachedImage; |
| // A cached set of the content types currently being used for the clipboard. |
| @property(nonatomic, strong) NSSet<ContentType>* cachedContentTypes; |
| |
| // Loads information from the user defaults about the latest pasteboard entry. |
| - (void)loadFromUserDefaults; |
| |
| // Returns the URL contained in `pasteboard` (if any). |
| - (NSURL*)URLFromPasteboard:(UIPasteboard*)pasteboard; |
| |
| // Returns the uptime. |
| - (NSTimeInterval)uptime; |
| |
| // Calls |completionHandler| with the result of whether or not the clipboard |
| // currently contains data matching |contentType|. |
| - (void)checkForContentType:(ContentType)contentType |
| pasteboard:(UIPasteboard*)pasteboard |
| completionHandler:(void (^)(BOOL))completionHandler; |
| |
| // Checks the clipboard for content matching |types| and calls |
| // |completionHandler| once all types are checked. This method is called |
| // recursively and partial results are passed in |results| until all types have |
| // been checked. |
| - (void) |
| hasContentMatchingRemainingTypes:(NSSet<ContentType>*)types |
| pasteboard:(UIPasteboard*)pasteboard |
| results: |
| (NSMutableDictionary<ContentType, NSNumber*>*) |
| results |
| completionHandler: |
| (void (^)(NSSet<ContentType>*))completionHandler; |
| |
| @end |
| |
| @implementation ClipboardRecentContentImplIOS |
| |
| - (instancetype)initWithMaxAge:(NSTimeInterval)maxAge |
| authorizedSchemes:(NSSet<NSString*>*)authorizedSchemes |
| userDefaults:(NSUserDefaults*)groupUserDefaults |
| onlyUseClipboardAsync:(BOOL)onlyUseClipboardAsync |
| delegate:(id<ClipboardRecentContentDelegate>)delegate { |
| self = [super init]; |
| if (self) { |
| _maximumAgeOfClipboard = maxAge; |
| _delegate = delegate; |
| _authorizedSchemes = authorizedSchemes; |
| _sharedUserDefaults = groupUserDefaults; |
| _onlyUseClipboardAsync = onlyUseClipboardAsync; |
| |
| _lastPasteboardChangeCount = NSIntegerMax; |
| [self loadFromUserDefaults]; |
| [self updateCachedClipboardState]; |
| |
| [[NSNotificationCenter defaultCenter] |
| addObserver:self |
| selector:@selector(didBecomeActive:) |
| name:UIApplicationDidBecomeActiveNotification |
| object:nil]; |
| [[NSNotificationCenter defaultCenter] |
| addObserver:self |
| selector:@selector(pasteboardDidChange:) |
| name:UIPasteboardChangedNotification |
| object:nil]; |
| |
| __weak __typeof(self) weakSelf = self; |
| GetGeneralPasteboard( |
| _onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) { |
| [weakSelf updateIfNeededWithPasteboard:pasteboard]; |
| // Makes sure |last_pasteboard_change_count_| was properly |
| // initialized. |
| DCHECK_NE(weakSelf.lastPasteboardChangeCount, NSIntegerMax); |
| })); |
| } |
| return self; |
| } |
| |
| - (void)dealloc { |
| [[NSNotificationCenter defaultCenter] removeObserver:self]; |
| } |
| |
| - (void)didBecomeActive:(NSNotification*)notification { |
| [self loadFromUserDefaults]; |
| [self updateCachedClipboardState]; |
| |
| __weak __typeof(self) weakSelf = self; |
| GetGeneralPasteboard(self.onlyUseClipboardAsync, |
| base::BindOnce(^(UIPasteboard* pasteboard) { |
| [weakSelf updateIfNeededWithPasteboard:pasteboard]; |
| })); |
| } |
| |
| #pragma mark - Public |
| |
| - (NSURL*)recentURLFromClipboard { |
| // If the clipboard can only be accessed asynchronously, then this method |
| // cannot even check whether the existing cached URL is stil valid. |
| if (self.onlyUseClipboardAsync) { |
| return nil; |
| } |
| return [self recentURLFromPasteboard:UIPasteboard.generalPasteboard]; |
| } |
| |
| - (NSString*)recentTextFromClipboard { |
| // If the clipboard can only be accessed asynchronously, then this method |
| // cannot even check whether the existing cached text is stil valid. |
| if (self.onlyUseClipboardAsync) { |
| return nil; |
| } |
| |
| return [self recentTextFromPasteboard:UIPasteboard.generalPasteboard]; |
| } |
| |
| - (UIImage*)recentImageFromClipboard { |
| // If the clipboard can only be accessed asynchronously, then this method |
| // cannot even check whether the existing cached image is stil valid. |
| if (self.onlyUseClipboardAsync) { |
| return nil; |
| } |
| |
| return [self recentImageFromPasteboard:UIPasteboard.generalPasteboard]; |
| } |
| |
| - (NSSet<ContentType>*)cachedClipboardContentTypes { |
| if (![self shouldReturnValueOfClipboard:nil]) { |
| return nil; |
| } |
| return self.cachedContentTypes; |
| } |
| |
| - (void)hasContentMatchingTypes:(NSSet<ContentType>*)types |
| completionHandler: |
| (void (^)(NSSet<ContentType>*))completionHandler { |
| __weak __typeof(self) weakSelf = self; |
| GetGeneralPasteboard(self.onlyUseClipboardAsync, |
| base::BindOnce(^(UIPasteboard* pasteboard) { |
| [weakSelf hasContentMatchingTypes:types |
| pasteboard:pasteboard |
| completionHandler:completionHandler]; |
| })); |
| } |
| |
| - (void)recentURLFromClipboardAsync:(void (^)(NSURL*))callback { |
| __weak __typeof(self) weakSelf = self; |
| GetGeneralPasteboard( |
| self.onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) { |
| [weakSelf recentURLFromClipboardAsyncWithPasteboard:pasteboard |
| callback:callback]; |
| })); |
| } |
| |
| - (void)recentTextFromClipboardAsync:(void (^)(NSString*))callback { |
| __weak __typeof(self) weakSelf = self; |
| GetGeneralPasteboard( |
| self.onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) { |
| [weakSelf recentTextFromClipboardAsyncWithPasteboard:pasteboard |
| callback:callback]; |
| })); |
| } |
| |
| - (void)recentImageFromClipboardAsync:(void (^)(UIImage*))callback { |
| __weak __typeof(self) weakSelf = self; |
| GetGeneralPasteboard( |
| self.onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) { |
| [weakSelf recentImageFromClipboardAsyncWithPasteboard:pasteboard |
| callback:callback]; |
| })); |
| } |
| |
| - (NSTimeInterval)clipboardContentAge { |
| return -[self.lastPasteboardChangeDate timeIntervalSinceNow]; |
| } |
| |
| - (void)suppressClipboardContent { |
| // User cleared the user data. The pasteboard entry must be removed from the |
| // omnibox list. Force entry expiration by setting copy date to 1970. |
| self.lastPasteboardChangeDate = |
| [[NSDate alloc] initWithTimeIntervalSince1970:0]; |
| [self saveToUserDefaults]; |
| } |
| |
| - (void)saveToUserDefaults { |
| [self.sharedUserDefaults setInteger:self.lastPasteboardChangeCount |
| forKey:kPasteboardChangeCountKey]; |
| [self.sharedUserDefaults setObject:self.lastPasteboardChangeDate |
| forKey:kPasteboardChangeDateKey]; |
| } |
| |
| #pragma mark - Private |
| |
| // Returns whether the pasteboard changed since the last time a pasteboard |
| // change was detected. |
| - (BOOL)hasPasteboardChanged:(UIPasteboard*)pasteboard { |
| return pasteboard.changeCount != self.lastPasteboardChangeCount; |
| } |
| |
| - (void)pasteboardDidChange:(NSNotification*)notification { |
| [self updateCachedClipboardState]; |
| } |
| |
| - (void)updateCachedClipboardState { |
| self.cachedContentTypes = nil; |
| |
| NSSet<ContentType>* desiredContentTypes = [NSSet |
| setWithArray:@[ ContentTypeImage, ContentTypeURL, ContentTypeText ]]; |
| __weak __typeof(self) weakSelf = self; |
| [self hasContentMatchingTypes:desiredContentTypes |
| completionHandler:^(NSSet<ContentType>* results) { |
| weakSelf.cachedContentTypes = results; |
| }]; |
| } |
| |
| // The synchronous version of this method is kept around for public APIs and old |
| // iOS versions. |
| - (NSURL*)recentURLFromPasteboard:(UIPasteboard*)pasteboard { |
| [self updateIfNeededWithPasteboard:pasteboard]; |
| |
| if (![self shouldReturnValueOfClipboard:pasteboard]) { |
| return nil; |
| } |
| |
| if (@available(iOS 14, *)) { |
| // On iOS 14, don't actually access the pasteboard in this method. This |
| // prevents the pasteboard access notification from appearing. |
| } else { |
| if (!self.cachedURL) { |
| self.cachedURL = [self URLFromPasteboard:pasteboard]; |
| } |
| } |
| return self.cachedURL; |
| } |
| |
| // The synchronous version of this method is kept around for public APIs and old |
| // iOS versions. |
| - (NSString*)recentTextFromPasteboard:(UIPasteboard*)pasteboard { |
| [self updateIfNeededWithPasteboard:pasteboard]; |
| |
| if (![self shouldReturnValueOfClipboard:pasteboard]) { |
| return nil; |
| } |
| |
| if (@available(iOS 14, *)) { |
| // On iOS 14, don't actually access the pasteboard in this method. This |
| // prevents the pasteboard access notification from appearing. |
| } else { |
| if (!self.cachedText) { |
| self.cachedText = pasteboard.string; |
| } |
| } |
| return self.cachedText; |
| } |
| |
| // The synchronous version of this method is kept around for public APIs and old |
| // iOS versions. |
| - (UIImage*)recentImageFromPasteboard:(UIPasteboard*)pasteboard { |
| [self updateIfNeededWithPasteboard:pasteboard]; |
| |
| if (![self shouldReturnValueOfClipboard:pasteboard]) { |
| return nil; |
| } |
| |
| if (@available(iOS 14, *)) { |
| // On iOS 14, don't actually access the pasteboard in this method. This |
| // prevents the pasteboard access notification from appearing. |
| } else { |
| if (!self.cachedImage) { |
| self.cachedImage = pasteboard.image; |
| } |
| } |
| |
| return self.cachedImage; |
| } |
| |
| // Checks for if the given `pasteboard` has content matching the provided |
| // `types`. |
| - (void)hasContentMatchingTypes:(NSSet<ContentType>*)types |
| pasteboard:(UIPasteboard*)pasteboard |
| completionHandler: |
| (void (^)(NSSet<ContentType>*))completionHandler { |
| [self updateIfNeededWithPasteboard:pasteboard]; |
| if (![self shouldReturnValueOfClipboard:pasteboard] || ![types count]) { |
| completionHandler([NSSet set]); |
| return; |
| } |
| |
| [self hasContentMatchingRemainingTypes:types |
| pasteboard:pasteboard |
| results:[[NSMutableDictionary alloc] init] |
| completionHandler:completionHandler]; |
| } |
| |
| - (void) |
| hasContentMatchingRemainingTypes:(NSSet<ContentType>*)types |
| pasteboard:(UIPasteboard*)pasteboard |
| results: |
| (NSMutableDictionary<ContentType, NSNumber*>*) |
| results |
| completionHandler: |
| (void (^)(NSSet<ContentType>*))completionHandler { |
| if ([types count] == 0) { |
| NSMutableSet<ContentType>* matchingTypes = [NSMutableSet set]; |
| for (ContentType type in results) { |
| if ([results[type] boolValue]) { |
| [matchingTypes addObject:type]; |
| } |
| } |
| completionHandler(matchingTypes); |
| return; |
| } |
| |
| __weak __typeof(self) weakSelf = self; |
| ContentType type = [types anyObject]; |
| [self checkForContentType:type |
| pasteboard:pasteboard |
| completionHandler:^(BOOL hasType) { |
| results[type] = @(hasType); |
| |
| NSMutableSet* remainingTypes = [types mutableCopy]; |
| [remainingTypes removeObject:type]; |
| [weakSelf hasContentMatchingRemainingTypes:remainingTypes |
| pasteboard:pasteboard |
| results:results |
| completionHandler:completionHandler]; |
| }]; |
| } |
| |
| - (void)checkForContentType:(ContentType)contentType |
| pasteboard:(UIPasteboard*)pasteboard |
| completionHandler:(void (^)(BOOL))completionHandler { |
| if ([contentType isEqualToString:ContentTypeText]) { |
| [self hasRecentTextFromClipboardInternalWithPasteboard:pasteboard |
| callback:^(BOOL hasText) { |
| completionHandler(hasText); |
| }]; |
| } else if ([contentType isEqualToString:ContentTypeURL]) { |
| [self hasRecentURLFromClipboardInternalWithPasteboard:pasteboard |
| callback:^(BOOL hasURL) { |
| completionHandler(hasURL); |
| }]; |
| } else if ([contentType isEqualToString:ContentTypeImage]) { |
| [self |
| hasRecentImageFromClipboardInternalWithPasteboard:pasteboard |
| callback:^(BOOL hasImage) { |
| completionHandler(hasImage); |
| }]; |
| } else { |
| NOTREACHED() << contentType; |
| } |
| } |
| |
| // The underlying logic to check if the clipboard has a recent URL, with the |
| // addition of a `pasteboard` parameter to aid in forcing all pasteboard access |
| // to be async. |
| - (void) |
| hasRecentURLFromClipboardInternalWithPasteboard:(UIPasteboard*)pasteboard |
| callback:(void (^)(BOOL))callback { |
| DCHECK(callback); |
| if (@available(iOS 14, *)) { |
| // Use cached value if it exists |
| if (self.cachedURL) { |
| callback(YES); |
| return; |
| } |
| |
| #if defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0 |
| NSSet<UIPasteboardDetectionPattern>* urlPattern = |
| [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebURL]; |
| [pasteboard |
| detectPatternsForPatterns:urlPattern |
| completionHandler:^( |
| NSSet<UIPasteboardDetectionPattern>* patterns, |
| NSError* error) { |
| callback([patterns |
| containsObject: |
| UIPasteboardDetectionPatternProbableWebURL]); |
| }]; |
| #else |
| // To prevent clipboard notification from appearing on iOS 14 with iOS 13 |
| // SDK, use the -hasURLs property to check for URL existence. This will |
| // cause crbug.com/1033935 to reappear in code using this method (also see |
| // the comments in -URLFromPasteboard in this file), but that is preferable |
| // to the notificatio appearing when it shouldn't. |
| callback(pasteboard.hasURLs); |
| #endif |
| } else { |
| callback([self recentURLFromPasteboard:pasteboard] != nil); |
| } |
| } |
| |
| // The underlying logic to check if the clipboard has recent text, with the |
| // addition of a `pasteboard` parameter to aid in forcing all pasteboard access |
| // to be async. |
| - (void) |
| hasRecentTextFromClipboardInternalWithPasteboard:(UIPasteboard*)pasteboard |
| callback:(void (^)(BOOL))callback { |
| DCHECK(callback); |
| if (@available(iOS 14, *)) { |
| // Use cached value if it exists |
| if (self.cachedText) { |
| callback(YES); |
| return; |
| } |
| |
| #if defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0 |
| NSSet<UIPasteboardDetectionPattern>* textPattern = |
| [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebSearch]; |
| [pasteboard |
| detectPatternsForPatterns:textPattern |
| completionHandler:^( |
| NSSet<UIPasteboardDetectionPattern>* patterns, |
| NSError* error) { |
| callback([patterns |
| containsObject: |
| UIPasteboardDetectionPatternProbableWebSearch]); |
| }]; |
| #else |
| callback(pasteboard.hasStrings); |
| #endif |
| } else { |
| callback([self recentTextFromPasteboard:pasteboard] != nil); |
| } |
| } |
| |
| // The underlying logic to check if the clipboard has a recent image, with the |
| // addition of a `pasteboard` parameter to aid in forcing all pasteboard access |
| // to be async. |
| - (void) |
| hasRecentImageFromClipboardInternalWithPasteboard:(UIPasteboard*)pasteboard |
| callback:(void (^)(BOOL))callback { |
| DCHECK(callback); |
| if (@available(iOS 14, *)) { |
| // Use cached value if it exists |
| if (self.cachedImage) { |
| callback(YES); |
| return; |
| } |
| |
| callback(pasteboard.hasImages); |
| } else { |
| callback([self recentImageFromPasteboard:pasteboard] != nil); |
| } |
| } |
| |
| // The underlying logic to check the recent url, with the addition of a |
| // `pasteboard` parameter to aid in forcing all pasteboard access to be async. |
| - (void)recentURLFromClipboardAsyncWithPasteboard:(UIPasteboard*)pasteboard |
| callback:(void (^)(NSURL*))callback { |
| DCHECK(callback); |
| if (@available(iOS 14, *)) { |
| [self updateIfNeededWithPasteboard:pasteboard]; |
| if (![self shouldReturnValueOfClipboard:pasteboard]) { |
| callback(nil); |
| return; |
| } |
| |
| // Use cached value if it exists. |
| if (self.cachedURL) { |
| callback(self.cachedURL); |
| return; |
| } |
| |
| #if defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0 |
| __weak __typeof(self) weakSelf = self; |
| NSSet<UIPasteboardDetectionPattern>* urlPattern = |
| [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebURL]; |
| [pasteboard |
| detectValuesForPatterns:urlPattern |
| completionHandler:^( |
| NSDictionary<UIPasteboardDetectionPattern, id>* values, |
| NSError* error) { |
| // On iOS 16, users can deny access to the clipboard. |
| if (error) { |
| weakSelf.cachedURL = nil; |
| callback(nil); |
| return; |
| } |
| NSURL* url = [NSURL |
| URLWithString: |
| values[UIPasteboardDetectionPatternProbableWebURL]]; |
| |
| // |detectValuesForPatterns:| will return a url even if the url |
| // is missing a scheme. In this case, default to https. |
| if (url && url.scheme == nil) { |
| NSURLComponents* components = |
| [[NSURLComponents alloc] initWithURL:url |
| resolvingAgainstBaseURL:NO]; |
| components.scheme = kDefaultScheme; |
| url = components.URL; |
| } |
| |
| if (![self.authorizedSchemes containsObject:url.scheme]) { |
| weakSelf.cachedURL = nil; |
| callback(nil); |
| } else { |
| weakSelf.cachedURL = url; |
| callback(url); |
| } |
| }]; |
| #else |
| callback([self recentURLFromPasteboard:pasteboard]); |
| #endif |
| } else { |
| callback([self recentURLFromPasteboard:pasteboard]); |
| } |
| } |
| |
| // The underlying logic to check the recent text, with the addition of a |
| // `pasteboard` parameter to aid in forcing all pasteboard access to be async. |
| - (void)recentTextFromClipboardAsyncWithPasteboard:(UIPasteboard*)pasteboard |
| callback: |
| (void (^)(NSString*))callback { |
| DCHECK(callback); |
| if (@available(iOS 14, *)) { |
| [self updateIfNeededWithPasteboard:pasteboard]; |
| if (![self shouldReturnValueOfClipboard:pasteboard]) { |
| callback(nil); |
| return; |
| } |
| |
| // Use cached value if it exists. |
| if (self.cachedText) { |
| callback(self.cachedText); |
| return; |
| } |
| |
| #if defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0 |
| __weak __typeof(self) weakSelf = self; |
| NSSet<UIPasteboardDetectionPattern>* textPattern = |
| [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebSearch]; |
| [pasteboard |
| detectValuesForPatterns:textPattern |
| completionHandler:^( |
| NSDictionary<UIPasteboardDetectionPattern, id>* values, |
| NSError* error) { |
| NSString* text = |
| values[UIPasteboardDetectionPatternProbableWebSearch]; |
| weakSelf.cachedText = text; |
| |
| callback(text); |
| }]; |
| #else |
| callback([self recentTextFromPasteboard:pasteboard]); |
| #endif |
| } else { |
| callback([self recentTextFromPasteboard:pasteboard]); |
| } |
| } |
| |
| // The underlying logic to check the recent image, with the addition of a |
| // `pasteboard` parameter to aid in forcing all pasteboard access to be async. |
| - (void)recentImageFromClipboardAsyncWithPasteboard:(UIPasteboard*)pasteboard |
| callback: |
| (void (^)(UIImage*))callback { |
| DCHECK(callback); |
| [self updateIfNeededWithPasteboard:pasteboard]; |
| if (![self shouldReturnValueOfClipboard:pasteboard]) { |
| callback(nil); |
| return; |
| } |
| |
| if (!self.cachedImage) { |
| self.cachedImage = pasteboard.image; |
| } |
| callback(self.cachedImage); |
| } |
| |
| // Returns whether the value of the given clipboard should be returned. |
| - (BOOL)shouldReturnValueOfClipboard:(UIPasteboard*)pasteboard { |
| if ([self clipboardContentAge] > self.maximumAgeOfClipboard) |
| return NO; |
| |
| // It is the common convention on iOS that password managers tag confidential |
| // data with the flavor "org.nspasteboard.ConcealedType". Obey this |
| // convention; the user doesn't want for their confidential data to be |
| // suggested as a search, anyway. See http://nspasteboard.org/ for more info. |
| NSArray<NSString*>* types = [pasteboard pasteboardTypes]; |
| if ([types containsObject:@"org.nspasteboard.ConcealedType"]) |
| return NO; |
| |
| return YES; |
| } |
| |
| // If the content of the pasteboard has changed, updates the change count |
| // and change date. |
| - (void)updateIfNeededWithPasteboard:(UIPasteboard*)pasteboard { |
| if (![self hasPasteboardChanged:pasteboard]) { |
| return; |
| } |
| |
| self.lastPasteboardChangeDate = [NSDate date]; |
| self.lastPasteboardChangeCount = pasteboard.changeCount; |
| |
| // Clear the cache because the pasteboard data has changed. |
| self.cachedURL = nil; |
| self.cachedText = nil; |
| self.cachedImage = nil; |
| |
| [self.delegate onClipboardChanged]; |
| |
| [self saveToUserDefaults]; |
| } |
| |
| - (NSURL*)URLFromPasteboard:(UIPasteboard*)pasteboard { |
| NSURL* url = pasteboard.URL; |
| // Usually, even if the user copies plaintext, if it looks like a URL, the URL |
| // property is filled. Sometimes, this doesn't happen, for instance when the |
| // pasteboard is sync'd from a Mac to the iOS simulator. In this case, |
| // fallback and manually check whether the pasteboard contains a url-like |
| // string. |
| if (!url) { |
| url = [NSURL URLWithString:pasteboard.string]; |
| } |
| if (![self.authorizedSchemes containsObject:url.scheme]) { |
| return nil; |
| } |
| return url; |
| } |
| |
| - (void)loadFromUserDefaults { |
| self.lastPasteboardChangeCount = |
| [self.sharedUserDefaults integerForKey:kPasteboardChangeCountKey]; |
| self.lastPasteboardChangeDate = base::apple::ObjCCastStrict<NSDate>( |
| [self.sharedUserDefaults objectForKey:kPasteboardChangeDateKey]); |
| } |
| |
| - (NSTimeInterval)uptime { |
| return base::SysInfo::Uptime().InSecondsF(); |
| } |
| |
| @end |