Skip to main content


Introdução ao Flutter​

O Flutter é um framework criado para desenvolver aplicações com interface gráfica. Ele é usado para criar aplicativos Android, iOS, web, desktop e outros tipos de interface usando a linguagem Dart.


O Dart é a linguagem, já o Flutter, é o framework. Assim como Python e Kivy. A linguagem é o que usamos para programar a lógica da aplicação. O framework é o conjunto de ferramentas que usa essa linguagem para facilitar a criação de algo específico, como telas, botões, navegação e interface no caso do Flutter.


O Flutter é usado quando a aplicação precisa ter tela, botão, campo de texto, lista, menu, navegação e interação visual.



Estrutura de um projeto Flutter​

Quando um projeto Flutter é criado, ele já vem com uma estrutura pronta. Essa estrutura separa o código Dart da aplicação, as configurações do projeto e os arquivos específicos de cada plataforma, como Android, iOS e web.


Um projeto simples pode aparecer assim:

controle_servidores/
├── android/
├── ios/
├── web/
├── lib/
│   └── main.dart
├── build/
├── pubspec.yaml
└── pubspec.lock

A parte mais importante no começo é a pasta lib, porque é nela que fica o código principal da aplicação Flutter.



lib​

A pasta lib é onde fica o código Dart da aplicação. No início, normalmente existe apenas um arquivo dentro dela:

lib/
└── main.dart

Com o tempo, a aplicação começa a crescer e podemos organizar melhor:

lib/
├── main.dart
├── models/
├── screens/
├── widgets/
├── repositories/
├── services/
└── database/

Por exemplo, em um app de controle de servidores, a pasta lib poderia guardar:

  • models/ → classe Servidor
  • screens/ → telas do app
  • widgets/ → partes reutilizáveis da interface
  • repositories/ → lógica de acesso aos dados
  • services/ → regras auxiliares da aplicação
  • database/ → configuração do SQLite

A ideia é evitar deixar tudo dentro do main.dart, porque isso funciona no começo, mas fica ruim quando a aplicação cresce.



main.dart​

O arquivo main.dart é o ponto de entrada da aplicação Flutter. É parecido com um script Python que começa a execução por um arquivo principal. Em Python, muitas vezes existe algo assim:

if __name__ == "__main__":
    main()

No Flutter, a aplicação normalmente começa com a função main():

void main() {
  runApp(const MeuApp());
}

A função main() inicia o programa. A função runApp() recebe o widget principal da aplicação e coloca ele para rodar na tela.


No começo, é normal escrever bastante coisa no main.dart. Depois, quando o projeto cresce, o ideal é deixar esse arquivo mais limpo e mover telas, models e regras para outros arquivos.



pubspec.yaml​

O pubspec.yaml é o arquivo de configuração principal do projeto Flutter. Todo projeto Flutter tem esse arquivo na raiz, e ele guarda informações que as ferramentas do Dart e do Flutter precisam para entender o projeto. Ele também é usado para declarar dependências, assets, fontes e outras configurações.


Exemplo simplificado:

name: controle_servidores
description: App simples para controle de servidores
publish_to: 'none'

version: 1.0.0+1

environment:
  sdk: ^3.0.0

dependencies:
  flutter:
    sdk: flutter

  sqflite: ^2.0.0
  path: ^1.8.0

flutter:
  uses-material-design: true

  • name: Define o nome do projeto.

  • dependencies: Define os pacotes usados pela aplicação. Por exemplo, quando formos usar SQLite no Flutter, vamos adicionar pacotes como sqflite e path.


Já o exemplo abaixo, indica que a aplicação vai usar recursos do Material Design, que é a base visual mais comum em apps Flutter com MaterialApp, Scaffold, AppBar, botões e outros widgets.

flutter:
  uses-material-design: true

O pubspec.yaml também é usado para registrar imagens, fontes e outros arquivos externos. Exemplo com assets:

flutter:
  assets:
    - assets/images/logo.png

Se o arquivo não estiver declarado corretamente, a aplicação pode até compilar, mas a imagem não vai carregar.



android​

A pasta android guarda o projeto Android gerado pelo Flutter. Ela contém arquivos usados pelo Gradle, configurações do Android, permissões, ícone, nome do app e outras partes específicas da plataforma Android.


No começo, quase não precisa mexer nessa pasta. Ela começa a importar mais quando for necessário fazer algo específico do Android, como:

  • alterar permissões no AndroidManifest.xml
  • mudar nome do aplicativo
  • configurar ícone
  • ajustar versão mínima do Android
  • configurar build de release
  • integrar algum recurso nativo

Por exemplo, se um app precisar acessar internet, arquivos, câmera ou notificações, algumas permissões podem envolver arquivos dentro da pasta android.



ios​

A pasta ios guarda o projeto iOS gerado pelo Flutter. Ela tem arquivos usados pelo Xcode e configurações específicas para gerar o app no iPhone ou iPad. Para quem está desenvolvendo no Linux, essa pasta normalmente não é usada diretamente, porque build de iOS depende do macOS e do Xcode.


Ela importa mais quando o projeto precisa:

  • gerar app para iPhone
  • configurar permissões do iOS
  • ajustar nome, ícone ou assinatura
  • publicar na App Store
  • integrar recurso nativo do iOS

No começo do aprendizado, dá para saber que ela existe, mas não precisa mexer nela.



web​

A pasta web guarda arquivos específicos da versão web da aplicação Flutter. Ele também pode gerar aplicações web usando a mesma base de código Dart/Flutter. Essa pasta importa quando a aplicação será executada no navegador.


Ela pode ser usada para configurar:

  • título da página
  • ícone do navegador
  • manifesto da aplicação
  • configurações específicas de web

Para um app simples de controle de servidores rodando em Android, a pasta web não precisa ser alterada.



build​

A pasta build é usada para guardar arquivos temporários e arquivos compilados durante o processo de execução ou geração da aplicação. Essa pasta não deve ser editada manualmente.


Ela também não deve ser tratada como código da aplicação. O Flutter pode apagar e recriar essa pasta quando necessário. Se der algum problema estranho de build, às vezes o comando abaixo ajuda:

flutter clean

Esse comando limpa arquivos gerados, incluindo partes da pasta build. Depois disso, o Flutter recria o que for necessário.



Instalando Flutter no Linux​

Vamos instalar as dependêncas primeiro:

sudo apt update && sudo apt-get update && sudo apt-get install -y curl git unzip xz-utils zip libglu1-mesa

Agora crie uma pasta para guardar o SDK:

mkdir -p ~/flutter

Baixe o Flutter SDK pela página oficial de instalação. O arquivo costuma vir no formato .tar.xz.:

# Baixando o flutter:
cd /tmp/ && wget https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_3.44.2-stable.tar.xz

# Decompacte o código do Flutter:
tar -xf /tmp/flutter_linux_3.44.2-stable.tar.xz -C ~/flutter/

Agora adicione o Flutter ao PATH:

echo 'export PATH="$HOME/flutter/flutter/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Adicionar o Flutter ao PATH permite usar os comandos flutter e dart direto no terminal, sem precisar informar o caminho completo até o SDK. Agora vamos testar:

$ flutter --version
Flutter 3.44.2 • channel stable • https://github.com/flutter/flutter.git
Framework • revision c9a6c48423 (3 days ago) • 2026-06-10 15:52:41 -0700
Engine • hash 04efd7c093d4e9281d5526ebcad6ecc60ba8badf (revision 77e2e94772) (3 days ago) • 2026-06-10 19:59:06.000Z
Tools • Dart 3.12.2 • DevTools 2.57.0

$ dart --version
Dart SDK version: 3.12.2 (stable) (Tue Jun 9 01:11:39 2026 -0700) on "linux_x64"

Depois rode:

flutter doctor -v

O flutter doctor verifica se falta alguma dependência no ambiente. Para rodar apps Flutter como aplicação Linux desktop, também são necessários pacotes como clang, cmake, ninja-build, pkg-config, libgtk-3-dev e libstdc++-12-dev.


Pode instalar eles com o comando abaixo:

sudo apt-get install -y clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-12-dev

Depois rode novamente:

flutter doctor -v

Para ver se o Flutter encontrou o Linux como dispositivo de execução:

$ flutter devices
Found 2 connected devices:
  Linux (desktop) • linux  • linux-x64      • Ubuntu 24.04.4 LTS 6.17.0-35-generic
  Chrome (web)    • chrome • web-javascript • Google Chrome 148.0.7778.215

Run "flutter emulators" to list and start any available device emulators.

Se aparecer uma entrada com plataforma linux, já dá para testar um app Flutter direto no desktop. A documentação oficial também recomenda usar flutter devices para confirmar se o Flutter encontrou um dispositivo Linux disponível.



Instalação recomendada para Flutter no Linux​

Para desenvolver Flutter no Linux com foco em Android, o ideal é instalar:

  1. Flutter SDK
  2. Android Studio
  3. Android SDK
  4. Android Emulator
  5. Um dispositivo virtual Android, chamado AVD

O Android Studio não é obrigatório como editor. Dá para programar no VS Code, Vim, Zed ou outra IDE. O ponto é que ele facilita bastante a instalação do Android SDK, do emulador e da criação do dispositivo virtual.


Na prática, o fluxo fica assim:

  • Flutter escreve e compila o app
  • Android SDK fornece as ferramentas do Android
  • Android Emulator executa um Android virtual
  • AVD define qual celular Android virtual será usado

Com isso, podemos rodar:

flutter run

E o app abre no emulador Android.


Quando o código é alterado, o Flutter permite usar hot reload, que atualiza a interface sem reiniciar o app inteiro.



Instalando ambiente SDK completo​

Antes de prosseguir, faça a instalação do Flutter como foi demonstrado acima.



Instalar o Android Studio​

O Android Studio é usado principalmente para instalar e gerenciar o Android SDK, o Android Emulator e os dispositivos virtuais Android.


O Flutter usa esse ambiente para compilar e executar apps Android. A documentação do Flutter recomenda instalar a versão estável mais recente do Android Studio para desenvolvimento Android. Antes, instale algumas bibliotecas exigidas pelo Android Studio em Ubuntu 64-bit:

# Ubuntu 22.04:
sudo apt install -y libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1 libbz2-1.0:i386

A documentação oficial do Android Studio lista essas bibliotecas para Linux 64-bit. Agora baixe o Android Studio para Linux pelo site oficial do Android Developers. Ele vem como .tar.gz, depois extraia para /opt:

# Baixe:
wget https://edgedl.me.gvt1.com/android/studio/ide-zips/2026.1.1.9/android-studio-quail1-patch1-linux.tar.gz

# Descompacte:
sudo tar -xzf android-studio-quail1-patch1-linux.tar.gz -C /opt/

Abra o Android Studio:

/opt/android-studio/bin/studio

Se você estiver executando em um servidor sem interface gráfica, será necessário instalar a interface gráfica. No Ubuntu, podemos usar o comando abaixo:

sudo apt install ubuntu-desktop

Na primeira abertura, ele vai abrir um assistente de configuração. Siga o assistente e aceite instalar os componentes recomendados. Depois, dentro do Android Studio, dá para criar atalho no menu por:

Tools > Create Desktop Entry


Instalar Android SDK e Emulator pelo Android Studio​

Com o Android Studio aberto, vá em: More Actions -> SDK Manager.


Se já estiver dentro de um projeto:

Tools > SDK Manager

Na aba SDK Platforms, selecione uma versão do Android SDK, recomendo começar com Android 16. Se você quer desenvolver para alguma versão mais antiga, pode selecionar ela. Depois vá na aba SDK Tools e confirme se estes itens estão instalados:

Android SDK Build-Tools
Android SDK Command-line Tools
Android SDK Platform-Tools
Android Emulator
CMake
NDK (Side by side)

Depois disso, volte ao terminal e aceite as licenças:

flutter doctor --android-licenses

Vá aceitando com y.


Depois rode:

flutter doctor -v

A parte de Android deve começar a aparecer como configurada.



Configurar aceleração do emulador com KVM​

O emulador Android fica muito melhor com virtualização ativada. No Linux, usamos o KVM para essa aceleração, mas só funcionar se o processador tiver suporte a VT-x ou AMD-V.


Instale o verificador:

sudo apt-get install -y cpu-checker

Verifique se a CPU suporta virtualização:

egrep -c '(vmx|svm)' /proc/cpuinfo

Se retornar 1 ou mais, tem suporte. Se retornar 0, a CPU não expôs virtualização para o sistema, ou isso está desativado na BIOS/UEFI. Agora teste o KVM:

sudo kvm-ok

Se aparecer algo como abaixo, está certo.

INFO: /dev/kvm exists
KVM acceleration can be used

Se precisar instalar KVM:

sudo apt-get install -y qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils

Depois adicione seu usuário aos grupos:

sudo usermod -aG kvm $USER
sudo usermod -aG libvirt $USER

Depois faça logout/login no sistema, ou reinicie.



Criar um emulador Android​

No Android Studio, vá em: More Actions -> Virtual Device Manager.


Se estiver dentro de um projeto: View -> Tool Windows -> Device Manager. Depois:

  1. Create Virtual Device
  2. Phone
  3. Medium Phone
  4. Next
  5. API: 34 ou 35 - Services: Google APIs - ABI: x86_64
  6. Download, se ainda não estiver baixada
  7. Finish

Um AVD é a configuração de um Android virtual, com perfil de hardware, imagem do sistema, armazenamento e outras propriedades. O Android Studio usa o Device Manager para criar e gerenciar esses dispositivos virtuais.


Depois de criado, clique no botão de play para iniciar o emulador.



Testar se o Flutter encontrou o emulador​

Com o emulador aberto, rode:

flutter devices

Deve aparecer algo parecido com:

  sdk gphone64 x86 64 (mobile) • emulator-5554 • android-x64    • Android 15 (API 35) (emulator)

Agora crie um projeto:

flutter create controle_servidores
cd controle_servidores

Execute:

flutter run

O app deve abrir no emulador Android.


Problema de performance

Se você tiver pouca memória RAM e/ou estiver tendo problemas com o emulador do Android, caso ele fique travando e encerrando, inicialize ele de forma mais leve:

~/Android/Sdk/emulator/emulator -avd Medium_Phone -no-snapshot -no-boot-anim -gpu swiftshader_indirect -memory 2048


Usar hot reload​

Com o app rodando pelo terminal, altere algo no código em:

lib/main.dart

Depois volte no terminal e pressione:

r

Isso aplica o hot reload. A ideia é atualizar a interface sem reiniciar o app inteiro, o que facilita muito durante o aprendizado.