Expand support for different share types

markdaws · markdaws · commit 6dee20eafff4 · 2017-04-12T12:34:02.000-07:00
This is a breaking change. The current version of the code doesn't
handle public.image correctly in some cases. It assumes that the
value returned from getItemForTypeIdentifier is always a NSURL*.
This is true for things like Photos, but the app can define what
it passes back, while testing, I found that it can also be a
UIImage* instance or even NSData*, for example in Notes if you
create a note, add a drawing and insert a photo, the drawing will
be found as a public.image but it will be in NSData format, not
NSURL.

In the cases where we get UIImage* or NSData* in order to share them
later on we have to have a URL to them on disk, so I used app groups
to create a temporary container location to store the files. Then the
caller can reference these URLs in the JS code, and finally when we
close the share extension we clean up all the temp files to make sure
we don't keep growing the size of our disk footprint.
diff --git a/ios/ReactNativeShareExtension.m b/ios/ReactNativeShareExtension.m
@@ -1,8 +1,13 @@
 #import "ReactNativeShareExtension.h"
 #import "React/RCTRootView.h"
 
-#define ITEM_IDENTIFIER @"public.url"
-#define IMAGE_IDENTIFIER @"public.image"
+//public.url
+//public.image
+//public.movie
+//public.plain-text
+//#define URL_IDENTIFIER @"public.url"
+//#define IMAGE_IDENTIFIER @"public.image"
+
 
 NSExtensionContext* extensionContext;
 
@@ -34,16 +39,18 @@ - (void)viewDidLoad {
 }
 
 
-RCT_EXPORT_METHOD(close) {
- [extensionContext completeRequestReturningItems:nil
-                               completionHandler:nil];
+RCT_EXPORT_METHOD(close:(NSString *)appGroupId) {
+  [self cleanUpTempFiles:appGroupId];
+  [extensionContext completeRequestReturningItems:nil
+                                completionHandler:nil];
 }
 
 RCT_REMAP_METHOD(data,
-                resolver:(RCTPromiseResolveBlock)resolve
-                rejecter:(RCTPromiseRejectBlock)reject)
+                 appGroupId: (NSString *)appGroupId
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
 {
-  [self extractDataFromContext: extensionContext withCallback:^(NSArray* items ,NSException* err) {
+  [self extractDataFromContext: extensionContext withAppGroup:appGroupId andCallback:^(NSArray* items ,NSException* err) {
     if (items == nil) {
       resolve(nil);
       return;
@@ -53,80 +60,173 @@ - (void)viewDidLoad {
 }
 
 RCT_REMAP_METHOD(dataMulti,
+                 appGroupId: (NSString *)appGroupId
                  resolverMulti:(RCTPromiseResolveBlock)resolve
                  rejecterMulti:(RCTPromiseRejectBlock)reject)
 {
-  [self extractDataFromContext: extensionContext withCallback:^(NSArray* items ,NSException* err) {
+  [self extractDataFromContext: extensionContext withAppGroup: appGroupId andCallback:^(NSArray* items ,NSException* err) {
     resolve(items);
   }];
 }
 
-typedef void (^ProviderCallback)(NSURL *url, NSString *contentType, NSException *exception);
+typedef void (^ProviderCallback)(NSString *content, NSString *contentType, BOOL owner, NSException *exception);
 
-- (void)extractDataFromContext:(NSExtensionContext *)context withCallback:(void(^)(NSArray *items ,NSException *exception))callback {
+- (void)extractDataFromContext:(NSExtensionContext *)context withAppGroup:(NSString *) appGroupId andCallback:(void(^)(NSArray *items ,NSException *exception))callback {
   @try {
     NSExtensionItem *item = [context.inputItems firstObject];
     NSArray *attachments = item.attachments;
     NSMutableArray *items = [[NSMutableArray alloc] init];
-     
+    
     __block int attachmentIdx = 0;
     __block ProviderCallback providerCb = nil;
-    providerCb = ^ void (NSURL *url, NSString *contentType, NSException *exception) {
+    providerCb = ^ void (NSString *content, NSString *contentType, BOOL owner, NSException *exception) {
       if (exception) {
         callback(nil, exception);
         return;
       }
-    
-      [items addObject:@{
-                        @"type": contentType,
-                        @"value": [url absoluteString]
-                        }];
+      
+      if (content != nil) {
+        [items addObject:@{
+                           @"type": contentType,
+                           @"value": content,
+                           @"owner": [NSNumber numberWithBool:owner],
+                           }];
+      }
 
       ++attachmentIdx;
       if (attachmentIdx == [attachments count]) {
         callback(items, nil);
       } else {
-        [self extractDataFromProvider:attachments[attachmentIdx] withCallback: providerCb];
+        [self extractDataFromProvider:attachments[attachmentIdx] withAppGroup:appGroupId andCallback: providerCb];
       }
     };
-    [self extractDataFromProvider:attachments[0] withCallback: providerCb];
+    [self extractDataFromProvider:attachments[0] withAppGroup:appGroupId andCallback: providerCb];
   }
   @catch (NSException *exception) {
     callback(nil,exception);
   }
 }
 
-- (void)extractDataFromProvider:(NSItemProvider *)provider withCallback:(void(^)(NSURL* url, NSString* contentType ,NSException *exception))callback {
-  NSItemProvider *urlProvider = nil;
-  NSItemProvider *imageProvider = nil;
-    
-  if([provider hasItemConformingToTypeIdentifier:ITEM_IDENTIFIER]) {
-    urlProvider = provider;
-  }else if ([provider hasItemConformingToTypeIdentifier:IMAGE_IDENTIFIER]){
-    imageProvider = provider;
-  }
-    
-  if(urlProvider) {
-    [urlProvider loadItemForTypeIdentifier:ITEM_IDENTIFIER options:nil completionHandler:^(id<NSSecureCoding> item, NSError *error) {
-      NSURL *url = (NSURL *)item;
+- (void)extractDataFromProvider:(NSItemProvider *)provider withAppGroup:(NSString *) appGroupId andCallback:(void(^)(NSString* content, NSString* contentType, BOOL owner, NSException *exception))callback {
+  
+  if([provider hasItemConformingToTypeIdentifier:@"public.image"]) {
+    [provider loadItemForTypeIdentifier:@"public.image" options:nil completionHandler:^(id<NSSecureCoding, NSObject> item, NSError *error) {
+      if (error) {
+        callback(nil, nil, NO, error);
+        return;
+      }
+      
+      if ([item isKindOfClass: NSURL.class]) {
+        NSURL *url = (NSURL *)item;
+        return callback([url absoluteString], @"public.image", NO, nil);
+      } else if ([item isKindOfClass: UIImage.class]) {
+        UIImage *image = (UIImage *)item;
+        NSString *fileName = [NSString stringWithFormat:@"%@.jpg", [[NSUUID UUID] UUIDString]];
+        NSURL *tempContainerURL = [ReactNativeShareExtension tempContainerURL:appGroupId];
+        if (tempContainerURL == nil){
+          return callback(nil, nil, NO, nil);
+        }
         
-      if(callback) {
-        callback(url,@"text/plain" ,nil);
+        NSURL *tempFileURL = [tempContainerURL URLByAppendingPathComponent: fileName];
+        BOOL created = [UIImageJPEGRepresentation(image, 0.95) writeToFile:[tempFileURL path] atomically:YES];
+        if (created) {
+          return callback([tempFileURL absoluteString], @"public.image", YES, nil);
+        } else {
+          return callback(nil, nil, NO, nil);
+        }
+      } else if ([item isKindOfClass: NSData.class]) {
+        NSString *fileName = [NSString stringWithFormat:@"%@.jpg", [[NSUUID UUID] UUIDString]];
+        NSData *data = (NSData *)item;
+        UIImage *image = [UIImage imageWithData:data];
+        NSURL *tempContainerURL = [ReactNativeShareExtension tempContainerURL:appGroupId];
+        if (tempContainerURL == nil){
+          return callback(nil, nil, NO, nil);
+        }
+        NSURL *tempFileURL = [tempContainerURL URLByAppendingPathComponent: fileName];
+        BOOL created = [UIImageJPEGRepresentation(image, 0.95) writeToFile:[tempFileURL path] atomically:YES];
+        if (created) {
+          return callback([tempFileURL absoluteString], @"public.image", YES, nil);
+        } else {
+          return callback(nil, nil, NO, nil);
+        }
+      } else {
+        // Do nothing, some type we don't support.
+        return callback(nil, nil, NO, nil);
       }
     }];
-  }else if (imageProvider){
-    [imageProvider loadItemForTypeIdentifier:IMAGE_IDENTIFIER options:nil completionHandler:^(id<NSSecureCoding> item, NSError *error) {
-      NSURL *url = (NSURL *)item;
-        
-      if(callback) {
-        callback(url,[[[url absoluteString] pathExtension] lowercaseString] ,nil);
+    return;
+  }
+  
+  if([provider hasItemConformingToTypeIdentifier:@"public.url"]) {
+    [provider loadItemForTypeIdentifier:@"public.url" options:nil completionHandler:^(id<NSSecureCoding, NSObject> item, NSError *error) {
+      if (error) {
+        callback(nil, nil, NO, error);
+        return;
+      }
+      callback([(NSURL *)item absoluteString], @"public.url", NO, nil);
+    }];
+    return;
+  }
+  
+  if([provider hasItemConformingToTypeIdentifier:@"public.text"]) {
+    [provider loadItemForTypeIdentifier:@"public.text" options:nil completionHandler:^(id<NSSecureCoding, NSObject> item, NSError *error) {
+      if (error) {
+        callback(nil, nil, NO, error);
+        return;
+      }
+      
+      if ([item isKindOfClass:NSString.class]) {
+        return callback((NSString *)item, @"public.text", NO, nil);
+      } else if ([item isKindOfClass:NSData.class]) {
+        NSString *str = [[NSString alloc] initWithData:(NSData *)item encoding:NSUTF8StringEncoding];
+        if (str) {
+          return callback(str, @"public.text", NO, nil);
+        } else {
+          return callback(nil, nil, NO, nil);
+        }
+      } else {
+        return callback(nil, nil, NO, nil);
       }
     }];
-  } else {
-    if(callback) {
-      callback(nil, nil,[NSException exceptionWithName:@"Error" reason:@"couldn't find provider" userInfo:nil]);
+    return;
+  }
+  
+  callback(nil, nil, NO, nil);
+}
+
++ (NSURL*) tempContainerURL: (NSString*)appGroupId {
+  NSFileManager *manager = [NSFileManager defaultManager];
+  NSURL *containerURL = [manager containerURLForSecurityApplicationGroupIdentifier: appGroupId];
+  NSURL *tempDirectoryURL = [containerURL URLByAppendingPathComponent:@"shareTempItems"];
+  if (![manager fileExistsAtPath:[tempDirectoryURL path]]) {
+    NSError *err;
+    [manager createDirectoryAtURL:tempDirectoryURL withIntermediateDirectories:YES attributes:nil error:&err];
+    if (err) {
+      return nil;
     }
   }
+
+  return tempDirectoryURL;
+}
+
+- (void) cleanUpTempFiles:(NSString *)appGroupId {
+  NSURL *tmpDirectoryURL = [ReactNativeShareExtension tempContainerURL:appGroupId];
+  if (tmpDirectoryURL == nil) {
+    return;
+  }
+
+  NSFileManager *fileManager = [NSFileManager defaultManager];
+  NSError *error;
+  NSArray *tmpFiles = [fileManager contentsOfDirectoryAtPath:[tmpDirectoryURL path] error:&error];
+  if (error) {
+    return;
+  }
+
+  for (NSString *file in tmpFiles)
+  {
+    error = nil;
+    [fileManager removeItemAtPath:[[tmpDirectoryURL URLByAppendingPathComponent:file] path] error:&error];
+  }
 }
 
 @end
diff --git a/lib/index.js b/lib/index.js
@@ -4,7 +4,7 @@ import { NativeModules } from 'react-native'
 // const { type, value } = await NativeModules.ShareExtension.data()
 // NativeModules.ShareExtension.close()
 export default {
-  data: () => NativeModules.ReactNativeShareExtension.data(),
-  dataMulti: () => NativeModules.ReactNativeShareExtension.dataMulti(),
-  close: () => NativeModules.ReactNativeShareExtension.close()
+  data: (appGroupId) => NativeModules.ReactNativeShareExtension.data(appGroupId),
+  dataMulti: (appGroupId) => NativeModules.ReactNativeShareExtension.dataMulti(appGroupId),
+  close: (appGroupId) => NativeModules.ReactNativeShareExtension.close(appGroupId)
 }
