Add PDF worker support

.gitignore

@@ -81,3 +81,4 @@ bundled/translators
 bundled/styles
 bundled/locales
 bundled/note_editor
+bundled/pdf_worker

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "note-editor"]
 	path = note-editor
 	url = https://github.com/zotero/note-editor
+[submodule "pdf-worker"]
+	path = pdf-worker
+	url = https://github.com/zotero/pdf-worker

ZShare/Controllers/TranslationWebViewHandler.swift

@@ -269,7 +269,7 @@ final class TranslationWebViewHandler {
             self.observable.on(.error(Error.noSuccessfulTranslators))
 
         case .log:
-            DDLogInfo("JSLOG: \(body)")
+            DDLogInfo("TranslationWebViewHandler: JSLOG - \(body)")
         }
     }
 }

ZShare/View Controllers/ShareViewController.swift

@@ -67,6 +67,7 @@ final class ShareViewController: UIViewController {
     private var fileStorage: FileStorage!
     private var debugLogging: DebugLogging!
     private var schemaController: SchemaController!
+    private var pdfWorkerController: PDFWorkerController!
     private var secureStorage: KeychainSecureStorage!
     private var viewModel: ExtensionViewModel!
     private var storeCancellable: AnyCancellable?
@@ -714,15 +715,18 @@ final class ShareViewController: UIViewController {
         let translatorsController = TranslatorsAndStylesController(apiClient: apiClient, bundledDataStorage: bundledDataStorage, fileStorage: fileStorage)
         let secureStorage = KeychainSecureStorage()
         let webDavController = WebDavControllerImpl(dbStorage: dbStorage, fileStorage: fileStorage, sessionStorage: SecureWebDavSessionStorage(secureStorage: secureStorage))
+        let pdfWorkerController = PDFWorkerController()
 
         apiClient.set(authToken: ("Bearer " + session.apiToken))
         translatorsController.updateFromRepo(type: .shareExtension)
+        pdfWorkerController.webViewProvider = self
 
         self.fileStorage = fileStorage
         self.schemaController = schemaController
         self.dbStorage = dbStorage
         self.bundledDataStorage = bundledDataStorage
         self.translatorsController = translatorsController
+        self.pdfWorkerController = pdfWorkerController
         self.secureStorage = secureStorage
 
         self.viewModel = self.createViewModel(for: session.userId, dbStorage: dbStorage, apiClient: apiClient, schemaController: schemaController, fileStorage: fileStorage,
@@ -741,9 +745,39 @@ final class ShareViewController: UIViewController {
         let attachmentDownloader = AttachmentDownloader(userId: userId, apiClient: apiClient, fileStorage: fileStorage, dbStorage: dbStorage, webDavController: webDavController)
         let syncController = SyncController(userId: userId, apiClient: apiClient, dbStorage: dbStorage, fileStorage: fileStorage, schemaController: schemaController, dateParser: dateParser,
                                             backgroundUploaderContext: backgroundUploadContext, webDavController: webDavController, attachmentDownloader: attachmentDownloader, syncDelayIntervals: DelayIntervals.sync, maxRetryCount: DelayIntervals.retry.count)
+        let recognizerController = RecognizerController(
+            pdfWorkerController: pdfWorkerController,
+            apiClient: apiClient,
+            translatorsController: translatorsController,
+            schemaController: schemaController,
+            dbStorage: dbStorage,
+            dateParser: dateParser
+        )
+        recognizerController.webViewProvider = self
+
+        return ExtensionViewModel(
+            webView: webView,
+            apiClient: apiClient,
+            attachmentDownloader: attachmentDownloader,
+            backgroundUploader: backgroundUploader,
+            backgroundUploadObserver: backgroundUploadObserver,
+            dbStorage: dbStorage,
+            schemaController: schemaController,
+            webDavController: webDavController,
+            dateParser: dateParser,
+            fileStorage: fileStorage,
+            syncController: syncController,
+            translatorsController: translatorsController,
+            recognizerController: recognizerController
+        )
+    }
+}
 
-        return ExtensionViewModel(webView: self.webView, apiClient: apiClient, attachmentDownloader: attachmentDownloader, backgroundUploader: backgroundUploader, backgroundUploadObserver: backgroundUploadObserver, dbStorage: dbStorage,
-                                  schemaController: schemaController, webDavController: webDavController, dateParser: dateParser, fileStorage: fileStorage, syncController: syncController,
-                                  translatorsController: translatorsController)
+extension ShareViewController: WebViewProvider {
+    func addWebView(configuration: WKWebViewConfiguration?) -> WKWebView {
+        let webView: WKWebView = configuration.flatMap({ WKWebView(frame: .zero, configuration: $0) }) ?? WKWebView()
+        webView.isHidden = true
+        view.insertSubview(webView, at: 0)
+        return webView
     }
 }

ZShare/ViewModels/ExtensionViewModel.swift

@@ -315,6 +315,7 @@ final class ExtensionViewModel {
     private let backgroundUploadObserver: BackgroundUploadObserver
     private let backgroundQueue: DispatchQueue
     private let backgroundScheduler: SerialDispatchQueueScheduler
+    private let recognizerController: RecognizerController
     private let disposeBag: DisposeBag
     // Custom `URLSession` has to be used for downloading, instead of existing `apiClient`, so that we can include original cookies in download requests.
     private let downloadUrlSession: URLSession
@@ -325,8 +326,21 @@ final class ExtensionViewModel {
         let mtime: Int
     }
 
-    init(webView: WKWebView, apiClient: ApiClient, attachmentDownloader: AttachmentDownloader, backgroundUploader: BackgroundUploader, backgroundUploadObserver: BackgroundUploadObserver, dbStorage: DbStorage, schemaController: SchemaController,
-         webDavController: WebDavController, dateParser: DateParser, fileStorage: FileStorage, syncController: SyncController, translatorsController: TranslatorsAndStylesController) {
+    init(
+        webView: WKWebView,
+        apiClient: ApiClient,
+        attachmentDownloader: AttachmentDownloader,
+        backgroundUploader: BackgroundUploader,
+        backgroundUploadObserver: BackgroundUploadObserver,
+        dbStorage: DbStorage,
+        schemaController: SchemaController,
+        webDavController: WebDavController,
+        dateParser: DateParser,
+        fileStorage: FileStorage,
+        syncController: SyncController,
+        translatorsController: TranslatorsAndStylesController,
+        recognizerController: RecognizerController
+    ) {
         let queue = DispatchQueue(label: "org.zotero.ZShare.BackgroundQueue", qos: .userInteractive)
 
         let storage = HTTPCookieStorage.sharedCookieStorage(forGroupContainerIdentifier: AppGroup.identifier)
@@ -355,6 +369,7 @@ final class ExtensionViewModel {
         self.translationHandler = TranslationWebViewHandler(webView: webView, translatorsController: translatorsController)
         self.backgroundQueue = queue
         self.backgroundScheduler = SerialDispatchQueueScheduler(queue: queue, internalSerialQueueName: "org.zotero.ZShare.BackgroundScheduler")
+        self.recognizerController = recognizerController
         self.state = State()
         self.disposeBag = DisposeBag()
 
@@ -501,17 +516,57 @@ final class ExtensionViewModel {
         let filename = url.lastPathComponent
         let tmpFile = Files.temporaryFile(ext: url.pathExtension)
 
-        self.copyFile(from: url.path, to: tmpFile)
-            .subscribe(with: self, onSuccess: { `self`, _ in
-                var state = self.state
-                state.processedAttachment = .file(file: tmpFile, filename: filename)
-                state.expectedAttachment = (filename, tmpFile)
-                state.attachmentState = .processed
-                self.state = state
-            }, onFailure: { `self`, _ in
-                self.state.attachmentState = .failed(.fileMissing)
+        copyFile(from: url.path, to: tmpFile)
+            .subscribe(onSuccess: { [weak self] _ in
+                guard let self else { return }
+                guard fileStorage.isPdf(file: tmpFile), let file = tmpFile as? FileData else {
+                    updateState(with: .processed)
+                    return
+                }
+                recognize(file: file)
+            }, onFailure: { [weak self] _ in
+                self?.state.attachmentState = .failed(.fileMissing)
             })
-            .disposed(by: self.disposeBag)
+            .disposed(by: disposeBag)
+
+        func updateState(with attachmentState: State.AttachmentState) {
+            var state = self.state
+            state.processedAttachment = .file(file: tmpFile, filename: filename)
+            state.expectedAttachment = (filename, tmpFile)
+            state.attachmentState = attachmentState
+            self.state = state
+        }
+
+        func recognize(file: FileData) {
+            recognizerController.queue(task: .init(file: file, kind: .simple))
+                .subscribe { [weak self] update in
+                    guard let self else { return }
+                    switch update.kind {
+                    case .failed(let error):
+                        DDLogError("ExtensionViewModel: could not recognize shared file - \(error)")
+                        updateState(with: .processed)
+
+                    case .cancelled:
+                        updateState(with: .processed)
+
+                    case .inProgress:
+                        updateState(with: .decoding)
+
+                    case .translated(let item):
+                        var state = self.state
+                        state.expectedItem = item
+                        state.expectedAttachment = (filename, tmpFile)
+                        state.attachmentState = .processed
+                        // attachment is only used to get an optional URL, so we can safely pass an empty dictionary
+                        state.processedAttachment = .itemWithAttachment(item: item, attachment: [:], attachmentFile: file)
+                        self.state = state
+
+                    case .enqueued, .createdParent:
+                        break
+                    }
+                }
+                .disposed(by: disposeBag)
+        }
     }
 
     private func process(remoteFileUrl url: URL, contentType: String, cookies: String, userAgent: String, referrer: String) {