g3-native-plugins 0.4.2

Dioxus plugins for mobile permissions, auth, storage, purchases, media, notifications, over-the-air updates, deep links, and platform integration.
Documentation
import Foundation
import AuthenticationServices
import CryptoKit
import UIKit

@objc(AuthPlugin)
public class AuthPlugin: NSObject {
    private var coordinator: AppleSignInCoordinator?
    private var controller: ASAuthorizationController?
    private var pendingResult: String?
    private var isAwaiting = false

    @objc
    public func startAppleAuthFromRust(_ requestJson: String) -> String? {
        guard let data = requestJson.data(using: .utf8),
              let request = try? JSONDecoder().decode(AppleAuthRequest.self, from: data),
              !request.state.isEmpty,
              !request.nonce.isEmpty else {
            setPendingResult(nil)
            return nil
        }

        DispatchQueue.main.async { [weak self] in
            self?.startAppleAuthOnMainThread(request)
        }
        return nil
    }

    @objc
    public func getPendingResult() -> String? {
        let result = pendingResult
        pendingResult = nil
        return result
    }

    @objc
    public func getAuthState() -> String? {
        isAwaiting ? "awaiting" : "idle"
    }

    func setPendingResult(_ result: String?) {
        DispatchQueue.main.async {
            self.pendingResult = result
            self.isAwaiting = false
            self.controller = nil
            self.coordinator = nil
        }
    }

    private func startAppleAuthOnMainThread(_ authRequest: AppleAuthRequest) {
        pendingResult = nil
        isAwaiting = true

        let provider = ASAuthorizationAppleIDProvider()
        let request = provider.createRequest()
        request.requestedScopes = [.fullName, .email]
        request.state = authRequest.state
        request.nonce = Self.sha256(authRequest.nonce)

        let controller = ASAuthorizationController(authorizationRequests: [request])
        let coordinator = AppleSignInCoordinator(plugin: self)
        self.controller = controller
        self.coordinator = coordinator
        controller.delegate = coordinator
        controller.presentationContextProvider = coordinator
        controller.performRequests()
    }

    private static func sha256(_ value: String) -> String {
        SHA256.hash(data: Data(value.utf8)).map { String(format: "%02x", $0) }.joined()
    }
}

private struct AppleAuthRequest: Decodable {
    let state: String
    let nonce: String
}

private final class AppleSignInCoordinator: NSObject, ASAuthorizationControllerDelegate,
    ASAuthorizationControllerPresentationContextProviding
{
    private let plugin: AuthPlugin

    init(plugin: AuthPlugin) {
        self.plugin = plugin
    }

    func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor {
        for scene in UIApplication.shared.connectedScenes {
            guard let windowScene = scene as? UIWindowScene,
                  windowScene.activationState == .foregroundActive else {
                continue
            }
            if let window = windowScene.windows.first(where: \.isKeyWindow) {
                return window
            }
            if let window = windowScene.windows.first {
                return window
            }
        }

        for scene in UIApplication.shared.connectedScenes {
            if let window = (scene as? UIWindowScene)?.windows.first {
                return window
            }
        }

        return ASPresentationAnchor()
    }

    func authorizationController(
        controller: ASAuthorizationController,
        didCompleteWithAuthorization authorization: ASAuthorization
    ) {
        guard let credential = authorization.credential as? ASAuthorizationAppleIDCredential,
              let tokenData = credential.identityToken,
              let identityToken = String(data: tokenData, encoding: .utf8),
              let codeData = credential.authorizationCode,
              let authorizationCode = String(data: codeData, encoding: .utf8),
              let state = credential.state,
              !state.isEmpty else {
            plugin.setPendingResult(nil)
            return
        }

        var payload: [String: String] = [
            "identity_token": identityToken,
            "authorization_code": authorizationCode,
            "state": state,
        ]

        if let email = credential.email, !email.isEmpty {
            payload["email"] = email
        }

        let name = [credential.fullName?.givenName, credential.fullName?.familyName]
            .compactMap { $0 }
            .joined(separator: " ")
            .trimmingCharacters(in: .whitespacesAndNewlines)
        if !name.isEmpty {
            payload["display_name"] = name
        }

        guard let data = try? JSONSerialization.data(withJSONObject: payload),
              let json = String(data: data, encoding: .utf8) else {
            plugin.setPendingResult(nil)
            return
        }
        plugin.setPendingResult(json)
    }

    func authorizationController(
        controller: ASAuthorizationController,
        didCompleteWithError error: Error
    ) {
        plugin.setPendingResult(nil)
    }
}