483 lines
15 KiB
Swift
483 lines
15 KiB
Swift
// Autogenerated from Pigeon (v26.0.2), do not edit directly.
|
|
// See also: https://pub.dev/packages/pigeon
|
|
|
|
import Foundation
|
|
|
|
#if os(iOS)
|
|
import Flutter
|
|
#elseif os(macOS)
|
|
import FlutterMacOS
|
|
#else
|
|
#error("Unsupported platform.")
|
|
#endif
|
|
|
|
private func wrapResult(_ result: Any?) -> [Any?] {
|
|
return [result]
|
|
}
|
|
|
|
private func wrapError(_ error: Any) -> [Any?] {
|
|
if let pigeonError = error as? PigeonError {
|
|
return [
|
|
pigeonError.code,
|
|
pigeonError.message,
|
|
pigeonError.details,
|
|
]
|
|
}
|
|
if let flutterError = error as? FlutterError {
|
|
return [
|
|
flutterError.code,
|
|
flutterError.message,
|
|
flutterError.details,
|
|
]
|
|
}
|
|
return [
|
|
"\(error)",
|
|
"\(type(of: error))",
|
|
"Stacktrace: \(Thread.callStackSymbols)",
|
|
]
|
|
}
|
|
|
|
private func isNullish(_ value: Any?) -> Bool {
|
|
return value is NSNull || value == nil
|
|
}
|
|
|
|
private func nilOrValue<T>(_ value: Any?) -> T? {
|
|
if value is NSNull { return nil }
|
|
return value as! T?
|
|
}
|
|
|
|
func deepEqualsUploadTask(_ lhs: Any?, _ rhs: Any?) -> Bool {
|
|
let cleanLhs = nilOrValue(lhs) as Any?
|
|
let cleanRhs = nilOrValue(rhs) as Any?
|
|
switch (cleanLhs, cleanRhs) {
|
|
case (nil, nil):
|
|
return true
|
|
|
|
case (nil, _), (_, nil):
|
|
return false
|
|
|
|
case is (Void, Void):
|
|
return true
|
|
|
|
case let (cleanLhsHashable, cleanRhsHashable) as (AnyHashable, AnyHashable):
|
|
return cleanLhsHashable == cleanRhsHashable
|
|
|
|
case let (cleanLhsArray, cleanRhsArray) as ([Any?], [Any?]):
|
|
guard cleanLhsArray.count == cleanRhsArray.count else { return false }
|
|
for (index, element) in cleanLhsArray.enumerated() {
|
|
if !deepEqualsUploadTask(element, cleanRhsArray[index]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
|
|
case let (cleanLhsDictionary, cleanRhsDictionary) as ([AnyHashable: Any?], [AnyHashable: Any?]):
|
|
guard cleanLhsDictionary.count == cleanRhsDictionary.count else { return false }
|
|
for (key, cleanLhsValue) in cleanLhsDictionary {
|
|
guard cleanRhsDictionary.index(forKey: key) != nil else { return false }
|
|
if !deepEqualsUploadTask(cleanLhsValue, cleanRhsDictionary[key]!) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
|
|
default:
|
|
// Any other type shouldn't be able to be used with pigeon. File an issue if you find this to be untrue.
|
|
return false
|
|
}
|
|
}
|
|
|
|
func deepHashUploadTask(value: Any?, hasher: inout Hasher) {
|
|
if let valueList = value as? [AnyHashable] {
|
|
for item in valueList { deepHashUploadTask(value: item, hasher: &hasher) }
|
|
return
|
|
}
|
|
|
|
if let valueDict = value as? [AnyHashable: AnyHashable] {
|
|
for key in valueDict.keys {
|
|
hasher.combine(key)
|
|
deepHashUploadTask(value: valueDict[key]!, hasher: &hasher)
|
|
}
|
|
return
|
|
}
|
|
|
|
if let hashableValue = value as? AnyHashable {
|
|
hasher.combine(hashableValue.hashValue)
|
|
}
|
|
|
|
return hasher.combine(String(describing: value))
|
|
}
|
|
|
|
|
|
|
|
enum UploadApiErrorCode: Int {
|
|
case unknown = 0
|
|
case assetNotFound = 1
|
|
case fileNotFound = 2
|
|
case resourceNotFound = 3
|
|
case invalidResource = 4
|
|
case encodingFailed = 5
|
|
case writeFailed = 6
|
|
case notEnoughSpace = 7
|
|
case networkError = 8
|
|
case photosInternalError = 9
|
|
case photosUnknownError = 10
|
|
case interrupted = 11
|
|
case cancelled = 12
|
|
case downloadStalled = 13
|
|
case forceQuit = 14
|
|
case outOfResources = 15
|
|
case backgroundUpdatesDisabled = 16
|
|
case uploadTimeout = 17
|
|
case iCloudRateLimit = 18
|
|
case iCloudThrottled = 19
|
|
case invalidResponse = 20
|
|
case badRequest = 21
|
|
case internalServerError = 22
|
|
case unauthorized = 23
|
|
}
|
|
|
|
enum UploadApiStatus: Int {
|
|
case downloadPending = 0
|
|
case downloadQueued = 1
|
|
case downloadFailed = 2
|
|
case uploadPending = 3
|
|
case uploadQueued = 4
|
|
case uploadFailed = 5
|
|
case uploadComplete = 6
|
|
case uploadSkipped = 7
|
|
}
|
|
|
|
/// Generated class from Pigeon that represents data sent in messages.
|
|
struct UploadApiTaskStatus: Hashable {
|
|
var id: String
|
|
var filename: String
|
|
var status: UploadApiStatus
|
|
var errorCode: UploadApiErrorCode? = nil
|
|
var httpStatusCode: Int64? = nil
|
|
|
|
|
|
// swift-format-ignore: AlwaysUseLowerCamelCase
|
|
static func fromList(_ pigeonVar_list: [Any?]) -> UploadApiTaskStatus? {
|
|
let id = pigeonVar_list[0] as! String
|
|
let filename = pigeonVar_list[1] as! String
|
|
let status = pigeonVar_list[2] as! UploadApiStatus
|
|
let errorCode: UploadApiErrorCode? = nilOrValue(pigeonVar_list[3])
|
|
let httpStatusCode: Int64? = nilOrValue(pigeonVar_list[4])
|
|
|
|
return UploadApiTaskStatus(
|
|
id: id,
|
|
filename: filename,
|
|
status: status,
|
|
errorCode: errorCode,
|
|
httpStatusCode: httpStatusCode
|
|
)
|
|
}
|
|
func toList() -> [Any?] {
|
|
return [
|
|
id,
|
|
filename,
|
|
status,
|
|
errorCode,
|
|
httpStatusCode,
|
|
]
|
|
}
|
|
static func == (lhs: UploadApiTaskStatus, rhs: UploadApiTaskStatus) -> Bool {
|
|
return deepEqualsUploadTask(lhs.toList(), rhs.toList()) }
|
|
func hash(into hasher: inout Hasher) {
|
|
deepHashUploadTask(value: toList(), hasher: &hasher)
|
|
}
|
|
}
|
|
|
|
/// Generated class from Pigeon that represents data sent in messages.
|
|
struct UploadApiTaskProgress: Hashable {
|
|
var id: String
|
|
var progress: Double
|
|
var speed: Double? = nil
|
|
var totalBytes: Int64? = nil
|
|
|
|
|
|
// swift-format-ignore: AlwaysUseLowerCamelCase
|
|
static func fromList(_ pigeonVar_list: [Any?]) -> UploadApiTaskProgress? {
|
|
let id = pigeonVar_list[0] as! String
|
|
let progress = pigeonVar_list[1] as! Double
|
|
let speed: Double? = nilOrValue(pigeonVar_list[2])
|
|
let totalBytes: Int64? = nilOrValue(pigeonVar_list[3])
|
|
|
|
return UploadApiTaskProgress(
|
|
id: id,
|
|
progress: progress,
|
|
speed: speed,
|
|
totalBytes: totalBytes
|
|
)
|
|
}
|
|
func toList() -> [Any?] {
|
|
return [
|
|
id,
|
|
progress,
|
|
speed,
|
|
totalBytes,
|
|
]
|
|
}
|
|
static func == (lhs: UploadApiTaskProgress, rhs: UploadApiTaskProgress) -> Bool {
|
|
return deepEqualsUploadTask(lhs.toList(), rhs.toList()) }
|
|
func hash(into hasher: inout Hasher) {
|
|
deepHashUploadTask(value: toList(), hasher: &hasher)
|
|
}
|
|
}
|
|
|
|
private class UploadTaskPigeonCodecReader: FlutterStandardReader {
|
|
override func readValue(ofType type: UInt8) -> Any? {
|
|
switch type {
|
|
case 129:
|
|
let enumResultAsInt: Int? = nilOrValue(self.readValue() as! Int?)
|
|
if let enumResultAsInt = enumResultAsInt {
|
|
return UploadApiErrorCode(rawValue: enumResultAsInt)
|
|
}
|
|
return nil
|
|
case 130:
|
|
let enumResultAsInt: Int? = nilOrValue(self.readValue() as! Int?)
|
|
if let enumResultAsInt = enumResultAsInt {
|
|
return UploadApiStatus(rawValue: enumResultAsInt)
|
|
}
|
|
return nil
|
|
case 131:
|
|
return UploadApiTaskStatus.fromList(self.readValue() as! [Any?])
|
|
case 132:
|
|
return UploadApiTaskProgress.fromList(self.readValue() as! [Any?])
|
|
default:
|
|
return super.readValue(ofType: type)
|
|
}
|
|
}
|
|
}
|
|
|
|
private class UploadTaskPigeonCodecWriter: FlutterStandardWriter {
|
|
override func writeValue(_ value: Any) {
|
|
if let value = value as? UploadApiErrorCode {
|
|
super.writeByte(129)
|
|
super.writeValue(value.rawValue)
|
|
} else if let value = value as? UploadApiStatus {
|
|
super.writeByte(130)
|
|
super.writeValue(value.rawValue)
|
|
} else if let value = value as? UploadApiTaskStatus {
|
|
super.writeByte(131)
|
|
super.writeValue(value.toList())
|
|
} else if let value = value as? UploadApiTaskProgress {
|
|
super.writeByte(132)
|
|
super.writeValue(value.toList())
|
|
} else {
|
|
super.writeValue(value)
|
|
}
|
|
}
|
|
}
|
|
|
|
private class UploadTaskPigeonCodecReaderWriter: FlutterStandardReaderWriter {
|
|
override func reader(with data: Data) -> FlutterStandardReader {
|
|
return UploadTaskPigeonCodecReader(data: data)
|
|
}
|
|
|
|
override func writer(with data: NSMutableData) -> FlutterStandardWriter {
|
|
return UploadTaskPigeonCodecWriter(data: data)
|
|
}
|
|
}
|
|
|
|
class UploadTaskPigeonCodec: FlutterStandardMessageCodec, @unchecked Sendable {
|
|
static let shared = UploadTaskPigeonCodec(readerWriter: UploadTaskPigeonCodecReaderWriter())
|
|
}
|
|
|
|
var uploadTaskPigeonMethodCodec = FlutterStandardMethodCodec(readerWriter: UploadTaskPigeonCodecReaderWriter());
|
|
|
|
|
|
/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
|
|
protocol UploadApi {
|
|
func initialize(completion: @escaping (Result<Void, Error>) -> Void)
|
|
func refresh(completion: @escaping (Result<Void, Error>) -> Void)
|
|
func cancelAll(completion: @escaping (Result<Void, Error>) -> Void)
|
|
func enqueueAssets(localIds: [String], completion: @escaping (Result<Void, Error>) -> Void)
|
|
func enqueueFiles(paths: [String], completion: @escaping (Result<Void, Error>) -> Void)
|
|
func onConfigChange(key: Int64, completion: @escaping (Result<Void, Error>) -> Void)
|
|
}
|
|
|
|
/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
|
|
class UploadApiSetup {
|
|
static var codec: FlutterStandardMessageCodec { UploadTaskPigeonCodec.shared }
|
|
/// Sets up an instance of `UploadApi` to handle messages through the `binaryMessenger`.
|
|
static func setUp(binaryMessenger: FlutterBinaryMessenger, api: UploadApi?, messageChannelSuffix: String = "") {
|
|
let channelSuffix = messageChannelSuffix.count > 0 ? ".\(messageChannelSuffix)" : ""
|
|
let initializeChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.initialize\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
|
|
if let api = api {
|
|
initializeChannel.setMessageHandler { _, reply in
|
|
api.initialize { result in
|
|
switch result {
|
|
case .success:
|
|
reply(wrapResult(nil))
|
|
case .failure(let error):
|
|
reply(wrapError(error))
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
initializeChannel.setMessageHandler(nil)
|
|
}
|
|
let refreshChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.refresh\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
|
|
if let api = api {
|
|
refreshChannel.setMessageHandler { _, reply in
|
|
api.refresh { result in
|
|
switch result {
|
|
case .success:
|
|
reply(wrapResult(nil))
|
|
case .failure(let error):
|
|
reply(wrapError(error))
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
refreshChannel.setMessageHandler(nil)
|
|
}
|
|
let cancelAllChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.cancelAll\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
|
|
if let api = api {
|
|
cancelAllChannel.setMessageHandler { _, reply in
|
|
api.cancelAll { result in
|
|
switch result {
|
|
case .success:
|
|
reply(wrapResult(nil))
|
|
case .failure(let error):
|
|
reply(wrapError(error))
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
cancelAllChannel.setMessageHandler(nil)
|
|
}
|
|
let enqueueAssetsChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.enqueueAssets\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
|
|
if let api = api {
|
|
enqueueAssetsChannel.setMessageHandler { message, reply in
|
|
let args = message as! [Any?]
|
|
let localIdsArg = args[0] as! [String]
|
|
api.enqueueAssets(localIds: localIdsArg) { result in
|
|
switch result {
|
|
case .success:
|
|
reply(wrapResult(nil))
|
|
case .failure(let error):
|
|
reply(wrapError(error))
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
enqueueAssetsChannel.setMessageHandler(nil)
|
|
}
|
|
let enqueueFilesChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.enqueueFiles\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
|
|
if let api = api {
|
|
enqueueFilesChannel.setMessageHandler { message, reply in
|
|
let args = message as! [Any?]
|
|
let pathsArg = args[0] as! [String]
|
|
api.enqueueFiles(paths: pathsArg) { result in
|
|
switch result {
|
|
case .success:
|
|
reply(wrapResult(nil))
|
|
case .failure(let error):
|
|
reply(wrapError(error))
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
enqueueFilesChannel.setMessageHandler(nil)
|
|
}
|
|
let onConfigChangeChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.onConfigChange\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
|
|
if let api = api {
|
|
onConfigChangeChannel.setMessageHandler { message, reply in
|
|
let args = message as! [Any?]
|
|
let keyArg = args[0] as! Int64
|
|
api.onConfigChange(key: keyArg) { result in
|
|
switch result {
|
|
case .success:
|
|
reply(wrapResult(nil))
|
|
case .failure(let error):
|
|
reply(wrapError(error))
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
onConfigChangeChannel.setMessageHandler(nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
private class PigeonStreamHandler<ReturnType>: NSObject, FlutterStreamHandler {
|
|
private let wrapper: PigeonEventChannelWrapper<ReturnType>
|
|
private var pigeonSink: PigeonEventSink<ReturnType>? = nil
|
|
|
|
init(wrapper: PigeonEventChannelWrapper<ReturnType>) {
|
|
self.wrapper = wrapper
|
|
}
|
|
|
|
func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink)
|
|
-> FlutterError?
|
|
{
|
|
pigeonSink = PigeonEventSink<ReturnType>(events)
|
|
wrapper.onListen(withArguments: arguments, sink: pigeonSink!)
|
|
return nil
|
|
}
|
|
|
|
func onCancel(withArguments arguments: Any?) -> FlutterError? {
|
|
pigeonSink = nil
|
|
wrapper.onCancel(withArguments: arguments)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
class PigeonEventChannelWrapper<ReturnType> {
|
|
func onListen(withArguments arguments: Any?, sink: PigeonEventSink<ReturnType>) {}
|
|
func onCancel(withArguments arguments: Any?) {}
|
|
}
|
|
|
|
class PigeonEventSink<ReturnType> {
|
|
private let sink: FlutterEventSink
|
|
|
|
init(_ sink: @escaping FlutterEventSink) {
|
|
self.sink = sink
|
|
}
|
|
|
|
func success(_ value: ReturnType) {
|
|
sink(value)
|
|
}
|
|
|
|
func error(code: String, message: String?, details: Any?) {
|
|
sink(FlutterError(code: code, message: message, details: details))
|
|
}
|
|
|
|
func endOfStream() {
|
|
sink(FlutterEndOfEventStream)
|
|
}
|
|
|
|
}
|
|
|
|
class StreamStatusStreamHandler: PigeonEventChannelWrapper<UploadApiTaskStatus> {
|
|
static func register(with messenger: FlutterBinaryMessenger,
|
|
instanceName: String = "",
|
|
streamHandler: StreamStatusStreamHandler) {
|
|
var channelName = "dev.flutter.pigeon.immich_mobile.UploadFlutterApi.streamStatus"
|
|
if !instanceName.isEmpty {
|
|
channelName += ".\(instanceName)"
|
|
}
|
|
let internalStreamHandler = PigeonStreamHandler<UploadApiTaskStatus>(wrapper: streamHandler)
|
|
let channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: uploadTaskPigeonMethodCodec)
|
|
channel.setStreamHandler(internalStreamHandler)
|
|
}
|
|
}
|
|
|
|
class StreamProgressStreamHandler: PigeonEventChannelWrapper<UploadApiTaskProgress> {
|
|
static func register(with messenger: FlutterBinaryMessenger,
|
|
instanceName: String = "",
|
|
streamHandler: StreamProgressStreamHandler) {
|
|
var channelName = "dev.flutter.pigeon.immich_mobile.UploadFlutterApi.streamProgress"
|
|
if !instanceName.isEmpty {
|
|
channelName += ".\(instanceName)"
|
|
}
|
|
let internalStreamHandler = PigeonStreamHandler<UploadApiTaskProgress>(wrapper: streamHandler)
|
|
let channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: uploadTaskPigeonMethodCodec)
|
|
channel.setStreamHandler(internalStreamHandler)
|
|
}
|
|
}
|
|
|