Já tivemos uma introdução sobre o Flutter e sabemos como preparar o ambiente e criar nosso projeto. Nosso próximo passo será abrir o projeto com a nossa IDE, no caso o IntelliJ, para entendermos a estrutura do projeto e aprendermos a modificar o código de modo que essas alterações reflitam no aplicativo.
Começaremos fechando o Prompt de Comando, pois não o utilizaremos mais ao longo do curso. É uma ferramenta bastante poderosa, mas passaremos a usar o próprio IntelliJ para executar os nossos procedimentos. Ao fazermos isso, como o emulador foi aberto pelo Prompt, ele também será fechado.
Ao abrirmos o IntelliJ, nos deparemos com uma tela que nos permite importar um projeto já existente ou criar um novo. Se quiséssemos começar um projeto do zero, bastaria acessarmos a opção "Create New Project" e selecionarmos a opção "Flutter", seguindo as instruções na tela para realizar as configurações necessárias.
No entanto, já geramos o projeto no nosso terminal, e como essa é uma solução universal, ela poderia ser utilizada posteriormente no IntelliJ, Visual Studio Code ou qualquer outro editor. Então, cancelaremos a opção de criar um novo projeto e na página inicial do IntelliJ clicaremos na opção "Open".
É importante esclarecer que durante o curso usaremos a versão 2019.2.1 desse programa, a mais atual no momento de criação deste treinamento. Recomenda-se uutilizar essa ou a versão mais recente para ter um resultado similar.
Pelo explorador de arquivos, selecionaremos a pasta do projeto ("bytebank") e clicaremos em "Ok" para abrí-lo. Nesse momento, o IntelliJ fará diversas configurações para importar o projeto, executando diversas tasks que podem servir para resolução de dependências, indexação de arquivos e assim por diante. Isso pode levar algum tempo, mas depois da primeira importação esse tempo será otimizado.
Agora vamos explorar as possibilidades do IntelliJ. Nosso projeto estará estruturado no menu à esquerda da tela, onde estarão as pastas, como "bytebank", que se trata do projeto em si. Quando clicarmos nela, será mostrado tudo que foi criado pelo Flutter, como os diretórios referentes a "android", "ios" e "lib", os três principais em relação ao nosso desenvolvimento.

Os diretórios referentes a Android e IOS permitem acesso a todos os arquivos que normalmente constam num projeto nativo dessas plataformas. Como estamos utilizando o Flutter, cujo código será acessado pela pasta "lib", não precisaremos nos preocupar com esses dois diretórios. Dentro da pasta "lib", abriremos o arquivo main.dart com um duplo clique.
O código contido nesse arquivo, relativamente extenso e com diversos comentários, representa o nosso aplicativo. Nosso objetivo agora é reproduzirmos as mesmas ações que fizemos anteriormente no Prompt de Comando, mas com o IntelliJ. Primeiro, para executarmos a aplicação, podemos clicar no botão "Play" na parte superior da tela (cujo atalho é "Shift + F10").

Receberemos a mesma mensagem vista antes no Prompt, informando que não há nenhum dispositivo conectado. Clicaremos em "Ok" nessa janela de alerta e em seguida clicaremos na combo box à esquerda de main.dart, que atualmente indica que nenhum dispostivo está conectado ("no devices").
Serão mostrados todos os dispositivos disponíveis para utilizarmos com o Flutter, dentre eles o emulador que executamos anteriormente, Pixel API 28. Selecionaremos o emulador e executaremos a aplicação novamente com "Shift + F10". É dessa forma que trabalharemos com a execução dentro do IntelliJ.
Após a execução das tasks, teremos acesso ao aplicativo Flutter Demo no emulador. Tendo conhecido um pouco mais da estrutura do projeto, nosso próximo passo será começarmos a editar o código e vermos os resultados na tela. No momento não temos muita noção dos códigos que geram o nosso aplicativo. Sendo assim, apagaremos todo o código que temos depois da função main(), do próprio Dart, incluindo a instrução runApp() e a indicação da classe MyApp.
import 'package:flutter/material.dart';
void main() => ;
Dado que esse é um código em Dart, podemos realizar um print(), muito comum quando estamos trabalhando com a linguagem, passando a mensagem "Bem vindo ao Bytebank".
Chamaremos esse print de 'Bem vindo ao Bytebank'). Então, teremos:
import 'package:flutter/material.dart';
void main() => print('Bem vindo ao Bytebank');
Ao executarmos com "Shift + F10", a mensagem "Bem vindo ao Bytebank" será mostrada no console como uma saída do Flutter. Porém, nenhum resultado visual será mostrado no aplicativo, que manterá a mesma tela anterior.

Isso acontece porque, para conseguirmos implementar todo o comportamento visual e de aplicativo que desejamos usando o Flutter, precisaremos seguir as regras dele. A primeira regra é que, quando queremos executar ações para nosso aplicativo, elas sempre precisam estar dentro da chamada de runApp().
Portanto, runApp() será o nosso ponto de partida com o Flutter. Por mais que haja a função main()do Dart, o que realmente servirá para mostrar as modificações do Flutter no nosso aplicativo será o runApp().
import 'package:flutter/material.dart';
void main() => runApp();
Ao incluirmos a chamada de runApp(), o código deixará de compilar, pois requere um argumento. Mas qual? Alguns atalhos do IntelliJ podem nos auxiliar nesse ponto, como o "Ctrl + P", que mostra o argumento e o seu tipo. Ao usarmos o atalho, será exibido um balão indicando que o argumento esperado se chama app e é do tipo Widget.
No Flutter, widget faz referência aos elementos visuais do projeto, ou seja, é uma representação genérica para qualquer elemento que veremos no aplicativo. Por se tratar de referência genérica, se tentarmos mandar para runApp() uma instância de uma classe Widget, o compilador nos avisará da impossibilidade de fazer isso pelo fato dessa ser uma classe abstrata.
import 'package:flutter/material.dart';
void main() => runApp(Widget());
Portanto, é necessária a implementação de um widget. No entanto, a ideia do Flutter é podermos desenvolver de maneira mais rápida, assim como vimos na documentação da ferramenta. Pensando nisso, já existem widgets prontos que podemos utilizar. Dentre eles, para os nossos testes, podemos considerar um que nos mostre um texto, no caso o próprio Text(), que é importado do pacote material.dart (ao qual não nos atentaremos agora).
import 'package:flutter/material.dart';
void main() => runApp(Text());
Esse widget também exige um argumento. Com "Ctrl + P", veremos que existem diversos argumentos possíveis para serem enviados.

O primeiro deles, data, será exibido em negrito por ser um argumento obrigatório. Porém, não sabemos exatamente qual é o tipo desse argumento e que informações devemos mandar. Nessa situação, podemos selecionar a referência da classe e usar o atalho "Ctrl + Q" para mostrar na tela a documentação da classe que está sendo utilizada.

Nesse caso, dentre os vários argumentos, encontraremos a informação de que o data, que é obrigatório, é uma String. Assim, com o auxílio dos atalhos "Ctrl + P" (para mostrar os argumentos) e "Ctrl + Q" (para exibir a documentação), conseguimos nos localizar melhor dentro do Flutter.
Mais abaixo na documentação, encontramos a informação de que essa classe cria um Widget de texto. Agora que conhecemos o tipo do argumento, mandaremos a String "Bem vindo ao Bytebank" para o widget criado da seguinte forma:
Mandaremos nossa string da seguinte forma:
import 'package:flutter/material.dart';
void main() => runApp(Text('Bem vindo ao Bytebank'));
Ao executarmos esse código com "Shift + F10", a tela do nosso aplicativo apresentará um erro.

Esse erro foi proposital, feito para entendermos o feedback recebido. Note que, na ocorrência de um erro, é exibida no aplicativo uma tela vermelha com um texto em amarelo descrevendo os motivos disso ter acontecido. Além disso, o console do IntelliJ tentará expôr tudo o que aconteceu na tela, o que nos permite identificar a causa do problema. Por exemplo:
I/flutter ( 4824): The following assertion was thrown building Text("Bem vindo ao Bytebank"):
I/flutter ( 4824): No Directionality widget found.
Temos aqui uma mensagem informando que, a partir de determinado ponto - no caso, a execução do widget Text(), aconteceu um erro, mais especificamente em relação à falta de direcionamento do texto (No Directionality widget found). Identificar o erro e como solucioná-lo depende dos seus conhecimentos da linguagem e do framework, além, é claro, de muita pesquisa.
Para incluirmos o direcionamento faltante, colocaremos uma vírgula após a mensagem 'Bem vindo ao Bytebank', o que nos permitirá adicionarmos mais argumentos. Com o atalho "Ctrl + P", veremos que dentre as possibilidades temos o textDirection, que espera uma referência de TextDirection. Poderíamos instanciar essa classe, mas ela já nos disponibiliza algumas constantes que indicam a direção, como ltr (esquerda para a direita), rtl (direita para a esquerda) e assim por diante, todas elas acessadas a partir de um ponto (.). No nosso exemplo, usaremos TextDirection.ltr.
import 'package:flutter/material.dart';
void main() => runApp(Text('Bem vindo ao Bytebank', textDirection: TextDirection.ltr,));
Ao executarmos a aplicação, a mensagem será exibida na tela do nosso aplicativo, ainda que bem pequena e quase ilegível.

Essa foi uma demonstração da forma como trabalharemos com o Flutter a princípio: usaremos o runApp() para mandar um widget de modo a alterarmos o nosso código e visualizarmos o resultado na tela. Nessa primeira abordagem, nossa experiência pode não ter sido tão interessante, afinal ainda temos uma tela totalmente preta com um texto mal posicionado. Entretanto, esse primeiro contato é importante para explorarmos as possibilidades do Flutter e entendermos como utilizá-lo passo a passo.