Configurações do Sistema — Crypto App

Documento técnico detalhando todas as versões, SDKs, ferramentas de build e compatibilidade de dispositivos do projeto.

1. Versões Principais do Ecossistema

2. Como Essas Versões se Relacionam

Flutter SDK 3.41.7
    ├── contém Dart SDK 3.11.5 (embutido)
    ├── gera o código Dart → compila para ARM/x86 nativo
    └── integra com o build system Android via:
            │
            ├── Gradle 8.14 (orquestra o build)
            │       └── usa Android Gradle Plugin 8.11.1
            │               └── compila código Kotlin 2.2.20
            │                       └── com JVM target Java 17
            │
            └── Flutter Gradle Plugin (dev.flutter.flutter-gradle-plugin)
                    └── conecta o engine Flutter ao APK final

Resumo da cadeia:

1. Você escreve Dart → Flutter compila para código nativo
2. O Gradle monta o APK Android, incluindo o engine Flutter + código Kotlin
3. O Kotlin é usado apenas para a MainActivity (ponto de entrada Android)
4. O Java 17 é o target de compilação do bytecode Kotlin/Java

3. Dart SDK — ^3.11.5

Definido em: pubspec.yaml → environment.sdk

environment:
  sdk: ^3.11.5

Por que esta versão:

• Suporta sealed class e final class (Dart 3.0+)
• Suporta pattern matching com desestruturação no switch (Dart 3.0+)
• Suporta records e class modifiers (Dart 3.0+)
• O ^ significa "3.11.5 ou superior, mas menor que 4.0.0"

O que o Dart SDK faz:

• Compila o código .dart para código de máquina nativo (AOT para release)
• Executa em modo JIT durante desenvolvimento (hot reload)
• Gerencia pacotes via pub (equivalente ao npm/pip)

4. Flutter SDK — 3.41.7

Definido em: .metadata e .dart_tool/package_config.json

Canal: stable

O que o Flutter SDK faz:

• Fornece o framework de widgets (Material, Cupertino)
• Fornece o engine de renderização (Skia/Impeller)
• Gerencia o build para cada plataforma (Android, iOS, Web, Desktop)
• Inclui o Dart SDK embutido

Por que Flutter:

• Um único código Dart → roda em Android, iOS, Web, Desktop
• Hot reload para desenvolvimento rápido
• Performance nativa (compila para ARM, não usa bridge como React Native)
• Material 3 nativo com useMaterial3: true

5. Android SDK — Configuração

Definido em: android/app/build.gradle.kts

Por que esses valores:

• minSdk 21 (Android 5.0): Cobre ~99% dos dispositivos Android ativos no mundo
• targetSdk 35: Garante conformidade com as políticas mais recentes do Google Play
• compileSdk 35: Permite usar as APIs mais recentes durante o desenvolvimento

6. Compatibilidade de Dispositivos

Android

Cobertura total estimada: ~99% dos dispositivos Android ativos.

iOS

O projeto tem a pasta ios/ configurada, então também suporta iOS. A versão mínima é definida pelo Flutter (atualmente iOS 12+), cobrindo praticamente todos os iPhones em uso (iPhone 5s em diante).

Outras Plataformas (configuradas mas não priorizadas)

O .metadata mostra que o projeto foi criado com suporte a:

• ✅ Android (principal)
• ✅ iOS
• ⚠️ Web (ícones desabilitados no launcher_icons)
• ⚠️ Linux, macOS, Windows (estrutura existe mas não é foco)

7. Gradle — 8.14

Definido em: android/gradle/wrapper/gradle-wrapper.properties

distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-all.zip

O que faz:

• É o sistema de build do Android (como Make/CMake para C++)
• Resolve dependências, compila código, gera o APK/AAB
• Executa tasks como assembleRelease, assembleDebug

Por que 8.14:

• Compatível com AGP 8.11.1
• Performance melhorada de build (cache, paralelismo)
• Suporte a Kotlin DSL (.gradle.kts ao invés de .gradle)

Configuração de memória (gradle.properties):

org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m

• 8GB de heap para o Gradle — necessário para projetos Flutter que compilam código nativo
• android.useAndroidX=true — usa as bibliotecas AndroidX modernas

8. Kotlin — 2.2.20

Definido em: android/settings.gradle.kts

id("org.jetbrains.kotlin.android") version "2.2.20" apply false

O que faz no projeto:

• Apenas a MainActivity.kt é escrita em Kotlin
• É o ponto de entrada nativo Android que inicializa o Flutter engine
• Plugins nativos Android também podem usar Kotlin

Por que Kotlin e não Java:

• Flutter gera projetos com Kotlin por padrão desde 2020
• Kotlin é a linguagem oficial recomendada pelo Google para Android
• Mais conciso e seguro (null safety nativo)

9. Android Gradle Plugin (AGP) — 8.11.1

Definido em: android/settings.gradle.kts

id("com.android.application") version "8.11.1" apply false

O que faz:

• Transforma código Kotlin/Java em bytecode DEX (Dalvik Executable)
• Empacota resources, assets, manifest no APK
• Aplica ProGuard/R8 para minificação e ofuscação

Configuração de release (build.gradle.kts):

buildTypes {
    release {
        isMinifyEnabled = true      // R8 remove código não usado
        isShrinkResources = true    // Remove resources não usados
        proguardFiles(...)          // Regras de ofuscação
    }
}

10. Configuração de Assinatura (Release)

Definido em: android/key.properties + android/app/upload-keystore.jks

O app usa um keystore para assinar o APK de release (necessário para publicar na Play Store):

• key.properties — contém alias, senha e caminho do keystore
• upload-keystore.jks — arquivo de chave criptográfica

Se o key.properties não existir, o build usa a chave de debug automaticamente (com aviso no log).

11. Permissões Android

Definido em: android/app/src/main/AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET"/>

Apenas uma permissão: acesso à internet. Necessária porque o app faz chamadas HTTP à API de criptografia.

O connectivity_plus não precisa de permissão extra — ele usa APIs do sistema que já estão disponíveis.

12. Dependências e Suas Versões Resolvidas

Produção

Desenvolvimento/Testes

Dependências Transitivas Importantes

13. Por Que Cada Dependência Foi Escolhida

flutter_bloc — Gerenciamento de Estado

• Alternativas: Provider puro, Riverpod, GetX, MobX
• Por que Bloc/Cubit: Separação clara entre lógica e UI, testabilidade excelente, padrão da comunidade para Clean Architecture
• Cubit vs Bloc: Cubit é mais simples (não usa Events), ideal para operações diretas como encrypt/decrypt

dio — HTTP Client

• Alternativas: http (pacote padrão), retrofit, chopper
• Por que Dio: Interceptors, timeout granular (connect/receive/send), cancelamento de requests, upload com progresso
• Relação com o projeto: Configurado com base URL e timeout de 30s via DioClient

connectivity_plus — Verificação de Rede

• Alternativas: internet_connection_checker, data_connection_checker
• Por que connectivity_plus: Mantido pela comunidade Flutter (Plus Plugins), leve, multiplataforma
• Relação com o projeto: Verifica conexão ANTES de fazer a requisição HTTP (fail-fast)

dartz — Programação Funcional

• Alternativas: fpdart, oxidized, result_type
• Por que dartz: Maduro, amplamente usado com Clean Architecture, tipo Either bem documentado
• Relação com o projeto: Todo retorno de repositório é Either<Failure, CryptoResult> — elimina try/catch na camada de apresentação

glados — Property-Based Testing

• Alternativas: quickcheck (não existe em Dart), test_randomized
• Por que glados: Único PBT maduro para Dart, gera inputs aleatórios e encontra edge cases automaticamente
• Relação com o projeto: Testa propriedades como "encrypt nunca retorna string vazia para input válido"

14. Configuração do Ícone do App

Definido em: pubspec.yaml → flutter_launcher_icons

flutter_launcher_icons:
  android: "launcher_icon"
  ios: true
  image_path: "assets/icons/icon.png"
  min_sdk_android: 21
  adaptive_icon_background: "#1E252B"          # Midnight Blue-Grey
  adaptive_icon_foreground: "assets/icons/icon_foreground.png"

Ícone Adaptativo Android (API 26+):

• Background: cor sólida #1E252B (escuro)
• Foreground: imagem PNG com o logo
• O sistema Android recorta em círculo, quadrado arredondado, etc. conforme o launcher

Densidades geradas:

• mdpi (1x) — 48x48px
• hdpi (1.5x) — 72x72px
• xhdpi (2x) — 96x96px
• xxhdpi (3x) — 144x144px
• xxxhdpi (4x) — 192x192px

15. Estrutura de Build — Debug vs Release

16. Fluxo de Build Completo

flutter build apk --release
    │
    ├── 1. Dart AOT Compiler
    │       └── Compila lib/*.dart → código ARM nativo (libapp.so)
    │
    ├── 2. Flutter Engine
    │       └── Inclui libflutter.so (engine de renderização)
    │
    ├── 3. Gradle Build
    │       ├── Compila MainActivity.kt → DEX
    │       ├── Processa AndroidManifest.xml
    │       ├── Empacota assets/ (ícones)
    │       ├── Aplica R8 (minificação + ofuscação)
    │       └── Assina com keystore
    │
    └── 4. Output
            └── build/app/outputs/flutter-apk/app-release.apk

17. Resumo de Compatibilidade

18. Comandos Úteis

# Ver versão do Flutter e Dart instalados
flutter --version

# Ver dispositivos conectados
flutter devices

# Build debug APK
flutter build apk --debug

# Build release APK (assinado)
flutter build apk --release

# Build App Bundle para Play Store
flutter build appbundle --release

# Analisar tamanho do APK
flutter build apk --analyze-size

# Gerar ícones do app
dart run flutter_launcher_icons

# Rodar testes
flutter test

# Verificar problemas no projeto
flutter doctor
flutter analyze

19. Glossário de Termos Técnicos