Swift Carrier SDK

// swift-tools-version: 5.9
import PackageDescription

let package = Package(
    name: "CarrierQuickstart",
    platforms: [.iOS(.v15)],
    products: [
        .library(name: "CarrierQuickstart", targets: ["CarrierQuickstart"]),
    ],
    dependencies: [
        .package(url: "https://github.com/0xli/Elastos.CarrierClassic.Swift", exact: "6.1.0"),
    ],
    targets: [
        .target(name: "CarrierQuickstart", dependencies: [
            .product(name: "ElastosCarrierSDK", package: "Elastos.CarrierClassic.Swift"),
        ]),
    ]
)

pod 'ElastosCarrierSDK', :podspec => 'https://raw.githubusercontent.com/0xli/Elastos.CarrierClassic.Swift/6.1.0/ElastosCarrierSDK.podspec'

git clone --branch v6.1.0 https://github.com/0xli/Elastos.NET.Carrier.Native.SDK.git native
mkdir -p native/build/ios-sim-arm64 && cd native/build/ios-sim-arm64
cmake -DIOS_PLATFORM=iphonesimulator -DIOS_ARCH=arm64 \
      -DCMAKE_TOOLCHAIN_FILE=../../cmake/iOSToolchain2.cmake \
      -DCMAKE_BUILD_TYPE=Release -DENABLE_APPS=OFF -DENABLE_TESTS=OFF \
      -DENABLE_SHARED=OFF -DENABLE_STATIC=ON ../..
make -j8 && make install

git clone --branch 6.1.0 https://github.com/0xli/Elastos.CarrierClassic.Swift.git carrier-swift
B=native/build/ios-sim-arm64; D=carrier-swift/NativeDistributions/lib/-iphonesimulator
mkdir -p "$D"
for l in libcarrier.a libcarriersession.a libcarrierfiletrans.a libcjson.a libcrypto.a \
         libcrystal.a libcurl.a libflatccrt.a libpj.a libpjlib-util.a libpjmedia.a \
         libpjnath.a libsodium.a libsrtp.a libssl.a libtls.a libtoxcore.a libz.a; do
  for p in $B/src/carrier/$l $B/src/session/$l $B/src/filetransfer/$l $B/intermediates/lib/$l; do
    [ -f "$p" ] && cp "$p" "$D/$l" && break
  done
done

cd carrier-swift
xcodebuild -project ElastosCarrierSDK.xcodeproj -target ElastosCarrierSDK \
  -configuration Release -sdk iphonesimulator ARCHS=arm64 EXCLUDED_ARCHS= \
  ONLY_ACTIVE_ARCH=NO BUILD_LIBRARY_FOR_DISTRIBUTION=YES SKIP_INSTALL=NO \
  IPHONEOS_DEPLOYMENT_TARGET=15.0 CODE_SIGNING_ALLOWED=NO \
  CONFIGURATION_BUILD_DIR=$PWD/../out/iphonesimulator build
cd ..
xcodebuild -create-xcframework \
  -framework out/iphonesimulator/ElastosCarrierSDK.framework \
  -output ElastosCarrierSDK.xcframework

// swift-tools-version: 5.9
import PackageDescription

let package = Package(
    name: "CarrierQuickstart",
    platforms: [.iOS(.v15)],
    products: [
        .library(name: "CarrierQuickstart", targets: ["CarrierQuickstart"]),
    ],
    targets: [
        // The xcframework you built yourself.
        .binaryTarget(name: "ElastosCarrierSDK", path: "ElastosCarrierSDK.xcframework"),
        .target(name: "CarrierQuickstart", dependencies: ["ElastosCarrierSDK"]),
    ]
)

import Foundation
import ElastosCarrierSDK

/// Receives every Carrier callback. All methods are optional; they run on
/// the SDK's background queue, not the main thread.
public final class QuickstartNode: NSObject, CarrierDelegate {
    public let ready = DispatchSemaphore(value: 0)

    public func connectionStatusDidChange(_ carrier: Carrier,
                                          _ newStatus: CarrierConnectionStatus) {
        print("connection: \(newStatus)")
    }

    public func didBecomeReady(_ carrier: Carrier) {
        print("ready")
        ready.signal()
    }

    public func didReceiveFriendRequest(_ carrier: Carrier, _ userId: String,
                                        _ userInfo: CarrierUserInfo, _ hello: String) {
        print("friend request from \(userId): \(hello)")
        try? carrier.acceptFriend(with: userId)
    }

    public func didReceiveFriendMessage(_ carrier: Carrier, _ from: String, _ data: Data,
                                        _ timestamp: Date, _ isOffline: Bool) {
        print("message from \(from) (offline: \(isOffline)): \(String(decoding: data, as: UTF8.self))")
    }
}

public func makeOptions(dataDir: String) -> CarrierOptions {
    let options = CarrierOptions()
    options.persistentLocation = dataDir        // identity + friend list live here
    options.udpEnabled = true
    options.loglevel = .Warning

    // Bootstrap and Express nodes: config/carrier.conf in the native SDK repo.
    let bootstrap = BootstrapNode()
    bootstrap.ipv4 = "13.58.208.50"
    bootstrap.port = "33445"
    bootstrap.publicKey = "89vny8MrKdDKs7Uta9RdVmspPjnRMdwMmaiEW27pZ7gh"
    options.bootstrapNodes = [bootstrap]        // required: must not be nil

    let express = ExpressNode()
    express.ipv4 = "lens.beagle.chat"
    express.port = "443"
    express.publicKey = "ECbs4GxwGzxGerNkmqDJFibEmevu8jAXqAZtikccvD95"
    options.expressNodes = [express]            // offline (Express) delivery
    return options
}

public func runQuickstart(dataDir: String, waitSeconds: Int = 60) throws {
    print("Carrier version: \(Carrier.getVersion())")

    let delegate = QuickstartNode()
    let carrier = try Carrier.createInstance(options: makeOptions(dataDir: dataDir),
                                             delegate: delegate)
    print("userId:  \(carrier.getUserId())")
    print("address: \(carrier.getAddress())")
    print("address valid: \(Carrier.isValidAddress(carrier.getAddress()))")

    // Identity signatures (XEdDSA): anyone holding the userId can verify.
    let message = Data("hello decent".utf8)
    let signature = try carrier.identitySign(message)
    let ok = Carrier.identityVerify(userId: carrier.getUserId(),
                                    message: message, signature: signature)
    print("signature: \(signature.count) bytes, verifies: \(ok)")

    try carrier.setClientInfo(CarrierClientInfo(protoVersion: 1, platform: "ios",
                                                osVersion: "18", appVersion: "0.1"))

    try carrier.start(iterateInterval: 1000)
    if delegate.ready.wait(timeout: .now() + .seconds(waitSeconds)) == .success {
        print("friends: \(try carrier.getFriends().count)")
    } else {
        print("not ready after \(waitSeconds) s")
    }
    carrier.kill()
    print("killed")
}

Carrier version: 52master
userId:  BZb6K3TqEhpaMXsNZC5f6R9nUjk1caAkg8iGP7TmJidA
address: QDS1fGKx48cgsbMtEbJuHAwYXVkFC3sFtWKgXSgsf5btxqL4toRK
address valid: true
signature: 64 bytes, verifies: true
ready
connection: Connected
friends: 0
killed

func identityBackup(carrier: Carrier) throws -> Data {
    return try carrier.exportSecretKey()   // 32 bytes; keep it in the Keychain
}
func restoreOptions(secretKey: Data, freshDataDir: String) -> CarrierOptions {
    let options = makeOptions(dataDir: freshDataDir)
    options.secret_key = secretKey
    return options
}

func profileSample(carrier: Carrier) throws {
    let me = try carrier.getSelfUserInfo()
    me.name = "Bob"
    me.briefDescription = "testing Carrier on iOS"
    try carrier.setSelfUserInfo(me)
    try carrier.setSelfPresence(.None)
    try carrier.setSelfProfileExt(CarrierProfileExt(avatarUrl: "https://example.com/a.png",
                                                    url: "", ens: "", extra: ""))
}

func friendsSample(carrier: Carrier, friendAddress: String) throws {
    // addFriend takes the friend's *address* (not the userId).
    if Carrier.isValidAddress(friendAddress) {
        try carrier.addFriend(with: friendAddress, withGreeting: "hi, it's me")
    }
    for friend in try carrier.getFriends() {
        print(friend.userId ?? "", friend.name ?? "", friend.status, friend.presence)
    }
    if let friendId = Carrier.getUserIdFromAddress(friendAddress),
       carrier.isFriend(with: friendId) {
        try carrier.setFriendLabel(forFriend: friendId, newLabel: "Alice")
        // try carrier.removeFriend(friendId)
    }
}

func messageSample(carrier: Carrier, friendId: String) throws {
    let payload = Data("hello".utf8)
    let msgId: UInt32 = try carrier.sendFriendMessage(to: friendId, withMessage: payload) { id, state in
        switch state {
        case .ByFriend: print("\(id) delivered to the friend")
        case .Offline:  print("\(id) stored for offline delivery (Express)")
        case .Error:    print("\(id) failed")
        @unknown default: break
        }
    }
    print("queued message \(msgId)")
}

func inviteSample(carrier: Carrier, friendId: String) throws {
    try carrier.sendInviteFriendRequest(to: friendId, withData: "ping") { _, from, status, reason, data in
        print("invite reply from \(from): status \(status) reason \(reason ?? "-") data \(data ?? "-")")
    }
}
// The receiving side gets CarrierDelegate.didReceiveFriendInviteRequest and answers with:
func replyInvite(carrier: Carrier, from: String) throws {
    try carrier.replyFriendInviteRequest(to: from, withStatus: 0, reason: nil, data: "pong")
}

func groupSample(carrier: Carrier, friendId: String) throws -> CarrierGroup {
    let group = try carrier.createGroup()
    try group.setTitle("Team")
    try group.inviteFriend(friendId)
    try group.sendMessage(Data("hello group".utf8))
    return group
}

final class FileSender: NSObject, CarrierFileTransferDelegate {
    let path: String
    init(path: String) { self.path = path }

    func fileTransferStateDidChange(_ fileTransfer: CarrierFileTransfer,
                                    _ newState: CarrierFileTransferConnectionState) {
        print("file transfer: \(newState)")
    }
    // The receiver asked for data starting at `offset`.
    func didReceivePullRequest(_ fileTransfer: CarrierFileTransfer, _ fileId: String, _ offset: UInt64) {
        guard let handle = FileHandle(forReadingAtPath: path) else { return }
        handle.seek(toFileOffset: offset)
        while case let chunk = handle.readData(ofLength: 4096), !chunk.isEmpty {
            try? fileTransfer.sendData(fileId: fileId, withData: chunk)
        }
        handle.closeFile()
    }
}

func fileSendSample(manager: CarrierFileTransferManager, friendId: String, path: String,
                    delegate: FileSender) throws -> CarrierFileTransfer {
    let info = CarrierFileTransferInfo()
    info.fileName = (path as NSString).lastPathComponent
    info.fileSize = (try FileManager.default.attributesOfItem(atPath: path)[.size] as? UInt64) ?? 0
    let transfer = try manager.createFileTransfer(to: friendId, withFileInfo: info, delegate: delegate)
    try transfer.sendConnectionRequest()
    return transfer
}

final class FileReceiver: NSObject, CarrierFileTransferDelegate {
    func didReceiveFileRequest(_ fileTransfer: CarrierFileTransfer, _ fileId: String,
                               _ fileName: String, _ size: UInt64) {
        try? fileTransfer.sendPullRequest(fileId: fileId, withOffset: 0)
    }
    func didReceiveFileTransferData(_ fileTransfer: CarrierFileTransfer, _ fileId: String,
                                    _ data: Data) -> Bool {
        // append `data` to the file being written; return true to keep receiving
        return true
    }
}

/// Accepts incoming file transfers. Keep the manager and the transfers alive.
final class FileInbox {
    private(set) var manager: CarrierFileTransferManager!
    private var transfers: [CarrierFileTransfer] = []
    private let receiver = FileReceiver()

    init(carrier: Carrier) throws {
        manager = try CarrierFileTransferManager.createInstance(carrier: carrier) { [weak self] _, from, fileInfo in
            guard let self,
                  let transfer = try? self.manager.createFileTransfer(to: from, withFileInfo: fileInfo,
                                                                      delegate: self.receiver) else { return }
            try? transfer.acceptConnectionRequest()
            self.transfers.append(transfer)
        }
    }
}

final class StreamHandler: NSObject, CarrierStreamDelegate {
    var onStateChange: ((CarrierStream, CarrierStreamState) -> Void)?
    func streamStateDidChange(_ stream: CarrierStream, _ newState: CarrierStreamState) {
        onStateChange?(stream, newState)
    }
    func didReceiveStreamData(_ stream: CarrierStream, _ data: Data) {
        print("stream \(stream.getStreamId()) got \(data.count) bytes")
    }
}

// Caller: add a stream, send the invite once the stream is Initialized,
// start the session with the callee's SDP, write once Connected.
func openSession(manager: CarrierSessionManager, friendId: String,
                 handler: StreamHandler) throws -> CarrierSession {
    let session = try manager.createSession(to: friendId)
    handler.onStateChange = { stream, state in
        switch state {
        case .Initialized:
            try? session.sendInviteRequest { session, status, reason, sdp in
                guard status == 0, let sdp = sdp else { return print("refused: \(reason ?? "")") }
                try? session.start(remoteSdp: sdp)
            }
        case .Connected:
            _ = try? stream.writeData(Data("hello over a stream".utf8))
        default: break
        }
    }
    _ = try session.addStream(type: .Application, options: [.reliable], delegate: handler)
    return session
}

// Callee: createInstance(carrier:sessionRequestHandler:) receives (carrier, from, sdp).
func acceptSessions(carrier: Carrier, handler: StreamHandler) throws -> CarrierSessionManager {
    var accepted: [CarrierSession] = []
    var manager: CarrierSessionManager?
    manager = try CarrierSessionManager.createInstance(carrier: carrier) { _, from, sdp in
        guard let session = try? manager?.createSession(to: from) else { return }
        accepted.append(session)
        handler.onStateChange = { _, state in
            if state == .Initialized { try? session.replyInviteRequest(with: 0, reason: nil) }
            if state == .TransportReady { try? session.start(remoteSdp: sdp) }
        }
        _ = try? session.addStream(type: .Application, options: [.reliable], delegate: handler)
    }
    return manager!
}

func extensionSample(carrier: Carrier, friendId: String) throws -> CarrierExtension {
    let ext = CarrierExtension(carrier)
    try ext.registerExtension { _, from, data in
        print("extension invite from \(from): \(data ?? "")")
    }
    let turn = try ext.turnServerInfo()
    print("turn:\(turn.server):\(turn.port) user \(turn.username)")
    try ext.sendInviteFriendRequest(to: friendId, withData: "{\"type\":\"offer\"}") { _, from, status, _, data in
        print("reply from \(from): \(status) \(data ?? "")")
    }
    return ext
}