expo-document-picker 11.2.2 → 11.4.0

package/ios/DocumentPickerModule.swift

@@ -0,0 +1,172 @@
+import ExpoModulesCore
+import UIKit
+import MobileCoreServices
+
+struct PickingContext {
+  let promise: Promise
+  let options: DocumentPickerOptions
+  let delegate: DocumentPickingDelegate
+}
+
+public class DocumentPickerModule: Module, PickingResultHandler {
+  private var pickingContext: PickingContext?
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoDocumentPicker")
+
+    AsyncFunction("getDocumentAsync") { (options: DocumentPickerOptions, promise: Promise) in
+      if pickingContext != nil {
+        throw PickingInProgressException()
+      }
+
+      guard let currentVc = appContext?.utilities?.currentViewController() else {
+        throw MissingViewControllerException()
+      }
+
+      let documentPickerVC = createDocumentPicker(with: options)
+      let pickerDelegate = DocumentPickingDelegate(resultHandler: self)
+
+      pickingContext = PickingContext(promise: promise, options: options, delegate: pickerDelegate)
+
+      documentPickerVC.delegate = pickerDelegate
+      documentPickerVC.presentationController?.delegate = pickerDelegate
+      documentPickerVC.allowsMultipleSelection = options.multiple
+
+      if UIDevice.current.userInterfaceIdiom == .pad {
+        let viewFrame = currentVc.view.frame
+        documentPickerVC.popoverPresentationController?.sourceRect = CGRect(
+          x: viewFrame.midX,
+          y: viewFrame.maxY,
+          width: 0,
+          height: 0
+        )
+        documentPickerVC.popoverPresentationController?.sourceView = currentVc.view
+        documentPickerVC.modalPresentationStyle = .pageSheet
+      }
+      currentVc.present(documentPickerVC, animated: true)
+    }.runOnQueue(.main)
+  }
+
+  func didPickDocumentsAt(urls: [URL]) {
+    guard let options = self.pickingContext?.options,
+    let promise = self.pickingContext?.promise else {
+      log.error("Picking context has been lost.")
+      return
+    }
+    pickingContext = nil
+
+    do {
+      if options.multiple {
+        let assets = try urls.map {
+          try readDocumentDetails(
+            documentUrl: $0,
+            copy: options.copyToCacheDirectory
+          )
+        }
+        promise.resolve(DocumentPickerResponse(assets: assets))
+      } else {
+        let asset = try readDocumentDetails(
+          documentUrl: urls[0],
+          copy: options.copyToCacheDirectory
+        )
+        promise.resolve(DocumentPickerResponse(assets: [asset]))
+      }
+    } catch {
+      promise.reject(error)
+    }
+  }
+
+  func didCancelPicking() {
+    guard let context = pickingContext else {
+      log.error("Picking context lost")
+      return
+    }
+
+    pickingContext = nil
+    context.promise.resolve(DocumentPickerResponse(canceled: true))
+  }
+
+  private func getFileSize(path: URL) -> Int? {
+    guard let resource = try? path.resourceValues(forKeys: [.fileSizeKey, .isDirectoryKey]) else {
+      return 0
+    }
+
+    if let isDirectory = resource.isDirectory {
+      if !isDirectory {
+        return resource.fileSize
+      }
+    }
+
+    guard let contents = try? FileManager.default.contentsOfDirectory(atPath: path.absoluteString) else {
+      return 0
+    }
+
+    let folderSize = contents.reduce(0) { currentSize, file in
+      let fileSize = getFileSize(path: path.appendingPathComponent(file)) ?? 0
+      return currentSize + fileSize
+    }
+
+    return folderSize
+  }
+
+  private func readDocumentDetails(documentUrl: URL, copy: Bool) throws -> DocumentInfo {
+    let pathExtension = documentUrl.pathExtension
+    var newUrl = documentUrl
+
+    guard let fileSystem = self.appContext?.fileSystem else {
+      throw Exceptions.FileSystemModuleNotFound()
+    }
+
+    guard let fileSize = try? getFileSize(path: documentUrl) else {
+      throw InvalidFileException()
+    }
+
+    if copy {
+      let directory = fileSystem.cachesDirectory.appending("DocumentPicker")
+      let path = fileSystem.generatePath(inDirectory: directory, withExtension: pathExtension)
+      newUrl = URL(fileURLWithPath: path)
+      try FileManager.default.copyItem(at: documentUrl, to: newUrl)
+    }
+
+    let mimeType = self.getMimeType(from: pathExtension)
+
+    return DocumentInfo(
+      uri: newUrl.absoluteString,
+      name: documentUrl.lastPathComponent,
+      size: fileSize,
+      mimeType: mimeType
+    )
+  }
+
+  private func getMimeType(from pathExtension: String) -> String? {
+    if #available(iOS 14, *) {
+      return UTType(filenameExtension: pathExtension)?.preferredMIMEType
+    } else {
+      if let uti = UTTypeCreatePreferredIdentifierForTag(
+        kUTTagClassFilenameExtension,
+        pathExtension as NSString, nil
+      )?.takeRetainedValue() {
+        if let mimetype = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassMIMEType)?.takeRetainedValue() {
+          return mimetype as String
+        }
+      }
+      return nil
+    }
+  }
+
+  private func createDocumentPicker(with options: DocumentPickerOptions) -> UIDocumentPickerViewController {
+    if #available(iOS 14.0, *) {
+      let utTypes = options.type.compactMap { $0.toUTType() }
+      return UIDocumentPickerViewController(
+        forOpeningContentTypes: utTypes,
+        asCopy: true
+      )
+    } else {
+      let utiTypes = options.type.map { $0.toUTI() }
+      return UIDocumentPickerViewController(
+        documentTypes: utiTypes,
+        in: .import
+      )
+    }
+  }
+}

package/ios/DocumentPickerOptions.swift

@@ -0,0 +1,68 @@
+import ExpoModulesCore
+import MobileCoreServices
+
+struct DocumentPickerOptions: Record {
+  @Field
+  var copyToCacheDirectory: Bool
+
+  @Field
+  var type: [MimeType]
+
+  @Field
+  var multiple: Bool
+}
+
+internal enum MimeType: String, Enumerable {
+  case item = "*/*"
+  case image = "image/*"
+  case video = "video/*"
+  case audio = "audio/*"
+  case text = "text/*"
+
+  @available(iOS 14.0, *)
+  func toUTType() -> UTType? {
+    switch self {
+    case .item:
+      return UTType.item
+    case .image:
+      return UTType.image
+    case .video:
+      return UTType.video
+    case .audio:
+      return UTType.audio
+    case .text:
+      return UTType.text
+    default:
+      return UTType(mimeType: self.rawValue)
+    }
+  }
+
+  func toUTI() -> String {
+    var uti: CFString
+
+    switch self {
+    case .item:
+      uti = kUTTypeItem
+    case .image:
+      uti = kUTTypeImage
+    case .video:
+      uti = kUTTypeVideo
+    case .audio:
+      uti = kUTTypeAudio
+    case .text:
+      uti = kUTTypeText
+    default:
+      if let ref = UTTypeCreatePreferredIdentifierForTag(
+        kUTTagClassMIMEType,
+        self.rawValue as CFString,
+        nil
+      )?.takeRetainedValue() {
+        uti = ref
+      } else {
+        uti = kUTTypeItem
+      }
+    }
+
+    return uti as String
+  }
+}

package/ios/DocumentPickerResponse.swift

@@ -0,0 +1,13 @@
+import ExpoModulesCore
+
+internal struct DocumentPickerResponse: Record {
+  @Field var assets: [DocumentInfo]? = nil
+  @Field var canceled: Bool = false
+}
+
+internal struct DocumentInfo: Record {
+  @Field var uri: String = ""
+  @Field var name: String? = nil
+  @Field var size: Int = 0
+  @Field var mimeType: String? = nil
+}

package/ios/DocumentPickingDelegate.swift

@@ -0,0 +1,26 @@
+import UIKit
+
+protocol PickingResultHandler {
+  func didPickDocumentsAt(urls: [URL])
+  func didCancelPicking()
+}
+
+internal class DocumentPickingDelegate: NSObject, UIDocumentPickerDelegate, UIAdaptivePresentationControllerDelegate {
+  private let resultHandler: PickingResultHandler
+
+  init(resultHandler: PickingResultHandler) {
+    self.resultHandler = resultHandler
+  }
+
+  func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+    self.resultHandler.didPickDocumentsAt(urls: urls)
+  }
+
+  func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+    self.resultHandler.didCancelPicking()
+  }
+
+  func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
+    self.resultHandler.didCancelPicking()
+  }
+}

package/ios/Exceptions.swift

@@ -0,0 +1,19 @@
+import ExpoModulesCore
+
+internal class InvalidFileException: Exception {
+  override var reason: String {
+    "Unable to get file size"
+  }
+}
+
+internal class PickingInProgressException: Exception {
+  override var reason: String {
+    "Different document picking in progress. Await other document picking first"
+  }
+}
+
+internal class MissingViewControllerException: Exception {
+  override var reason: String {
+    "Could not find the current ViewController"
+  }
+}

package/ios/{EXDocumentPicker.podspec → ExpoDocumentPicker.podspec}

@@ -3,7 +3,7 @@ require 'json'
 package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
 
 Pod::Spec.new do |s|
-  s.name           = 'EXDocumentPicker'
+  s.name           = 'ExpoDocumentPicker'
   s.version        = package['version']
   s.summary        = package['description']
   s.description    = package['description']
@@ -11,15 +11,22 @@ Pod::Spec.new do |s|
   s.author         = package['author']
   s.homepage       = package['homepage']
   s.platform       = :ios, '13.0'
+  s.swift_version  = '5.4'
   s.source         = { git: 'https://github.com/expo/expo.git' }
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
+  
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
 
   if !$ExpoUseSources&.include?(package['name']) && ENV['EXPO_USE_SOURCE'].to_i == 0 && File.exist?("#{s.name}.xcframework") && Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.10.0')
-    s.source_files = "#{s.name}/**/*.h"
+    s.source_files = "**/*.h"
     s.vendored_frameworks = "#{s.name}.xcframework"
   else
-    s.source_files = "#{s.name}/**/*.{h,m}"
+    s.source_files = "**/*.{h,m,swift}"
   end
 end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-document-picker",
-  "version": "11.2.2",
+  "version": "11.4.0",
   "description": "Provides access to the system's UI for selecting documents from the available providers on the user's device.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -40,5 +40,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "449f9edf2282fa984b6f694ce63867dffc65b580"
+  "gitHead": "4ba50c428c8369bb6b3a51a860d4898ad4ccbe78"
 }

package/src/ExpoDocumentPicker.web.ts

@@ -1,6 +1,6 @@
 import { Platform } from 'expo-modules-core';
 
-import { DocumentPickerOptions, DocumentResult } from './types';
+import { DocumentPickerOptions, DocumentPickerResult } from './types';
 
 export default {
   get name(): string {
@@ -10,10 +10,10 @@ export default {
   async getDocumentAsync({
     type = '*/*',
     multiple = false,
-  }: DocumentPickerOptions): Promise<DocumentResult> {
+  }: DocumentPickerOptions): Promise<DocumentPickerResult> {
     // SSR guard
     if (!Platform.isDOMAvailable) {
-      return { type: 'cancel' };
+      return { canceled: true, assets: null };
     }
 
     const input = document.createElement('input');
@@ -39,9 +39,11 @@ export default {
           reader.onload = ({ target }) => {
             const uri = (target as any).result;
             resolve({
+              canceled: false,
               type: 'success',
               uri,
               mimeType,
+              assets: [],
               name: targetFile.name,
               file: targetFile,
               lastModified: targetFile.lastModified,
@@ -52,7 +54,7 @@ export default {
           // Read in the image file as a binary string.
           reader.readAsDataURL(targetFile);
         } else {
-          resolve({ type: 'cancel' });
+          resolve({ canceled: true, assets: null });
         }
 
         document.body.removeChild(input);

package/src/index.ts

@@ -1,6 +1,39 @@
 import ExpoDocumentPicker from './ExpoDocumentPicker';
-import { DocumentPickerOptions, DocumentResult } from './types';
-export { DocumentPickerOptions, DocumentResult };
+import { DocumentPickerOptions, DocumentPickerResult } from './types';
+
+const DEPRECATED_RESULT_KEYS = [
+  'name',
+  'size',
+  'uri',
+  'mimeType',
+  'lastModified',
+  'file',
+  'output',
+];
+
+function mergeDeprecatedResult(result: DocumentPickerResult): DocumentPickerResult {
+  const firstAsset = result.assets?.[0];
+  const deprecatedResult = {
+    ...result,
+    get type() {
+      console.warn(
+        'Key "type" in the document picker result is deprecated and will be removed in SDK 49, use "canceled" instead'
+      );
+      return this.canceled ? 'cancel' : 'success';
+    },
+  };
+  for (const key of DEPRECATED_RESULT_KEYS) {
+    Object.defineProperty(deprecatedResult, key, {
+      get() {
+        console.warn(
+          `Key "${key}" in the document picker result is deprecated and will be removed in SDK 49, you can access selected assets through the "assets" array instead`
+        );
+        return firstAsset?.[key];
+      },
+    });
+  }
+  return deprecatedResult;
+}
 
 // @needsAudit
 /**
@@ -18,9 +51,16 @@ export async function getDocumentAsync({
   type = '*/*',
   copyToCacheDirectory = true,
   multiple = false,
-}: DocumentPickerOptions = {}): Promise<DocumentResult> {
+}: DocumentPickerOptions = {}): Promise<DocumentPickerResult> {
   if (typeof type === 'string') {
     type = [type] as string[];
   }
-  return await ExpoDocumentPicker.getDocumentAsync({ type, copyToCacheDirectory, multiple });
+  const result = await ExpoDocumentPicker.getDocumentAsync({
+    type,
+    copyToCacheDirectory,
+    multiple,
+  });
+  return mergeDeprecatedResult(result);
 }
+
+export * from './types';

package/src/types.ts

@@ -2,7 +2,7 @@
 export type DocumentPickerOptions = {
   /**
    * The [MIME type(s)](https://en.wikipedia.org/wiki/Media_type) of the documents that are available
-   * to be picked. Is also supports wildcards like `'image/*'` to choose any image. To allow any type
+   * to be picked. It also supports wildcards like `'image/*'` to choose any image. To allow any type
    * of document you can use `'*/*'`.
    * @default '*/*'
    */
@@ -18,56 +18,100 @@ export type DocumentPickerOptions = {
   /**
    * Allows multiple files to be selected from the system UI.
    * @default false
-   * @platform web
+   *
    */
   multiple?: boolean;
 };
 
+export type DocumentPickerAsset = {
+  /**
+   * Document original name.
+   */
+  name: string;
+  /**
+   * Document size in bytes.
+   */
+  size?: number;
+  /**
+   * An URI to the local document file.
+   */
+  uri: string;
+  /**
+   * Document MIME type.
+   */
+  mimeType?: string;
+  /**
+   * Timestamp of last document modification.
+   */
+  lastModified?: number;
+  /**
+   * `File` object for the parity with web File API.
+   * @platform web
+   */
+  file?: File;
+  /**
+   * `FileList` object for the parity with web File API.
+   * @platform web
+   */
+  output?: FileList | null;
+};
+
 // @needsAudit @docsMissing
+export type DocumentPickerResult = {
+  /**
+   * Boolean flag which shows if request was canceled. If asset data have been returned this should
+   * always be `false`.
+   */
+  canceled: boolean;
+  type?: string;
+  /**
+   * Document original name.
+   */
+  name?: string;
+  /**
+   * Document size in bytes.
+   */
+  size?: number;
+  /**
+   * An array of picked assets or `null` when the request was canceled.
+   */
+  assets: DocumentPickerAsset[] | null;
+  /**
+   * An URI to the local document file.
+   */
+  uri?: string;
+  /**
+   * Document MIME type.
+   */
+  mimeType?: string;
+  /**
+   * Timestamp of last document modification.
+   */
+  lastModified?: number;
+  /**
+   * `File` object for the parity with web File API.
+   * @platform web
+   */
+  file?: File;
+  /**
+   * `FileList` object for the parity with web File API.
+   * @platform web
+   */
+  output?: FileList | null;
+} & (DocumentPickerSuccessResult | DocumentPickerCanceledResult);
+
 /**
- * First object represents the result when the document pick has been cancelled.
- * The second one represents the successful document pick result.
+ * @hidden
  */
-export type DocumentResult =
-  | {
-      /**
-       * Field indicating that the document pick has been cancelled.
-       */
-      type: 'cancel';
-    }
-  | {
-      /**
-       * Field indicating that the document pick has been successful.
-       */
-      type: 'success';
-      /**
-       * Document original name.
-       */
-      name: string;
-      /**
-       * Document size in bytes.
-       */
-      size?: number;
-      /**
-       * An URI to the local document file.
-       */
-      uri: string;
-      /**
-       * Document MIME type.
-       */
-      mimeType?: string;
-      /**
-       * Timestamp of last document modification.
-       */
-      lastModified?: number;
-      /**
-       * `File` object for the parity with web File API.
-       * @platform web
-       */
-      file?: File;
-      /**
-       * `FileList` object for the parity with web File API.
-       * @platform web
-       */
-      output?: FileList | null;
-    };
+export type DocumentPickerSuccessResult = {
+  canceled: false;
+  assets: DocumentPickerAsset[];
+};
+
+/**
+ * @hidden
+ */
+export type DocumentPickerCanceledResult = {
+  canceled: true;
+  assets: null;
+};

package/ios/EXDocumentPicker/EXDocumentPickerModule.h

@@ -1,7 +0,0 @@
-//  Copyright © 2018 650 Industries. All rights reserved.
-
-#import <ExpoModulesCore/EXExportedModule.h>
-#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
-
-@interface EXDocumentPickerModule : EXExportedModule <EXModuleRegistryConsumer>
-@end