mirror of
https://github.com/immich-app/immich.git
synced 2026-03-23 02:28:53 +03:00
92bc22620b
add schemas sync variants formatting initial implementation use existing db, wip move to separate folder fix table definitions wip wiring it up repository pattern
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)
|
|
}
|
|
}
|
|
|