Capítulo 33 — Aplicativo Mobile: React Native

react-native@0.73+                    (framework)
typescript@5.3+                       (tipagem)
@react-native-community/cli           (CLI)
react-native-windows                  (suporte a Windows quando necessário)

nativewind@4.0+                       (Tailwind CSS para React Native)
@brasfy/core                          (design system compartilhado com portal)
react-native-svg                      (renderização de SVGs)
react-native-linear-gradient          (gradientes)

@react-navigation/native@6.1+         (framework de navegação)
@react-navigation/bottom-tabs         (abas na base)
@react-navigation/native-stack        (pilha de navegação)
@react-navigation/drawer              (gaveta lateral quando necessária)
react-native-screens                  (otimização de performance)
react-native-safe-area-context        (gerenciamento de safe areas)

zustand@4.4+ ou Redux Toolkit         (estado compartilhado)
redux-persist                         (persistência de estado)
immer                                 (mutations imutáveis)

axios@1.6+                            (cliente HTTP)
react-query ou @tanstack/react-query  (cache e sincronização de dados)

react-native-keychain                 (acesso seguro a Keychain/Keystore)
react-native-secure-randombytes       (PKCE code_verifier)
react-native-config                   (variáveis de ambiente)

react-native-vision-camera@2.0+       (acesso à câmera)
react-native-skia                     (processamento de imagem)
ml-kit (Google ML Kit)                (detecção de documentos via ML)

@react-native-firebase/app            (Firebase — gerenciador)
@react-native-firebase/messaging      (FCM — Android e iOS opcional)
react-native-push-notification        (APNS — iOS; FCM — Android)

react-native-biometrics               (Face ID, Touch ID, impressão digital)
react-native-localize                 (détection de linguagem do dispositivo)

@sentry/react-native                  (crash reporting e error tracking)
react-native-performance-metrics      (métricas de performance)

src/
├── assets/
│   ├── images/
│   ├── icons/
│   └── fonts/
├── screens/
│   ├── auth/
│   │   ├── LoginScreen.tsx
│   │   ├── GovBrFlowScreen.tsx
│   │   └── BiometrySetupScreen.tsx
│   ├── home/
│   │   └── HomeScreen.tsx
│   ├── services/
│   │   ├── CatalogScreen.tsx
│   │   ├── ServiceDetailScreen.tsx
│   │   └── ServiceSearchScreen.tsx
│   ├── requests/
│   │   ├── RequestListScreen.tsx
│   │   ├── RequestDetailScreen.tsx
│   │   ├── RequestCreateScreen.tsx
│   │   └── DocumentUploadScreen.tsx
│   ├── messages/
│   │   └── MessagesScreen.tsx
│   └── profile/
│       ├── ProfileScreen.tsx
│       ├── PersonalDataScreen.tsx
│       └── PrivacyScreen.tsx
├── components/
│   ├── FormField/
│   ├── DocumentPicker/
│   ├── CameraScanner/
│   ├── NotificationBanner/
│   ├── LoadingIndicator/
│   └── ... (componentes reutilizáveis)
├── services/
│   ├── api/
│   │   ├── client.ts (instância de Axios)
│   │   ├── requests.ts
│   │   ├── services.ts
│   │   ├── messages.ts
│   │   └── ... (serviços de API)
│   ├── auth/
│   │   ├── authService.ts (IAM próprio + GOV.BR)
│   │   ├── keychain.ts (armazenamento seguro)
│   │   └── biometry.ts
│   ├── storage/
│   │   ├── localStorage.ts (dados não sensíveis em cache)
│   │   └── secureStorage.ts (tokens em Keychain/Keystore)
│   └── notifications/
│       └── pushService.ts
├── store/
│   ├── auth/
│   │   ├── authSlice.ts
│   │   └── authSelectors.ts
│   ├── requests/
│   │   ├── requestsSlice.ts
│   │   └── requestsSelectors.ts
│   ├── ui/
│   │   └── uiSlice.ts
│   └── store.ts (configuração Redux)
├── hooks/
│   ├── useAuth.ts
│   ├── useRequests.ts
│   ├── usePushNotifications.ts
│   ├── useBiometry.ts
│   └── ... (custom hooks)
├── utils/
│   ├── deeplink.ts (validação e processamento)
│   ├── errorHandler.ts
│   ├── logger.ts
│   ├── dateFormatter.ts
│   └── validators.ts
├── navigation/
│   ├── RootNavigator.tsx (stack raiz)
│   ├── AuthNavigator.tsx
│   ├── AppNavigator.tsx (abas principais)
│   ├── RequestsStackNavigator.tsx
│   └── ProfileStackNavigator.tsx
├── types/
│   ├── api.ts (tipos de resposta de API)
│   ├── domain.ts (modelos de negócio)
│   └── ui.ts (tipos de UI)
├── config/
│   ├── constants.ts
│   ├── environment.ts
│   └── apiConfig.ts
├── i18n/
│   ├── en.json
│   ├── pt-BR.json
│   └── i18n.ts
└── App.tsx (entrada)

import React from 'react';
import { View, TouchableOpacity, Text } from 'react-native';
import { useNavigation } from '@react-navigation/native';
import { RequestCard } from './RequestCard';
import type { Request } from '../types/domain';

interface RequestListProps {
  requests: Request[];
  loading: boolean;
  onRefresh: () => void;
}

export const RequestList: React.FC<RequestListProps> = ({
  requests,
  loading,
  onRefresh,
}) => {
  const navigation = useNavigation();

  return (
    <View className="flex-1 bg-white">
      {requests.length === 0 ? (
        <View className="flex-1 items-center justify-center">
          <Text className="text-gray-500">Nenhuma solicitação encontrada</Text>
        </View>
      ) : (
        <FlatList
          data={requests}
          renderItem={({ item }) => (
            <RequestCard
              request={item}
              onPress={() =>
                navigation.navigate('RequestDetail', { requestId: item.id })
              }
            />
          )}
          keyExtractor={(item) => item.id}
          onRefresh={onRefresh}
          refreshing={loading}
        />
      )}
    </View>
  );
};

RootNavigator
├── AuthNavigator (quando não autenticado)
│   ├── LoginScreen
│   ├── SignUpScreen
│   └── GovBrFlowScreen
└── AppNavigator (quando autenticado)
    ├── HomeTab
    │   └── HomeNavigator (stack)
    │       └── HomeScreen
    ├── ServicesTab
    │   └── ServicesNavigator (stack)
    │       ├── CatalogScreen
    │       ├── ServiceDetailScreen
    │       └── RequestCreateScreen
    ├── RequestsTab
    │   └── RequestsNavigator (stack)
    │       ├── RequestListScreen
    │       ├── RequestDetailScreen
    │       └── DocumentUploadScreen
    ├── MessagesTab
    │   └── MessagesNavigator (stack)
    │       └── MessagesScreen
    └── ProfileTab
        └── ProfileNavigator (stack)
            ├── ProfileScreen
            ├── PersonalDataScreen
            ├── PrivacyScreen
            └── LogoutScreen

const linking = {
  prefixes: ['plataforma://', 'https://plataforma.app'],
  config: {
    screens: {
      RequestDetail: 'requests/:requestId',
      ServiceDetail: 'services/:serviceId',
      NewRequest: 'services/:serviceId/new',
      Messages: 'messages',
      AgendamentDetail: 'agendamentos/:agendamentoId',
    },
  },
};

function validateDeepLink(url: string): boolean {
  // Validar esquema
  if (!url.startsWith('plataforma://')) return false;
  
  // Validar formato
  const pattern = /^plataforma:\/\/(requests|services|messages|agendamentos)\/[a-f0-9\-]+$/;
  if (!pattern.test(url)) return false;
  
  // Validar parâmetros (nunca usados como token ou autorização)
  return true;
}

// store/auth/authSlice.ts
import { createSlice, PayloadAction } from '@reduxjs/toolkit';

interface AuthState {
  isAuthenticated: boolean;
  token: string | null;
  user: User | null;
  loading: boolean;
  error: string | null;
}

const initialState: AuthState = {
  isAuthenticated: false,
  token: null,
  user: null,
  loading: false,
  error: null,
};

export const authSlice = createSlice({
  name: 'auth',
  initialState,
  reducers: {
    setLoading: (state, action: PayloadAction<boolean>) => {
      state.loading = action.payload;
    },
    setAuthenticated: (state, action: PayloadAction<{
      token: string;
      user: User;
    }>) => {
      state.isAuthenticated = true;
      state.token = action.payload.token;
      state.user = action.payload.user;
      state.error = null;
    },
    setError: (state, action: PayloadAction<string>) => {
      state.error = action.payload;
      state.loading = false;
    },
    logout: (state) => {
      state.isAuthenticated = false;
      state.token = null;
      state.user = null;
      state.error = null;
    },
  },
});

export const { setLoading, setAuthenticated, setError, logout } = authSlice.actions;

import { persistStore, persistReducer } from 'redux-persist';
import AsyncStorage from '@react-native-async-storage/async-storage';

const persistConfig = {
  key: 'root',
  storage: AsyncStorage,
  whitelist: ['auth'], // apenas auth persiste
  blacklist: ['ui'], // ui não persiste
};

const persistedReducer = persistReducer(persistConfig, rootReducer);

export const store = configureStore({
  reducer: persistedReducer,
});

export const persistor = persistStore(store);

export const selectIsAuthenticated = (state: RootState) => 
  state.auth.isAuthenticated;

export const selectUser = (state: RootState) => 
  state.auth.user;

export const selectToken = (state: RootState) => 
  state.auth.token;

// Uso em componente
const isAuthenticated = useSelector(selectIsAuthenticated);

export const loginWithCredentials = async (
  email: string,
  password: string
): Promise<AuthResponse> => {
  try {
    const response = await apiClient.post('/auth/login', {
      email,
      password,
    });

    const { token, user } = response.data;

    // Armazenar token em Keychain/Keystore
    await secureStorage.setToken(token);

    // Atualizar Redux
    dispatch(setAuthenticated({ token, user }));

    return { success: true, user };
  } catch (error) {
    const message = error.response?.data?.message || 'Erro ao autenticar';
    dispatch(setError(message));
    return { success: false, error: message };
  }
};

export const initiateGovBrFlow = async (): Promise<void> => {
  // 1. Gerar PKCE pair
  const codeVerifier = await generateCodeVerifier(); // 128 caracteres aleatórios
  const codeChallenge = await generateCodeChallenge(codeVerifier);
  const state = await generateCodeVerifier(); // state único para CSRF

  // 2. Armazenar temporariamente (será limpo após troca)
  await secureStorage.setTemporaryValue('pkce_verifier', codeVerifier);
  await secureStorage.setTemporaryValue('oauth_state', state);

  // 3. Preparar Authorization Request
  const params = new URLSearchParams({
    client_id: GOV_BR_CLIENT_ID,
    response_type: 'code',
    scope: 'openid profile email',
    redirect_uri: 'plataforma://oauth/callback',
    code_challenge: codeChallenge,
    code_challenge_method: 'S256',
    state: state,
  });

  const authUrl = `${GOV_BR_AUTH_ENDPOINT}?${params.toString()}`;

  // 4. Abrir navegador nativo
  await Linking.openURL(authUrl);
};

// Receber callback via deep link
export const handleGovBrCallback = async (code: string, state: string) => {
  try {
    // 1. Validar state
    const storedState = await secureStorage.getTemporaryValue('oauth_state');
    if (state !== storedState) {
      throw new Error('CSRF validation failed');
    }

    // 2. Recuperar code_verifier
    const codeVerifier = await secureStorage.getTemporaryValue('pkce_verifier');

    // 3. Trocar code por token no backend
    const response = await apiClient.post('/auth/gov-br/callback', {
      code,
      codeVerifier,
      redirectUri: 'plataforma://oauth/callback',
    });

    const { token, user } = response.data;

    // 4. Armazenar token seguro
    await secureStorage.setToken(token);

    // 5. Atualizar Redux
    dispatch(setAuthenticated({ token, user }));

    // 6. Limpar valores temporários
    await secureStorage.removeTemporaryValues(['pkce_verifier', 'oauth_state']);

  } catch (error) {
    dispatch(setError('Falha na autenticação GOV.BR'));
  }
};

export const setupBiometry = async (): Promise<boolean> => {
  try {
    // Verificar disponibilidade
    const available = await ReactNativeBiometrics.isSensorAvailable();
    if (!available) return false;

    // Solicitar biometria
    const { success } = await ReactNativeBiometrics.simplePrompt({
      promptMessage: 'Use sua biometria para desbloquear',
    });

    if (success) {
      // Marcar que biometria foi habilitada
      await secureStorage.setBiometryEnabled(true);
      return true;
    }
    return false;
  } catch (error) {
    console.error('Erro ao configurar biometria:', error);
    return false;
  }
};

export const unlockWithBiometry = async (): Promise<boolean> => {
  try {
    const { success } = await ReactNativeBiometrics.simplePrompt({
      promptMessage: 'Desbloqueie o aplicativo',
    });

    if (success) {
      // Recuperar token armazenado
      const token = await secureStorage.getToken();
      if (token) {
        dispatch(setAuthenticated({ token, user: getCurrentUser() }));
        return true;
      }
    }
    return false;
  } catch (error) {
    return false;
  }
};

import { messaging } from '@react-native-firebase/app';
import PushNotification from 'react-native-push-notification';

export const setupPushNotifications = async () => {
  // iOS — APNS token
  if (Platform.OS === 'ios') {
    messaging().requestPermission().then((authStatus) => {
      if (authStatus === messaging.AuthorizationStatus.AUTHORIZED) {
        messaging().getToken().then((token) => {
          registerPushToken(token);
        });
      }
    });
  }

  // Android — FCM token
  if (Platform.OS === 'android') {
    messaging().getToken().then((token) => {
      registerPushToken(token);
    });
  }

  // Listener para notificações recebidas
  messaging().onMessage(async (remoteMessage) => {
    handleNotification(remoteMessage);
  });

  // Listener para notificações quando app está em background
  messaging().onNotificationOpenedApp((remoteMessage) => {
    navigateFromNotification(remoteMessage);
  });
};

const registerPushToken = async (token: string) => {
  try {
    await api.post('/notifications/push-token', {
      token,
      platform: Platform.OS,
      deviceId: getDeviceId(),
    });
  } catch (error) {
    console.error('Erro ao registrar token de push:', error);
  }
};

const handleNotification = (remoteMessage: FirebaseMessagingTypes.RemoteMessage) => {
  const { notification, data } = remoteMessage;

  // Exibir notificação no cliente
  PushNotification.localNotification({
    channelId: 'default-channel',
    title: notification?.title,
    message: notification?.body,
    bigText: notification?.body,
    data: data || {},
  });

  // Registrar recebimento no backend
  logNotificationDelivery(remoteMessage.messageId);
};

const navigateFromNotification = (remoteMessage: FirebaseMessagingTypes.RemoteMessage) => {
  const { data } = remoteMessage;

  if (data?.type === 'protocol_updated') {
    navigation.navigate('ProtocolDetail', { protocolId: data.protocolId });
  } else if (data?.type === 'complementation_needed') {
    navigation.navigate('Complementation', { requestId: data.requestId });
  }
};

import { useCamera } from '@react-native-camera-roll/camera-roll';
import DocumentScanner from 'react-native-document-scanner-api';

export const DocumentCaptureScreen = () => {
  const [scannedDocument, setScannedDocument] = useState<string | null>(null);

  const captureDocument = async () => {
    try {
      // Abrir scanner com guia visual
      const result = await DocumentScanner.scanDocument({
        croppedImageQuality: 100,
        responseType: 'base64',
      });

      if (result && result.scannedImage) {
        // Armazenar localmente para preview
        setScannedDocument(result.scannedImage);
      }
    } catch (error) {
      if (error.code !== 'USER_CANCELLED') {
        Alert.alert('Erro', 'Não foi possível capturar o documento. Tente novamente.');
      }
    }
  };

  const uploadDocument = async () => {
    if (!scannedDocument) return;

    try {
      const formData = new FormData();
      formData.append('file', {
        uri: `data:image/jpeg;base64,${scannedDocument}`,
        type: 'image/jpeg',
        name: `document_${Date.now()}.jpg`,
      });
      formData.append('type', 'RG');

      const response = await api.post('/documents/upload', formData, {
        headers: { 'Content-Type': 'multipart/form-data' },
      });

      Alert.alert('Sucesso', 'Documento enviado com sucesso.');
      setScannedDocument(null);
    } catch (error) {
      Alert.alert('Erro', 'Falha ao enviar documento.');
    }
  };

  return (
    <View style={styles.container}>
      {scannedDocument ? (
        <>
          <Image source={{ uri: `data:image/jpeg;base64,${scannedDocument}` }} style={styles.preview} />
          <Button title="Confirmar" onPress={uploadDocument} />
          <Button title="Refazer" onPress={() => setScannedDocument(null)} />
        </>
      ) : (
        <Button title="Capturar Documento" onPress={captureDocument} />
      )}
    </View>
  );
};

import { NavigationContainer } from '@react-navigation/native';
import { linking } from './linking';

const linking: LinkingOptions<RootStackParamList> = {
  prefixes: ['plataforma://', 'https://app.example.com'],
  config: {
    screens: {
      ProtocolDetail: 'protocolo/:protocolId',
      Complementation: 'complementacao/:requestId',
      NewRequest: 'solicitacao/novo?serviceId=:serviceId',
      Messages: 'mensagens',
      Profile: 'perfil',
      NotFound: '*',
    },
  },
};

export const AppNavigator = () => {
  const linking = useMemo(() => ({
    prefixes: ['plataforma://', 'https://app.example.com'],
    config: { /* ... */ },
    async getInitialURL() {
      // Processar deep link inicial
      const url = await getInitialURL();
      if (url != null) {
        return url;
      }
      return undefined;
    },
    subscribe(listener: (url: string) => void) {
      // Listener para deep links recebidos enquanto app está em background
      const onReceiveURL = ({ url }: { url: string }) => {
        listener(url);
      };

      const subscription = linking.addEventListener('url', onReceiveURL);
      return () => {
        subscription.remove();
      };
    },
  }), []);

  return (
    <NavigationContainer linking={linking}>
      <RootNavigator />
    </NavigationContainer>
  );
};

const validateDeepLink = (url: string): boolean => {
  try {
    const parsed = new URL(url);

    // Validar esquema
    if (!['plataforma://', 'https://app.example.com'].includes(parsed.origin)) {
      return false;
    }

    // Validar path e parâmetros
    const pathname = parsed.pathname;
    const allowedPaths = ['/protocolo', '/complementacao', '/solicitacao', '/mensagens', '/perfil'];
    
    return allowedPaths.some((path) => pathname.startsWith(path));
  } catch {
    return false;
  }
};

// Componente de lista com virtualização
import { FlatList } from 'react-native';

const RequestsList = ({ requests }: { requests: RequestItem[] }) => {
  const keyExtractor = (item: RequestItem) => item.id;
  const renderItem = ({ item }: { item: RequestItem }) => <RequestCard request={item} />;

  return (
    <FlatList
      data={requests}
      renderItem={renderItem}
      keyExtractor={keyExtractor}
      maxToRenderPerBatch={10}
      updateCellsBatchingPeriod={50}
      initialNumToRender={20}
      removeClippedSubviews={true}
    />
  );
};

import FastImage from 'react-native-fast-image';

const OptimizedImage = ({ uri, style }: { uri: string; style: any }) => (
  <FastImage
    source={{ uri, priority: FastImage.priority.normal }}
    style={style}
    resizeMode={FastImage.resizeMode.contain}
  />
);

import { performance } from 'react-native-perf';

export const measureScreenLoad = (screenName: string) => {
  const startTime = performance.now();

  return () => {
    const duration = performance.now() - startTime;
    logMetric(`screen_load_${screenName}`, duration);
  };
};

import { render, screen, fireEvent, waitFor } from '@testing-library/react-native';
import { AuthScreen } from './AuthScreen';

describe('AuthScreen', () => {
  it('deve fazer login com credenciais válidas', async () => {
    const { getByText, getByPlaceholderText } = render(<AuthScreen />);

    fireEvent.changeText(getByPlaceholderText('E-mail'), 'user@example.com');
    fireEvent.changeText(getByPlaceholderText('Senha'), 'password123');
    fireEvent.press(getByText('Entrar'));

    await waitFor(() => {
      expect(screen.queryByText('Carregando')).not.toBeOnTheScreen();
    });
  });

  it('deve exibir erro com credenciais inválidas', async () => {
    const { getByText, getByPlaceholderText } = render(<AuthScreen />);

    fireEvent.changeText(getByPlaceholderText('E-mail'), 'invalid@example.com');
    fireEvent.changeText(getByPlaceholderText('Senha'), 'wrong');
    fireEvent.press(getByText('Entrar'));

    await waitFor(() => {
      expect(screen.getByText('Credenciais inválidas')).toBeOnTheScreen();
    });
  });
});

import { by, element, expect as detoxExpect } from 'detox';

describe('Request Creation E2E', () => {
  beforeAll(async () => {
    await device.launchApp();
  });

  it('deve criar uma solicitação nova', async () => {
    await element(by.id('tab_services')).tap();
    await element(by.text('Habilitação')).tap();
    await element(by.id('btn_start_request')).tap();

    await element(by.id('input_name')).typeText('João Silva');
    await element(by.id('btn_submit')).tap();

    await detoxExpect(element(by.text('Protocolo gerado'))).toBeVisible();
  });
});

import axios from 'axios';
import RNFetchBlob from 'rn-fetch-blob';

const createPinnedClient = () => {
  const certificate = require('./certificates/api-certificate.pem');

  return RNFetchBlob.config({
    trusty: true,
    sslPinning: {
      certs: ['api-certificate.pem'],
    },
  }).fetch;
};

export const api = axios.create({
  baseURL: API_BASE_URL,
  adapter: createPinnedClient(),
});

import { useFocusEffect } from '@react-navigation/native';

export const SensitiveScreen = () => {
  useFocusEffect(
    useCallback(() => {
      // Ao entrar na tela, desabilitar screenshots
      ViewShot.captureRef(viewRef, { format: 'png', quality: 0.8 }).catch(() => {
        // Capture desabilitada em telas sensíveis
      });

      return () => {
        // Ao sair, limpar dados sensíveis
        clearSensitiveData();
      };
    }, []),
  );

  return (
    <ViewShot ref={viewRef} options={{ format: 'png', quality: 0.8 }}>
      {/* Conteúdo sensível */}
    </ViewShot>
  );
};

import crashlytics from '@react-native-firebase/crashlytics';

// Configurar listener global de erros
setJSExceptionHandler((error, isFatal) => {
  crashlytics().recordError(error);
  
  if (isFatal) {
    // Enviar relatório crítico
    crashlytics().log('Fatal error occurred');
  }
});

// Capturar erros de promise não tratada
setJSExceptionHandler((error: Error, isFatal: boolean) => {
  crashlytics().recordError(error);
}, true);

import { logEvent, setUserProperty } from '@react-native-firebase/analytics';

export const logScreenView = (screenName: string) => {
  logEvent('screen_view', {
    firebase_screen: screenName,
    firebase_screen_class: screenName,
  });
};

export const logRequestCreation = (serviceId: string) => {
  logEvent('request_created', {
    service_id: serviceId,
    timestamp: new Date().toISOString(),
  });
};

export const setUserContext = (userId: string) => {
  setUserProperty('user_id', userId);
  setUserProperty('app_version', getAppVersion());
};

<View
  accessible={true}
  accessibilityLabel="Lista de solicitações"
  accessibilityHint="Deslize para baixo para atualizar"
  accessibilityRole="list"
>
  {requests.map((request) => (
    <RequestCard key={request.id} request={request} />
  ))}
</View>

// Botão com descrição acessível
<TouchableOpacity
  accessible={true}
  accessibilityLabel="Abrir solicitação"
  accessibilityRole="button"
  accessibilityState={{ disabled: loading }}
  onPress={handleOpenRequest}
>
  <Text>Abrir</Text>
</TouchableOpacity>

// Imagem com descrição
<Image
  source={require('./logo.png')}
  accessibilityLabel="Logo do órgão"
  accessible={true}
/>

import { Text, PixelRatio } from 'react-native';

const fontScale = PixelRatio.getFontScale();

const styles = StyleSheet.create({
  body: {
    fontSize: 16 * Math.min(fontScale, 1.3), // limitar escala a 30%
    lineHeight: 24,
  },
  heading: {
    fontSize: 24 * Math.min(fontScale, 1.3),
    fontWeight: '600',
  },
});

// app.config.js (React Native CLI)
export default {
  name: 'Cidadão',
  slug: 'cidadao',
  version: '1.2.3',
  ios: {
    bundleIdentifier: 'br.gov.mg.cidadao',
    buildNumber: '203',
    supportsTablet: true,
    infoPlist: {
      NSCameraUsageDescription: 'Permitimos capturar documentos para envio.',
      NSFaceIDUsageDescription: 'Permitimos desbloquear com biometria para sua conveniência.',
    },
  },
  android: {
    package: 'br.gov.mg.cidadao',
    versionCode: 203,
    permissions: [
      'android.permission.CAMERA',
      'android.permission.USE_BIOMETRIC',
      'android.permission.USE_FINGERPRINT',
    ],
  },
  extra: {
    apiUrl: process.env.API_URL || 'https://api.dev.example.com',
    sentryDsn: process.env.SENTRY_DSN,
  },
};

const MIN_VERSION = '1.0.0';
const CURRENT_VERSION = '1.2.3';

const checkCompatibility = async () => {
  try {
    const response = await api.get('/version/check');
    const { minimumVersion, supportedUntil } = response.data;

    if (compareVersions(CURRENT_VERSION, minimumVersion) < 0) {
      Alert.alert(
        'Atualização necessária',
        'Esta versão do aplicativo não é mais suportada. Atualize na loja de aplicativos.',
        [{ text: 'Atualizar', onPress: () => Linking.openURL(APP_STORE_URL) }],
      );
    }
  } catch (error) {
    console.error('Falha ao verificar compatibilidade:', error);
  }
};

// services/storage/secureStorage.ts

export const secureStorage = {
  // Tokens e dados sensíveis → Keychain / Keystore
  async setToken(token: string): Promise<void> {
    await RNKeychain.setGenericPassword('plataforma', token, {
      service: 'token',
      accessibilitySharedUIElements: [], // não em screenshots
    });
  },

  async getToken(): Promise<string | null> {
    const credentials = await RNKeychain.getGenericPassword({
      service: 'token',
    });
    return credentials ? credentials.password : null;
  },

  async clearToken(): Promise<void> {
    await RNKeychain.resetGenericPassword({ service: 'token' });
  },

  // Dados não sensíveis → AsyncStorage com cache
  async setCacheData(key: string, data: any): Promise<void> {
    await AsyncStorage.setItem(key, JSON.stringify(data));
  },

  async getCacheData(key: string): Promise<any | null> {
    const data = await AsyncStorage.getItem(key);
    return data ? JSON.parse(data) : null;
  },

  // Valores temporários (PKCE, state) → Memória durante a sessão
  async setTemporaryValue(key: string, value: string): Promise<void> {
    temporaryStorage[key] = value;
    // Auto-limpar após 10 minutos
    setTimeout(() => delete temporaryStorage[key], 10 * 60 * 1000);
  },

  async getTemporaryValue(key: string): Promise<string | null> {
    return temporaryStorage[key] || null;
  },
};