react-native-healthkit-bridge/lib/hooks/useSmartAuthorization.js

A comprehensive React Native bridge for Apple HealthKit with TypeScript support, advanced authorization, and flexible data queries

import { useState, useCallback } from 'react';
import { HealthKitBridge } from '../core/HealthKitBridge';
export function useSmartAuthorization() {
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);
    /**
     * 🚀 Autorização Inteligente
     * Verifica e solicita autorização apenas para tipos necessários
     */
    const requestSmartAuthorization = useCallback(async (requiredTypes) => {
        setLoading(true);
        setError(null);
        try {
            const bridge = new HealthKitBridge();
            const result = await bridge.requestSmartAuthorization(requiredTypes);
            if (!result.success) {
                setError(result.message);
            }
            return result;
        }
        catch (e) {
            const errorMessage = (e === null || e === void 0 ? void 0 : e.message) || 'Erro na autorização inteligente';
            setError(errorMessage);
            return {
                success: false,
                authorizedTypes: [],
                deniedTypes: [],
                notDeterminedTypes: requiredTypes,
                message: errorMessage
            };
        }
        finally {
            setLoading(false);
        }
    }, []);
    /**
     * 🚀 Verificar e Solicitar Autorização para Dados Específicos
     * Verifica se um tipo específico está autorizado e solicita se necessário
     */
    const ensureDataTypeAuthorization = useCallback(async (dataType) => {
        setLoading(true);
        setError(null);
        try {
            const bridge = new HealthKitBridge();
            const result = await bridge.ensureDataTypeAuthorization(dataType);
            if (!result.isAuthorized) {
                setError(result.message);
            }
            return result;
        }
        catch (e) {
            const errorMessage = (e === null || e === void 0 ? void 0 : e.message) || 'Erro ao verificar autorização';
            setError(errorMessage);
            return {
                isAuthorized: false,
                wasRequested: false,
                message: errorMessage
            };
        }
        finally {
            setLoading(false);
        }
    }, []);
    /**
     * 🚀 Verificar Status de Múltiplos Tipos
     * Verifica o status de autorização de vários tipos de uma vez
     */
    const checkMultipleAuthStatus = useCallback(async (types) => {
        setLoading(true);
        setError(null);
        try {
            const bridge = new HealthKitBridge();
            const status = await bridge.getAuthorizationStatus(types);
            const authorized = status
                .filter((item) => item.status === 'sharingAuthorized')
                .map((item) => item.identifier);
            const denied = status
                .filter((item) => item.status === 'sharingDenied')
                .map((item) => item.identifier);
            const notDetermined = status
                .filter((item) => item.status === 'notDetermined' || item.status === 'unknown')
                .map((item) => item.identifier);
            return { authorized, denied, notDetermined };
        }
        catch (e) {
            const errorMessage = (e === null || e === void 0 ? void 0 : e.message) || 'Erro ao verificar status';
            setError(errorMessage);
            return {
                authorized: [],
                denied: [],
                notDetermined: types
            };
        }
        finally {
            setLoading(false);
        }
    }, []);
    /**
     * 🚀 Solicitar Apenas Tipos Não Autorizados
     * Verifica quais tipos não estão autorizados e solicita apenas esses
     */
    const requestOnlyUnauthorized = useCallback(async (types) => {
        setLoading(true);
        setError(null);
        try {
            const bridge = new HealthKitBridge();
            // 1. Verificar status atual
            const status = await bridge.getAuthorizationStatus(types);
            // 2. Identificar tipos não autorizados
            const unauthorizedTypes = status
                .filter((item) => item.status !== 'sharingAuthorized')
                .map((item) => item.identifier);
            // 3. Se todos estão autorizados, retornar sucesso
            if (unauthorizedTypes.length === 0) {
                return {
                    success: true,
                    authorizedTypes: types.map(t => t.toString()),
                    deniedTypes: [],
                    notDeterminedTypes: [],
                    message: 'Todos os tipos já estão autorizados'
                };
            }
            // 4. Solicitar autorização apenas para tipos não autorizados
            return await bridge.requestSmartAuthorization(unauthorizedTypes);
        }
        catch (e) {
            const errorMessage = (e === null || e === void 0 ? void 0 : e.message) || 'Erro ao solicitar autorização';
            setError(errorMessage);
            return {
                success: false,
                authorizedTypes: [],
                deniedTypes: [],
                notDeterminedTypes: types,
                message: errorMessage
            };
        }
        finally {
            setLoading(false);
        }
    }, []);
    return {
        loading,
        error,
        requestSmartAuthorization,
        ensureDataTypeAuthorization,
        checkMultipleAuthStatus,
        requestOnlyUnauthorized
    };
}