呈祥
745 lines
23 KiB
Swift
745 lines
23 KiB
Swift
import Flutter
|
|
import ImageIO
|
|
import Photos
|
|
import UniformTypeIdentifiers
|
|
import UIKit
|
|
|
|
class SceneDelegate: FlutterSceneDelegate {
|
|
private var imageBridge: NativeImageBridge?
|
|
|
|
override func scene(
|
|
_ scene: UIScene,
|
|
willConnectTo session: UISceneSession,
|
|
options connectionOptions: UIScene.ConnectionOptions
|
|
) {
|
|
super.scene(scene, willConnectTo: session, options: connectionOptions)
|
|
|
|
if let controller = window?.rootViewController as? FlutterViewController {
|
|
let bridge = NativeImageBridge(controller: controller)
|
|
imageBridge = bridge
|
|
bridge.handleOpenURLContexts(connectionOptions.urlContexts, notifyFlutter: false)
|
|
}
|
|
}
|
|
|
|
override func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
|
|
super.scene(scene, openURLContexts: URLContexts)
|
|
imageBridge?.handleOpenURLContexts(URLContexts, notifyFlutter: true)
|
|
}
|
|
}
|
|
|
|
private final class NativeImageBridge: NSObject, UIDocumentPickerDelegate, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
|
|
private enum PendingOperation {
|
|
case pickFile(FlutterResult)
|
|
case pickAlbum(FlutterResult)
|
|
}
|
|
|
|
private weak var controller: FlutterViewController?
|
|
private var channel: FlutterMethodChannel?
|
|
private var pendingOperation: PendingOperation?
|
|
private var pendingShareResult: FlutterResult?
|
|
private var pendingSharedImages: [[String: Any]] = []
|
|
private var sources: [String: URL] = [:]
|
|
|
|
init(controller: FlutterViewController) {
|
|
self.controller = controller
|
|
super.init()
|
|
|
|
let channel = FlutterMethodChannel(
|
|
name: "luban_imager/native_images",
|
|
binaryMessenger: controller.binaryMessenger
|
|
)
|
|
self.channel = channel
|
|
channel.setMethodCallHandler { [weak self] call, result in
|
|
self?.handle(call: call, result: result)
|
|
}
|
|
}
|
|
|
|
private func handle(call: FlutterMethodCall, result: @escaping FlutterResult) {
|
|
switch call.method {
|
|
case "pickImages":
|
|
pickImages(result: result)
|
|
case "pickAlbumImage":
|
|
pickAlbumImage(result: result)
|
|
case "takeSharedImages":
|
|
takeSharedImages(result: result)
|
|
case "compressImage":
|
|
compressImage(arguments: call.arguments, result: result)
|
|
case "overwriteOriginal":
|
|
overwriteOriginal(arguments: call.arguments, result: result)
|
|
case "saveToGallery":
|
|
saveToGallery(arguments: call.arguments, result: result)
|
|
case "shareImage":
|
|
shareImage(arguments: call.arguments, result: result)
|
|
default:
|
|
result(FlutterMethodNotImplemented)
|
|
}
|
|
}
|
|
|
|
func handleOpenURLContexts(
|
|
_ URLContexts: Set<UIOpenURLContext>,
|
|
notifyFlutter: Bool
|
|
) {
|
|
let payload = URLContexts.compactMap { context -> [String: Any]? in
|
|
do {
|
|
return try buildSharedImage(sourceURL: context.url)
|
|
} catch {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
guard !payload.isEmpty else {
|
|
return
|
|
}
|
|
|
|
pendingSharedImages = payload
|
|
if notifyFlutter {
|
|
channel?.invokeMethod("sharedImages", arguments: payload)
|
|
}
|
|
}
|
|
|
|
private func takeSharedImages(result: @escaping FlutterResult) {
|
|
let images = pendingSharedImages
|
|
pendingSharedImages.removeAll()
|
|
result(images)
|
|
}
|
|
|
|
private func pickImages(result: @escaping FlutterResult) {
|
|
guard pendingOperation == nil else {
|
|
result(FlutterError(code: "busy", message: "正在选择图片", details: nil))
|
|
return
|
|
}
|
|
|
|
let picker: UIDocumentPickerViewController
|
|
if #available(iOS 14.0, *) {
|
|
picker = UIDocumentPickerViewController(
|
|
forOpeningContentTypes: [UTType.image],
|
|
asCopy: false
|
|
)
|
|
} else {
|
|
picker = UIDocumentPickerViewController(documentTypes: ["public.image"], in: .open)
|
|
}
|
|
picker.allowsMultipleSelection = false
|
|
picker.delegate = self
|
|
pendingOperation = .pickFile(result)
|
|
controller?.present(picker, animated: true)
|
|
}
|
|
|
|
private func pickAlbumImage(result: @escaping FlutterResult) {
|
|
guard pendingOperation == nil else {
|
|
result(FlutterError(code: "busy", message: "正在选择图片", details: nil))
|
|
return
|
|
}
|
|
guard let controller = controller else {
|
|
result(FlutterError(code: "picker_unavailable", message: "无法打开相册", details: nil))
|
|
return
|
|
}
|
|
guard UIImagePickerController.isSourceTypeAvailable(.photoLibrary) else {
|
|
result(FlutterError(code: "picker_unavailable", message: "相册不可用", details: nil))
|
|
return
|
|
}
|
|
|
|
let picker = UIImagePickerController()
|
|
picker.sourceType = .photoLibrary
|
|
picker.mediaTypes = ["public.image"]
|
|
picker.allowsEditing = false
|
|
picker.delegate = self
|
|
pendingOperation = .pickAlbum(result)
|
|
controller.present(picker, animated: true)
|
|
}
|
|
|
|
private func compressImage(arguments: Any?, result: @escaping FlutterResult) {
|
|
guard
|
|
let args = arguments as? [String: Any],
|
|
let sourceHandle = args["sourceHandle"] as? String,
|
|
let sourceURL = sources[sourceHandle]
|
|
else {
|
|
result(FlutterError(code: "bad_args", message: "缺少 sourceHandle", details: nil))
|
|
return
|
|
}
|
|
|
|
DispatchQueue.global(qos: .userInitiated).async { [weak self] in
|
|
guard let self else { return }
|
|
do {
|
|
let payload = try self.compress(sourceURL: sourceURL)
|
|
DispatchQueue.main.async { result(payload) }
|
|
} catch {
|
|
DispatchQueue.main.async {
|
|
result(
|
|
FlutterError(
|
|
code: "compress_failed",
|
|
message: error.localizedDescription,
|
|
details: nil
|
|
)
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func overwriteOriginal(arguments: Any?, result: @escaping FlutterResult) {
|
|
guard
|
|
let args = arguments as? [String: Any],
|
|
let sourceHandle = args["sourceHandle"] as? String,
|
|
let compressedPath = args["compressedPath"] as? String,
|
|
let sourceURL = sources[sourceHandle]
|
|
else {
|
|
result(FlutterError(code: "bad_args", message: "缺少覆盖参数", details: nil))
|
|
return
|
|
}
|
|
|
|
let compressedURL = URL(fileURLWithPath: compressedPath)
|
|
do {
|
|
let data = try Data(contentsOf: compressedURL)
|
|
let scoped = sourceURL.startAccessingSecurityScopedResource()
|
|
defer {
|
|
if scoped {
|
|
sourceURL.stopAccessingSecurityScopedResource()
|
|
}
|
|
}
|
|
try data.write(to: sourceURL)
|
|
result(["overwritten": true, "target": sourceHandle])
|
|
} catch {
|
|
result(
|
|
FlutterError(
|
|
code: "overwrite_failed",
|
|
message: error.localizedDescription,
|
|
details: nil
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
private func shareImage(arguments: Any?, result: @escaping FlutterResult) {
|
|
guard
|
|
let args = arguments as? [String: Any],
|
|
let compressedPath = args["compressedPath"] as? String
|
|
else {
|
|
result(FlutterError(code: "bad_args", message: "缺少 compressedPath", details: nil))
|
|
return
|
|
}
|
|
guard pendingShareResult == nil else {
|
|
result(FlutterError(code: "busy", message: "正在分享", details: nil))
|
|
return
|
|
}
|
|
guard let controller = controller else {
|
|
result(FlutterError(code: "share_unavailable", message: "无法打开分享面板", details: nil))
|
|
return
|
|
}
|
|
|
|
do {
|
|
let sourceURL = URL(fileURLWithPath: compressedPath)
|
|
let suggestedName = args["suggestedName"] as? String ?? sourceURL.lastPathComponent
|
|
let exportURL = try makeExportCopy(sourceURL: sourceURL, suggestedName: suggestedName)
|
|
|
|
let activityController = UIActivityViewController(
|
|
activityItems: [exportURL],
|
|
applicationActivities: nil
|
|
)
|
|
if let popover = activityController.popoverPresentationController,
|
|
let view = controller.view
|
|
{
|
|
popover.sourceView = view
|
|
popover.sourceRect = CGRect(x: view.bounds.midX, y: view.bounds.midY, width: 0, height: 0)
|
|
popover.permittedArrowDirections = []
|
|
}
|
|
pendingShareResult = result
|
|
activityController.completionWithItemsHandler = { [weak self] _, completed, _, error in
|
|
guard let self = self else {
|
|
return
|
|
}
|
|
let pendingResult = self.pendingShareResult
|
|
self.pendingShareResult = nil
|
|
if let error = error {
|
|
pendingResult?(
|
|
FlutterError(code: "share_failed", message: error.localizedDescription, details: nil)
|
|
)
|
|
} else {
|
|
pendingResult?(["shared": completed])
|
|
}
|
|
}
|
|
controller.present(activityController, animated: true)
|
|
} catch {
|
|
result(
|
|
FlutterError(code: "share_failed", message: error.localizedDescription, details: nil)
|
|
)
|
|
}
|
|
}
|
|
|
|
private func saveToGallery(arguments: Any?, result: @escaping FlutterResult) {
|
|
guard
|
|
let args = arguments as? [String: Any],
|
|
let compressedPath = args["compressedPath"] as? String
|
|
else {
|
|
result(FlutterError(code: "bad_args", message: "缺少 compressedPath", details: nil))
|
|
return
|
|
}
|
|
|
|
let sourceURL = URL(fileURLWithPath: compressedPath)
|
|
saveImageToPhotoLibrary(sourceURL: sourceURL, result: result)
|
|
}
|
|
|
|
private func saveImageToPhotoLibrary(
|
|
sourceURL: URL,
|
|
result: @escaping FlutterResult
|
|
) {
|
|
let saveChanges = {
|
|
PHPhotoLibrary.shared().performChanges({
|
|
_ = PHAssetCreationRequest.creationRequestForAssetFromImage(atFileURL: sourceURL)
|
|
}) { success, error in
|
|
DispatchQueue.main.async {
|
|
if let error = error {
|
|
result(FlutterError(code: "save_failed", message: error.localizedDescription, details: nil))
|
|
} else if success {
|
|
result(["saved": true])
|
|
} else {
|
|
result(FlutterError(code: "save_failed", message: "保存到相册失败", details: nil))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if #available(iOS 14.0, *) {
|
|
switch PHPhotoLibrary.authorizationStatus(for: .addOnly) {
|
|
case .authorized, .limited:
|
|
saveChanges()
|
|
case .notDetermined:
|
|
PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in
|
|
if status == .authorized || status == .limited {
|
|
saveChanges()
|
|
} else {
|
|
DispatchQueue.main.async {
|
|
result(FlutterError(code: "photo_denied", message: "没有相册保存权限", details: nil))
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
result(FlutterError(code: "photo_denied", message: "没有相册保存权限", details: nil))
|
|
}
|
|
} else {
|
|
switch PHPhotoLibrary.authorizationStatus() {
|
|
case .authorized:
|
|
saveChanges()
|
|
case .notDetermined:
|
|
PHPhotoLibrary.requestAuthorization { status in
|
|
if status == .authorized {
|
|
saveChanges()
|
|
} else {
|
|
DispatchQueue.main.async {
|
|
result(FlutterError(code: "photo_denied", message: "没有相册保存权限", details: nil))
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
result(FlutterError(code: "photo_denied", message: "没有相册保存权限", details: nil))
|
|
}
|
|
}
|
|
}
|
|
|
|
func documentPicker(
|
|
_ controller: UIDocumentPickerViewController,
|
|
didPickDocumentsAt urls: [URL]
|
|
) {
|
|
guard let operation = pendingOperation else {
|
|
return
|
|
}
|
|
pendingOperation = nil
|
|
|
|
switch operation {
|
|
case .pickFile(let result):
|
|
do {
|
|
if let url = urls.first {
|
|
result([try buildPickedImage(sourceURL: url)])
|
|
} else {
|
|
result([])
|
|
}
|
|
} catch {
|
|
result(
|
|
FlutterError(code: "pick_failed", message: error.localizedDescription, details: nil)
|
|
)
|
|
}
|
|
case .pickAlbum(let result):
|
|
result([])
|
|
}
|
|
}
|
|
|
|
func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
|
|
guard let operation = pendingOperation else {
|
|
return
|
|
}
|
|
pendingOperation = nil
|
|
|
|
switch operation {
|
|
case .pickFile(let result), .pickAlbum(let result):
|
|
result([])
|
|
}
|
|
}
|
|
|
|
func imagePickerController(
|
|
_ picker: UIImagePickerController,
|
|
didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]
|
|
) {
|
|
picker.dismiss(animated: true)
|
|
|
|
guard let operation = pendingOperation else {
|
|
return
|
|
}
|
|
pendingOperation = nil
|
|
|
|
guard case .pickAlbum(let result) = operation else {
|
|
return
|
|
}
|
|
|
|
do {
|
|
if let url = info[.imageURL] as? URL {
|
|
result([try buildGalleryImage(sourceURL: url)])
|
|
return
|
|
}
|
|
if let image = info[.originalImage] as? UIImage {
|
|
result([try buildGalleryImage(image: image)])
|
|
return
|
|
}
|
|
result([])
|
|
} catch {
|
|
result(FlutterError(code: "gallery_pick_failed", message: error.localizedDescription, details: nil))
|
|
}
|
|
}
|
|
|
|
func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
|
|
picker.dismiss(animated: true)
|
|
|
|
guard let operation = pendingOperation else {
|
|
return
|
|
}
|
|
pendingOperation = nil
|
|
|
|
switch operation {
|
|
case .pickFile(let result), .pickAlbum(let result):
|
|
result([])
|
|
}
|
|
}
|
|
|
|
private func buildPickedImage(sourceURL: URL) throws -> [String: Any] {
|
|
let scoped = sourceURL.startAccessingSecurityScopedResource()
|
|
defer {
|
|
if scoped {
|
|
sourceURL.stopAccessingSecurityScopedResource()
|
|
}
|
|
}
|
|
|
|
let id = UUID().uuidString
|
|
sources[id] = sourceURL
|
|
|
|
let previewURL = try copyToCache(
|
|
sourceURL: sourceURL,
|
|
child: "originals",
|
|
preferredName: sourceURL.lastPathComponent
|
|
)
|
|
let dimensions = imageDimensions(for: sourceURL) ?? imageDimensions(for: previewURL)
|
|
let size = fileSize(sourceURL) ?? fileSize(previewURL) ?? 0
|
|
|
|
return [
|
|
"sourceHandle": id,
|
|
"displayName": sourceURL.lastPathComponent.isEmpty
|
|
? "image"
|
|
: sourceURL.lastPathComponent,
|
|
"previewPath": previewURL.path,
|
|
"originalSize": size,
|
|
"width": dimensions?.width ?? 0,
|
|
"height": dimensions?.height ?? 0,
|
|
"canOverwrite": FileManager.default.isWritableFile(atPath: sourceURL.path),
|
|
]
|
|
}
|
|
|
|
private func buildSharedImage(sourceURL: URL) throws -> [String: Any] {
|
|
return try buildCachedReadOnlyImage(sourceURL: sourceURL, child: "shared-originals")
|
|
}
|
|
|
|
private func buildGalleryImage(sourceURL: URL) throws -> [String: Any] {
|
|
return try buildCachedReadOnlyImage(sourceURL: sourceURL, child: "gallery-originals")
|
|
}
|
|
|
|
private func buildGalleryImage(image: UIImage) throws -> [String: Any] {
|
|
let hasAlpha = Self.hasAlpha(image)
|
|
let displayName = hasAlpha ? "album-image.png" : "album-image.jpg"
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(
|
|
"gallery-picker",
|
|
isDirectory: true
|
|
)
|
|
try FileManager.default.createDirectory(
|
|
at: directory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
let targetURL = directory.appendingPathComponent("\(UUID().uuidString)-\(displayName)")
|
|
let data = hasAlpha ? image.pngData() : image.jpegData(compressionQuality: 1)
|
|
guard let data else {
|
|
throw NativeImageError.message("无法读取相册图片")
|
|
}
|
|
try data.write(to: targetURL, options: .atomic)
|
|
return try buildGalleryImage(sourceURL: targetURL)
|
|
}
|
|
|
|
private func buildCachedReadOnlyImage(sourceURL: URL, child: String) throws -> [String: Any] {
|
|
let scoped = sourceURL.startAccessingSecurityScopedResource()
|
|
defer {
|
|
if scoped {
|
|
sourceURL.stopAccessingSecurityScopedResource()
|
|
}
|
|
}
|
|
|
|
let displayName = sourceURL.lastPathComponent.isEmpty
|
|
? "image"
|
|
: sourceURL.lastPathComponent
|
|
let previewURL = try copyToCache(
|
|
sourceURL: sourceURL,
|
|
child: child,
|
|
preferredName: displayName
|
|
)
|
|
let id = UUID().uuidString
|
|
sources[id] = previewURL
|
|
let dimensions = imageDimensions(for: previewURL)
|
|
let size = fileSize(previewURL) ?? 0
|
|
|
|
return [
|
|
"sourceHandle": id,
|
|
"displayName": displayName,
|
|
"previewPath": previewURL.path,
|
|
"originalSize": size,
|
|
"width": dimensions?.width ?? 0,
|
|
"height": dimensions?.height ?? 0,
|
|
"canOverwrite": false,
|
|
]
|
|
}
|
|
|
|
private func compress(sourceURL: URL) throws -> [String: Any] {
|
|
let scoped = sourceURL.startAccessingSecurityScopedResource()
|
|
defer {
|
|
if scoped {
|
|
sourceURL.stopAccessingSecurityScopedResource()
|
|
}
|
|
}
|
|
|
|
let originalData = try Data(contentsOf: sourceURL)
|
|
guard let image = UIImage(data: originalData) else {
|
|
throw NativeImageError.message("无法解码图片")
|
|
}
|
|
|
|
let originalDimensions = imageDimensions(for: sourceURL)
|
|
?? PixelSize(
|
|
width: max(1, Int(image.size.width * image.scale)),
|
|
height: max(1, Int(image.size.height * image.scale))
|
|
)
|
|
let targetDimensions = Self.targetSize(for: originalDimensions)
|
|
let hasAlpha = Self.hasAlpha(image)
|
|
let rendered = Self.render(image: image, target: targetDimensions, opaque: !hasAlpha)
|
|
let preservePng = hasAlpha && originalData.count <= 1_500_000
|
|
let quality = Self.jpegQuality(for: targetDimensions)
|
|
|
|
let encodedData = preservePng
|
|
? rendered.pngData()
|
|
: rendered.jpegData(compressionQuality: quality)
|
|
guard let encoded = encodedData else {
|
|
throw NativeImageError.message("无法生成压缩图片")
|
|
}
|
|
|
|
var outputData = encoded
|
|
var outputDimensions = targetDimensions
|
|
var outputExtension = preservePng ? "png" : "jpg"
|
|
var passthrough = false
|
|
|
|
if encoded.count >= originalData.count {
|
|
outputData = originalData
|
|
outputDimensions = originalDimensions
|
|
outputExtension = sourceURL.pathExtension.isEmpty ? outputExtension : sourceURL.pathExtension
|
|
passthrough = true
|
|
}
|
|
|
|
let outputURL = try makeCompressedURL(
|
|
originalName: sourceURL.deletingPathExtension().lastPathComponent,
|
|
extensionName: outputExtension
|
|
)
|
|
try outputData.write(to: outputURL, options: .atomic)
|
|
|
|
return [
|
|
"path": outputURL.path,
|
|
"outputSize": outputData.count,
|
|
"width": outputDimensions.width,
|
|
"height": outputDimensions.height,
|
|
"passthrough": passthrough,
|
|
]
|
|
}
|
|
|
|
private func copyToCache(
|
|
sourceURL: URL,
|
|
child: String,
|
|
preferredName: String
|
|
) throws -> URL {
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(
|
|
child,
|
|
isDirectory: true
|
|
)
|
|
try FileManager.default.createDirectory(
|
|
at: directory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
let targetURL = directory.appendingPathComponent(
|
|
"\(UUID().uuidString)-\(Self.sanitizeFileName(preferredName))"
|
|
)
|
|
|
|
do {
|
|
try FileManager.default.copyItem(at: sourceURL, to: targetURL)
|
|
} catch {
|
|
let data = try Data(contentsOf: sourceURL)
|
|
try data.write(to: targetURL, options: .atomic)
|
|
}
|
|
return targetURL
|
|
}
|
|
|
|
private func makeCompressedURL(originalName: String, extensionName: String) throws -> URL {
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(
|
|
"compressed",
|
|
isDirectory: true
|
|
)
|
|
try FileManager.default.createDirectory(
|
|
at: directory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
let safeName = Self.sanitizeFileName(originalName.isEmpty ? "image" : originalName)
|
|
return directory.appendingPathComponent("\(UUID().uuidString)-\(safeName).\(extensionName)")
|
|
}
|
|
|
|
private func makeExportCopy(sourceURL: URL, suggestedName: String) throws -> URL {
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(
|
|
"exports",
|
|
isDirectory: true
|
|
)
|
|
try FileManager.default.createDirectory(
|
|
at: directory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
let targetURL = directory.appendingPathComponent(Self.sanitizeFileName(suggestedName))
|
|
if FileManager.default.fileExists(atPath: targetURL.path) {
|
|
try FileManager.default.removeItem(at: targetURL)
|
|
}
|
|
try FileManager.default.copyItem(at: sourceURL, to: targetURL)
|
|
return targetURL
|
|
}
|
|
|
|
private func imageDimensions(for url: URL) -> PixelSize? {
|
|
guard
|
|
let source = CGImageSourceCreateWithURL(url as CFURL, [
|
|
kCGImageSourceShouldCache: false
|
|
] as CFDictionary),
|
|
let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any],
|
|
let width = properties[kCGImagePropertyPixelWidth] as? NSNumber,
|
|
let height = properties[kCGImagePropertyPixelHeight] as? NSNumber
|
|
else {
|
|
return nil
|
|
}
|
|
return PixelSize(width: width.intValue, height: height.intValue)
|
|
}
|
|
|
|
private func fileSize(_ url: URL) -> Int? {
|
|
if let values = try? url.resourceValues(forKeys: [.fileSizeKey]),
|
|
let size = values.fileSize
|
|
{
|
|
return size
|
|
}
|
|
if let attrs = try? FileManager.default.attributesOfItem(atPath: url.path),
|
|
let size = attrs[.size] as? NSNumber
|
|
{
|
|
return size.intValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func targetSize(for source: PixelSize) -> PixelSize {
|
|
let width = max(1, source.width)
|
|
let height = max(1, source.height)
|
|
let longSide = max(width, height)
|
|
let shortSide = min(width, height)
|
|
let aspect = Double(shortSide) / Double(longSide)
|
|
var scale = 1.0
|
|
|
|
if longSide > 10_800 && aspect > 0.25 {
|
|
scale = min(scale, 1440.0 / Double(longSide))
|
|
} else if shortSide > 1440 {
|
|
scale = min(scale, 1440.0 / Double(shortSide))
|
|
}
|
|
|
|
let sourcePixels = Double(width) * Double(height)
|
|
if sourcePixels > 40_960_000 {
|
|
scale = min(scale, 0.5)
|
|
}
|
|
|
|
let scaledPixels = sourcePixels * scale * scale
|
|
if scaledPixels > 10_240_000 {
|
|
scale = min(scale, sqrt(10_240_000 / sourcePixels))
|
|
}
|
|
|
|
return PixelSize(
|
|
width: max(1, Int((Double(width) * scale).rounded(.down))),
|
|
height: max(1, Int((Double(height) * scale).rounded(.down)))
|
|
)
|
|
}
|
|
|
|
private static func jpegQuality(for size: PixelSize) -> CGFloat {
|
|
let megapixels = Double(size.width * size.height) / 1_000_000
|
|
if megapixels < 0.5 {
|
|
return 0.92
|
|
}
|
|
if megapixels < 1.0 {
|
|
return 0.88
|
|
}
|
|
if megapixels < 3.0 {
|
|
return 0.8
|
|
}
|
|
return 0.72
|
|
}
|
|
|
|
private static func render(image: UIImage, target: PixelSize, opaque: Bool) -> UIImage {
|
|
let size = CGSize(width: CGFloat(target.width), height: CGFloat(target.height))
|
|
let format = UIGraphicsImageRendererFormat.default()
|
|
format.scale = 1
|
|
format.opaque = opaque
|
|
return UIGraphicsImageRenderer(size: size, format: format).image { _ in
|
|
image.draw(in: CGRect(origin: .zero, size: size))
|
|
}
|
|
}
|
|
|
|
private static func hasAlpha(_ image: UIImage) -> Bool {
|
|
guard let alpha = image.cgImage?.alphaInfo else {
|
|
return false
|
|
}
|
|
switch alpha {
|
|
case .first, .last, .premultipliedFirst, .premultipliedLast:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
private static func sanitizeFileName(_ name: String) -> String {
|
|
let allowed = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-")
|
|
let sanitized = name.unicodeScalars
|
|
.map { allowed.contains($0) ? String($0) : "_" }
|
|
.joined()
|
|
return sanitized.isEmpty ? "image.jpg" : sanitized
|
|
}
|
|
}
|
|
|
|
private struct PixelSize {
|
|
let width: Int
|
|
let height: Int
|
|
}
|
|
|
|
private enum NativeImageError: LocalizedError {
|
|
case message(String)
|
|
|
|
var errorDescription: String? {
|
|
switch self {
|
|
case .message(let message):
|
|
return message
|
|
}
|
|
}
|
|
}
|