fal-ai / fal-swift Goto Github PK

connection = try! falClient.realtime.connect(
    to: OptimizedLatentConsistency,
    connectionKey: "ReproDemo",
    throttleInterval: .milliseconds(0), // no need to throttle since i'm calling generate in response to a button tap
    onResult: { (result: Result<LcmResponse, Error>) in
        switch result {
        case .success(let data):
            // Can do things with data.requestId here
            print(data.requestId!)
        case .failure(let error):
            // ISSUE: Can't tie this back to the originating request, since there's no way to access request_id
            print(error)
        }
    }
)

GENERATING: <SOME_UUID>
SUCCESS

GENERATING: <SOME_UUID>
nw_connection_copy_connected_local_endpoint_block_invoke [C2] Client called nw_connection_copy_connected_local_endpoint on unconnected nw_connection
nw_connection_copy_connected_remote_endpoint_block_invoke [C2] Client called nw_connection_copy_connected_remote_endpoint on unconnected nw_connection
nw_connection_copy_protocol_metadata_internal_block_invoke [C2] Client called nw_connection_copy_protocol_metadata_internal on unconnected nw_connection
SUCCESS
Connection 3: received failure notification
nw_read_request_report [C3] Receive failed with error "Socket is not connected"
RESULT ERROR Error Domain=NSPOSIXErrorDomain Code=57 "Socket is not connected" UserInfo={NSErrorFailingURLStringKey=https://110602490-lcm-sd15-i2i.gateway.alpha.fal.ai/ws?fal_jwt_token=<SOME_JWT_TOKEN>, NSErrorFailingURLKey=https://110602490-lcm-sd15-i2i.gateway.alpha.fal.ai/ws?fal_jwt_token=<SOME_JWT_TOKEN>}
nw_flow_service_reads [C3 130.211.36.43:443 failed parent-flow (satisfied (Path is satisfied), interface: en0[802.11], ipv4, dns, uses wifi)] No output handler
nw_flow_add_write_request [C3 130.211.36.43:443 failed parent-flow (satisfied (Path is satisfied), interface: en0[802.11], ipv4, dns, uses wifi)] cannot accept write requests
nw_write_request_report [C3] Send failed with error "Socket is not connected"
tcp_input [C3.1.1:3] flags=4 seq=404,865,952, ack=0, win=0 state=8 rcv_nxt=404,865,952, snd_una=102,004,591
tcp_input [C3.1.1:3] flags=4 seq=404,865,952, ack=0, win=0 state=0 rcv_nxt=404,865,952, snd_una=102,004,591
tcp_input [C3.1.1:3] flags=4 seq=404,865,952, ack=0, win=0 state=0 rcv_nxt=404,865,952, snd_una=102,004,591
tcp_input [C3.1.1:3] flags=4 seq=404,865,952, ack=0, win=0 state=0 rcv_nxt=404,865,952, snd_una=102,004,591
tcp_input [C3.1.1:3] flags=4 seq=404,865,952, ack=0, win=0 state=0 rcv_nxt=404,865,952, snd_una=102,004,591

import SwiftUI
import FalClient
import Kingfisher

let falClient = FalClient.withCredentials(.keyPair("\(FAL_KEY_ID):\(FAL_KEY_SECRET)"))

let OptimizedLatentConsistency = "110602490-lcm-sd15-i2i"

struct LcmInput: Encodable {
    let requestId: String
    let prompt: String
    let imageUrl: String
    let seed: Int?
    let syncMode: Bool

    enum CodingKeys: String, CodingKey {
        case requestId = "request_id"
        case prompt
        case imageUrl = "image_url"
        case seed
        case syncMode = "sync_mode"
    }
}

struct LcmImage: Decodable {
    let contentType: String
    let url: String
    let width: CGFloat
    let height: CGFloat

    enum CodingKeys: String, CodingKey {
        case contentType = "content_type"
        case url
        case width
        case height
    }
}

struct LcmResponse: Decodable {
    let requestId: String?
    let seed: Float
    let nsfwContentDetected: [Bool]
    let numInferenceSteps: Int
    let images: [LcmImage]

    enum CodingKeys: String, CodingKey {
        case requestId = "request_id"
        case seed
        case nsfwContentDetected = "nsfw_content_detected"
        case numInferenceSteps = "num_inference_steps"
        case images
    }
}

class ViewModel: ObservableObject {
    @Published var currentImage: Data?
    var connection: RealtimeConnection<LcmInput>?

    init() {
        connection = try! falClient.realtime.connect(
            to: OptimizedLatentConsistency,
            connectionKey: "ReproDemo",
            throttleInterval: .milliseconds(0), // no need to throttle since i'm calling generate in response to a button tap
            onResult: { (result: Result<LcmResponse, Error>) in
                switch result {
                case .success(let data):
                    print("SUCCESS")
                    if let image = data.images.first {
                        let data = try? Data(contentsOf: URL(string: image.url)!)
                        DispatchQueue.main.async {
                            self.currentImage = data
                        }
                    }
                case .failure(let error):
                    print("RESULT ERROR \(error)")
                }
            }
        )
    }

    func generate(_ input: LcmInput) {
        guard let connection = connection else { fatalError("No connection") }
        do {
            try connection.send(input)
        } catch {
            print("SEND ERROR \(error)")
        }
    }
}

struct CanvasView: View {
    @State var strokes: [[CGPoint]] = []
    @State var currentStroke: [CGPoint] = []

    var body: some View {
        Canvas { context, size in
            for stroke in strokes {
                var path = Path()
                path.addSmoothLines(stroke)
                context.stroke(path, with: .color(.black), lineWidth: 5)
            }
            var path = Path()
            path.addSmoothLines(currentStroke)
            context.stroke(path, with: .color(.black), lineWidth: 5)
        }
        .background(Color.canvasBackground)
        .gesture(DragGesture(minimumDistance: 0, coordinateSpace: .local)
            .onChanged({ value in
                currentStroke.append(value.location)
            })
            .onEnded({ value in
                strokes.append(currentStroke)
                currentStroke = []
            })
        )
    }
}

struct ReproView: View {
    @StateObject var model = ViewModel()

    var canvas: some View {
        CanvasView()
            .frame(width: 300, height: 300)
    }

    var body: some View {
        VStack {
            canvas

            if let image = model.currentImage {
                KFImage.data(image, cacheKey: UUID().uuidString)
            }

            Button("Generate") {
                let renderer = ImageRenderer(content: canvas)
                let image = renderer.uiImage!
                let base64 = image.jpegData(compressionQuality: 0.6)!.base64EncodedString()
                let requestId = UUID().uuidString
                print("GENERATING: \(requestId)")
                model.generate(
                    LcmInput(
                        requestId: requestId,
                        prompt: "a moon in a starry night sky",
                        imageUrl: "data:image/jpeg;base64,\(base64)",
                        seed: 6_252_023,
                        syncMode: true
                    )
                )
            }
        }
        .padding()
    }
}

@main
struct ReproApp: SwiftUI.App {
    var body: some Scene {
        WindowGroup {
            ReproView()
        }
    }
}