@ion299/sdk-react-native 0.1.0-beta.1

package/android/src/main/java/com/chatplatform/sdk/ChatSdkFilePickerModule.kt

@@ -0,0 +1,165 @@
+package com.chatplatform.sdk
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.database.Cursor
+import android.net.Uri
+import android.provider.OpenableColumns
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.BaseActivityEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableNativeArray
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+
+class ChatSdkFilePickerModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = NAME
+
+    private var pendingPromise: Promise? = null
+
+    private val activityEventListener = object : BaseActivityEventListener() {
+        override fun onActivityResult(
+            activity: Activity?,
+            requestCode: Int,
+            resultCode: Int,
+            data: Intent?,
+        ) {
+            if (requestCode != REQUEST_CODE) return
+            val promise = pendingPromise ?: return
+            pendingPromise = null
+
+            if (resultCode != Activity.RESULT_OK || data == null) {
+                promise.resolve(null)
+                return
+            }
+
+            try {
+                val context = reactApplicationContext
+                val uris = collectUris(data)
+                if (uris.isEmpty()) {
+                    promise.resolve(null)
+                    return
+                }
+                val result: WritableArray = WritableNativeArray()
+                for (uri in uris) {
+                    val copy = copyToCache(context, uri) ?: continue
+                    val map = Arguments.createMap()
+                    map.putString("uri", Uri.fromFile(copy.file).toString())
+                    map.putString("name", copy.name)
+                    map.putString("mime", copy.mime)
+                    map.putDouble("size", copy.size.toDouble())
+                    result.pushMap(map)
+                }
+                promise.resolve(result)
+            } catch (e: Throwable) {
+                promise.reject("PICKER_ERROR", e.message ?: "Не удалось обработать выбор файлов", e)
+            }
+        }
+    }
+
+    init {
+        reactContext.addActivityEventListener(activityEventListener)
+    }
+
+    @ReactMethod
+    fun pick(options: ReadableMap, promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "Нет активной Activity")
+            return
+        }
+        if (pendingPromise != null) {
+            promise.reject("ALREADY_PICKING", "Пикер файлов уже открыт")
+            return
+        }
+
+        val multiple = if (options.hasKey("multiple")) options.getBoolean("multiple") else false
+        val mimeFilter: Array<String> = readMimeFilter(options)
+
+        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+            addCategory(Intent.CATEGORY_OPENABLE)
+            putExtra(Intent.EXTRA_ALLOW_MULTIPLE, multiple)
+            type = if (mimeFilter.size == 1) mimeFilter[0] else "*/*"
+            if (mimeFilter.size > 1) putExtra(Intent.EXTRA_MIME_TYPES, mimeFilter)
+            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        }
+
+        pendingPromise = promise
+        try {
+            activity.startActivityForResult(intent, REQUEST_CODE)
+        } catch (e: Throwable) {
+            pendingPromise = null
+            promise.reject("PICKER_LAUNCH_FAILED", e.message ?: "Не удалось открыть пикер", e)
+        }
+    }
+
+    private fun readMimeFilter(options: ReadableMap): Array<String> {
+        if (!options.hasKey("mimeFilter")) return arrayOf("*/*")
+        val arr: ReadableArray = options.getArray("mimeFilter") ?: return arrayOf("*/*")
+        if (arr.size() == 0) return arrayOf("*/*")
+        return Array(arr.size()) { i -> arr.getString(i) ?: "*/*" }
+    }
+
+    private fun collectUris(data: Intent): List<Uri> {
+        val clip = data.clipData
+        if (clip != null && clip.itemCount > 0) {
+            return (0 until clip.itemCount).mapNotNull { clip.getItemAt(it).uri }
+        }
+        return listOfNotNull(data.data)
+    }
+
+    private data class CachedFile(val file: File, val name: String, val mime: String, val size: Long)
+
+    private fun copyToCache(context: Context, uri: Uri): CachedFile? {
+        val resolver = context.contentResolver
+        val (name, declaredSize) = queryNameAndSize(resolver, uri)
+        val mime = resolver.getType(uri) ?: "application/octet-stream"
+        val safeName = sanitize(name)
+        val targetDir = File(context.cacheDir, "chat-sdk-picker").apply { mkdirs() }
+        val target = File(targetDir, "${UUID.randomUUID()}_$safeName")
+
+        resolver.openInputStream(uri).use { input ->
+            if (input == null) return null
+            FileOutputStream(target).use { output -> input.copyTo(output) }
+        }
+
+        val size = if (declaredSize > 0) declaredSize else target.length()
+        return CachedFile(target, safeName, mime, size)
+    }
+
+    private fun queryNameAndSize(resolver: android.content.ContentResolver, uri: Uri): Pair<String, Long> {
+        var name = "file"
+        var size = 0L
+        val cursor: Cursor? = resolver.query(uri, null, null, null, null)
+        cursor?.use { c ->
+            if (c.moveToFirst()) {
+                val nameIdx = c.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+                val sizeIdx = c.getColumnIndex(OpenableColumns.SIZE)
+                if (nameIdx >= 0 && !c.isNull(nameIdx)) name = c.getString(nameIdx) ?: name
+                if (sizeIdx >= 0 && !c.isNull(sizeIdx)) size = c.getLong(sizeIdx)
+            }
+        }
+        return name to size
+    }
+
+    private fun sanitize(name: String): String {
+        val cleaned = name.replace(Regex("[/\\\\?%*:|\"<>]"), "_").trim()
+        return if (cleaned.isEmpty()) "file" else cleaned
+    }
+
+    companion object {
+        const val NAME = "ChatSdkFilePicker"
+        private const val REQUEST_CODE = 0x6C1C
+    }
+}

package/android/src/main/java/com/chatplatform/sdk/ChatSdkPackage.kt

@@ -0,0 +1,15 @@
+package com.chatplatform.sdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ChatSdkPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = listOf(
+        ChatSdkFilePickerModule(reactContext),
+        ChatSdkDownloaderModule(reactContext),
+    )
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}

package/android/src/main/res/xml/chat_sdk_file_paths.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <cache-path name="chat_sdk_cache" path="." />
+    <files-path name="chat_sdk_files" path="." />
+    <external-files-path name="chat_sdk_external_files" path="." />
+    <external-cache-path name="chat_sdk_external_cache" path="." />
+</paths>

package/ios/ChatSdkDownloader.m

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(ChatSdkDownloader, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(download:(NSDictionary *)request
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/ChatSdkDownloader.swift

@@ -0,0 +1,141 @@
+import Foundation
+import UIKit
+import React
+
+@objc(ChatSdkDownloader)
+class ChatSdkDownloader: RCTEventEmitter {
+
+    private var listenerCount: Int = 0
+    private var sessions: [String: URLSessionDownloadTask] = [:]
+
+    override init() {
+        super.init()
+    }
+
+    @objc override static func requiresMainQueueSetup() -> Bool { return false }
+    override func supportedEvents() -> [String]! { return ["ChatSdkDownloadProgress"] }
+    override func startObserving() { listenerCount += 1 }
+    override func stopObserving() { listenerCount = max(0, listenerCount - 1) }
+
+    @objc(download:resolver:rejecter:)
+    func download(_ request: NSDictionary,
+                  resolver resolve: @escaping RCTPromiseResolveBlock,
+                  rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let urlString = request["url"] as? String, let url = URL(string: urlString) else {
+            reject("INVALID_URL", "URL не задан", nil)
+            return
+        }
+        let filename = sanitize((request["filename"] as? String) ?? "file")
+        let mime = (request["mime"] as? String) ?? "application/octet-stream"
+        let headers = (request["headers"] as? [String: String]) ?? [:]
+        let id = UUID().uuidString
+
+        var req = URLRequest(url: url)
+        for (k, v) in headers { req.setValue(v, forHTTPHeaderField: k) }
+
+        let delegate = DownloadDelegate(id: id, filename: filename, mime: mime, owner: self) { result in
+            switch result {
+            case .success(let targetUrl):
+                resolve(["id": id, "uri": targetUrl.absoluteString])
+            case .failure(let error):
+                reject("DOWNLOAD_FAILED", error.localizedDescription, error)
+            }
+            self.sessions.removeValue(forKey: id)
+        }
+        let session = URLSession(configuration: .default, delegate: delegate, delegateQueue: nil)
+        let task = session.downloadTask(with: req)
+        sessions[id] = task
+        task.resume()
+    }
+
+    fileprivate func emitProgress(id: String, written: Int64, total: Int64) {
+        guard listenerCount > 0 else { return }
+        sendEvent(withName: "ChatSdkDownloadProgress", body: [
+            "id": id,
+            "bytesWritten": NSNumber(value: written),
+            "totalBytes": NSNumber(value: total),
+        ])
+    }
+
+    fileprivate func presentShareSheet(for url: URL) {
+        DispatchQueue.main.async {
+            guard let root = Self.topViewController() else { return }
+            let activity = UIActivityViewController(activityItems: [url], applicationActivities: nil)
+            if let pop = activity.popoverPresentationController {
+                pop.sourceView = root.view
+                pop.sourceRect = CGRect(x: root.view.bounds.midX, y: root.view.bounds.midY, width: 0, height: 0)
+                pop.permittedArrowDirections = []
+            }
+            root.present(activity, animated: true)
+        }
+    }
+
+    private func sanitize(_ name: String) -> String {
+        let invalid = CharacterSet(charactersIn: "/\\?%*:|\"<>")
+        let cleaned = name.components(separatedBy: invalid).joined(separator: "_")
+        let trimmed = cleaned.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? "file" : trimmed
+    }
+
+    private static func topViewController() -> UIViewController? {
+        for scene in UIApplication.shared.connectedScenes {
+            if let windowScene = scene as? UIWindowScene {
+                for window in windowScene.windows where window.isKeyWindow {
+                    var top = window.rootViewController
+                    while let presented = top?.presentedViewController { top = presented }
+                    return top
+                }
+            }
+        }
+        return nil
+    }
+}
+
+private final class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
+    enum DownloadResult { case success(URL); case failure(Error) }
+
+    let id: String
+    let filename: String
+    let mime: String
+    weak var owner: ChatSdkDownloader?
+    let completion: (DownloadResult) -> Void
+
+    init(id: String, filename: String, mime: String, owner: ChatSdkDownloader, completion: @escaping (DownloadResult) -> Void) {
+        self.id = id
+        self.filename = filename
+        self.mime = mime
+        self.owner = owner
+        self.completion = completion
+    }
+
+    func urlSession(_ session: URLSession,
+                    downloadTask: URLSessionDownloadTask,
+                    didWriteData bytesWritten: Int64,
+                    totalBytesWritten: Int64,
+                    totalBytesExpectedToWrite: Int64) {
+        owner?.emitProgress(id: id, written: totalBytesWritten, total: totalBytesExpectedToWrite)
+    }
+
+    func urlSession(_ session: URLSession,
+                    downloadTask: URLSessionDownloadTask,
+                    didFinishDownloadingTo location: URL) {
+        do {
+            let cache = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+            let dir = cache.appendingPathComponent("chat-sdk-downloads", isDirectory: true)
+            try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+            let target = dir.appendingPathComponent(filename)
+            if FileManager.default.fileExists(atPath: target.path) {
+                try FileManager.default.removeItem(at: target)
+            }
+            try FileManager.default.moveItem(at: location, to: target)
+            owner?.presentShareSheet(for: target)
+            completion(.success(target))
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        if let error = error { completion(.failure(error)) }
+    }
+}

package/ios/ChatSdkFilePicker.m

@@ -0,0 +1,9 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(ChatSdkFilePicker, NSObject)
+
+RCT_EXTERN_METHOD(pick:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/ChatSdkFilePicker.swift

@@ -0,0 +1,161 @@
+import Foundation
+import UIKit
+import MobileCoreServices
+import UniformTypeIdentifiers
+
+@objc(ChatSdkFilePicker)
+class ChatSdkFilePicker: NSObject {
+
+    private var pendingResolve: RCTPromiseResolveBlock?
+    private var pendingReject: RCTPromiseRejectBlock?
+    private var holder: PickerHolder?
+
+    @objc static func requiresMainQueueSetup() -> Bool { return true }
+
+    @objc(pick:resolver:rejecter:)
+    func pick(_ options: NSDictionary,
+              resolver resolve: @escaping RCTPromiseResolveBlock,
+              rejecter reject: @escaping RCTPromiseRejectBlock) {
+        if pendingResolve != nil {
+            reject("ALREADY_PICKING", "Пикер файлов уже открыт", nil)
+            return
+        }
+
+        let multiple = (options["multiple"] as? Bool) ?? false
+        let mimeFilter = (options["mimeFilter"] as? [String]) ?? []
+
+        DispatchQueue.main.async {
+            guard let root = Self.topViewController() else {
+                reject("NO_VIEW_CONTROLLER", "Нет корневого view controller", nil)
+                return
+            }
+
+            self.pendingResolve = resolve
+            self.pendingReject = reject
+
+            let picker: UIDocumentPickerViewController
+            if #available(iOS 14.0, *) {
+                let types = Self.contentTypes(from: mimeFilter)
+                picker = UIDocumentPickerViewController(forOpeningContentTypes: types, asCopy: true)
+            } else {
+                let types = mimeFilter.isEmpty ? [String(kUTTypeItem)] : mimeFilter
+                picker = UIDocumentPickerViewController(documentTypes: types, in: .import)
+            }
+            picker.allowsMultipleSelection = multiple
+
+            let holder = PickerHolder(owner: self)
+            self.holder = holder
+            picker.delegate = holder
+            root.present(picker, animated: true)
+        }
+    }
+
+    fileprivate func finishCancelled() {
+        let resolve = pendingResolve
+        pendingResolve = nil
+        pendingReject = nil
+        holder = nil
+        resolve?(NSNull())
+    }
+
+    fileprivate func finishSuccess(urls: [URL]) {
+        let resolve = pendingResolve
+        let reject = pendingReject
+        pendingResolve = nil
+        pendingReject = nil
+        holder = nil
+
+        do {
+            let items = try urls.map { try Self.copyAndDescribe($0) }
+            resolve?(items)
+        } catch {
+            reject?("PICKER_ERROR", error.localizedDescription, error)
+        }
+    }
+
+    @available(iOS 14.0, *)
+    private static func contentTypes(from mimeFilter: [String]) -> [UTType] {
+        if mimeFilter.isEmpty { return [.item] }
+        let types = mimeFilter.compactMap { UTType(mimeType: $0) }
+        return types.isEmpty ? [.item] : types
+    }
+
+    private static func copyAndDescribe(_ url: URL) throws -> [String: Any] {
+        let needsScope = url.startAccessingSecurityScopedResource()
+        defer { if needsScope { url.stopAccessingSecurityScopedResource() } }
+
+        let cache = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+        let dir = cache.appendingPathComponent("chat-sdk-picker", isDirectory: true)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        let safeName = sanitize(url.lastPathComponent)
+        let target = dir.appendingPathComponent("\(UUID().uuidString)_\(safeName)")
+        if FileManager.default.fileExists(atPath: target.path) {
+            try FileManager.default.removeItem(at: target)
+        }
+        try FileManager.default.copyItem(at: url, to: target)
+
+        let attrs = try FileManager.default.attributesOfItem(atPath: target.path)
+        let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
+
+        return [
+            "uri": target.absoluteString,
+            "name": safeName,
+            "mime": mimeType(for: url.pathExtension),
+            "size": NSNumber(value: size),
+        ]
+    }
+
+    private static func sanitize(_ name: String) -> String {
+        let invalid = CharacterSet(charactersIn: "/\\?%*:|\"<>")
+        let cleaned = name.components(separatedBy: invalid).joined(separator: "_")
+        let trimmed = cleaned.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? "file" : trimmed
+    }
+
+    private static func mimeType(for ext: String) -> String {
+        if ext.isEmpty { return "application/octet-stream" }
+        if #available(iOS 14.0, *) {
+            if let t = UTType(filenameExtension: ext), let m = t.preferredMIMEType {
+                return m
+            }
+            return "application/octet-stream"
+        }
+        let tagClass = kUTTagClassFilenameExtension
+        guard
+            let uti = UTTypeCreatePreferredIdentifierForTag(tagClass, ext as CFString, nil)?.takeRetainedValue(),
+            let mime = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassMIMEType)?.takeRetainedValue() as String?
+        else { return "application/octet-stream" }
+        return mime
+    }
+
+    private static func topViewController() -> UIViewController? {
+        let scenes = UIApplication.shared.connectedScenes
+        for scene in scenes {
+            if let windowScene = scene as? UIWindowScene {
+                for window in windowScene.windows where window.isKeyWindow {
+                    var top = window.rootViewController
+                    while let presented = top?.presentedViewController { top = presented }
+                    return top
+                }
+            }
+        }
+        return nil
+    }
+}
+
+private final class PickerHolder: NSObject, UIDocumentPickerDelegate {
+    weak var owner: ChatSdkFilePicker?
+
+    init(owner: ChatSdkFilePicker) {
+        self.owner = owner
+    }
+
+    func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+        owner?.finishSuccess(urls: urls)
+    }
+
+    func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+        owner?.finishCancelled()
+    }
+}