iOS SDK (Swift)

dependencies: [
    .package(url: "https://github.com/Dial-WTF/Dial-iOS-SDK.git", from: "1.0.0")
]

pod 'DialSDK', '~> 1.0'

import DialSDK
 
let dial = DialClient(
    apiKey: "your-api-key",
    walletAddress: "0x..."
)

// Sign message with wallet
let signature = await wallet.sign(message: "Authenticate with Dial")
 
try await dial.authenticate(
    walletAddress: "0x...",
    signature: signature
)

let call = try await dial.calls.start(
    to: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    type: .video
)

import CallKit
import DialSDK
 
class CallManager: NSObject, DialCallDelegate {
    let callKitProvider = CXProvider(configuration: createConfiguration())
    
    func dialDidReceiveIncomingCall(_ call: DialCall) {
        // Automatically displayed in native iOS call UI
        let update = CXCallUpdate()
        update.remoteHandle = CXHandle(type: .generic, value: call.from)
        update.hasVideo = call.type == .video
        
        callKitProvider.reportNewIncomingCall(
            with: call.uuid,
            update: update
        ) { error in
            if let error = error {
                print("Error reporting call: \(error)")
            }
        }
    }
}

import SwiftUI
import DialSDK
 
struct CallView: View {
    @StateObject var callManager = CallManager()
    
    var body: some View {
        VStack {
            if let call = callManager.currentCall {
                if call.status == .ringing {
                    IncomingCallView(call: call)
                } else {
                    ActiveCallView(call: call)
                }
            } else {
                Button("Make Call") {
                    Task {
                        await callManager.startCall(to: "0x...")
                    }
                }
            }
        }
    }
}
 
struct IncomingCallView: View {
    let call: DialCall
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Incoming call from")
            Text(call.from)
                .font(.headline)
            
            HStack(spacing: 40) {
                Button(action: { call.decline() }) {
                    Image(systemName: "phone.down.fill")
                        .foregroundColor(.red)
                }
                
                Button(action: { call.answer() }) {
                    Image(systemName: "phone.fill")
                        .foregroundColor(.green)
                }
            }
            .font(.system(size: 30))
        }
    }
}

import UIKit
import DialSDK
 
class CallViewController: UIViewController {
    let dial = DialClient.shared
    var currentCall: DialCall?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        dial.delegate = self
    }
    
    @IBAction func makeCall(_ sender: UIButton) {
        Task {
            currentCall = try await dial.calls.start(
                to: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
                type: .video
            )
        }
    }
}
 
extension CallViewController: DialClientDelegate {
    func dialDidReceiveIncomingCall(_ call: DialCall) {
        currentCall = call
        presentCallViewController(for: call)
    }
}

// Send message
try await dial.messages.send(
    to: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    content: "Hello!",
    type: .text
)
 
// Listen for messages
dial.messages.onReceived { message in
    print("New message from \(message.from): \(message.content)")
}

import UserNotifications
import DialSDK
 
class AppDelegate: NSObject, UIApplicationDelegate {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        // Register for push notifications
        UNUserNotificationCenter.current().requestAuthorization(
            options: [.alert, .sound, .badge]
        ) { granted, error in
            if granted {
                DispatchQueue.main.async {
                    application.registerForRemoteNotifications()
                }
            }
        }
        
        return true
    }
    
    func application(
        _ application: UIApplication,
        didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
    ) {
        DialClient.shared.registerForPushNotifications(deviceToken: deviceToken)
    }
}

// All API calls support async/await
let call = try await dial.calls.start(to: "0x...", type: .audio)
let messages = try await dial.messages.getHistory(with: "0x...")
let voicemails = try await dial.voicemail.getAll()

import Combine
import DialSDK
 
class CallViewModel: ObservableObject {
    @Published var currentCall: DialCall?
    @Published var messages: [DialMessage] = []
    
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        DialClient.shared.callPublisher
            .sink { [weak self] call in
                self?.currentCall = call
            }
            .store(in: &cancellables)
    }
}

import Intents
import DialSDK
 
class CallIntentHandler: NSObject, CallIntentHandling {
    func handle(intent: CallIntent, completion: @escaping (CallIntentResponse) -> Void) {
        Task {
            let call = try await DialClient.shared.calls.start(
                to: intent.recipient,
                type: .audio
            )
            completion(CallIntentResponse.success(call: call))
        }
    }
}

import WidgetKit
import SwiftUI
import DialSDK
 
struct CallHistoryWidget: Widget {
    let kind: String = "CallHistoryWidget"
    
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            CallHistoryWidgetView(entry: entry)
        }
        .configurationDisplayName("Call History")
        .description("View your recent Dial calls")
    }
}

import CarPlay
import DialSDK
 
class CarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDelegate {
    func templateApplicationScene(
        _ templateApplicationScene: CPTemplateApplicationScene,
        didConnect interfaceController: CPInterfaceController
    ) {
        // Add Dial calling to CarPlay
        let callTemplate = CPListTemplate(
            title: "Dial",
            sections: createCallingSections()
        )
        
        interfaceController.setRootTemplate(callTemplate, animated: true)
    }
}

<key>NSCameraUsageDescription</key>
<string>We need camera access for video calls</string>
 
<key>NSMicrophoneUsageDescription</key>
<string>We need microphone access for calls</string>
 
<key>NSPhotoLibraryUsageDescription</key>
<string>We need photo library access to share images</string>

// Automatically stores auth tokens in Keychain
try await dial.authenticate(
    walletAddress: "0x...",
    signature: signature
)
// Token securely stored in iOS Keychain