permissionkit

import PermissionKit

import PermissionKit
 
func needsPermissionPrompt(for handle: CommunicationHandle) async -> Bool {
    let limits = CommunicationLimits.current
    let isKnown = await limits.isKnownHandle(handle)
    return !isKnown
}
 
// Check multiple handles at once.
func filterKnownHandles(_ handles: Set<CommunicationHandle>) async -> Set<CommunicationHandle> {
    guard Bundle.main.bundleIdentifier?.isEmpty == false else { return [] }
 
    let limits = CommunicationLimits.current
    return await limits.knownHandles(in: handles)
}

let phoneHandle = CommunicationHandle(
    value: "+1234567890",
    kind: .phoneNumber
)
 
let emailHandle = CommunicationHandle(
    value: "friend@example.com",
    kind: .emailAddress
)
 
let customHandle = CommunicationHandle(
    value: "user123",
    kind: .custom
)

// Question for a single contact
let handle = CommunicationHandle(value: "+1234567890", kind: .phoneNumber)
let question = PermissionQuestion<CommunicationTopic>(handle: handle)
 
// Question for multiple contacts
let handles = [
    CommunicationHandle(value: "+1234567890", kind: .phoneNumber),
    CommunicationHandle(value: "friend@example.com", kind: .emailAddress)
]
let multiQuestion = PermissionQuestion<CommunicationTopic>(handles: handles)

let personInfo = CommunicationTopic.PersonInformation(
    handle: CommunicationHandle(value: "+1234567890", kind: .phoneNumber),
    nameComponents: {
        var name = PersonNameComponents()
        name.givenName = "Alex"
        name.familyName = "Smith"
        return name
    }(),
    avatarImage: nil
)
 
let topic = CommunicationTopic(
    personInformation: [personInfo],
    actions: [.message, .audioCall]
)
 
let question = PermissionQuestion<CommunicationTopic>(communicationTopic: topic)

import PermissionKit
 
func requestPermission(
    for question: PermissionQuestion<CommunicationTopic>,
    in viewController: UIViewController
) async {
    do {
        try await AskCenter.shared.ask(question, in: viewController)
        // Question send flow was started; wait for responses(for:) separately.
    } catch let error as AskError {
        switch error {
        case .communicationLimitsNotEnabled:
            // Communication limits not active -- continue with normal app flow.
            break
        case .contactSyncNotSetup:
            // Contact sync not configured
            break
        case .invalidQuestion:
            // Question is malformed
            break
        case .notAvailable:
            // PermissionKit not available on this device
            break
        case .systemError(let underlying):
            print("System error: \(underlying)")
        case .unknown:
            break
        @unknown default:
            break
        }
    }
}

import SwiftUI
import PermissionKit
 
struct ContactPermissionView: View {
    let handle = CommunicationHandle(value: "+1234567890", kind: .phoneNumber)
 
    var body: some View {
        let question = PermissionQuestion<CommunicationTopic>(handle: handle)
 
        PermissionButton(question: question) {
            Label("Ask to Message", systemImage: "message")
        }
    }
}

enum PermissionRequestState {
    case pending, approved, denied, expired
}
 
var requestStates: [UUID: PermissionRequestState] = [:]
 
func expireIfStillPending(_ id: UUID) {
    guard requestStates[id] == .pending else { return }
    requestStates[id] = .expired
    // Re-enable asking or show retry/canceled UI.
}
 
func observeResponses() async {
    let responses = AskCenter.shared.responses(for: CommunicationTopic.self)
 
    for await response in responses {
        let choice = response.choice
        let question = response.question
 
        switch choice.answer {
        case .approval:
            // Parent approved -- enable communication
            requestStates[question.id] = .approved
            print("Approved for topic: \(question.topic)")
        case .denial:
            // Parent denied -- keep restriction
            requestStates[question.id] = .denied
            print("Denied")
        @unknown default:
            break
        }
    }
}

let choice: PermissionChoice = response.choice
print("Answer: \(choice.answer)")  // .approval or .denial
print("Choice ID: \(choice.id)")
print("Title: \(choice.title)")
 
// Convenience statics
let approved = PermissionChoice.approve
let declined = PermissionChoice.decline

let updateTopic = SignificantAppUpdateTopic(
    description: "This update adds multiplayer chat features"
)
 
let question = PermissionQuestion<SignificantAppUpdateTopic>(
    significantAppUpdateTopic: updateTopic
)
 
// Present the question
try await AskCenter.shared.ask(question, in: viewController)
requestStates[question.id] = .pending
scheduleExpiration(for: question.id)
 
// Listen for responses
for await response in AskCenter.shared.responses(for: SignificantAppUpdateTopic.self) {
    switch response.choice.answer {
    case .approval:
        // Proceed with update
        requestStates[response.question.id] = .approved
    case .denial:
        // Skip update
        requestStates[response.question.id] = .denied
    @unknown default:
        break
    }
}
 
// If no response arrives before your pending window expires, keep the update
// blocked or offer a retry. Child cancellation produces no denial response.