initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/CameraRoll/CameraRoll.js

@@ -0,0 +1,245 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule CameraRoll
+ * @flow
+ * @format
+ */
+'use strict';
+
+const PropTypes = require('prop-types');
+const {checkPropTypes} = PropTypes;
+const RCTCameraRollManager = require('NativeModules').CameraRollManager;
+
+const createStrictShapeTypeChecker = require('createStrictShapeTypeChecker');
+const invariant = require('fbjs/lib/invariant');
+
+const GROUP_TYPES_OPTIONS = {
+  Album: 'Album',
+  All: 'All',
+  Event: 'Event',
+  Faces: 'Faces',
+  Library: 'Library',
+  PhotoStream: 'PhotoStream',
+  SavedPhotos: 'SavedPhotos', // default
+};
+
+const ASSET_TYPE_OPTIONS = {
+  All: 'All',
+  Videos: 'Videos',
+  Photos: 'Photos',
+};
+
+type GetPhotosParams = {
+  first: number,
+  after?: string,
+  groupTypes?: $Keys<typeof GROUP_TYPES_OPTIONS>,
+  groupName?: string,
+  assetType?: $Keys<typeof ASSET_TYPE_OPTIONS>,
+  mimeTypes?: Array<string>,
+};
+
+/**
+ * Shape of the param arg for the `getPhotos` function.
+ */
+const getPhotosParamChecker = createStrictShapeTypeChecker({
+  /**
+   * The number of photos wanted in reverse order of the photo application
+   * (i.e. most recent first for SavedPhotos).
+   */
+  first: PropTypes.number.isRequired,
+
+  /**
+   * A cursor that matches `page_info { end_cursor }` returned from a previous
+   * call to `getPhotos`
+   */
+  after: PropTypes.string,
+
+  /**
+   * Specifies which group types to filter the results to.
+   */
+  groupTypes: PropTypes.oneOf(Object.keys(GROUP_TYPES_OPTIONS)),
+
+  /**
+   * Specifies filter on group names, like 'Recent Photos' or custom album
+   * titles.
+   */
+  groupName: PropTypes.string,
+
+  /**
+   * Specifies filter on asset type
+   */
+  assetType: PropTypes.oneOf(Object.keys(ASSET_TYPE_OPTIONS)),
+
+  /**
+   * Filter by mimetype (e.g. image/jpeg).
+   */
+  mimeTypes: PropTypes.arrayOf(PropTypes.string),
+});
+
+type GetPhotosReturn = Promise<{
+  edges: Array<{
+    node: {
+      type: string,
+      group_name: string,
+      image: {
+        uri: string,
+        height: number,
+        width: number,
+        isStored?: boolean,
+        playableDuration: number,
+      },
+      timestamp: number,
+      location?: {
+        latitude?: number,
+        longitude?: number,
+        altitude?: number,
+        heading?: number,
+        speed?: number,
+      },
+    },
+  }>,
+  page_info: {
+    has_next_page: boolean,
+    start_cursor?: string,
+    end_cursor?: string,
+  },
+}>;
+
+/**
+ * Shape of the return value of the `getPhotos` function.
+ */
+const getPhotosReturnChecker = createStrictShapeTypeChecker({
+  edges: PropTypes.arrayOf(
+    /* $FlowFixMe(>=0.66.0 site=react_native_fb) This comment suppresses an
+     * error found when Flow v0.66 was deployed. To see the error delete this
+     * comment and run Flow. */
+    createStrictShapeTypeChecker({
+      node: createStrictShapeTypeChecker({
+        type: PropTypes.string.isRequired,
+        group_name: PropTypes.string.isRequired,
+        image: createStrictShapeTypeChecker({
+          uri: PropTypes.string.isRequired,
+          height: PropTypes.number.isRequired,
+          width: PropTypes.number.isRequired,
+          isStored: PropTypes.bool,
+          playableDuration: PropTypes.number.isRequired,
+        }).isRequired,
+        timestamp: PropTypes.number.isRequired,
+        location: createStrictShapeTypeChecker({
+          latitude: PropTypes.number,
+          longitude: PropTypes.number,
+          altitude: PropTypes.number,
+          heading: PropTypes.number,
+          speed: PropTypes.number,
+        }),
+      }).isRequired,
+    }),
+  ).isRequired,
+  page_info: createStrictShapeTypeChecker({
+    has_next_page: PropTypes.bool.isRequired,
+    start_cursor: PropTypes.string,
+    end_cursor: PropTypes.string,
+  }).isRequired,
+});
+
+/**
+ * `CameraRoll` provides access to the local camera roll or photo library.
+ *
+ * See https://facebook.github.io/react-native/docs/cameraroll.html
+ */
+class CameraRoll {
+  static GroupTypesOptions: Object = GROUP_TYPES_OPTIONS;
+  static AssetTypeOptions: Object = ASSET_TYPE_OPTIONS;
+
+  /**
+   * `CameraRoll.saveImageWithTag()` is deprecated. Use `CameraRoll.saveToCameraRoll()` instead.
+   */
+  static saveImageWithTag(tag: string): Promise<string> {
+    console.warn(
+      '`CameraRoll.saveImageWithTag()` is deprecated. Use `CameraRoll.saveToCameraRoll()` instead.',
+    );
+    return this.saveToCameraRoll(tag, 'photo');
+  }
+
+  static deletePhotos(photos: Array<string>) {
+    return RCTCameraRollManager.deletePhotos(photos);
+  }
+
+  /**
+   * Saves the photo or video to the camera roll or photo library.
+   *
+   * See https://facebook.github.io/react-native/docs/cameraroll.html#savetocameraroll
+   */
+  static saveToCameraRoll(
+    tag: string,
+    type?: 'photo' | 'video',
+  ): Promise<string> {
+    invariant(
+      typeof tag === 'string',
+      'CameraRoll.saveToCameraRoll must be a valid string.',
+    );
+
+    invariant(
+      type === 'photo' || type === 'video' || type === undefined,
+      `The second argument to saveToCameraRoll must be 'photo' or 'video'. You passed ${type ||
+        'unknown'}`,
+    );
+
+    let mediaType = 'photo';
+    if (type) {
+      mediaType = type;
+    } else if (['mov', 'mp4'].indexOf(tag.split('.').slice(-1)[0]) >= 0) {
+      mediaType = 'video';
+    }
+
+    return RCTCameraRollManager.saveToCameraRoll(tag, mediaType);
+  }
+
+  /**
+   * Returns a Promise with photo identifier objects from the local camera
+   * roll of the device matching shape defined by `getPhotosReturnChecker`.
+   *
+   * See https://facebook.github.io/react-native/docs/cameraroll.html#getphotos
+   */
+  static getPhotos(params: GetPhotosParams): GetPhotosReturn {
+    if (__DEV__) {
+      checkPropTypes(
+        {params: getPhotosParamChecker},
+        {params},
+        'params',
+        'CameraRoll.getPhotos',
+      );
+    }
+    if (arguments.length > 1) {
+      console.warn(
+        'CameraRoll.getPhotos(tag, success, error) is deprecated.  Use the returned Promise instead',
+      );
+      let successCallback = arguments[1];
+      if (__DEV__) {
+        const callback = arguments[1];
+        successCallback = response => {
+          checkPropTypes(
+            {response: getPhotosReturnChecker},
+            {response},
+            'response',
+            'CameraRoll.getPhotos callback',
+          );
+          callback(response);
+        };
+      }
+      const errorCallback = arguments[2] || (() => {});
+      RCTCameraRollManager.getPhotos(params).then(
+        successCallback,
+        errorCallback,
+      );
+    }
+    // TODO: Add the __DEV__ check back in to verify the Promise result
+    return RCTCameraRollManager.getPhotos(params);
+  }
+}
+
+module.exports = CameraRoll;

node_modules/react-native/Libraries/CameraRoll/ImagePickerIOS.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImagePickerIOS
+ * @flow
+ */
+'use strict';
+
+var RCTImagePicker = require('NativeModules').ImagePickerIOS;
+
+var ImagePickerIOS = {
+  canRecordVideos: function(callback: Function) {
+    return RCTImagePicker.canRecordVideos(callback);
+  },
+  canUseCamera: function(callback: Function) {
+    return RCTImagePicker.canUseCamera(callback);
+  },
+  openCameraDialog: function(config: Object, successCallback: Function, cancelCallback: Function) {
+    config = {
+      videoMode: false,
+      ...config,
+    };
+    return RCTImagePicker.openCameraDialog(config, successCallback, cancelCallback);
+  },
+  openSelectDialog: function(config: Object, successCallback: Function, cancelCallback: Function) {
+    config = {
+      showImages: true,
+      showVideos: false,
+      ...config,
+    };
+    return RCTImagePicker.openSelectDialog(config, successCallback, cancelCallback);
+  },
+};
+
+module.exports = ImagePickerIOS;

node_modules/react-native/Libraries/CameraRoll/RCTAssetsLibraryRequestHandler.h

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridge.h>
+#import <React/RCTURLRequestHandler.h>
+
+@class ALAssetsLibrary;
+
+@interface RCTAssetsLibraryRequestHandler : NSObject <RCTURLRequestHandler>
+
+@end
+
+@interface RCTBridge (RCTAssetsLibraryImageLoader)
+
+/**
+ * The shared asset library instance.
+ */
+@property (nonatomic, readonly) ALAssetsLibrary *assetsLibrary;
+
+@end

node_modules/react-native/Libraries/CameraRoll/RCTAssetsLibraryRequestHandler.m

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAssetsLibraryRequestHandler.h"
+
+#import <stdatomic.h>
+
+#import <AssetsLibrary/AssetsLibrary.h>
+#import <MobileCoreServices/MobileCoreServices.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTUtils.h>
+
+@implementation RCTAssetsLibraryRequestHandler
+{
+  ALAssetsLibrary *_assetsLibrary;
+}
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+
+- (ALAssetsLibrary *)assetsLibrary
+{
+  return _assetsLibrary ?: (_assetsLibrary = [ALAssetsLibrary new]);
+}
+
+#pragma mark - RCTURLRequestHandler
+
+- (BOOL)canHandleRequest:(NSURLRequest *)request
+{
+  return [request.URL.scheme caseInsensitiveCompare:@"assets-library"] == NSOrderedSame;
+}
+
+- (id)sendRequest:(NSURLRequest *)request
+     withDelegate:(id<RCTURLRequestDelegate>)delegate
+{
+  __block atomic_bool cancelled = ATOMIC_VAR_INIT(NO);
+  void (^cancellationBlock)(void) = ^{
+    atomic_store(&cancelled, YES);
+  };
+
+  [[self assetsLibrary] assetForURL:request.URL resultBlock:^(ALAsset *asset) {
+    if (atomic_load(&cancelled)) {
+      return;
+    }
+
+    if (asset) {
+
+      ALAssetRepresentation *representation = [asset defaultRepresentation];
+      NSInteger length = (NSInteger)representation.size;
+      CFStringRef MIMEType = UTTypeCopyPreferredTagWithClass((__bridge CFStringRef _Nonnull)(representation.UTI), kUTTagClassMIMEType);
+
+      NSURLResponse *response =
+      [[NSURLResponse alloc] initWithURL:request.URL
+                                MIMEType:(__bridge NSString *)(MIMEType)
+                   expectedContentLength:length
+                        textEncodingName:nil];
+
+      [delegate URLRequest:cancellationBlock didReceiveResponse:response];
+
+      NSError *error = nil;
+      uint8_t *buffer = (uint8_t *)malloc((size_t)length);
+      if ([representation getBytes:buffer
+                        fromOffset:0
+                            length:length
+                             error:&error]) {
+
+        NSData *data = [[NSData alloc] initWithBytesNoCopy:buffer
+                                                    length:length
+                                              freeWhenDone:YES];
+
+        [delegate URLRequest:cancellationBlock didReceiveData:data];
+        [delegate URLRequest:cancellationBlock didCompleteWithError:nil];
+
+      } else {
+        free(buffer);
+        [delegate URLRequest:cancellationBlock didCompleteWithError:error];
+      }
+
+    } else {
+      NSString *errorMessage = [NSString stringWithFormat:@"Failed to load asset"
+                                " at URL %@ with no error message.", request.URL];
+      NSError *error = RCTErrorWithMessage(errorMessage);
+      [delegate URLRequest:cancellationBlock didCompleteWithError:error];
+    }
+  } failureBlock:^(NSError *loadError) {
+    if (atomic_load(&cancelled)) {
+      return;
+    }
+    [delegate URLRequest:cancellationBlock didCompleteWithError:loadError];
+  }];
+
+  return cancellationBlock;
+}
+
+- (void)cancelRequest:(id)requestToken
+{
+  ((void (^)(void))requestToken)();
+}
+
+@end
+
+@implementation RCTBridge (RCTAssetsLibraryImageLoader)
+
+- (ALAssetsLibrary *)assetsLibrary
+{
+  return [[self moduleForClass:[RCTAssetsLibraryRequestHandler class]] assetsLibrary];
+}
+
+@end

node_modules/react-native/Libraries/CameraRoll/RCTCameraRoll.xcodeproj/project.pbxproj

@@ -0,0 +1,283 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		137620351B31C53500677FF0 /* RCTImagePickerManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 137620341B31C53500677FF0 /* RCTImagePickerManager.m */; };
+		143879351AAD238D00F088A5 /* RCTCameraRollManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 143879341AAD238D00F088A5 /* RCTCameraRollManager.m */; };
+		8312EAEE1B85EB7C001867A2 /* RCTAssetsLibraryRequestHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 8312EAED1B85EB7C001867A2 /* RCTAssetsLibraryRequestHandler.m */; };
+		8312EAF11B85F071001867A2 /* RCTPhotoLibraryImageLoader.m in Sources */ = {isa = PBXBuildFile; fileRef = 8312EAF01B85F071001867A2 /* RCTPhotoLibraryImageLoader.m */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		58B5115B1A9E6B3D00147676 /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "include/$(PRODUCT_NAME)";
+			dstSubfolderSpec = 16;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		137620331B31C53500677FF0 /* RCTImagePickerManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTImagePickerManager.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		137620341B31C53500677FF0 /* RCTImagePickerManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImagePickerManager.m; sourceTree = "<group>"; };
+		143879331AAD238D00F088A5 /* RCTCameraRollManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTCameraRollManager.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		143879341AAD238D00F088A5 /* RCTCameraRollManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTCameraRollManager.m; sourceTree = "<group>"; };
+		58B5115D1A9E6B3D00147676 /* libRCTCameraRoll.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRCTCameraRoll.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		8312EAEC1B85EB7C001867A2 /* RCTAssetsLibraryRequestHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTAssetsLibraryRequestHandler.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		8312EAED1B85EB7C001867A2 /* RCTAssetsLibraryRequestHandler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTAssetsLibraryRequestHandler.m; sourceTree = "<group>"; };
+		8312EAEF1B85F071001867A2 /* RCTPhotoLibraryImageLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTPhotoLibraryImageLoader.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		8312EAF01B85F071001867A2 /* RCTPhotoLibraryImageLoader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTPhotoLibraryImageLoader.m; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		58B5115A1A9E6B3D00147676 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		58B511541A9E6B3D00147676 = {
+			isa = PBXGroup;
+			children = (
+				8312EAEC1B85EB7C001867A2 /* RCTAssetsLibraryRequestHandler.h */,
+				8312EAED1B85EB7C001867A2 /* RCTAssetsLibraryRequestHandler.m */,
+				143879331AAD238D00F088A5 /* RCTCameraRollManager.h */,
+				143879341AAD238D00F088A5 /* RCTCameraRollManager.m */,
+				137620331B31C53500677FF0 /* RCTImagePickerManager.h */,
+				137620341B31C53500677FF0 /* RCTImagePickerManager.m */,
+				8312EAEF1B85F071001867A2 /* RCTPhotoLibraryImageLoader.h */,
+				8312EAF01B85F071001867A2 /* RCTPhotoLibraryImageLoader.m */,
+				58B5115E1A9E6B3D00147676 /* Products */,
+			);
+			indentWidth = 2;
+			sourceTree = "<group>";
+			tabWidth = 2;
+			usesTabs = 0;
+		};
+		58B5115E1A9E6B3D00147676 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				58B5115D1A9E6B3D00147676 /* libRCTCameraRoll.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		58B5115C1A9E6B3D00147676 /* RCTCameraRoll */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 58B511711A9E6B3D00147676 /* Build configuration list for PBXNativeTarget "RCTCameraRoll" */;
+			buildPhases = (
+				58B511591A9E6B3D00147676 /* Sources */,
+				58B5115A1A9E6B3D00147676 /* Frameworks */,
+				58B5115B1A9E6B3D00147676 /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = RCTCameraRoll;
+			productName = RCTNetworkImage;
+			productReference = 58B5115D1A9E6B3D00147676 /* libRCTCameraRoll.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		58B511551A9E6B3D00147676 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0610;
+				ORGANIZATIONNAME = Facebook;
+				TargetAttributes = {
+					58B5115C1A9E6B3D00147676 = {
+						CreatedOnToolsVersion = 6.1.1;
+					};
+				};
+			};
+			buildConfigurationList = 58B511581A9E6B3D00147676 /* Build configuration list for PBXProject "RCTCameraRoll" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 58B511541A9E6B3D00147676;
+			productRefGroup = 58B5115E1A9E6B3D00147676 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				58B5115C1A9E6B3D00147676 /* RCTCameraRoll */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		58B511591A9E6B3D00147676 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				8312EAEE1B85EB7C001867A2 /* RCTAssetsLibraryRequestHandler.m in Sources */,
+				8312EAF11B85F071001867A2 /* RCTPhotoLibraryImageLoader.m in Sources */,
+				137620351B31C53500677FF0 /* RCTImagePickerManager.m in Sources */,
+				143879351AAD238D00F088A5 /* RCTCameraRollManager.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		58B5116F1A9E6B3D00147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Debug;
+		};
+		58B511701A9E6B3D00147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				VALIDATE_PRODUCT = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Release;
+		};
+		58B511721A9E6B3D00147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = (
+					"$(inherited)",
+				);
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RCTCameraRoll;
+				RUN_CLANG_STATIC_ANALYZER = YES;
+			};
+			name = Debug;
+		};
+		58B511731A9E6B3D00147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = (
+					"$(inherited)",
+				);
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RCTCameraRoll;
+				RUN_CLANG_STATIC_ANALYZER = NO;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		58B511581A9E6B3D00147676 /* Build configuration list for PBXProject "RCTCameraRoll" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B5116F1A9E6B3D00147676 /* Debug */,
+				58B511701A9E6B3D00147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		58B511711A9E6B3D00147676 /* Build configuration list for PBXNativeTarget "RCTCameraRoll" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511721A9E6B3D00147676 /* Debug */,
+				58B511731A9E6B3D00147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 58B511551A9E6B3D00147676 /* Project object */;
+}

node_modules/react-native/Libraries/CameraRoll/RCTCameraRollManager.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <AssetsLibrary/AssetsLibrary.h>
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTConvert.h>
+
+@interface RCTConvert (ALAssetGroup)
+
++ (ALAssetsGroupType)ALAssetsGroupType:(id)json;
++ (ALAssetsFilter *)ALAssetsFilter:(id)json;
+
+@end
+
+@interface RCTCameraRollManager : NSObject <RCTBridgeModule>
+
+@end

node_modules/react-native/Libraries/CameraRoll/RCTCameraRollManager.m

@@ -0,0 +1,266 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTCameraRollManager.h"
+
+#import <CoreLocation/CoreLocation.h>
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <Photos/Photos.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTImageLoader.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#import "RCTAssetsLibraryRequestHandler.h"
+
+@implementation RCTConvert (ALAssetGroup)
+
+RCT_ENUM_CONVERTER(ALAssetsGroupType, (@{
+
+  // New values
+  @"album": @(ALAssetsGroupAlbum),
+  @"all": @(ALAssetsGroupAll),
+  @"event": @(ALAssetsGroupEvent),
+  @"faces": @(ALAssetsGroupFaces),
+  @"library": @(ALAssetsGroupLibrary),
+  @"photo-stream": @(ALAssetsGroupPhotoStream),
+  @"saved-photos": @(ALAssetsGroupSavedPhotos),
+
+  // Legacy values
+  @"Album": @(ALAssetsGroupAlbum),
+  @"All": @(ALAssetsGroupAll),
+  @"Event": @(ALAssetsGroupEvent),
+  @"Faces": @(ALAssetsGroupFaces),
+  @"Library": @(ALAssetsGroupLibrary),
+  @"PhotoStream": @(ALAssetsGroupPhotoStream),
+  @"SavedPhotos": @(ALAssetsGroupSavedPhotos),
+
+}), ALAssetsGroupSavedPhotos, integerValue)
+
++ (ALAssetsFilter *)ALAssetsFilter:(id)json
+{
+  static NSDictionary<NSString *, ALAssetsFilter *> *options;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    options = @{
+
+      // New values
+      @"photos": [ALAssetsFilter allPhotos],
+      @"videos": [ALAssetsFilter allVideos],
+      @"all": [ALAssetsFilter allAssets],
+
+      // Legacy values
+      @"Photos": [ALAssetsFilter allPhotos],
+      @"Videos": [ALAssetsFilter allVideos],
+      @"All": [ALAssetsFilter allAssets],
+    };
+  });
+
+  ALAssetsFilter *filter = options[json ?: @"photos"];
+  if (!filter) {
+    RCTLogError(@"Invalid filter option: '%@'. Expected one of 'photos',"
+                "'videos' or 'all'.", json);
+  }
+  return filter ?: [ALAssetsFilter allPhotos];
+}
+
+@end
+
+@implementation RCTCameraRollManager
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+
+static NSString *const kErrorUnableToLoad = @"E_UNABLE_TO_LOAD";
+static NSString *const kErrorUnableToSave = @"E_UNABLE_TO_SAVE";
+
+RCT_EXPORT_METHOD(saveToCameraRoll:(NSURLRequest *)request
+                  type:(NSString *)type
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  if ([type isEqualToString:@"video"]) {
+    // It's unclear if writeVideoAtPathToSavedPhotosAlbum is thread-safe
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self->_bridge.assetsLibrary writeVideoAtPathToSavedPhotosAlbum:request.URL completionBlock:^(NSURL *assetURL, NSError *saveError) {
+        if (saveError) {
+          reject(kErrorUnableToSave, nil, saveError);
+        } else {
+          resolve(assetURL.absoluteString);
+        }
+      }];
+    });
+  } else {
+    [_bridge.imageLoader loadImageWithURLRequest:request
+                                        callback:^(NSError *loadError, UIImage *loadedImage) {
+      if (loadError) {
+        reject(kErrorUnableToLoad, nil, loadError);
+        return;
+      }
+      // It's unclear if writeImageToSavedPhotosAlbum is thread-safe
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [self->_bridge.assetsLibrary writeImageToSavedPhotosAlbum:loadedImage.CGImage metadata:nil completionBlock:^(NSURL *assetURL, NSError *saveError) {
+          if (saveError) {
+            RCTLogWarn(@"Error saving cropped image: %@", saveError);
+            reject(kErrorUnableToSave, nil, saveError);
+          } else {
+            resolve(assetURL.absoluteString);
+          }
+        }];
+      });
+    }];
+  }
+}
+
+static void RCTResolvePromise(RCTPromiseResolveBlock resolve,
+                              NSArray<NSDictionary<NSString *, id> *> *assets,
+                              BOOL hasNextPage)
+{
+  if (!assets.count) {
+    resolve(@{
+      @"edges": assets,
+      @"page_info": @{
+        @"has_next_page": @NO,
+      }
+    });
+    return;
+  }
+  resolve(@{
+    @"edges": assets,
+    @"page_info": @{
+      @"start_cursor": assets[0][@"node"][@"image"][@"uri"],
+      @"end_cursor": assets[assets.count - 1][@"node"][@"image"][@"uri"],
+      @"has_next_page": @(hasNextPage),
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(getPhotos:(NSDictionary *)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  checkPhotoLibraryConfig();
+
+  NSUInteger first = [RCTConvert NSInteger:params[@"first"]];
+  NSString *afterCursor = [RCTConvert NSString:params[@"after"]];
+  NSString *groupName = [RCTConvert NSString:params[@"groupName"]];
+  ALAssetsFilter *assetType = [RCTConvert ALAssetsFilter:params[@"assetType"]];
+  ALAssetsGroupType groupTypes = [RCTConvert ALAssetsGroupType:params[@"groupTypes"]];
+
+  BOOL __block foundAfter = NO;
+  BOOL __block hasNextPage = NO;
+  BOOL __block resolvedPromise = NO;
+  NSMutableArray<NSDictionary<NSString *, id> *> *assets = [NSMutableArray new];
+
+  [_bridge.assetsLibrary enumerateGroupsWithTypes:groupTypes usingBlock:^(ALAssetsGroup *group, BOOL *stopGroups) {
+    if (group && (groupName == nil || [groupName isEqualToString:[group valueForProperty:ALAssetsGroupPropertyName]])) {
+
+      [group setAssetsFilter:assetType];
+      [group enumerateAssetsWithOptions:NSEnumerationReverse usingBlock:^(ALAsset *result, NSUInteger index, BOOL *stopAssets) {
+        if (result) {
+          NSString *uri = ((NSURL *)[result valueForProperty:ALAssetPropertyAssetURL]).absoluteString;
+          if (afterCursor && !foundAfter) {
+            if ([afterCursor isEqualToString:uri]) {
+              foundAfter = YES;
+            }
+            return; // Skip until we get to the first one
+          }
+          if (first == assets.count) {
+            *stopAssets = YES;
+            *stopGroups = YES;
+            hasNextPage = YES;
+            RCTAssert(resolvedPromise == NO, @"Resolved the promise before we finished processing the results.");
+            RCTResolvePromise(resolve, assets, hasNextPage);
+            resolvedPromise = YES;
+            return;
+          }
+          CGSize dimensions = [result defaultRepresentation].dimensions;
+          CLLocation *loc = [result valueForProperty:ALAssetPropertyLocation];
+          NSDate *date = [result valueForProperty:ALAssetPropertyDate];
+          NSString *filename = [result defaultRepresentation].filename;
+          int64_t duration = 0;
+          if ([[result valueForProperty:ALAssetPropertyType] isEqualToString:ALAssetTypeVideo]) {
+            duration = [[result valueForProperty:ALAssetPropertyDuration] intValue];
+          }
+
+          [assets addObject:@{
+            @"node": @{
+              @"type": [result valueForProperty:ALAssetPropertyType],
+              @"group_name": [group valueForProperty:ALAssetsGroupPropertyName],
+              @"image": @{
+                @"uri": uri,
+                @"filename" : filename ?: [NSNull null],
+                @"height": @(dimensions.height),
+                @"width": @(dimensions.width),
+                @"isStored": @YES,
+                @"playableDuration": @(duration),
+              },
+              @"timestamp": @(date.timeIntervalSince1970),
+              @"location": loc ? @{
+                @"latitude": @(loc.coordinate.latitude),
+                @"longitude": @(loc.coordinate.longitude),
+                @"altitude": @(loc.altitude),
+                @"heading": @(loc.course),
+                @"speed": @(loc.speed),
+              } : @{},
+            }
+          }];
+        }
+      }];
+    }
+
+    if (!group) {
+      // Sometimes the enumeration continues even if we set stop above, so we guard against resolving the promise
+      // multiple times here.
+      if (!resolvedPromise) {
+        RCTResolvePromise(resolve, assets, hasNextPage);
+        resolvedPromise = YES;
+      }
+    }
+  } failureBlock:^(NSError *error) {
+    if (error.code != ALAssetsLibraryAccessUserDeniedError) {
+      RCTLogError(@"Failure while iterating through asset groups %@", error);
+    }
+    reject(kErrorUnableToLoad, nil, error);
+  }];
+}
+
+RCT_EXPORT_METHOD(deletePhotos:(NSArray<NSString *>*)assets
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  NSArray<NSURL *> *assets_ = [RCTConvert NSURLArray:assets];
+  [[PHPhotoLibrary sharedPhotoLibrary] performChanges:^{
+      PHFetchResult<PHAsset *> *fetched =
+        [PHAsset fetchAssetsWithALAssetURLs:assets_ options:nil];
+      [PHAssetChangeRequest deleteAssets:fetched];
+    }
+  completionHandler:^(BOOL success, NSError *error) {
+      if (success == YES) {
+     	    resolve(@(success));
+      }
+      else {
+	        reject(@"Couldn't delete", @"Couldn't delete assets", error);
+      }
+    }
+    ];
+}
+
+static void checkPhotoLibraryConfig()
+{
+#if RCT_DEV
+  if (![[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSPhotoLibraryUsageDescription"]) {
+    RCTLogError(@"NSPhotoLibraryUsageDescription key must be present in Info.plist to use camera roll.");
+  }
+#endif
+}
+
+@end

node_modules/react-native/Libraries/CameraRoll/RCTImagePickerManager.h

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCTImagePickerManager : NSObject <RCTBridgeModule>
+
+@end

node_modules/react-native/Libraries/CameraRoll/RCTImagePickerManager.m

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import "RCTImagePickerManager.h"
+
+#import <MobileCoreServices/UTCoreTypes.h>
+#import <UIKit/UIKit.h>
+
+#import <React/RCTConvert.h>
+#import <React/RCTImageStoreManager.h>
+#import <React/RCTRootView.h>
+#import <React/RCTUtils.h>
+
+@interface RCTImagePickerManager () <UIImagePickerControllerDelegate, UINavigationControllerDelegate>
+
+@end
+
+@implementation RCTImagePickerManager
+{
+  NSMutableArray<UIImagePickerController *> *_pickers;
+  NSMutableArray<RCTResponseSenderBlock> *_pickerCallbacks;
+  NSMutableArray<RCTResponseSenderBlock> *_pickerCancelCallbacks;
+}
+
+RCT_EXPORT_MODULE(ImagePickerIOS);
+
+@synthesize bridge = _bridge;
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+RCT_EXPORT_METHOD(canRecordVideos:(RCTResponseSenderBlock)callback)
+{
+  NSArray<NSString *> *availableMediaTypes = [UIImagePickerController availableMediaTypesForSourceType:UIImagePickerControllerSourceTypeCamera];
+  callback(@[@([availableMediaTypes containsObject:(NSString *)kUTTypeMovie])]);
+}
+
+RCT_EXPORT_METHOD(canUseCamera:(RCTResponseSenderBlock)callback)
+{
+  callback(@[@([UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera])]);
+}
+
+RCT_EXPORT_METHOD(openCameraDialog:(NSDictionary *)config
+                  successCallback:(RCTResponseSenderBlock)callback
+                  cancelCallback:(RCTResponseSenderBlock)cancelCallback)
+{
+  if (RCTRunningInAppExtension()) {
+    cancelCallback(@[@"Camera access is unavailable in an app extension"]);
+    return;
+  }
+
+  UIImagePickerController *imagePicker = [UIImagePickerController new];
+  imagePicker.delegate = self;
+  imagePicker.sourceType = UIImagePickerControllerSourceTypeCamera;
+
+  if ([RCTConvert BOOL:config[@"videoMode"]]) {
+    imagePicker.cameraCaptureMode = UIImagePickerControllerCameraCaptureModeVideo;
+  }
+
+  [self _presentPicker:imagePicker
+       successCallback:callback
+        cancelCallback:cancelCallback];
+}
+
+RCT_EXPORT_METHOD(openSelectDialog:(NSDictionary *)config
+                  successCallback:(RCTResponseSenderBlock)callback
+                  cancelCallback:(RCTResponseSenderBlock)cancelCallback)
+{
+  if (RCTRunningInAppExtension()) {
+    cancelCallback(@[@"Image picker is currently unavailable in an app extension"]);
+    return;
+  }
+
+  UIImagePickerController *imagePicker = [UIImagePickerController new];
+  imagePicker.delegate = self;
+  imagePicker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
+
+  NSMutableArray<NSString *> *allowedTypes = [NSMutableArray new];
+  if ([RCTConvert BOOL:config[@"showImages"]]) {
+    [allowedTypes addObject:(NSString *)kUTTypeImage];
+  }
+  if ([RCTConvert BOOL:config[@"showVideos"]]) {
+    [allowedTypes addObject:(NSString *)kUTTypeMovie];
+  }
+
+  imagePicker.mediaTypes = allowedTypes;
+
+  [self _presentPicker:imagePicker
+       successCallback:callback
+        cancelCallback:cancelCallback];
+}
+
+- (void)imagePickerController:(UIImagePickerController *)picker
+didFinishPickingMediaWithInfo:(NSDictionary<NSString *, id> *)info
+{
+  NSString *mediaType = info[UIImagePickerControllerMediaType];
+  BOOL isMovie = [mediaType isEqualToString:(NSString *)kUTTypeMovie];
+  NSString *key = isMovie ? UIImagePickerControllerMediaURL : UIImagePickerControllerReferenceURL;
+  NSURL *imageURL = info[key];
+  UIImage *image = info[UIImagePickerControllerOriginalImage];
+  NSNumber *width = 0;
+  NSNumber *height = 0;
+  if (image) {
+    height = @(image.size.height);
+    width = @(image.size.width);
+  }
+  if (imageURL) {
+    [self _dismissPicker:picker args:@[imageURL.absoluteString, RCTNullIfNil(height), RCTNullIfNil(width)]];
+    return;
+  }
+
+  // This is a newly taken image, and doesn't have a URL yet.
+  // We need to save it to the image store first.
+  UIImage *originalImage = info[UIImagePickerControllerOriginalImage];
+
+  // WARNING: Using ImageStoreManager may cause a memory leak because the
+  // image isn't automatically removed from store once we're done using it.
+  [_bridge.imageStoreManager storeImage:originalImage withBlock:^(NSString *tempImageTag) {
+    [self _dismissPicker:picker args:tempImageTag ? @[tempImageTag, height, width] : nil];
+  }];
+}
+
+- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker
+{
+  [self _dismissPicker:picker args:nil];
+}
+
+- (void)_presentPicker:(UIImagePickerController *)imagePicker
+       successCallback:(RCTResponseSenderBlock)callback
+        cancelCallback:(RCTResponseSenderBlock)cancelCallback
+{
+  if (!_pickers) {
+    _pickers = [NSMutableArray new];
+    _pickerCallbacks = [NSMutableArray new];
+    _pickerCancelCallbacks = [NSMutableArray new];
+  }
+
+  [_pickers addObject:imagePicker];
+  [_pickerCallbacks addObject:callback];
+  [_pickerCancelCallbacks addObject:cancelCallback];
+
+  UIViewController *rootViewController = RCTPresentedViewController();
+  [rootViewController presentViewController:imagePicker animated:YES completion:nil];
+}
+
+- (void)_dismissPicker:(UIImagePickerController *)picker args:(NSArray *)args
+{
+  NSUInteger index = [_pickers indexOfObject:picker];
+  RCTResponseSenderBlock successCallback = _pickerCallbacks[index];
+  RCTResponseSenderBlock cancelCallback = _pickerCancelCallbacks[index];
+
+  [_pickers removeObjectAtIndex:index];
+  [_pickerCallbacks removeObjectAtIndex:index];
+  [_pickerCancelCallbacks removeObjectAtIndex:index];
+
+  UIViewController *rootViewController = RCTPresentedViewController();
+  [rootViewController dismissViewControllerAnimated:YES completion:nil];
+
+  if (args) {
+    successCallback(args);
+  } else {
+    cancelCallback(@[]);
+  }
+}
+
+@end

node_modules/react-native/Libraries/CameraRoll/RCTPhotoLibraryImageLoader.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTImageLoader.h>
+
+@interface RCTPhotoLibraryImageLoader : NSObject <RCTImageURLLoader>
+
+@end

node_modules/react-native/Libraries/CameraRoll/RCTPhotoLibraryImageLoader.m

@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTPhotoLibraryImageLoader.h"
+
+#import <Photos/Photos.h>
+
+#import <React/RCTUtils.h>
+
+@implementation RCTPhotoLibraryImageLoader
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+
+#pragma mark - RCTImageLoader
+
+- (BOOL)canLoadImageURL:(NSURL *)requestURL
+{
+  if (![PHAsset class]) {
+    return NO;
+  }
+  return [requestURL.scheme caseInsensitiveCompare:@"assets-library"] == NSOrderedSame ||
+    [requestURL.scheme caseInsensitiveCompare:@"ph"] == NSOrderedSame;
+}
+
+- (RCTImageLoaderCancellationBlock)loadImageForURL:(NSURL *)imageURL
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                   progressHandler:(RCTImageLoaderProgressBlock)progressHandler
+                                partialLoadHandler:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
+                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler
+{
+  // Using PhotoKit for iOS 8+
+  // The 'ph://' prefix is used by FBMediaKit to differentiate between
+  // assets-library. It is prepended to the local ID so that it is in the
+  // form of an, NSURL which is what assets-library uses.
+  NSString *assetID = @"";
+  PHFetchResult *results;
+  if (!imageURL) {
+    completionHandler(RCTErrorWithMessage(@"Cannot load a photo library asset with no URL"), nil);
+    return ^{};
+  } else if ([imageURL.scheme caseInsensitiveCompare:@"assets-library"] == NSOrderedSame) {
+    assetID = [imageURL absoluteString];
+    results = [PHAsset fetchAssetsWithALAssetURLs:@[imageURL] options:nil];
+  } else {
+    assetID = [imageURL.absoluteString substringFromIndex:@"ph://".length];
+    results = [PHAsset fetchAssetsWithLocalIdentifiers:@[assetID] options:nil];
+  }
+  if (results.count == 0) {
+    NSString *errorText = [NSString stringWithFormat:@"Failed to fetch PHAsset with local identifier %@ with no error message.", assetID];
+    completionHandler(RCTErrorWithMessage(errorText), nil);
+    return ^{};
+  }
+
+  PHAsset *asset = [results firstObject];
+  PHImageRequestOptions *imageOptions = [PHImageRequestOptions new];
+
+  // Allow PhotoKit to fetch images from iCloud
+  imageOptions.networkAccessAllowed = YES;
+
+  if (progressHandler) {
+    imageOptions.progressHandler = ^(double progress, NSError *error, BOOL *stop, NSDictionary<NSString *, id> *info) {
+      static const double multiplier = 1e6;
+      progressHandler(progress * multiplier, multiplier);
+    };
+  }
+
+  // Note: PhotoKit defaults to a deliveryMode of PHImageRequestOptionsDeliveryModeOpportunistic
+  // which means it may call back multiple times - we probably don't want that
+  imageOptions.deliveryMode = PHImageRequestOptionsDeliveryModeHighQualityFormat;
+
+  BOOL useMaximumSize = CGSizeEqualToSize(size, CGSizeZero);
+  CGSize targetSize;
+  if (useMaximumSize) {
+    targetSize = PHImageManagerMaximumSize;
+    imageOptions.resizeMode = PHImageRequestOptionsResizeModeNone;
+  } else {
+    targetSize = CGSizeApplyAffineTransform(size, CGAffineTransformMakeScale(scale, scale));
+    imageOptions.resizeMode = PHImageRequestOptionsResizeModeFast;
+  }
+
+  PHImageContentMode contentMode = PHImageContentModeAspectFill;
+  if (resizeMode == RCTResizeModeContain) {
+    contentMode = PHImageContentModeAspectFit;
+  }
+
+  PHImageRequestID requestID =
+  [[PHImageManager defaultManager] requestImageForAsset:asset
+                                             targetSize:targetSize
+                                            contentMode:contentMode
+                                                options:imageOptions
+                                          resultHandler:^(UIImage *result, NSDictionary<NSString *, id> *info) {
+    if (result) {
+      completionHandler(nil, result);
+    } else {
+      completionHandler(info[PHImageErrorKey], nil);
+    }
+  }];
+
+  return ^{
+    [[PHImageManager defaultManager] cancelImageRequest:requestID];
+  };
+}
+
+@end