target 'YourProjectTarget' do  
  pod 'AtomicXCore'
end

pod install --repo-update

import UIKit
import AtomicXCore

class CallViewController: UIViewController {
    // 1. Create the call screen
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .black
        // 2. Attach CallCoreView to the call screen
        callCoreView = CallCoreView(frame: view.bounds)
        callCoreView?.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        if let callCoreView = callCoreView {
            view.addSubview(callCoreView)
        }
    }
}

import UIKit
import AtomicXCore

class CallViewController: UIViewController {
    private var buttonReject: UIButton?
    private var buttonAccept: UIButton?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .black
        addControlButtons()
    }
  
    private func addControlButtons() {
        let buttonWidth: CGFloat = 80
        let buttonHeight: CGFloat = 80
        let spacing: CGFloat = 60
        let bottomMargin: CGFloat = 100
        let totalWidth = buttonWidth * 2 + spacing
        let startX = (view.bounds.width - totalWidth) / 2
        let buttonY = view.bounds.height - bottomMargin - buttonHeight
        
        // Answer button
        buttonAccept = createButton(
            frame: CGRect(x: startX, y: buttonY, width: buttonWidth, height: buttonHeight),
            title: "Answer",
            backgroundColor: .systemGreen
        )
        buttonAccept?.addTarget(self, action: #selector(touchAcceptButton), for: .touchUpInside)
        view.addSubview(buttonAccept!)
        
        // Reject button
        buttonReject = createButton(
            frame: CGRect(x: startX + buttonWidth + spacing, y: buttonY, width: buttonWidth, height: buttonHeight),
            title: "Reject",
            backgroundColor: .systemRed
        )
        buttonReject?.addTarget(self, action: #selector(touchRejectButton), for: .touchUpInside)
        view.addSubview(buttonReject!)
    }
    
    @objc private func touchAcceptButton() {
        CallStore.shared.accept(completion: nil)
    }
    
    @objc private func touchRejectButton() {
        CallStore.shared.reject(completion: nil)
    }
    
    private func createButton(frame: CGRect, title: String, backgroundColor: UIColor) -> UIButton {
        let button = UIButton(type: .system)
        button.frame = frame
        button.setTitle(title, for: .normal)
        button.setTitleColor(.white, for: .normal)
        button.backgroundColor = backgroundColor
        button.layer.cornerRadius = frame.width / 2
        button.titleLabel?.font = UIFont.systemFont(ofSize: 16)
        return button
    }
}

import UIKit
import AtomicXCore
import Combine

class CallViewController: UIViewController {
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        addListener()
    }
    
    private func addListener() {
        CallStore.shared.callEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] event in
                if case .onCallEnded = event {
                    self?.dismiss(animated: true)
                }
            }
            .store(in: &cancellables)
    }
}

<key>NSCameraUsageDescription</key>
<string>Camera access is required for video calls and group video calls.</string>
<key>NSMicrophoneUsageDescription</key>
<string>Microphone access is required for audio calls, group audio calls, video calls, and group video calls.</string>

import AVFoundation
import UIKit

extension UIViewController {
    // Check microphone permission
    func checkMicrophonePermission(completion: @escaping (Bool) -> Void) {
        let status = AVCaptureDevice.authorizationStatus(for: .audio)
        switch status {
        case .authorized:
            completion(true)
        case .notDetermined:
            AVCaptureDevice.requestAccess(for: .audio) { granted in
                DispatchQueue.main.async {
                    completion(granted)
                }
            }
        case .denied, .restricted:
            completion(false)
        @unknown default:
            completion(false)
        }
    }
    
    // Check camera permission
    func checkCameraPermission(completion: @escaping (Bool) -> Void) {
        let status = AVCaptureDevice.authorizationStatus(for: .video)
        switch status {
        case .authorized:
            completion(true)
        case .notDetermined:
            AVCaptureDevice.requestAccess(for: .video) { granted in
                DispatchQueue.main.async {
                    completion(granted)
                }
            }
        case .denied, .restricted:
            completion(false)
        @unknown default:
            completion(false)
        }
    }
    
    // Show permission alert
    func showPermissionAlert(message: String) {
        let alert = UIAlertController(
            title: "Permission Request",
            message: message,
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "Go to Settings", style: .default) { _ in
            if let url = URL(string: UIApplication.openSettingsURLString) {
                UIApplication.shared.open(url)
            }
        })
        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
        present(alert, animated: true)
    }
}

import UIKit
import AtomicXCore
import Combine
import AVFoundation

class MainViewController: UIViewController {
    private var audioPlayer: AVAudioPlayer?
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        observeSelfStatus()
    }
    
    private func observeSelfStatus() {
        CallStore.shared.state
            .subscribe(StatePublisherSelector<CallState, CallParticipantStatus>(keyPath: \\.selfInfo.status))
            .removeDuplicates()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] status in
                self?.handleRingtoneByStatus(status)
            }
            .store(in: &cancellables)
    }
    
    private func handleRingtoneByStatus(_ status: CallParticipantStatus) {
        switch status {
        case .waiting:
            // Start ringtone while waiting to answer
            // playRingtone()
        case .accept:
            // Stop ringtone after answering
            // stopRingtone()
        default:
            // Stop ringtone for other statuses
            // stopRingtone()
        }
    }
}

import UIKit
import AtomicXCore
import Combine

class MainViewController: UIViewController {
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        addListener()
    }
    
    private func addListener() {
        CallStore.shared.callEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] event in
                if case .onCallReceived(_, let mediaType, _) = event {
                    self?.openDeviceForMediaType(mediaType)
                }
            }
            .store(in: &cancellables)
    }
    
    private func openDeviceForMediaType(_ mediaType: CallMediaType) {
        DeviceStore.shared.openLocalMicrophone(completion: nil)
        if mediaType == .video {
            let isFront = true
            DeviceStore.shared.openLocalCamera(isFront: isFront, completion: nil)
        }
    }
}

import UIKit
import AtomicXCore
import Combine

class MainViewController: UIViewController {
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        addListener()
    }
    
    private func addListener() {
        CallStore.shared.callEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] event in
                if case .onCallReceived(_, _, _) = event {
                    let callVC = CallViewController()
                    callVC.modalPresentationStyle = .fullScreen
                    self?.present(callVC, animated: true)
                }
            }
            .store(in: &cancellables)
    }
}