Já pensou em criar seus próprios aplicativos, sites ou até jogos, mas não sabe por onde começar?

Fala, galera! Tudo bem com vocês? Espero que sim.
No momento em que escrevo este artigo, estou a caminho de outro país (Lima, Peru) para participar de um evento do Google sobre comunidades. Durante essa viagem, decidi compartilhar um pouco da minha história com a tecnologia e mostrar como iniciei do absoluto zero.

Eu só tinha um computador velho com Windows 7 e um sonho. 🥺

O que é programação e por que aprender?

Programação de computadores nada mais é do que mandar no computador e pedir pra ele fazer coisas pra você, o computador de fato só entende zero e um, já ouviu falar que os computadores são burros? Então isso é bem verdade.

Mas Ian, como eu peço para ele fazer o que eu quero? Como me comunico com ele? Sim, e aí entram as linguagens de programação: elas são a forma com que você escreve um comando e o computador entende isso e conversa com você. Com elas você pode escrever ou criar programas que rodam no computador ou qualquer dispositivo inteligente.

Por exemplo, o aplicativo do facebook no seu celular foi escrito em uma linguagem de programação chamada kotlin, o programa Microsoft office do seu computador foi escrito em uma linguagem chamada .NET.

A programação hoje está em todos os lugares, em forma de software ou programas. Está nos aviões, carros autônomos, celulares, caixa de supermercados, consultórios etc em todos os lugares.

O mundo hoje não evolui mas sem tecnologia, eu nao consigo imaginar com seria se nao existisse por exemplo o (Ifood, Uber, aplicativos de viagem, bancos online etc), por exemplo faz 5 anos que nao vou mais em lotérica ou banco presencialmente pagar contas hahaha, sim era um saco ficar esperando em filas gigantescas só pra pagar uma conta de energia ou internet.

Por isso eu acredito que esse mundo é o presente e futuro. Cada vez se necessita de profissionais capacitados nessa área, seja em engenharia de software ou áreas relacionadas.

Benefícios da área de tecnologia

Trabalho remoto : Quando eu entrei pra área de programação eu nunca pensei que isso existiria, sério. 🙀

Com desenvolvimento de software ou áreas relacionadas (marketing digital, design, Scrum master etc) é possível você atuar da sua casa (Home office) ou em qualquer outro lugar do planeta terra. Vc só precisa de duas coisas, internet e um computador.

Isso é bem maravilhoso, hoje posso ter qualidade de vida e tempo com a minha família, o que é incrível.

Altas demandas no mercado de trabalho (nacional e internacional):

Como eu falei o mundo hoje não sobrevive sem tecnologia e internet, cada vez mais as pessoas estão dependentes da tecnologia pois ela traz facilidade para as nossas vidas. É muito bom pagar contas da sua casa ou receber um pix, pedir comida ou comprar passagens no conforto do seu lar não é mesmo?

Cada dia mais as empresas e os governos estão adotando tecnologia, o futuro será tecnológico sem dúvidas rsrs é aí que o mercado só cresce. e a medida que cresce faltam vagas e mais vagas. Sim, falta gente capacitada e experiente no mercado.

Outra coisa incrível é que o código que você faz no brasil é o mesmo código que o cara da china faz, ou seja esse mercado é global o que possibilita você no brasil, lá da cidade do interior prestar serviços para empresas estrangeiras e ganhar em moeda forte como dólar por exemplo.

Em um cenário em que o dólar bateu $6.30 nesses últimos dias, você pode até ficar rico fazendo isso, sério imagina ganhar 5k de dólar convertendo para real dar uns 30 mil reais o que e 1% da renda dos mais ricos do país.

Para chegar nesse nível, sim aprenda inglês. Essa é uma das minhas principais metas do ano.

Possibilidade de criar projetos pessoais ou empreender: Uma das coisas mais incríveis no mundo de desenvolvimento de software é a possibilidade de você criar produtos que resolvam problemas das pessoas e usar isso para ganhar muito dinheiro.

Foi isso que o Mark Zuckerberg fez ao criar o facebook, ele criou um software que resolvia um problema real e acabou que deu muito certo.

Explore ao seu redor e veja quais as suas dificuldades e problemas, o que daria pra resolver com programação seja criando um aplicativo ou sistema da web.

Recentemente eu vi uma história de um garoto de 17 anos que fez 1 milhão de dólares apenas com um aplicativo que usa inteligência artificial. Ele criou um app que tira foto da comida e diz quantas calorias tem para o usuário, o que é bem legal se você segue uma dieta à risca.

Assista aqui o case dele. Vale a pena para se inspirar. ✨

Minha história: como comecei nesse mundo tech

O Início:

Iniciei minha jornada no mundo da programação em 2014 estudando no curso técnico de informática em uma escola pública da minha cidade no interior do piauí, foi ali onde vi as primeiras linhas de código e sim foi algo extraordinário e apaixonante à primeira vista.

Um pouco antes em 2013, encerrando o ensino fundamental não tinha nem noção do que queria seguir na vida rsrsrs informática e computadores na época era algo pra mim ainda de difícil acesso pois era bem caro e meus pais não podiam comprar.

Por sorte no mesmo ano meu irmão tinha conseguido um notebook velho com o meu tio em uma troca, foi ali onde me interessei com computadores e informática pois tinha pego um computador pela primeira vez, e achei algo fantástico pois antes eu só via nas revistas da veja os computadores e ficava com vontade de possuir um.

Naquele mesmo ano de 2013, eu falei pra mãe:

Mãe proximo ano vou fazer fazer curso tecnico de informatica integrado ao ensino médio, me bote lá rsrsr porque não aproveitar a oportunidade e fazer as duas coisas juntas ensino médio + curso técnico, até o momento só curtia ir pra escola de manhã e a única vaga que a mãe conseguiu foi a tarde, não hesitei e mesmo assim eu fui hahaha, foi difícil nos primeiros dias mas depois me acostumei e até achei legal estudar no turno da tarde.

Iniciei o curso achando que ia aprender a mexer em word, excel, powerpoint alias quem nunca pensou isso, não conhecia nada de programação, sem saber o que era.

A realidade foi que vi as primeiras linhas de código e foi ali que já tinha a perfeita certeza que queria seguir carreira em desenvolvimento de software.

Foram 3 anos de curso, entre 2014 a 2016. No primeiro ano eu aprendi lógica de programação e toda a base de algoritmos, estruturas de dados.

A tecnologia que o professor usou para mostrar a lógica de programação foi o VisualG com portugol.

O VisuAlg é uma ótima ferramenta para quem quer começar a aprender programação, especialmente porque usa uma linguagem simples, baseada no português estruturado. Ele é muito indicado para iniciantes porque permite praticar lógica de programação sem se preocupar com sintaxes complexas de linguagens mais avançadas.

Lembro que meu primeiro código foi um simples ‘Olá, Mundo’, e isso me deixou empolgado!

Depois desse dia eu fui inserido em um novo mundo, onde eu podia me divertir criando pequenos scripts e dando vida a eles.

Nas horas vagas eu via aulas complementares às do curso no youtube, passava as manhãs assistindo cursos de algoritmos e praticava bastante em casa, eu só queria aprender mais e mais.

Lembro que fiquei tão animado que passei as férias estudando Java, Html, Css e Javascript, já queria entrar no segundo ano de curso sabendo o máximo que podia.

Segundo ano ensino médio e de curso:

Acabou que no segundo ano de curso em 2015 o professor ensinou a linguagem Python com o framework Django, o que foi incrível. Fiquei apaixonado pela tecnologia, comecei a estudá- la mais a fundo em casa e entender como tudo funcionava.

O meu professor do ensino médio era expert em django e então após as aulas eu sempre mostrava pra ele o que eu estava construindo e também aproveitava para tirar dúvidas, com isso ele viu meu potencial e meses depois ele me chamou para ajudá-lo em um projeto de um sistema web, foi ai onde eu fiz meu primeiro freela e pude ganhar algum dinheirinho com programação. Com isso fui virando muito amigo dele e nos falamos até hoje.

Um abraço Jefferson se tiver lendo esse artigo 🙏 ✨

Terceiro ano ensino médio:

No último ano de curso em 2016 foi ensinado a linguagem Java, e nessa mesma época eu já sabia que queria seguir com a área de programação, então fiz o Enem para tentar faculdade na área.

Aqui na minha cidade os cursos que tinha eram Ciência da Computação na faculdade pública ou Sistemas de Informação na privada.

Nessa mesma época eu comecei a prestar serviços de freelancer desenvolvendo para web com Python e Django, era o que eu tinha aprendido no curso que mais me chamou atenção na época.

Então decidi focar nessa stack e tentar conseguir mais projetos.

Tentei também aprender um pouco de desenvolvimento de apps android mas por conta que tinha um pc muito ruinzinho e não dava conta de compilar o projeto no android studio então abandonei isso e fiquei só na web mesmo e segui nisso.

Por sorte meu antigo professor de python que antes tinha visto minhas habilidades me chamou pra ajudar em um projeto web para um cliente de advocacia da cidade.

Eu fiquei maravilhado pois essa foi a minha primeira oportunidade de fazer parte de uma empresa de desenvolvimento de software, sim meu professor era sócio de uma empresa juntamente com alguns colegas.

Trabalhei com ele alguns meses nesse projeto, foi daí que recebi meu primeiro salário como programador web, até hoje eu lembro foi 300 reais haha o primeiro mês. eu lembro que quando recebi essa grana fiquei muito entusiasmado com o futuro e pensei é realmente possível fazer grana com programação e e aqui que vou ficar. 🤑

Infelizmente o projeto não foi entregue com sucesso, eu não lembro bem o motivo mas sei que ainda recebi dois meses que atuei no projeto e ainda trabalhei mais outro de graça rsrs. So queria aprender mais e mais.

Apesar de não ter dado certo, eu sou grato por essa oportunidade, ganhei experiência o que é mais importante.

E daí mais à frente eu Fiz o enem pois estava decidido a cursar ciência da computação na UESPI a estadual do piauí, graça a Deus eu passei e em 2017 iniciei na graduação.

Nesse mesmo ano eu tentei fundar uma empresa com um outro amigo da igreja que prestasse serviços freelancer de desenvolvimento web aqui na minha cidade.

Tínhamos criados alguns produtos como sistemas de igrejas e de clínicas, websites e consultorias. Tentamos também vender algumas soluções como sistema de mapeamento de UBS e controle de estoque para a prefeitura, mas acabou que tentamos por um bom tempo negociar o que não deu certo a venda de nenhum deles, tínhamos feitos MVP e tudo mas infelizmente não deu.

De novo, tudo o que sobrou foi a experiência no meio de várias tentativas e falhas, tentativas e falhas. 🤣

Passamos 2017 e 2018 tentando emplacar a empresa mas sem muito sucesso, éramos ruim de vendas hahaha So sabiamos programar mas vender não era nosso forte.

Período de Faculdade:

Em 2018 eu estava no terceiro período da faculdade já indo pro quarto, naquela época o curso era integral o que dificultava eu ter tempo pra focar no negócio que eu estava montando e então decidir desistir de empreender com o meu colega e não colocar mais a nossa software house pra frente.

Tinha decidido focar mais na faculdade, estudar um pouco mais e tentar aplicar para algumas vagas para ser funcionário de uma empresa de fato, visto que tentar montar o próprio negócio naquela época não rolou.

Na faculdade nos primeiros períodos o que mais eu via era cálculo, álgebra e física, sim eu era péssimo nessas matérias, por diversas vezes eu pensei em desistir do curso para focar em outras coisas mas Deus me ajudou e continuei firme, eu tive que pagar calculo || duas vezes e física 3x hahah pensa no desafio grande emplacar isso .

Aqui quero tirar que computação é só para inteligentes, eu era péssimo em cálculo mas o que me ajudou a chegar lá foi a pesistencia e muito estudo.

Ainda em 2018 eu decidi desenvolver tecnologias novas, queria aprender desenvolvimento de aplicativos móveis. Sim voltar em uma meta antiga, então comecei aprender Kotlin para android, comprei um curso na udemy e arrumei outro notebook melhorzinho mas ainda velho.

Acho que foi a primeira vez que tinha comprado algo lá, peguei o boleto e fui no banco pagar depois da faculdade, sim nessa época internet banking eu ainda não tinha acesso, então sempre quando tinha contas ia no banco pagar, pegar uma fila gigante 😭 mas era o que eu queria, tinha fome de conhecimento e estava ansioso pelo o curso.

A chegada do Flutter.

Ainda em março 2018 eu estava em uma comunidade do telegram de devs android e lá alguém postou um link de uma notícia do tecmundo onde falava o seguinte “Google lança Flutter Beta para unificar criação de apps para Android e iOS”

A Google lançou durante a MWC 2018 a primeira versão beta do Flutter, sua plataforma de desenvolvimento para criação de apps para Android e iOS. A empresa explica que, com o Flutter, é possível desenvolver apps e games para as duas principais plataformas mobile do mundo simultaneamente, sem que isso implique de qualquer maneira no desempenho ou na funcionalidade desses apps.

Eu li isso e pensei que seria incrível, pra que desenvolver com kotlin apenas para android se posso usar o Flutter para ambas as plataformas 😏

Então decidi pesquisar mais sobre no youtube e de cara vi alguns vídeos tutoriais onde pessoas faziam coisas legais com o framework o que me chamou muito atenção.

Então baixei o sdk do Flutter e decidi testar eu mesmo e vi que era bem simples construir interfaces do que com kotlin e android nativo.

Foi aí que decidi largar os estudos em android nativo kotlin e foquei apenas flutter, e lhe digo foi a melhor decisão que pude tomar! 🩵

Há alguns meses eu já tinha desenvolvido o primeiro aplicativo e publiquei na loja. Foi incrível, o primeiro aplicativo que você publica na loja é algo marcante. Eu lembro que levei 2 dias pra fazer-lo e outro pra enviar a loja do android.

2019

Continuei estudando Flutter e até que em 2019 decidi criar conteúdo e palestrar sobre Flutter em meetups de tecnologia.

Um dos momentos mais marcantes foi quando participei do maior evento de computação do meu estado como palestrante do Enucomp 2019, como flutter era extremamente novo acabou que foi pra mais de 100 pessoas inscritas na palestra o que foi incrível!

Nunca pensei que fosse palestrar para mais de 100 pessoas. Naquele dia eu realmente tive certeza que estava no caminho certo.

Por causa desse evento acabei sendo chamado para o time do Flutterando a maior comunidade de flutter na época, o que foi incrível, lá conheci outros experts em flutter.

Ainda em 2019 eu fundei a comunidade local de flutter do estado chamada de Flutter Piauí e começamos a fazer vários meetups e eventos na cidade pra divulgar a ferramenta.

Foi dai que começou minha paixão por comunidades de tecnologia e virei community manager.

2020 a 2023 — Pandemia 😷

Em 2020 eu ainda estava na faculdade, se nao me engano 5 período onde veio a pandemia o que foi bem ruim, lembro que todo mundo teve que ficar trancado dentro de suas casas sem poder sair, foi aí que os eventos online ganharam fama e eu comecei a palestrar de forma online sobre flutter ao mesmo tempo que estudava todo dia coisas novas sobre o framework.

Nessa época me envolvi muitos com eventos e comunidades online. Fui compartilhando conhecimentos com quem eu podia.

Nessa mesma época eu acabei arrumando minha primeira vaga como desenvolvedor Flutter Júnior na empresa de um dos colegas da comunidade chamada Fteam.

Flutter tava em completa ascensão mas ter bons desenvolvedores na época era ainda bem difícil e como eu já tava me preparando desde de 2018 eu entrei lá e comecei atuar sendo terceirizado a diversas empresas e projetos e isso me fez crescer muito rapidamente.

Passei 3 anos e meio nessa empresa onde eu agradeço de coração pela a oportunidade pois lá realmente eu cresci e conheci pessoas muitos boas que até hoje são meus amigos.

Em seguida, continuei fazendo eventos, me envolvendo com a comunidade e viajando bastante, conheci muita gente legal e estados!

Aqui na minha cidade ainda em 2022 fundei o GDG Parnaiba uma comunidade apoiada pelo o Google e isso me levou a uma viagem pra Colômbia e agora Peru, também a conhecer os escritórios do Google No Brasil tanto em SP como em BH.

2024 e 2025

Nos últimos dois anos estou trabalhando em plena era da IA estou trabalhando nos meus próprios aplicativos como desenvolvedor solor e em alguns produtos que usam IA na empresa onde eu Atuo Hoje. O que é incrível 🤩

Estou bem feliz com tudo que está acontecendo. Obrigado Deus!

Passo a passo para iniciar na programação do zero

Passo 1: Defina seus objetivos

Antes de começar, reflita:

• Você quer aprender programação por hobby, para mudar de carreira ou para resolver um problema específico?

• Qual área mais te atrai: desenvolvimento web, aplicativos móveis, backend, frontend, ciência de dados, IA ou outra?

Saber aonde você quer chegar é essencial. Se sua meta é realmente seguir carreira, isso já é o suficiente para te motivar a buscar cada vez mais conhecimento.

Quando eu comecei, não sabia exatamente qual área iria seguir. Só tinha uma certeza: queria ser desenvolvedor. Comecei na web com Django e, anos depois, descobri minha verdadeira paixão: o Desenvolvimento Mobile.

💡 Dica: apenas comece. Teste várias áreas, descubra o que gosta mais e depois foque nisso.

Passo 2: Aprenda os fundamentos, Algoritmos e Lógica de Programação

“Você pode praticar arremessos oito horas por dia, mas se sua técnica estiver errada, tudo o que você se tornará será muito bom em arremessar da maneira errada. Pratique os fundamentos e o nível de tudo o que você fizer vai subir.” — Michael Jordan

Se você quer ser programador, precisa dominar os fundamentos. Eles são a base de tudo.

Em 2014, no meu curso técnico, meu professor explicou o que são algoritmos:
👉 “Algoritmos são uma sequência de passos lógicos que levam à resolução de problemas.”

Essa frase ficou gravada em mim até hoje. 🥺

Pode parecer lento no começo, mas aprender lógica é o melhor investimento da sua jornada. Ela te prepara para resolver problemas complexos, aumenta sua confiança e te dá independência para criar soluções.

Por que os fundamentos são importantes?

• Construção de uma base sólida: assim como uma casa, sem fundação qualquer estrutura desmorona.

• Conhecimento transferível: os conceitos básicos funcionam em qualquer linguagem de programação.

• Resolução de problemas: mais do que escrever código, você aprende a pensar de forma lógica.

• Evitar erros comuns: fundamentos te ensinam boas práticas desde cedo.

Passo 3: Escolha sua primeira linguagem de programação

Depois de dominar algoritmos, é hora de escolher uma linguagem.

Algumas opções recomendadas:

• Python: simples, versátil e ótimo para iniciantes.

• JavaScript: ideal para criar sites e projetos web.

• Dart: perfeito para quem quer desenvolver aplicativos com Flutter.

Minha primeira linguagem foi Python, apresentada no curso técnico. Hoje, com experiência, recomendo Python, JavaScript ou Java como ótimos pontos de partida.

➡️ Importante: escolha uma, foque até ganhar segurança e só depois explore outras. Como dizia meu professor: “A primeira linguagem é a mais difícil. Depois, todas ficam mais fáceis.”

Passo 4: Use recursos acessíveis e gratuitos

Você não precisa gastar muito para começar. Algumas opções:

• Codecademy

• Cursos no YouTube e materiais abertos na internet.

Passo 5: Pratique com projetos pequenos

Aprender programação é como aprender um idioma: você só melhora praticando.

💡 Sugestões de projetos iniciais:

• Criar uma calculadora simples.

• Desenvolver um jogo da forca.

• Fazer um site pessoal com HTML, CSS e JS.

Esses projetos parecem simples, mas ensinam muito.

Passo 6: Participe de comunidades e busque ajuda

A jornada é muito mais leve quando você não está sozinho.

Participe de fóruns, grupos e comunidades em algumas plataformas como Telegram, Whatsapp e discord.

Trocar experiências acelera seu aprendizado e te mostra que todo mundo erra no começo e isso é normal.

Passo 7: Participe de eventos de tecnologia

Acredite em mim: envolva-se com a comunidade local de desenvolvedores. Aprenda com outros desenvolvedores: participar de eventos de tecnologia, palestrar e contribuir com conteúdos pode expô-lo a uma variedade de ideias, tecnologias e abordagens diferentes.

Isso pode enriquecer seu conhecimento e ampliar sua perspectiva sobre a indústria de desenvolvimento de software.

Conheça novas pessoas e faça networking nos eventos, pois isso pode abrir portas para novos contatos e oportunidades valiosas em sua carreira.

Dicas extras para manter a motivação

• Tenha paciência com seus erros: eles fazem parte do processo.

• Estabeleça metas pequenas e comemore suas vitórias.

• Se possível, estude com amigos ou participe de bootcamps.

Use a IA como guia, não como muleta, IA pode explicar conceitos, sugerir código, resumir documentações mas não substitui a prática: você só aprende de verdade escrevendo, testando e errando pois foi assim que eu aprendi.

Aprenda a pensar antes de pedir à IA, escreva sua lógica, tente resolver e só depois peça ajuda assim você entende a solução, em vez de só copiar/colar código.

Conclusão ✅

Qualquer pessoa pode aprender programação não importa idade, formação ou de onde vem. O principal ponto é gostar pois não é facil e quando se ama o que faz o processo fica bem legal.

Eu mesmo já pensei em desistir várias vezes. Fui ruim em matemática, reprovei em cálculo na faculdade, mas continuei. O que me manteve foi persistência.

Tecnologia hoje é presente e o futuro então sim é uma área muito boa para se construir carreira.

Se eu consegui aprender do zero, você também pode. O mais importante é dar o primeiro passo.

Espero que você tenha gostado! Se tiver alguma dúvida ou contribuição, deixe nos comentários ou me mande nas redes sociais!

Me siga para estar sempre por dentro dos próximos artigos ou assine a neswletter 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter | Medium

Essa comunicação é algo bem legal e venho aqui ensinar tudo isso pra vocês.

Ao integrar os Atalhos da Siri, seu aplicativo pode destacar suas principais funcionalidades, oferecendo aos usuários maneiras novas e interativas de interagir com ele — uma estratégia simples, porém eficaz, para se manter à frente da concorrência.

O que são Apple Shortcuts ou Atalhos

Segundo o site da apple: Um atalho é uma maneira rápida de realizar uma ou mais tarefas com seus aplicativos economizando tempo em ações repetitivas, como definir alarmes ou lembretes. O aplicativo Atalhos permite que você crie seus próprios atalhos com várias etapas. Por exemplo, crie um atalho para "Tempo de Surfe" que exibe o relatório de surfe, informa o horário previsto para a praia e inicia sua playlist de músicas de surfe.

Os Shortcuts ficam disponíveis assim que o aplicativo é instalado no iOS e podem ser executados no Spotlight, na tela Inicial, no aplicativo Atalhos ou até mesmo usando a voz com a Siri que é o que vamos fazer hoje.

E para fazermos o nosso aplicativo Flutter comunicar com os Atalhos do iOS vamos usar algo chamado App Intents que oferece funcionalidades para integrar profundamente as ações e o conteúdo do seu aplicativo com as experiências do sistema em todas as plataformas, incluindo Siri, Spotlight, widgets, controles e muito mais.

Utilizando as Intents no Flutter com o package Intelligence

1 — Adicionando a dependência em seu projeto

Vamos começar adicionando a dependência ao nosso arquivo pubspec.yaml.

Instale o pacote a partir da linha de comando com o Flutter

$ flutter pub add intelligence

Ou adicione intelligence diretamente em seu pubspec.yaml e execute flutter pub get no momento da criação desse artigo ele está na versão 0.2.0.

dependencies:
  intelligence: ^0.2.0

Agora, no seu código Dart, você pode importar o package:

import 'package:intelligence/intelligence.dart';

2 - Vamos criar um novo aplicativo Flutter para o nosso exemplo de hoje.

flutter create flutter_siri_example

Após o nosso projeto criado vamos fazer a configuração na parte nativa do iOS, então abra a pasta ios no Xcode clicando com o botão direito no vsCode.

Agora você precisa definir a versão mínima do iOS para 16.0 no Xcode para o projeto, veja a imagem abaixo:

Após feito isso vamos integrar os comandos que queremos que a siri interprete em nosso aplicativo.

Abra o Xcode e crie uma novo arquivo Swift. Vamos usar o exemplo padrão do Flutter de app contador e adicionar dois comandos, um para incrementar e outro para resetar o valor.

Crie o arquivo IncrementeIntent.Swift no Xcode, veja o exemplo abaixo e código que você precisa escrever.

import AppIntents
import intelligence

struct IncrementIntent: AppIntent {
  static var title: LocalizedStringResource = "Aumentar contador"
  static var openAppWhenRun: Bool = true

  @MainActor
  func perform() async throws -> some IntentResult {
    IntelligencePlugin.notifier.push("increment")
    return .result()
  }
}

Vamos criar nossa segunda Intent onde vai interpretar o comando de reset do valores do contador.

Crie um arquivo chamado RefreshIntent.Swfit conforme a imagem abaixo:

import AppIntents
import intelligence

struct RefreshIntent: AppIntent {
  static var title: LocalizedStringResource = "Atualizar contador"
  static var openAppWhenRun: Bool = true

  @MainActor
  func perform() async throws -> some IntentResult {
    IntelligencePlugin.notifier.push("refresh")
    return .result()
  }
}

Em seguida vamos criar último arquivo para interpretar as strings dos comandos e acionar a Intent correta declarado acima apenas falando uma frase específica para a Siri.

Veja o exemplo abaixo:

import AppIntents

struct AllAppShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
       return [
            AppShortcut(
                intent: IncrementIntent(),
                phrases: [
                    "Incrementar número no \(.applicationName)",
                    "Adicionar número no \(.applicationName)",
                    "Aumentar número no \(.applicationName)",

                ]
            ),
            AppShortcut(
                intent: RefreshIntent(),
                phrases: [
                    "Resetar contador no \(.applicationName)"
                ]
            ),
        ]
    }
}

Agora o lado do Flutter 💙

No lado do Flutter na nossa página principal vamos chamar o método para escutar se o aplicativo foi aberto pela a Siri e interpretando os comandos.

 void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }

  void _refreshCounter() {
    setState(() {
      _counter = 0;
    });
  }

  @override
  void initState() {
    super.initState();
    _initSiri();
  }

  void _initSiri() {
    if (Platform.isIOS) {
      Intelligence().selectionsStream().listen(_trackSiri);
    }
  }

  void _trackSiri(String selection) {
    log('Siri Command triggered: $selection');
    switch (selection) {
      case 'increment':
        _incrementCounter();
        break;
      case 'refresh':
        _refreshCounter();
        break;

      default:
        break;
    }
  }

O código acima é responsável por ouvir os comandos passados para a Siri e acionar os métodos corretos que no nosso caso são dois em nosso app.

_incrementCounter e _refreshCounter o resto do código você pode consultar no link do repositório aqui.

Rodando e testando o aplicativo

Execute o aplicativo no simulador do iOS e ative a Siri com a opção mostrada abaixo:

Quando a Siri detectar pela primeira vez o comando de voz, pode ser que o iOS peça para adicionar o comando no app Atalhos do iOS mas nos meus testes teve vez que foi automático mas se aparecer apenas clique em Ativar.

Veja o link do video do aplicativo de demonstração em funcionamento abaixo: 👇🏻

https://drive.google.com/file/d/1CddUVKZt8iCdSNgNx7Z_oLPSNrGQOk5C/view?usp=sharing

Conclusão ✅

Bom foi isso, os atalhos da Siri podem automatizar diversas tarefas, como iniciar aplicativos, enviar mensagens, definir lembretes e deixar nossos apps muito mais inteligentes e legais. O céu é o limite ✨

Você pode consultar o código de exemplo no github.

Obrigado por ler até aqui. 😁

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição me manda uma DM ou deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos sobre desenvolvimento móvel 📲 🚀

🌐 Minhas redes sociais 🌐

Github | LinkedIn | Instagram | X (Twitter) | Medium

Hoje vou ensinar vocês a gerar os Termos de Uso ou a Política de Privacidade para nossos aplicativos de forma automatizada e simples.

Toda vez que vamos publicar um app nas lojas, enfrentamos a mesma chatice: é necessário informar o link dos nossos termos ou da política de privacidade.

A boa notícia é que encontrei um site muito útil que tem me ajudado bastante com isso, e resolvi vir aqui compartilhar com vocês.

O site se chama: https://www.privacypolicytemplate.net/

No exemplo de hoje vamos gerar nossas politicas de privacidade mas no site tem termos também.

O que e politica de privacidade?

É um documento legal que detalha como um site coleta, armazena, compartilha e vende dados sobre seus visitantes. Esses dados geralmente incluem itens como nome, endereço, data de nascimento, estado civil, histórico médico e comportamento do consumidor do usuário.

Criando nossos termos

O primeiro passo é acessar o site e clique em App e em seguida você sera redirecionado para o site https://app.termsfeed.com/

Veja a imagem abaixo:

Em seguida coloque o nome do aplicativo e os dados que ele vai solicitando no passo a passo.

Veja o exemplo: 👇🏻

Se eu aplicativo coletar dados pessoais do usuário apenas vá marcando quais: 👇🏻

O quarto passo é colocar o email ou qualquer outro contato para receber dúvidas sobre sua politica de privacidade.

E para finalizar clique na segunda opção para conseguir criar gratuitamente sua politica de privacidade para seu aplicativo. 👇🏻

No sexto e último passo ele pede o email pra lhe enviar o link da politica criada para seu app.

Agora no Google Play console insira a URL da sua politica de privacidade e seja feliz:

Na Apple também👇🏻

Conclusão

Bom, nos meus projetos pessoais eu sempre uso esse site e tem me ajudado bastante! ✨

Obrigado por ler até aqui. 🎉

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir aplicativos incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição me manda uma DM ou deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos sobre engenharia de software 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

Observabilidade (ou o11y ) nos permite entender um sistema de fora, permitindo-nos fazer perguntas sem conhecer o funcionamento interno desse sistema, baseado apenas nas suas saídas externas, como logs, métricas e traces.

Com isso podemos solucionar e lidar facilmente com problemas novos (ou seja, "desconhecidos").

Ela oferece monitoramento de desempenho de ponta a ponta, permitindo que as organizações monitorem todo o ciclo de vida de uma aplicação, desde as interações do usuário no front-end até os processos de back-end.

Se você está apenas começando com esse tema, as postagens abaixo ajudarão você a se aprofundar um pouco mais:

• Desvendando a Observabilidade: Um guia para iniciantes

• Logs, Events, Traces, and Spans : Os Fundamentos

O que é Open Telemetry?

OpenTelemetry (OTel) segundo o site: é uma coleção de APIs, SDKs e ferramentas. Use-o para instrumentar, gerar, coletar e exportar dados de telemetria (métricas, logs e rastros) para ajudar você a analisar o desempenho e o comportamento do seu software.

É também um framework de código aberto para instrumentação de código, e muitos dos principais fornecedores de ferramentas de observabilidade o suportam.

Ele é independente de fornecedor, então, se você optar por trocar sua ferramenta de coleta de dados para uma nova de fornecedor diferente, não será prejudicado pois isso significa que ele não está vinculado a nenhum fornecedor específico de monitoramento ou observabilidade.

A ferramenta que eu uso atualmente para coletar os dados se chama Elastic APM e vou falar um pouco dela mais tarde mas você pode usar qualquer outra de sua preferência.

Antes de começar a usar o OpenTelemetry , é importante entender alguns conceitos básicos, como Spans e Traces.

A instrumentação de código com a OpenTelemetry é suportada por muitas linguagens de programação populares como o exemplo abaixo:

Instrumentação manual vs. automática

Existem duas formas de instrumentar uma aplicação com o OpenTelemetry: manual e automática. No caso do Flutter, como ainda não há um SDK oficial, utilizamos a instrumentação manual.

Já em outras stacks, é possível usar a instrumentação automática, que oferece um conjunto de módulos predefinidos e prontos para uso. Com isso, é possível coletar dados de telemetria com pouca ou nenhuma necessidade de alterações no código.

O que é Elastic APM (Application Performance Monitoring)

É uma solução de observabilidade oferecida pelo Elastic para para instrumentalizar e observar aplicações backend ou frontend. Com ela é possível monitorar o desempenho de aplicações em tempo real coletando dados sobre como sua aplicação está se comportando — por exemplo:

• Quanto tempo as requisições levam para serem processadas.

• Onde estão os gargalos (funções lentas, chamadas de banco de dados demoradas, etc.).

• Quais erros estão acontecendo e com que frequência.

• Como os serviços estão interagindo em uma arquitetura distribuída (ex: microserviços).

Ele possui integração com as principais ferramentas do mercado e inclusive com a Open telemetry.

Agora vamos adicionar nossa aplicação ao elastic, veja o passo a passo abaixo:

1 - No painel do Elastic no canto superior direito clique em Add data:

2 - Depois selecione Application e Open Telemetry:

3 - E por último mais abaixo selecione Open Telemetry novamente:

A variável OTEL_EXPORTER_OTLP_ENDPOINT contém o endpoint para coleta dos dados da sua aplicação e vamos usá-la mais tarde.

Conceitos-Chave do OpenTelemetry

Os exemplos abaixo estão na linguagem Dart.

1. Tracer

• O objeto principal e um ponto de entrada para criar spans. Um Trace é composto por uma árvore de Spans e oferece uma visão holística do seu sistema.

• Você pega ele com algo tipo:

    final tracer = tracerProvider.getTracer('meu-serviço');

Você pode também ter vários traces e um pra cada contexto e assim organizar melhor os dados no Elastic, filtrar por tipo de operação ou subsistema, ter granularidade no controle.

Veja o exemplo abaixo:

final apiTracer = tracerProvider.getTracer('api-tracer');
final uiTracer = tracerProvider.getTracer('ui-tracer');

No seu app Flutter, na maioria dos casos, você pode usar apenas um Tracer global que já é o suficiente. Se no futuro seu app crescer muito e tiver múltiplos módulos/libraries com integração separada, aí pode fazer sentido separar Tracers

Apesar de você poder ter vários tracers, o que realmente importa são os spans e atributos que você gera.

final span = tracer.startSpan('api.chamada.login');
span.setAttribute('feature', 'login');
span.setAttribute('http.url', '/auth/login');

2. Span

• Representa uma unidade de trabalho (ex: carregar dados, enviar mensagem, fazer login…). Spans contêm Eventos , logs estruturados (JSON) que descrevem ocorrências pontuais durante aquele período e podem ser usados para:

  • Medir tempo de tela

  • Performance de chamadas de APIs

  • Acompanhamento de eventos e jornada do usuário

• Combine com try/catch pra capturar erros:

    final span = tracer.startSpan("fazer-login");
    try {
      await login();
    } catch (e) {
      span.setStatus(StatusCode.error, description: e.toString());
    } finally {
      span.end();
    }
  

• Um Span pode ter:

  • Nome (operation-flutter) O nome do microsserviço que está sendo executado ou uma chamada de função.

  • Tempo de início/fim

  • Atributos (ex: status, erro, nome do usuário) Lista de pares de chave-valor usados ​​para agregação ou filtragem de dados de rastreamento (por exemplo, identificador do cliente, nome do host do processo). Usados ​​para descrever e contextualizar o trabalho realizado em um Span.

  • Hierarquia (spans filhos)

  • Eventos : Strings com registro de data e hora compostas por registro de data e hora, nome e atributos opcionais usadas para descrever e contextualizar o trabalho realizado em um período.

final span = tracer.startSpan("carregar-dados");
// faz algo
span.end();

Para enriquecer com atributos use o span.setAttribute(...) para dar contexto:

  void _spanWithAttribute() {
    final span = tracer.startSpan(
      'GET /resource/catalog',
      kind: SpanKind.client,
    );
    span.setAttribute(Attribute.fromString('http.method', 'GET'));
    span.setAttribute(Attribute.fromString('http.url', 'your http url'));
    //faça algo
    span.end();
  }

3. Traces

• É como o OpenTelemetry conecta vários spans (inclusive em diferentes serviços).

• Permite criar um span filho ligado ao span pai:

Context.current.withSpan(parentSpan).execute(() {
  final child = tracer.startSpan("operação-filho");
  child.end();
});

4. TracerProvider

• Gerencia os tracers e controla como eles se comportam. Nele você configurar:

  • Processadores de span (ex: batch ou simples)

  • Exportadores (pra onde os dados vão: console, Elastic, etc)

  • Metadata sobre o app (nome do serviço, versão…)

5. Exporter

• Responsável por enviar os dados dos spans pro backend (Elastic, Zipkin, Jaeger, etc).

• Ex: CollectorExporter, ConsoleExporter, ou SlsExporter.

6. Span Processor

Eles são responsáveis por processar e exportar os spans assim que eles são criados (ou finalizados).

• SimpleSpanProcessor: exporta logo após o .end() imediatamente

• BatchSpanProcessor: agrupa vários e exporta em lote (mais eficiente e indicado para produção)

• Recomendado: sempre usar BatchSpanProcessor no app real.

• Exibir no console (SimpleSpanProcessor com ConsoleExporter)

Você pode registrar vários ao mesmo tempo:

final tracerProvider = TracerProviderBase(
  processors: [
    BatchSpanProcessor(exporterElastic),
    SimpleSpanProcessor(ConsoleExporter()),
  ],
);

Neste caso:

• Um envia os dados pra sua ferramenta que vai receber os dados que nesse caso usamos o Elastic APM

• Outro imprime os spans no console para debug localmente

7. Resource

• Metadados sobre o app: nome, versão, ambiente (dev/prod), etc.

• Isso ajuda a identificar o app no painel de observabilidade.

Resource([
  Attribute.fromString("service.name", "meu_app"),
  Attribute.fromString("deployment.environment", "dev"),
])

8. Metrics e Logs (Futuramente no Flutter)

• OpenTelemetry também suporta métricas e logs estruturados, mas a maior parte do suporte em Flutter ainda é centrada em traces (spans).

• A comunidade tá evoluindo isso aos poucos em relação ao package que usamos.

Utilizando o package do open telemetry no Flutter

1— Adicionando a dependência em seu projeto

Vamos começar adicionando a dependência ao nosso arquivo pubspec.yaml.

Instale o pacote a partir da linha de comando com o Flutter:

 $ flutter pub add opentelemetry

Ou adicione opentelemetry diretamente em seu pubspec.yaml e execute flutter pub get no momento da criação desse post ele está na versão 0.18.10 .

dependencies:
 opentelemetry: ^0.18.10

Agora, no seu código Dart, você pode importar o package:

import 'package:opentelemetry/api.dart';
import 'package:opentelemetry/sdk.dart';

2 - Para inicializar o SDK vamos criar um arquivo chamado telemetry_initializer.dart veja como ficou abaixo:

import 'package:opentelemetry/api.dart' as otel_api;
import 'package:opentelemetry/sdk.dart' as otel_sdk;

late otel_api.Tracer tracer;

Future<void> initTelemetry() async {
  final exporter = otel_sdk.CollectorExporter(
    Uri.parse(
      'https://<seu-endpoint>/v1/traces', // 👈 não esqueça de incluir o /v1/traces!
    ),
    headers: {
      'Authorization': 'Bearer <sua-api-key>',
      'Content-Type': 'application/json',
    },
  );

  final simpleProcessor = otel_sdk.SimpleSpanProcessor(exporter);
  final batchProcessor = otel_sdk.BatchSpanProcessor(exporter);

  final tracerProvider = otel_sdk.TracerProviderBase(
    processors: [batchProcessor, simpleProcessor],
    resource: otel_sdk.Resource([
      otel_api.Attribute.fromString('service.name', 'main'),
      otel_api.Attribute.fromString('service.version', '1.0.0'),
      otel_api.Attribute.fromString('deployment.environment', 'dev'),
    ]),
  );

  otel_api.setTracerProvider(tracerProvider);

  tracer = tracerProvider.getTracer('flutter-app');
}

Acima, importamos o TraceProviderBase, que é o ponto inicial do open telemetry, ele fornece acesso ao Tracer, a classe responsável pela criação de spans.

Além disso, especificamos o uso do BatchSpanProcessor ele agrupa spans e os envia em massa.

Isolando a regra da coleta de erros com o padrão Service (error_reporter_service.dart)

A finalidade da camada de serviço, por outro lado, é encapsular a lógica de negócios em um único local para promover a reutilização de código e a separação de interesses.

Basicamente seria isolar uma tarefa específica em um outro objeto sendo assim assumindo uma responsabilidade muito estreita de realizar alguma atividade útil.

Então, vamos criar um serviço para integrar apenas a coleta de erros ao seu projeto Flutter e gerenciar os relatórios de erros. 👇🏻

import 'dart:isolate';

import 'package:flutter/foundation.dart';
import 'package:opentelemetry/api.dart';
import 'package:opentelemetry/sdk.dart';

class ErrorReporterService {
  static void initialize() {
    FlutterError.onError = (FlutterErrorDetails details) {
      _report(
        details.exception,
        details.stack ?? StackTrace.empty,
        'FLUTTER_ERROR',
      );
    };

    Isolate.current.addErrorListener(_isolateErrorListener);
  }

  static Future<void> _report(
    dynamic exception,
    StackTrace stack,
    String tag,
  ) async {
    final tracer = globalTracerProvider.getTracer('flutter-my-app');
    final span = tracer.startSpan('error: $tag');

    span.setStatus(StatusCode.error, exception.toString());
    span
      ..addEvent('date', timestamp: DateTimeTimeProvider().now)
      ..setStatus(StatusCode.error, exception.toString())
      ..recordException(
        exception,
        stackTrace: stack,
        attributes: [
          Attribute.fromString(
            'exception.type',
            exception.runtimeType.toString(),
          ),
          Attribute.fromString('exception.message', exception.toString()),
          Attribute.fromString('exception.stacktrace', stack.toString()),
          Attribute.fromString('error.tag', tag),
        ],
      );

    span.end();

    debugPrint('Erro capturado: $exception');
    debugPrintStack(label: tag, stackTrace: stack);
  }

  static SendPort get _isolateErrorListener {
    return RawReceivePort((pair) async {
      final List errorAndStacktrace = pair;
      final exception = errorAndStacktrace[0];
      final stackTrace = errorAndStacktrace[1] as StackTrace;
      await _report(exception, stackTrace, 'ISOLATE');
    }).sendPort;
  }

  static void reportExternalFailure(
    dynamic exception,
    StackTrace? stack,
    String? label,
  ) {
    if (stack != null && label != null) {
      _report(exception, stack, 'EXTERNAL_FAILURE: $label');
    }
  }
}

• Isolate.current.addErrorListener(_isolateErrorListener): adiciona um ouvinte de erros para isolados (ou seja, quando múltiplos threads estão rodando em paralelo no app), garantindo que erros ocorridos fora do thread principal sejam capturados e reportados.

Exemplo de uso do ErrorReportService

Essa abordagem centraliza a manipulação de exceções e falhas no aplicativo, garante que erros sejam capturados e enviados para monitoramento via Elastic APM, e oferece flexibilidade para criar diferentes tipos de erros com pouca repetição de código.

import 'package:flutter/foundation.dart';

import '../service/crashlytics_service.dart';

abstract class Failure implements Exception {
  final String errorMessage;

  Failure({
    StackTrace? stackTrace,
    String? label,
    dynamic exception,
    this.errorMessage = '',
  }) {
    // Loga a stack trace apenas no modo debug para evitar poluição de logs em produção.
    if (stackTrace != null && kDebugMode) {
      debugPrintStack(label: label, stackTrace: stackTrace);
    }

    // Reporta o erro ao service se houver exception
    ErrorReport.externalFailureError(exception, stackTrace, label);
  }
}

class UnknownError extends Failure {
  UnknownError({
    String? label,
    dynamic exception,
    StackTrace? stackTrace,
  }) : super(
          stackTrace: stackTrace,
          label: label,
          exception: exception,
          errorMessage:
              'Unknown Error', // Passa a mensagem diretamente para a classe base
        );
}

Possíveis extensões

Se no futuro você quiser criar outras subclasses de Failure para diferentes tipos de erros, será muito fácil. Por exemplo, você pode criar uma classe NetworkError para representar erros relacionados à rede, e utilizar o mesmo padrão de construção.

class NetworkError extends Failure {
  NetworkError({
    String? label,
    dynamic exception,
    StackTrace? stackTrace,
  }) : super(
          stackTrace: stackTrace,
          label: label,
          exception: exception,
          errorMessage: 'Network Error',
        );
}

Visualizando os dados no Elastic APM:

Abaixo na aba Traces veremos todos os erros coletados do nosso aplicativo, se você clicar nele verá vários dados e insights sobre ocorrido:

Conclusão

Bom é isso 😎.

Neste artigo, você aprendeu como configurar e preparar nossos aplicativos Flutter para serem usados ​​com o padrão da Open Telemetry o que é incrível pois é uma ferramenta robusta para coletar e analisar dados.

Aqui está o código do projeto de exemplo no github. 🔗

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter (X) | Medium

Se não for agora, quando vai ser?

Muita gente sonha em aprender a programar, mas sempre encontra uma desculpa para adiar: "não tenho tempo", "é difícil", "começo na próxima semana"... Mas a verdade é que o melhor momento para começar é HOJE!

A Era da Informação ao Seu Favor

Antigamente, aprender a programar exigia acesso a cursos caros, livros técnicos ou até mesmo uma faculdade. Hoje, basta um computador ou até mesmo um smartphone e conexão com a internet para começar.

Claro, e muita disposição de sentar na cadeira e aprender, chega de procrastinar. 😉

Há milhares de cursos gratuitos e pagos, desde plataformas como Codecademy, Udemy e Coursera até tutoriais no YouTube e documentações oficiais de linguagens populares como Python, Dart e JavaScript.

Comece com Pequenos Passos mas dê o Primeiro Passo

O segredo para aprender programação é começar com pequenos projetos e ir evoluindo. Aqui estão algumas sugestões:

1. Aprenda Lógica de Programação – Use Ferramentas como Scratch ou Portugol com VisualG para entender os fundamentos.

2. Escolha uma Linguagem – Python ou Dart é uma excelente opção para iniciantes pela sua sintaxe simples.

3. Construa Pequenos Projetos – Criar uma calculadora, um jogo simples ou um bot para Telegram pode ser um ótimo início.

4. Divulgue o que você constrói – Sites, Apps tudo o que fazer mostre para o mundo e isso vai te motivando na jornada. Vai por mim é incrível.

O Melhor Momento é Agora

Você pode começar hoje mesmo, e com dedicação, em alguns meses já terá desenvolvido projetos interessantes e legais. Não espere pelo “momento ideal”, pois ele já chegou. Aproveite as ferramentas disponíveis e dê o primeiro passo para uma nova habilidade que pode transformar sua vida profissional e pessoal!

Se você quiser se tornar um desenvolvedor mobile, veja este meu artigo com dicas de conteúdos.

Conclusão ✅

Uma das melhores partes de aprender a desenvolver software é a capacidade de criar coisas do zero. Desde pequenos scripts que automatizam tarefas até aplicativos completos, a programação permite transformar ideias em realidade.

Imagine desenvolver seu próprio site, criar um jogo ou até mesmo construir uma inteligência artificial que ajuda no dia a dia. O poder da tecnologia está nas suas mãos, e quanto mais você pratica, mais possibilidades se abrem!

Obrigado por ler até aqui. 😁

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição me manda uma DM ou deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos sobre desenvolvimento móvel 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

O que é um Teste de Widget?

Os testes de widget no Flutter verificam a interface do usuário de forma isolada, garantindo que os componentes se comportem corretamente sem a necessidade de rodar o app inteiro. Eles ficam no meio termo entre os testes unitários (que verificam partes isoladas do código) e os testes de integração (que testam o aplicativo como um todo).

Problema ao testar widgets de imagem como o Image.network.

Recentemente, estava desenvolvendo um novo aplicativo e queria atingir uma cobertura de testes bem alta, próxima de 90%. Então, decidi testar as páginas e os widgets do meu aplicativo, mas tive um problema com widgets de imagem, especialmente com o Image.network().

Um dos meus cards renderizava imagens vindas da minha API e, nos testes, tive o seguinte erro, como mostrado na imagem abaixo:

Se vc quiser simular esse mesmo problema de forma simplificada, execute esse teste na sua maquina: 👇🏻

import 'package:flutter_test/flutter_test.dart';
void main() {
  testWidgets('my image test', (WidgetTester tester) async {
    await tester.pumpWidget(
      MaterialApp(
        home: Image.network(
            'https://www.cdc.gov/healthy-pets/media/images/2024/04/Cat-on-couch.jpg'),
      ),
    );
  });
}

Se você executou o teste acima, ele vai dar o seguinte erro: 👇🏻

Por que isso acontece? 😕

Isso ocorre porque, por padrão, o ambiente de teste do Flutter retorna respostas HTTP com status 400 para todas as requisições de rede, incluindo aquelas feitas pelo Image.network().

Fazer solicitações HTTP reais em testes é problemático. Primeiro, torna a execução de testes mais lenta. Também torna os testes imprevisíveis e instáveis.

Como resolver isso? 🤔

Para resolver esse problema, você pode utilizar pacotes que simulam as respostas das requisições de rede durante os testes. Aqui está a opção que usei, se chama flutter_image_test_utils ele fornece uma maneira simples de simular respostas de imagens de rede em testes de widget.

Isso garantirá que as chamadas ao Image.network() sejam simuladas durante os testes, evitando erros relacionados a requisições de rede.

1. • Adicione o packagete ao seu pubspec.yaml:

        dev_dependencies:
          flutter_image_test_utils: ^1.0.0
     

     • No seu arquivo de teste, importe o pacote e utilize a função provideMockedNetworkImages e envolva seu codigo com ela, veja o exemplo abaixo:

        import 'package:flutter_test/flutter_test.dart';
        import 'package:flutter_image_test_utils/image_test/image_test.dart';
       
        void main() {
          testWidgets('my image test', (WidgetTester tester) async {
            provideMockedNetworkImages(() async {
              await tester.pumpWidget(
                MaterialApp(
                  home: Image.network(
                      'https://www.cdc.gov/healthy-pets/media/images/2024/04/Cat-on-couch.jpg'),
                ),
              );
            });
          });
        }
       

2. Isso permitirá que você teste widgets que carregam imagens da rede sem enfrentar erros de requisição. Executando o teste novamente podemos ver que ele passa com sucesso. 🟢 👇🏻

Ao utilizar essa abordagem, todas as solicitações HTTP GET dentro do provideMockedNetworkImages receberão uma resposta de sucesso simulada, e seus testes não travarão mais com erros 404.

Agora você poderá testar seus widgets que dependem de imagens da internet sem enfrentar erros de requisição, garantindo uma cobertura de testes mais robusta para o seu aplicativo Flutter. 🧘🏻

Conclusão

Os testes de widget no Flutter são essenciais para garantir a qualidade do seu aplicativo. Com uma boa estratégia de testes, você pode detectar problemas rapidamente e oferecer uma experiência de usuário mais confiável. Experimente escrever seus próprios testes e veja como eles podem melhorar seu fluxo de desenvolvimento!

Obrigado por ler até aqui. 😁

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição me manda uma DM ou deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos sobre desenvolvimento móvel 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

Hoje vamos aprender a configurar o JAVA_HOME e o ANDROID_HOME no macOS, você precisará modificar o arquivo de configuração do seu shell.

Essas variáveis de ambiente essenciais no desenvolvimento de software, principalmente quando estamos lidando com Java e Android.

Elas servem para informar ao sistema operacional onde estão localizados os diretórios de instalação do Java e do Android SDK (Software Development Kit)

Vamos ver os passos para cada um.

Configurando o JAVA_HOME

O JAVA_HOME é uma variável de ambiente que aponta para o diretório onde o Java está instalado no seu sistema.

Passo a passo:

1. Encontre o caminho de instalação do seu Java:

No terminal, você pode usar o comando which java para encontrar onde o Java está instalado. Exemplo:

which java

Isso vai retornar algo como:

/Users/ian.oliveira/Library/Java/JavaVirtualMachines/corretto-15.0.2/Contents/Home/bin/java.

Porém, para obter o diretório exato do Java (que é o que você precisa), use o seguinte comando:

/usr/libexec/java_home

Esse comando irá fornecer o caminho completo para o JDK instalado, algo como no caso da minha máquina:

/Users/ian.oliveira/Library/Java/JavaVirtualMachines/corretto-15.0.2/Contents/Home

Definindo a variável de ambiente JAVA_HOME

Agora que você tem o caminho, é hora de adicionar a variável no seu arquivo de configuração de shell (~/.zshrc, se você usa o Zsh ou ~/.bash_profile se você usa o Bash).

Se você usa o Zsh (o shell é o padrão a partir do macOS Catalina):

Abra o arquivo ~/.zshrc com o comando abaixo:

nano ~/.zshrc

Veja o resultado do comando na imagem abaixo:

Se você usa o Bash: Abra o arquivo ~/.bash_profile:

nano ~/.bash_profile

No final do arquivo, adicione a seguinte linha, substituindo o caminho com o que você obteve no passo anterior: 👇🏻

export JAVA_HOME=$(/usr/libexec/java_home)
export PATH=$JAVA_HOME/bin:$PATH

Recarregando o shell: Após salvar e fechar o arquivo, recarregue o shell o comando abaixo para aplicar as mudanças:

source ~/.zshrc # Para Zsh

source ~/.bash_profile # Para Bash

Para confirmar que a variável foi configurada corretamente, execute no terminal o comando abaixo:

echo $JAVA_HOME

Ele deve retornar o caminho certinho do JDK no seu terminal. 🎉

Configurando o ANDROID_HOME 🛠️

O ANDROID_HOME é uma variável de ambiente que aponta para o diretório onde o Android SDK está instalado.

Passo a passo:

1. Encontre o caminho do Android SDK: Normalmente, o Android SDK é instalado em ~/Library/Android/sdk, mas se você não tiver certeza, pode verificar se o Android Studio está configurado corretamente e onde ele instalou o SDK.

No meu caso está em /Users/ian.oliveira/Library/Android/sdk

2. Definindo a variável de ambiente ANDROID_HOME: Abra novamente o arquivo de configuração do seu shell (~/.zshrc ou ~/.bash_profile).

No final do arquivo, adicione as seguintes linhas abaixo, substituindo o caminho de instalação do Android SDK, se necessário:

export ANDROID_HOME=~/Library/Android/sdk
export PATH=$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools:$PATH

Recarregue o seu shell: Após salvar e fechar o arquivo, recarregue o shell para aplicar as mudanças:

source ~/.zshrc # Para Zsh

source ~/.bash_profile # Para Bash

Verifique se deu certo: Para confirmar, execute:

echo $ANDROID_HOME

Isso deve retornar o caminho certinho do Android SDK.

Agora suas variáveis de ambiente JAVA_HOME e ANDROID_HOME estarão configuradas no seu sistema. 🎉

Conclusão

Bom é isso 😎.

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

Que tal aproveitar 2025 para investir no seu desenvolvimento como engenheiro de software?

Existem várias maneiras de consumir conhecimento como desenvolvedor de software. Dentre elas, Lendo Documentação, Posts de Blog, Livros, Desenvolvendo Projetos Paralelos (Side Projects), Cursos/Workshops, Escrevendo e Ensinando.

Eu particularmante acredito que a leitura é uma das ferramentas mais poderosas para o desenvolvimento profissional e pessoal.

Para engenheiros de software, ela oferece insights valiosos, não só sobre tecnologias, mas também sobre práticas, mentalidades e abordagens que podem melhorar a qualidade do código e otimizar os processos de desenvolvimento. Quando se trata de se tornar um profissional mais eficiente e competente, os livros são verdadeiros mestres que nos guiam, nos educam e nos inspiram.

Neste post, vou compartilhar com você 6 livros que li e que considero essenciais para a carreira em desenvolvimento de software. Se você quer aprimorar suas habilidades, aumentar sua produtividade e adotar as melhores práticas no seu dia a dia, esses livros são uma leitura obrigatória para 2025! ⚡️

1. O Programador Pragmático – Andrew Hunt e David Thomas

Este é um dos livros mais recomendados para programadores de todos os níveis, e não é à toa. O Programador Pragmático ensina que ser um bom programador não é apenas sobre escrever código que funciona, mas sobre como pensar de forma crítica e pragmática sobre os problemas que você está resolvendo.

O livro aborda princípios fundamentais, como design, refatoração, testes, depuração e como aprender constantemente. É um guia para ser um programador mais eficiente, flexível e criativo, sempre em busca de soluções práticas e elegantes.

Eu curti bastante esse livro pois ele mostrou para mim como construir uma mentalidade mais pragmática e focada no valor real que o software pode oferecer. 🔥

2. Codificador Limpo (Clean Code) – Robert C. Martin

Se você quer escrever código legível, bem estruturado e fácil de manter, Codificador Limpo é uma leitura essencial. Robert C. Martin, um dos maiores nomes na área de desenvolvimento de software, compartilha as melhores práticas para escrever código limpo, que é uma das habilidades mais importantes para engenheiros de software.

O livro aborda conceitos como a importância de nomes significativos para variáveis e funções, a estruturação adequada do código, e como evitar a complexidade desnecessária.

O foco principal desse livro é lhe ensinar a conduta do programador como profissional, algo extremamente importante nos dias de hoje 😁.

3. Código Limpo (Clean Code) – Robert C. Martin

Agora se tem um livro que eu não poderia deixar de mencionar é o livro Código Limpo, ele é uma versão mais profunda e abrangente da filosofia do código limpo. o Uncle bob expande ainda mais as ideias do primeiro livro citado acima, trazendo mais exemplos, estudos de caso e explicações sobre como manter o código simples e organizado.

Nesse livro eu aprendi os principais princípios e práticas para garantir que o código seja não apenas limpo, mas também ágil, eficiente e fácil de modificar ✍🏻.

4. Arquitetura Limpa (Clean Architecture) – Robert C. Martin

Todo desenvolvedor de software precisa saber arquitetar bem um software, então o livro Arquitetura Limpa é fundamental.

Aqui, o autor vai além do código e mostra como criar uma arquitetura que seja robusta, escalável e fácil de entender.

O livro discute como organizar o código de forma a minimizar dependências e maximizar a flexibilidade. Para quem está lidando com sistemas complexos, este livro é uma verdadeira aula sobre como construir software com uma arquitetura sólida.

O que eu achei mais legal desse livro é que ele enfatiza a separação de responsabilidades, o uso de princípios como SOLID e como garantir que o código esteja preparado para mudanças futuras 🛠️.

5. Engenharia de Software Moderna – David Farley

Este livro é uma leitura obrigatória para quem quer entender as melhores práticas atualizadas de engenharia de software no contexto moderno. David Farley apresenta uma abordagem prática sobre como criar software de qualidade de forma ágil, confiável e eficiente.

Ele fala sobre automação de testes, integração contínua, desenvolvimento baseado em testes e outras práticas fundamentais para o sucesso em projetos de software.

Aqui são oferecidos insights sobre o desenvolvimento ágil, práticas de entrega contínua e como construir sistemas robustos e escaláveis em um ambiente de software dinâmico. 🎯

6. Deep Work: Retorne à Foco e Realize um Trabalho de Qualidade em um Mundo Distraído – Cal Newport

Agora pra finalizar vou mostrar o melhor livro que li nesse ano de 2024, embora não seja um livro específico sobre programação, Deep Work é altamente relevante para qualquer profissional.

Nosso trabalho como engenheiro de software geralmente necessita de foco, concentração profunda e sem distrações para realizarmos tarefas complexas dentro do prazo.

No livro o autor explora como o foco profundo é a chave para alcançar resultados excepcionais no trabalho. Em um campo como o de software, onde tarefas complexas e detalhadas exigem atenção total, aprender a trabalhar profundamente sem distrações é fundamental.

Com esse livro eu aprendi algumas estratégias para melhorar o foco, eliminar distrações e maximizar sua produtividade 🎧.

Outro ponto interessante é que o autor, sendo cientista da computação, apresenta diversos exemplos de sucesso na engenharia de software, destacando pessoas que alcançaram grandes resultados graças ao foco profundo. 🧘🏻

Conclusão

Não subestime o poder de um bom livro; eles contêm uma vasta quantidade de conhecimentos de profissionais altamente experientes em suas áreas. Afinal, nada melhor do que aprender com a experiência dos outros.

Em 2025, se você se comprometer com a leitura desses títulos, com certeza verá grandes melhorias no seu desempenho como desenvolvedor. Boa leitura e bons códigos 🧑🏻‍💻.

E para encerrar, mais uma dica valiosa, acredite em mim: aproveite esse fim de ano para planejar sua carreira e metas.

Obrigado por ler até aqui. Boas festas, bom natal e um feliz ano novo. 🥳🍾 🎉🌲

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir software incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição me manda uma DM ou deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos sobre engenharia de software 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

O Firebase Analytics, é uma ferramenta gratuita do Firebase, que coleta dados de uso, engajamento do usuário e comportamento para o seu aplicativo.

Com ele você pode obter insights de como as pessoas usam o seu aplicativo.

Saber quais partes ou funcionalidades são mais populares e por quanto tempo são utilizadas além de podermos registrar eventos e propriedades do usuário.

Imagine um aplicativo de exercícios físicos, o analytics pode registrar o exercício favorito de um usuário ou registrar o gênero favorito de um usuário para um aplicativo de música.

Outro exemplo, seria rastrear quando alguém termina um nível de jogo, compra algo ou usa uma parte específica do seu aplicativo.

No geral com os dados do Analytics você pode tomar decisões mais acertadas sobre marketing de aplicativos e otimizações de desempenho.

Você também pode olhar esse video do canal do Firebase onde eles explicam resumidamente como funciona a ferramenta.

Este artigo faz parte da série “Dominando o Firebase em Aplicativos Flutter”, uma sequência de posts que explora como utilizar todos os produtos do Firebase em conjunto com o Flutter. Confira as demais publicações da série no meu blog para aprofundar seus conhecimentos. 📚

Benefícios do Firebase Analytics

• Vários tipos de métricas: Ajuda a descrever comportamentos dos usuários – como informações geográficas, demográficas etc.

  • Informações demográficas  — quem são seus usuários.

  • Retenção  — com que regularidade eles usam seu aplicativo.

  • Engajamento  — quanto tempo eles gastam e em quê.

  • Receita média  — mostra quanto eles gastaram, se seu aplicativo oferecer suporte a compras no aplicativo

• Rastreamento de eventos: Você pode rastrear eventos que ocorrem dentro do seu aplicativo. Por exemplo um aplicativo de exercícios físicos pode registrar o exercício favorito de um usuário ou um aplicativo de música pode registrar o gênero favorito do usuário.

• Integração com o Firebase: O Analytics tem integração nativa com outras ferramentas do Firebase, como Crashlytics, fornecendo dados mais abrangentes sobre a saúde e o comportamento de seus aplicativos.

Configurando e utilizando em seu projeto 🛠️

1 — Habilitando o Analytics

Vá para o console do firebase e no painel esquerdo vá para Analytics no menu e clique no botão Ativar o Google analytics.

Em seguida ele vai abrir uma nova tela, apenas clique em Ativar, veja a imagem abaixo:

Em seguida uma nova tela será aberta pedindo pra configurar o Firebase no seu aplicativo caso ainda não tenha feito, se sim apenas prossiga clicando em concluir:

2 — Adicionando a dependência em seu projeto

Vamos começar adicionando a dependência ao nosso arquivo pubspec.yaml.

Instale o pacote a partir da linha de comando com o Flutter:

$ flutter pub add firebase_analytics

Ou adicione firebase_crashlytics diretamente em seu pubspec.yaml e execute flutter pub get no momento da criação desse post ele está na versão 4.1.1 .

dependencies:
 firebase_analytics: ^11.3.3

Agora, no seu código Dart, você pode importar o package:

import 'package:firebase_crashlytics/firebase_analytics.dart';

Painel do Analytics

Analytics do Firebase fornece um dashboard que mostra um gráfico somativo de métricas-chave para seu aplicativo. Aqui você pode obter as informações básicas e dados de seus usuários, como usuários ativos, usuários ativos nos últimos 30 minutos, principais eventos de conversão, receita total, adoção de versão do aplicativo, etc.

Bom não é mesmo? 😎

Eventos e Conversões

Eventos: No centro do Firebase Analytics, os eventos são o que acontece no seu aplicativo, como ações do usuário ou eventos do sistema ou erros.

Conversões: São ações importantes que os usuários do site ou app realizam e que os transformam em clientes, geram leads ou assinantes. São exemplos de conversões: compras, inscrições, entre outras.

Veremos um pouco mais sobre isso aditante.

O Analytics registra automaticamente alguns eventos para você. Não é necessário adicionar códigos para recebê-los. Caso o aplicativo precise coletar outros dados, é possível registrar até 500 tipos diferentes de eventos do Analytics no app, veja abaixo alguns exemplos:

first_open: Na primeira vez que um usuário inicia um app após a instalação ou reinstalação. Este evento não é acionado quando um usuário faz o download do app em um dispositivo, mas quando ele o utiliza pela primeira vez..

in_app_purchase : se seu aplicativo oferece compras no aplicativo, automaticamente um evento de compra no aplicativo será registrado para você, contendo o valor da compra e o produto que foi adquirido.

session_start: Quando um usuário interage com o app ou site.

Eventos sugeridos

O próprio google nos recomenda alguns eventos essenciais aos clientes em todos os verticais de negócio. O SDK define uma série de eventos sugeridos que são comuns entre diferentes tipos de aplicativos, incluindo aplicativos de varejo e comércio eletrônico, viagens e jogos.

Para saber mais sobre esses eventos e quando usá-los, navegue pelos artigos e clique nesse link e veja a lista completa dos eventos.

Nos eventos sugeridos, você pode usar:

• Jogos

• Varejo/comércio eletrônico

• Empregos

• Educação

• Viagem

• Ofertas locais

• Imobiliária

Por exemplo, se você quiser ver quando um usuário adicionar um produto no carrinho de compras, você pode usar o evento add_to_cart que se enquadra na categoria de eventos varejo/comércio eletrônico ou usar o evento view_item que indica que parte do conteúdo foi exibido ao usuário.

Eventos personalizados

Se seu aplicativo tiver necessidades específicas não cobertas por um tipo de evento sugerido, você pode registrar seus próprios eventos personalizados

Certifique-se de apenas criar eventos personalizados quando nenhum outro evento funciona para o seu exemplo de utilização. Os eventos personalizados não são apresentados na maioria dos relatórios padrão e, por isso, tem de configurar explorações ou relatórios personalizados para obter uma análise significativa.

Enviando eventos para Analytics ⚡️

Para implementar eventos de conversão com Firebase Analytics no seu app Flutter, a estratégia é identificar os principais pontos de interação do usuário com seu app. Esses eventos de conversão geralmente estão ligados a ações que têm impacto nos objetivos do app, como engajamento, retenção ou receita.

Sugiro que passe um tempo mapeando quais partes do seu aplicativo seriam importantes para estarem no analytics ✍🏻.

Para enviar dados de eventos ao Analytics, no seu main.dart adicione o seguinte trecho de código:

Future<void> main() async {
    WidgetsFlutterBinding.ensureInitialized();
    await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
    FirebaseAnalytics.instance.setAnalyticsCollectionEnabled(true);
    runApp(MyApp());
}

Antes de usar o Firebase Analytics, você precisa inicializar o Firebase.

Agora execute seu aplicativo e vá para o Dashboard do Analytics no console do firebase. A princípio, não haverá dados do usuário, pois o aplicativo é criado pela primeira vez, então levará tempo, e também não há eventos integrados no flutter, mas podemos ver um dado que é atualizado rapidamente que é os usuarios ativos no momento.

Você pode ver a atividade dos usuários nos últimos 30 minutos após buildar seu aplicativo no meu caso levou uns 3 minutos para aparecer essa informação no painel.

Adicionando eventos no Firebase Analytics

• Eventos: o que está acontecendo no seu aplicativo, como ações do usuário, eventos do sistema ou erros. Você pode relatar até 500 tipos diferentes de Eventos por aplicativo e pode associar até 25 parâmetros exclusivos a cada tipo de Evento.

  Cada tipo de evento é identificado por um nome exclusivo. Os nomes de eventos podem ter até 40 caracteres, podem conter apenas caracteres alfanuméricos e sublinhados ("_") e devem começar com um caractere alfabético.

• Propriedades do usuário: atributos que você define para descrever segmentos da sua base de usuários, como preferência de idioma ou localização geográfica.

Certos eventos são recomendados para todos os aplicativos, outros são recomendados para tipos de negócios ou verticais específicos.

Você deve enviar eventos sugeridos junto com seus parâmetros prescritos, para garantir o máximo de detalhes disponíveis em seus relatórios e para se beneficiar de recursos e integrações futuras conforme eles se tornam disponíveis.

await FirebaseAnalytics.instance
  .logBeginCheckout(
    value: 10.0,
    currency: 'USD',
    items: [
      AnalyticsEventItem(
        itemName: 'Socks',
        itemId: 'xjw73ndnw',
        price: '10.0'
      ),
    ],
    coupon: '10PERCENTOFF'
  );

Eventos predefinidos: O evento logBeginCheckout é criado especificamente para rastrear o início de um processo de checkout ele é um evento padrão do analytics para aplicativos de compras.

Eventos personalizados: Se seu aplicativo tiver necessidades específicas não cobertas por um tipo de evento sugerido, você pode registrar seus próprios eventos personalizados, conforme mostrado neste exemplo:

await FirebaseAnalytics.instance.logEvent(
    name: "share_image",
    parameters: {
        "image_name": name,
        "full_text": text,
    },
);

logEvent é um método de uso geral para registrar eventos personalizados com um nome e parâmetros definidos por você.

O evento do exemplo se chama share_image.

parameters: Aqui você pode passar informações adicionais, como o método de cadastro (ex: email, Google, etc.) ou até mesmo o ID do usuário recém-criado.

Parâmetros personalizados podem ser usados como dimensões ou métricas em relatórios do Analytics.

Aqui estão algumas sugestões de onde você pode implementar eventos de conversão 🎯

1. Cadastro/Login de Usuário:

   • Evento: sign_up ou login

   • Quando um usuário criar uma conta ou fizer login no app, você pode capturar esses eventos para medir o engajamento de novos usuários e a retenção de antigos.

2. Interações com Funcionalidades Importantes:

   • Evento: Defina eventos personalizados como feature_usage para funcionalidades que você considera chave no app.

   • Exemplo: No caso de um app de adoção de pets, pode ser quando o usuário visualizar um pet ou enviar uma solicitação de adoção.

3. Compra ou Ações Monetizadas (se houver):

   • Evento: purchase ou um evento personalizado como subscription_upgrade

   • Caso o app tenha compras ou assinatura premium, é essencial rastrear quando um usuário realiza uma compra ou upgrade.

4. Finalização de Fluxos Críticos:

   • Evento: conversion

   • Esse evento pode ser acionado quando o usuário completar um fluxo essencial para o objetivo do app. No seu caso, seria ideal rastrear quando um usuário adota um pet com sucesso, por exemplo.

Esses eventos darão insights sobre o comportamento do usuário e ajudarão a medir o sucesso das conversões dentro do seu app.

Onde integrar os eventos no aplicativo?

Para chamar os métodos do Firebase Analytics no Flutter, o ideal é integrá-los nos momentos corretos do ciclo de vida das telas e nas interações do usuário. Aqui estão os melhores pontos para chamar os métodos do Analytics no seu app Flutter:

1. Inicialização do App (Primeira execução ou navegação)

Se você deseja rastrear a primeira vez que o usuário abre o app ou chega em uma tela específica, pode usar o método logEvent no momento em que a tela é construída ou quando o app é iniciado.

•   @override
    void initState() {
      super.initState();
      FirebaseAnalytics.instance.logEvent(name: 'app_open');
    }
  

Esse código pode ser colocado no initState da tela inicial do seu app ou na primeira página carregada após o Splash Screen.

2. Navegação Entre Telas:

Use o Firebase Analytics para rastrear quando o usuário navega entre telas ou páginas importantes no seu app. Para isso, você pode utilizar o método setCurrentScreen quando a navegação for concluída.

•   @override
    void didChangeDependencies() {
      super.didChangeDependencies();
      FirebaseAnalytics.instance.setCurrentScreen(
        screenName: 'home_screen',
        screenClassOverride: 'HomeScreen',
      );
    }
  

Chame esse método quando o usuário acessar uma nova página, como na função de navegação ou ao construir o widget da página.

3. Interações de Usuário:

Para eventos que envolvem interações específicas, como clicar em um botão, enviar um formulário ou qualquer outra ação importante, você deve chamar o método logEvent diretamente dentro do callback do evento.

•   ElevatedButton(
      onPressed: () {
        FirebaseAnalytics.instance.logEvent(name: 'button_click', parameters: {
          'button_name': 'adopt_pet',
        });
      },
      child: Text('Adotar Pet'),
    )
  

Isso vai garantir que eventos de interação como cliques ou ações de formulário sejam registrados corretamente.

4. Finalização de Páginas

• Se você deseja rastrear quando o usuário deixa uma página ou completa uma tarefa (ex: finaliza o cadastro), você pode chamar o logEvent ou setCurrentScreen ao sair de uma página ou ao final de um fluxo de navegação.

Onde evitar? 🧐

• Construtor de Widgets: Evite chamar eventos de Analytics no build() de widgets. Isso pode resultar em chamadas excessivas e impactar o desempenho, já que o build pode ser chamado várias vezes durante a execução de uma página.

Conversões

São seus eventos mais importantes que contribuem para o sucesso do seu negócio. Quando você rotula um evento como um evento de conversão, ele será carregado imediatamente pelo SDK para torná-lo acionável mais rapidamente.

Coisas como fazer uma compra, inscrever-se para uma conta, compartilhar um produto e assim por diante são todos bons eventos que devem ser rotulados como conversões.

Por exemplos poderiamos ter uma conversão chamada begin_checkout que é quando um usuário clica no botão Checkout em seu carrinho de compras.

Audiências

São grupos específicos de usuários segmentados que você pode definir com base em certos critérios ou eventos dentro do seu app Flutter.

Isso permite que você segmente os usuários com base em atributos como idade, localização, eventos específicos que realizaram no app, ou até ações como interações com certas telas ou cliques em botões.

Essas audiências são úteis para acompanhar o comportamento de grupos específicos, criando campanhas personalizadas e direcionadas, como enviar notificações específicas via Firebase Cloud Messaging.

Por exemplo, poderiamos criar um audiência de usuários que visualizam produtos várias vezes, mas não fazem uma compra e nesse caso enviar enviar notificações específicas para esse público.

Rastrear propriedades do usuário

Você pode definir propriedades de asuário do Analytics para descrever os usuários do seu aplicativo. Analisar comportamentos de vários segmentos de usuários aplicando essas propriedades como filtros aos seus relatórios. Veja o exemplo abaixo:

await FirebaseAnalytics.instance
  .setUserProperty({
    name: 'favorite_food',
    value: favoriteFood,
  });

Rastrear IDS do usuário

O Google Analytics tem uma setUserID método, que permite que você armazene um ID de usuário para o indivíduo que usa seu aplicativo.

Observação: você é responsável por garantir que seu uso do ID do usuário esteja de acordo com os Termos de Serviço do Google Analytics .

Isso inclui evitar o uso de informações de identificação pessoal não permitidas e fornecer aviso apropriado sobre seu uso de identificadores em sua Política de Privacidade

await FirebaseAnalytics.instance
  .setUserId({
    id: 'xxxxxxx'
  });

Rastrear visualizações de tela

O Analytics rastreia transições de tela e anexa informações sobre a tela atual a eventos, permitindo que você rastreie métricas como engajamento do usuário ou comportamento do usuário por tela.

O método setCurrentScreen é usado para definir o nome da tela atual e a classe, que podem então aparecer no console do Firebase. Isso ajuda você a entender o fluxo de interação do usuário no seu aplicativo e identificar telas e caminhos de navegação populares onde os usuários passam a maior parte do tempo.

Entender isso pode ajudar você a tomar decisões baseadas em dados sobre em quais áreas do seu aplicativo concentrar seus esforços de desenvolvimento e melhoria.

await FirebaseAnalytics.instance.setCurrentScreen(
  screenName: 'screen_name',
  screenClassOverride: 'screen_class',
);

Firebase Analytics Observer ao Navigator (opcional)

Se você quiser rastrear eventos de navegação, precisará adicionar o FirebaseAnalyticsObserver à propriedade navigatorObservers do seu MaterialApp , WidgetsApp ou CupertinoApp .

Veja o exemplo abaixo: ⬇️

class MyApp extends StatelessWidget {
  // Inicializando o FirebaseAnalytics
  static FirebaseAnalytics analytics = FirebaseAnalytics();
  static FirebaseAnalyticsObserver observer =
      FirebaseAnalyticsObserver(analytics: analytics);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Firebase Analytics Example',
      navigatorObservers: [
        observer,  // Adiciona o FirebaseAnalyticsObserver ao sistema de navegação
      ],
      home: MyHomePage(),
    );
  }
}

O FirebaseAnalyticsObserver é uma classe do pacote firebase_analytics no Flutter, usada para integrar o Firebase Analytics ao sistema de navegação do Flutter.

Isso permite que eventos de navegação dentro do app sejam automaticamente rastreados e enviados ao Firebase Analytics, facilitando o acompanhamento de quais telas estão sendo acessadas pelos usuários e em que ordem.

Quando você adiciona o FirebaseAnalyticsObserver ao seu app Flutter, ele monitora as mudanças de rota (ou páginas) dentro da aplicação e envia eventos correspondentes para o Firebase Analytics, como o nome da rota que foi visitada. Isso é útil para medir o comportamento do usuário, como quais telas ele acessa mais frequentemente ou se ele completa um fluxo específico no app.

Conferindo os eventos no painel

Você pode encontrar estatísticas agregadas sobre os eventos nos painéis de controle do Console do Firebase. Eles são atualizados periodicamente ao longo do dia.

🛑 Segundo a documentação, pode ser que leve de 1h até 24 horas para aparecer os eventos clicados no aplicativo.

Siga para a proxíma seção: ⬇️

Exibir eventos na depuração (DebugView)

Com o modo DebugView, você pode ver dados brutos de eventos registrados pelo seu app quase em tempo real em dispositivos de desenvolvimento.

Isso é muito útil para fins de validação durante a fase de instrumentação do desenvolvimento e pode ajudar você a descobrir erros e falhas na sua implementação do Analytics, além de confirmar se todas as propriedades dos usuários e eventos estão sendo registrados corretamente.

Android

Para habilitar a depuração em dispositivos Android, execute o seguinte comando no seu terminal:

adb shell setprop debug.firebase.analytics.app [your_app_package_name]

O modo de depuração vai permanecer ativado até que você execute a linha de comando a seguir:

adb shell setprop debug.firebase.analytics.app .none.

iOS

Para habilitar o debug view para iOS, comece abrindo a pasta ios no Xcode. Em seguida, navegue até Product->Scheme->Edit Scheme.

Seguida adicione os seguintes argumentos -FIRDebugEnabled e -FIRDebugDisabled

Para adicionar esses argumentos, edite o esquema do projeto e adicione uma nova entrada a "Arguments Passed on Launch". conforme mostrado acima

🛑 Atenção! O debug view no iOS só funcionará se você executar seu aplicativo diretamente do Xcode . Executar o aplicativo usando flutter run ou por meio de outra IDE não acionará os argumentos a serem executados na inicialização.

Para desabilitar a depuração, você pode executar os seguintes argumentos na inicialização: *-*FIRDebugDisabled e -FIRAnalyticsDebugDisabled.

Visualizando o DebugView 💡

Rodei o aplicativo no android e os eventos apareceram em tempo real no painel como mostrado na imagem abaixo:

O streaming de segundos (coluna do meio) exibe os eventos que foram registrados nos últimos 60 segundos. O streaming de minutos (coluna da esquerda) exibe uma série de arquivos de eventos nos últimos 30 minutos.

A coluna da direita exibe os principais eventos registrados no intervalo de 30 minutos, bem como as propriedades do usuário atual do dispositivo de desenvolvimento selecionado no momento.

Saiba mais sobre o debug view no link: 🔗

Isolando a regra do Analytics com o padrão Service

A finalidade da camada de serviço, por outro lado, é encapsular a lógica de negócios em um único local para promover a reutilização de código e a separação de interesses.

Basicamente seria isolar uma tarefa específica em um outro objeto sendo assim assumindo uma responsabilidade muito estreita de realizar alguma atividade útil.

Então, vamos criar um serviço para integrar o Firebase Analytics ao seu projeto Flutter e gerenciar os relatórios de erros. 👇🏻

import 'package:firebase_analytics/firebase_analytics.dart';

import 'package:flutterfirebaseapp/errors/failure.dart';

abstract class AnalyticsService {
  /// If analytics is supported on the current platform.
  Future<void> initAnalytics();

  /// If analytics is supported on the current platform.
  Future<bool> isSupported();

  /// Retrieves the session id from the client. Returns null if analyticsStorageConsentGranted is false or session is expired.
  Future<int?> getSessionId();

  /// Logs the standard `app_open` event.
  Future<void> logAppOpen();

  /// Logs events customizeds with the given [name] and [parameters].
  /// [name] is the name of the event.
  /// [parameters] are the optional parameters.
  Future<void> logEvent({
    required String name,
    Map<String, Object>? parameters,
  });

  /// Logs the standard `screen_view` event.
  /// [screenClass] is the class of the screen.
  /// [screenName] is the name of the screen.
  /// [parameters] are the optional parameters.
  Future<void> logScreenView({
    String? screenClass,
    String? screenName,
    Map<String, Object>? parameters,
  });

  /// Logs the standard `sign_up` event.
  /// [signInMethod] is the method used to sign up.
  /// [parameters] are the optional parameters.
  Future<void> logSignUp({
    required String signUpMethod,
    Map<String, Object>? parameters,
  });

  /// Clears all analytics data for this app from the device and resets the app instance id.
  Future<void> resetAnalyticsData();

  /// Adds parameters that will be set on every event logged from the SDK, including automatic ones.
  /// [defaultParameters] are the default parameters.
  Future<void> setDefaultEventParameters(
    Map<String, Object?>? defaultParameters,
  );

  /// Sets the duration of inactivity that terminates the current session.
  /// [timeout] is the duration of inactivity that terminates the current session.
  Future<void> setSessionTimeoutDuration(Duration timeout);

  /// Sets the user id.
  /// [id] is the user id.
  Future<void> setUserId({String? id});

  /// Sets the user property.
  /// [name] is the name of the property.
  /// [value] is the value of the property.
  Future<void> setUserProperty({
    required String name,
    required String? value,
  });
}

/// A class that extends [AnalyticsService] to log events and
/// screen views for Google and Firebase Analytics
class CustomAnalyticsService implements AnalyticsService {
  final _firebaseAnalytics = FirebaseAnalytics.instance;
  @override
  Future<void> initAnalytics() async {
    await _firebaseAnalytics.setAnalyticsCollectionEnabled(true);
  }

  @override
  Future<int?> getSessionId() async {
    try {
      return await _firebaseAnalytics.getSessionId();
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried get session id from analytics: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<bool> isSupported() async {
    try {
      return await _firebaseAnalytics.isSupported();
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried check if analytics is supported: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> logAppOpen({Map<String, Object>? parameters}) async {
    try {
      await _firebaseAnalytics.logAppOpen(parameters: parameters);
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried register a log for app open: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> logEvent({
    required String name,
    Map<String, Object>? parameters,
  }) async {
    try {
      await _firebaseAnalytics.logEvent(
        name: name,
        parameters: parameters,
      );
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried register a event: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> logScreenView({
    String? screenClass,
    String? screenName,
    Map<String, Object>? parameters,
  }) async {
    try {
      await _firebaseAnalytics.logScreenView(
        screenClass: screenClass,
        screenName: screenName,
        parameters: parameters,
      );
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried register a event for Screen View: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> logSignUp({
    required String signUpMethod,
    Map<String, Object>? parameters,
  }) async {
    try {
      await _firebaseAnalytics.logSignUp(
        signUpMethod: signUpMethod,
        parameters: parameters,
      );
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried register a log for sign up: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> resetAnalyticsData() async {
    try {
      await _firebaseAnalytics.resetAnalyticsData();
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried reset log from analytics data: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> setDefaultEventParameters(
    Map<String, Object?>? defaultParameters,
  ) async {
    try {
      await _firebaseAnalytics.setDefaultEventParameters(defaultParameters);
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried set default event parameters on analytics: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> setSessionTimeoutDuration(Duration timeout) async {
    try {
      await _firebaseAnalytics.setSessionTimeoutDuration(timeout);
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried set session timeout on analytics: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> setUserId({String? id}) async {
    try {
      await _firebaseAnalytics.setUserId(id: id);
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried register user id on analytics: exception $exception stackTrace: $stackTrace",
      );
    }
  }

  @override
  Future<void> setUserProperty({
    required String name,
    required String? value,
  }) async {
    try {
      await _firebaseAnalytics.setUserProperty(name: name, value: value);
    } catch (exception, stackTrace) {
      throw AnalyticsException(
        "Error when tried register user property on analytics: exception $exception stackTrace: $stackTrace",
      );
    }
  }
}

Referências:

https://firebase.flutter.dev/docs/analytics/get-started

https://www.walturn.com/insights/how-to-set-up-analytics-in-flutter-using-firebase

https://firebasetutorials.com/events-in-firebase-analytics/

Conclusão

Bom é isso 😎.

O Firebase Analytics é uma ótima ferramenta para entender melhor o comportamento do seu cliente e o desempenho do aplicativo combinado a outros produtos do Firebase. 🔥

Neste artigo, você aprendeu como configurar e preparar nossos aplicativos Flutter para serem usados ​​com o Firebase Analytics. 📚

Aqui está o código do projeto de exemplo no github. 🔗

Em artigos futuros da série, veremos como usar outros recursos do Firebase, como Authentication, Remote Config, Admob e muito mais com Flutter. 💙

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo! 🌍

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter (X) | Medium

Diga adeus às falhas misteriosas com o Crashlytics!

O Firebase Crashlytics, uma ferramenta robusta e essencial do Firebase, é um serviço fornecido pelo Google projetado para rastrear e capturar falhas em tempo real em nossos aplicativos.

Sua funcionalidade crucial reside em manter um registro detalhado e imediato de qualquer falha que ocorra, oferecendo insights valiosos sobre a estabilidade do aplicativo. Ao enviar relatórios detalhados assim que as falhas acontecem, o Crashlytics fornece uma visão clara e profunda das questões que afetam a experiência do usuário.

Ao coletar dados preciosos, essa ferramenta capacita os desenvolvedores a entenderem melhor a causa raiz dos problemas e assim tomar medidas corretivas eficazes.

Este artigo faz parte da série “Dominando o Firebase em Aplicativos Flutter”, uma sequência de posts que explora como utilizar todos os produtos do Firebase em conjunto com o Flutter. Confira as demais publicações da série no blog para aprofundar seus conhecimentos.

Benefícios do Firebase Crashlytics

• Melhora na estabilidade do aplicativo: Com insights detalhados sobre as falhas, você pode corrigir bugs de forma rápida e eficiente, resultando em um aplicativo mais confiável.

• Experiência aprimorada do usuário: Identificando e corrigindo erros proativamente, você evita experiências ruins para os usuários, o que leva a melhor satisfação e retenção.

• Economia de tempo de desenvolvimento: As informações detalhadas do Crashlytics ajudam a localizar e solucionar problemas com muito mais rapidez em comparação a tentativas aleatórias de depuração.

• Integração com o Firebase: O Crashlytics tem integração nativa com outras ferramentas do Firebase, como Analytics, fornecendo dados mais abrangentes sobre a saúde e o comportamento de seus aplicativos.

Você também pode olhar esse video do canal do Flutter onde eles explicam resumidamente como funciona a ferramenta.

Configurando e utilizando em seu projeto

1 — Habilitando o Crashlytics

Vá para o Console do Firebase e no painel esquerdo, em Release & Monitor, vá para Crashlytics no menu e clique no botão.

2 — Adicionando a dependência em seu projeto

Vamos começar adicionando a dependência ao nosso arquivo pubspec.yaml.

Instale o pacote a partir da linha de comando com o Flutter:

$ flutter pub add firebase_crashlytics

Ou adicione firebase_crashlytics diretamente em seu pubspec.yaml e execute flutter pub get no momento da criação desse post ele está na versão 4.1.1 .

dependencies:
 firebase_crashlytics: ^4.1.1

Agora, no seu código Dart, você pode importar o package:

import 'package:firebase_crashlytics/firebase_crashlytics.dart';

Painel do crashytics

Essa é a parte central do Crashlytics. Ela contém informações sobre o dispositivo, usuário, logs, stack traces, etc.

Tipos de falhas

No Firebase Crashlytics, os erros são divididos em duas categorias principais: erros fatais e erros não fatais. Vamos entender cada um:

Erros Fatais (Fatal Errors)

São falhas que levam ao fechamento inesperado do aplicativo, interrompendo a execução imediatamente.

Por exemplo: quando uma exceção não tratada ocorre e o app é forçado a parar, como um erro de NullPointerException em uma linguagem como Kotlin ou Java.

Erros Não Fatais (Non-fatal Errors)

São erros que ocorrem dentro do aplicativo, mas que não causam o fechamento imediato. O aplicativo continua rodando, mas uma operação pode ter falhado ou algo não foi executado corretamente.

Por exemplo: uma requisição de rede que falha ou uma operação lógica que lança uma exceção tratada, como um erro de parsing JSON. Registrar exceções não fatais significa que podemos registrar exceções capturadas nos blocos catch do nosso aplicativo.

Enviando relatórios para Crashlytics ⚡️

Para enviar dados de relatório ao Crashlytics, o aplicativo deve ser reiniciado. O Crashlytics envia automaticamente quaisquer relatórios de falhas ao Firebase na próxima vez que o aplicativo for iniciado.

Para testar se a integração com o crashlytics foi realizada com sucesso vamos induzir um erro de propósito para que seja registrado no console do firebase.

No seu main.dart adicione o seguinte trecho de código:

Future<void> main() async {
    WidgetsFlutterBinding.ensureInitialized();
    await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
    FlutterError.onError = (errorDetails) {
      FirebaseCrashlytics.instance.recordFlutterFatalError(errorDetails);
    };
    // Pass all uncaught asynchronous errors that aren't handled by the Flutter framework to Crashlytics
    PlatformDispatcher.instance.onError = (error, stack) {
      FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
      return true;
    };
    runApp(MyApp());
}

Ao substituir o FlutterError.onError por FirebaseCrashlytics.instance.recordFlutterError, ele captura automaticamente todos os erros lançados na estrutura do Flutter e registra-os para enviar ao Firebase.

Para capturar quaisquer erros assíncronos que não são tratados pela estrutura do Flutter, podemos usar PlatformDispatcher.instance.onError

Depois que rodei o aplicativo com o código acima o crashlytics detectou a integração com o meu aplicativo automaticamente. Veja a imagem abaixo:

Gerando uma falha para registro

Agora crie um botão qualquer no seu aplicativo Flutter e coloque o seguinte trecho de código: FirebaseCrashlytics.instance.crash() .

ElevatedButton(
    onPressed: () {
      FirebaseCrashlytics.instance.crash();
    },
    child: const Text('Gerar falha'),
  )

Ao rodar o aplicativo e apertar no botão, quase instantaneamente, a aplicação quebrará.

Na próxima vez que ela for aberta, o aplicativo será sincronizado com o Firebase e teremos a estatística no painel do Crashlytics. As vezes pode demorar alguns minutinhos para aparecer no painel ou não, no meu caso foi instantâneo.

Confira a imagem abaixo:

O painel do crashlytics mostra detalhadamente e agrupa os problemas lhe ajudando a priorizar quais correções são mais urgentes no momento.

Quando você clica na mensagem de erro, você pode ver a mensagem de teste (This is a test crash caused by calling .crash() in Dart) como abaixo.

Personalizar relatórios de erros do Firebase Crashlytics

No Crashlytics é possível associar pares de chave-valor arbitrários aos seus relatórios de erros e usar as chaves personalizadas para pesquisar e filtrar relatórios no console do Firebase. Veja alguns exemplos:

// Set a key to a string.
FirebaseCrashlytics.instance.setCustomKey('str_key', 'hello');

// Set a key to a boolean.
FirebaseCrashlytics.instance.setCustomKey("bool_key", true);

// Set a key to an int.
FirebaseCrashlytics.instance.setCustomKey("int_key", 1);

// Set a key to a long.
FirebaseCrashlytics.instance.setCustomKey("int_key", 1L);

// Set a key to a float.
FirebaseCrashlytics.instance.setCustomKey("float_key", 1.0f);

// Set a key to a double.
FirebaseCrashlytics.instance.setCustomKey("double_key", 1.0);

Logs e informações relacionadas ao usuário.

setCustomKeyé usado para armazenar informações personalizadas sobre o usuário ou o aplicativo.

Você pode associar pares arbitrários de chave/valor aos seus relatórios de falha e, em seguida, usar as chaves personalizadas para pesquisar e filtrar relatórios de falha no console do Firebase.

// Chaves.
FirebaseCrashlytics.instance.setCustomKey('userId', '12345');
// Logs.
FirebaseCrashlytics.instance.log("Higgs-Boson detected! Bailing out");
// Dados.
FirebaseCrashlytics.instance.setUserIdentifier("12345");

logé usado para armazenar logs.

Para dar a si mesmo mais contexto para os eventos que levaram a uma falha, você pode adicionar logs personalizados do Crashlytics ao seu aplicativo.

setUserIdentifieré usado para definir a quem o relatório pertence.

Para diagnosticar um problema, geralmente é útil saber quais dos nossos usuários experimentaram uma determinada falha.

Desabilitando o envio de dados em desenvolvimento

Para garantir que o Crashlytics fique desabilitado quando seu aplicativo estiver no modo de debug, você pode fazer o seguinte:

import 'package:flutter/foundation.dart' show kDebugMode;

if (kDebugMode) {
  // Force disable Crashlytics collection while doing every day development.
  // Temporarily toggle this to true if you want to test crash reporting in your app.
  await FirebaseCrashlytics.instance
      .setCrashlyticsCollectionEnabled(false);
} else {
  // Handle Crashlytics enabled status when not in Debug,
  // e.g. allow your users to opt-in to crash reporting.
}

Você também consegue saber se ele está ativado com o seguinte trecho de código.

if (FirebaseCrashlytics.instance.isCrashlyticsCollectionEnabled) {
  // Collection is enabled.
}

Como capturar erros manualmente?

Os erros não fatais são exceções ou problemas que você quer registrar manualmente sem fechar o aplicativo. Para isso, o Firebase Crashlytics oferece métodos para logar esses erros, permitindo que você capture situações como falhas de rede ou erros de lógica tratáveis.

Você pode capturar exceções específicas com Crashlytics, se necessário, usando o código abaixo:

import 'package:firebase_crashlytics/firebase_crashlytics.dart';

void reportNonFatalError() {
  try {
    // Simulando um erro que você capturou e tratou
    throw Exception('Erro não fatal');
  } catch (error, stackTrace) {
    // Registra o erro manualmente no Crashlytics sem fechar o app
    FirebaseCrashlytics.instance.recordError(error, stackTrace);
  }
}

Esse código acima irá registrar no console do Firebase o erro e a stack trace no Crashlytics como erro não fatal, mas o aplicativo continuará rodando normalmente.

Isolando a regra do Crashlytics com o padrão Service

A finalidade da camada de serviço, por outro lado, é encapsular a lógica de negócios em um único local para promover a reutilização de código e a separação de interesses.

Basicamente seria isolar uma tarefa específica em um outro objeto sendo assim assumindo uma responsabilidade muito estreita de realizar alguma atividade útil.

Então, vamos criar um serviço para integrar o Firebase Crashlytics ao seu projeto Flutter e gerenciar os relatórios de erros. 👇🏻

• Isolate.current.addErrorListener(ErrorReport.isolateErrorListener) adiciona um ouvinte de erros para isolados (ou seja, quando múltiplos threads estão rodando em paralelo no app), garantindo que erros ocorridos fora do thread principal sejam capturados e reportados.

Exemplo de uso do CrashlytcsService

Essa abordagem centraliza a manipulação de exceções e falhas no aplicativo, garante que erros sejam capturados e enviados para monitoramento via Crashlytics, e oferece flexibilidade para criar diferentes tipos de erros com pouca repetição de código.

import 'package:flutter/foundation.dart';

import '../service/crashlytics_service.dart';

abstract class Failure implements Exception {
  final String errorMessage;

  Failure({
    StackTrace? stackTrace,
    String? label,
    dynamic exception,
    this.errorMessage = '',
  }) {
    // Loga a stack trace apenas no modo debug para evitar poluição de logs em produção.
    if (stackTrace != null && kDebugMode) {
      debugPrintStack(label: label, stackTrace: stackTrace);
    }

    // Reporta o erro ao Crashlytics se houver exception
    ErrorReport.externalFailureError(exception, stackTrace, label);
  }
}

class UnknownError extends Failure {
  UnknownError({
    String? label,
    dynamic exception,
    StackTrace? stackTrace,
  }) : super(
          stackTrace: stackTrace,
          label: label,
          exception: exception,
          errorMessage:
              'Unknown Error', // Passa a mensagem diretamente para a classe base
        );
}

Possíveis extensões

Se no futuro você quiser criar outras subclasses de Failure para diferentes tipos de erros, será muito fácil. Por exemplo, você pode criar uma classe NetworkError para representar erros relacionados à rede, e utilizar o mesmo padrão de construção.

class NetworkError extends Failure {
  NetworkError({
    String? label,
    dynamic exception,
    StackTrace? stackTrace,
  }) : super(
          stackTrace: stackTrace,
          label: label,
          exception: exception,
          errorMessage: 'Network Error',
        );
}

Configurando os arquivos dSYM do Xcode para o crashlytics no IOS 🛠️

Para gerar relatórios de falhas legíveis por humanos no IOS, o Crashlytics precisa dos arquivos de símbolo de depuração (dSYM) do seu projeto salvos no console do Firebase.

Sem isso o Crashlytics vai ficar te enviando emails constantemente pedindo que você faça esse upload dos (dSYM) no painel do crashlytics, veja a imagem abaixo:

Abra seu projeto no Xcode e gere um archive. Basta ir no menu, clicar em product > archive.

Depois de gerado com sucesso vai aparecer a seguinte tela para você: 👇🏻

Clique com o botão direito no archive e selecione a opção Show in Finder, e após abrir o finder clique no arquivo com o botão direito e selecione a opção Show Packages Contents, veja a imagem abaixo:

O resultado será uma listagem de arquivos e pastas e nela terá o que precisamos os nossos dSYMs.

Comprima essa pasta em um .zip e faça o upload dela no firebase crashlytics na parte do IOS.

Feito isso, podemos ver que os nossos dSYMs foi enviado com sucesso.

Conclusão

Bom é isso 😎.

Neste artigo, você aprendeu como configurar e preparar nossos aplicativos Flutter para serem usados ​​com o Firebase Crashlytics.

Aqui está o código do projeto de exemplo no github. 🔗

Em artigos futuros da série, veremos como usar outros recursos do Firebase, como Authentication, Remote Config, Analytics e muito mais com Flutter.

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter (X) | Medium

Nesse artigo vamos aprender a consumir dados da internet em nosso aplicativo utilizando um package chamado dio o client HTTP mais famoso do mundo Flutter. 💙

Consumir dados da internet é a coisa mais básica que praticamente todo aplicativo vai ter, então vamos lá ✍🏻

O que são APIS ?

De forma geral uma API significa Application Programming Interface (interface de programação de aplicações, ou seja, é uma forma que permite a transmissão de dados entre um software e outro, utilizando APIS empresas conseguem abrir os dados e funcionalidades de seus aplicativos para desenvolvedores externos de terceiros, parceiros de negócios, sistemas etc.

Sendo assim, as APIs proporcionam interoperabilidade entre aplicações totalmente diferentes possibilitando uma integração entre dois ou mais sistemas.

O mais interessante é que quem consome a API não precisa se preocupar com os detalhes da implementação dessa API, um exemplo disso é uma aplicação mobile consumindo dados de uma api de clima para obter os dados sobre o tempo local.

O que é REST?

o conceito de REST (Representational State Transfer) é como um modelo de boas práticas de arquitetura de software que define uma série de requisitos para que as APIs sejam desenvolvidas. Uma API REST é uma API que está em conformidade com os princípios de design do REST.

Se você quiser aprender um pouco mais sobre esse tema acesse esse link.

O que é HTTP?

O HTTP (Hypertext Transfer Protocol ou Protocolo de Transferência de Hipertexto em português) é o protocolo principal de comunicação entre computadores no mundo, oferece aos usuários uma maneira de interagir com recursos da Web, como arquivos HTML, transmitindo mensagens de hipertexto entre clientes e servidores.

Métodos de solicitação HTTP

O HTTP utiliza métodos ou verbos de solicitação específicos para realizar várias tarefas como solicitar, criar, atualizar e deletar os dados, abaixo eu mostro os principais e mais utilizados.

• GET Solicita e recupera dados do servidor

• POST Adicionar ou cria dados no servidor;

• PUT Atualizações de registros.

• DELETE Excluir um registro especificado.

• PATCH Atualiza ou modifica parcialmente um recurso.

Conhecendo o DIO

DIO é um Cliente HTTP para Dart e Flutter que trás uma experiência simples e robusta para os nossos aplicativos multiplataforma. Possui suporte para interceptores e headers personalizados, cancelamento de requisições, tempo limite, e muito mais.

Implementação do aplicativo de Games usando o DIO

Nesse exemplo, vamos criar um app bem simples de listagem de games consumindo alguns dados que estão na API RAWG. 🔗

Crie uma conta e pegue sua API Key para conseguir buscar os dados.

A ideia aqui é mostrar como é facil fazer essa integração para ter um aplicativo consumindo dados da internet sem muito trabalho.

1. Vamos começar adicionando a dependência ao nosso arquivo pubspec.yaml.

No momento desse artigo o mesmo se encontra em sua versão mais nova 5.6.0

dependencies:
  dio: ^5.6.0

Ou instale o pacote a partir da linha de comando com o Flutter:

$ flutter pub add dio

3. Agora, no seu código Dart, você pode importar o package:

import 'package:dio/dio.dart';

Sobre Boas Práticas

Quando nós vamos criar consumos de API geralmente é uma ótima prática usar o alguns design patterns como o Service ou Repository.

Basicamente esses padrões consistem em criarmos uma classe separada somente com a finalidade de acessar e buscar os dados do meio externo isso deixa as coisas mais organizadas, e mais bem definidas ajudando até mesmo com a manutenção futuramente em nosso aplicativo.

Service Pattern X Repository Pattern

Repositorios encapsulam a lógica necessária para acessar fontes de dados. Eles centralizam a funcionalidade comum de acesso a dados, oferecendo um nível adicional de abstração sobre o acesso a dados. Esse padrão é útil em situações em que o mecanismo de acesso aos dados podem mudar significativamente.

A finalidade da camada de serviço, por outro lado, é encapsular a lógica de negócios em um único local para promover a reutilização de código e a separação de interesses. Basicamente seria isolar uma tarefa específica em um outro objeto sendo assim assumindo uma responsabilidade muito estreita de realizar alguma atividade útil.

Nesse exemplo usaremos o padrão Repository 😉

Criando Nosso Repository para consumir dados da API 🛠️

Crie um repository chamado GamesRepository que vai conter a instância do Dio e métodos para fazer as requisições HTTP.

Veja o código completo abaixo:

class GamesRepository {
  final Dio dio;
  final String _apiKey = '';
  final String _baseUrl = 'https://api.rawg.io/api/games';

  GamesRepository(this.dio);

  Future<List<GameModel>> getGames() async {
    try {
      final response = await dio.get(
        _baseUrl,
        queryParameters: {
          'key': _apiKey,
        },
      );

      if (response.statusCode == 200) {
        return (response.data['results'] as List)
            .map((game) => GameModel.fromJson(game))
            .toList();
      } else {
        throw Exception('Erro ao obter games: Código ${response.statusCode}');
      }
    } on DioError catch (dioError) {
      throw Exception('Erro ao fazer a requisição: ${dioError.message}');
    }
  }
}

Se atente para API key onde você vai conseguir no site após realizar seu cadastro.

O principal objetivo do nosso repository é listar os games, convertendo os dados da API em modelos (GameModel) que podem ser usados no resto da aplicação.

O GamesRepository abstrai os detalhes de como os dados dos jogos são obtidos da API. Em vez de espalhar a lógica de requisição pela aplicação, ela fica centralizada no repositório.

Se você decidir mudar a fonte dos dados (por exemplo, mudar de uma API para um banco de dados local), você só precisaria alterar o repositório, sem impactar outras partes do código.

Acima temos o aplicativo rodando e trazendo os dados com sucesso ✅

Para a gerência de estado eu usei o Bloc, em um artigo futuro veremos sobre ele aqui também.

Aqui está o código completo caso queria ver como ficou todo o aplicativo. 👨🏻‍💻

Estrutura Básica do Games Repository

• Model (GameModel): Representa a estrutura dos dados que você está manipulando, neste caso, um jogo.

• Repository (GamesRepository): Contém a lógica de como obter, armazenar e manipular os dados (nesse caso, os jogos) de uma fonte externa, como uma API.

Vantagens do Padrão Repository

• Modularidade: A lógica de acesso a dados é separada do restante da aplicação, facilitando a manutenção e evolução do código.

• Testabilidade: Como o GamesRepository é uma camada separada, você pode testá-lo isoladamente, simulando a resposta da API e verificando se o repositório lida com os dados e erros corretamente.

• Facilidade de Substituição: Se futuramente você quiser trocar a API que fornece os dados dos jogos, ou quiser implementar caching, você só precisa alterar o GamesRepository.

Referências

• https://stackoverflow.com/questions/5049363/difference-between-repository-and-service-layer/5049454

• https://stackoverflow.com/questions/22963352/difference-between-repository-and-service-layer

Conclusão ✅

Bom, eu particulamente acho muito simples consumir APIS com o Flutter, já vi e tentei em outras tecnologias de desenvolvimento móvel e a curva de aprendizado é bem maior rsrsr.

E para encerrar, uma dica valiosa, acredite em mim: envolva-se com a comunidade local de desenvolvedores. Aprenda com outros desenvolvedores: participar de eventos de tecnologia, palestrar e contribuir com conteúdos pode expô-lo a uma variedade de ideias, tecnologias e abordagens diferentes.

Isso pode enriquecer seu conhecimento e ampliar sua perspectiva sobre a indústria de desenvolvimento de software.

Conheça novas pessoas e faça networking nos eventos, pois isso pode abrir portas para novos contatos e oportunidades valiosas em sua carreira.

Obrigado por ler até aqui. 😁

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição me manda uma DM ou deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos sobre desenvolvimento móvel 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

Você já se perguntou: "Por onde começar? Qual o melhor caminho? Quais as melhores dicas?" Essas são perguntas frequentes em eventos e nas redes sociais. Decidi escrever este guia para ajudar você a encontrar as respostas e trilhar o caminho do aprendizado dessa ferramenta incrível.

Hoje, vamos trilhar juntos o caminho das pedras para aprender o Flutter. Aqui, você encontrará dicas essenciais que irão descomplicar sua jornada, ajudando a transformar ideias em aplicativos funcionais e atraentes.

Seja você um desenvolvedor experiente em busca de uma nova habilidade ou um completo novato no mundo da programação, este artigo oferece o suporte necessário para dar seus primeiros passos com o Flutter além de também complementar um outro post que fiz com o tema "como se tornar um desenvolvedor Flutter."

Prepare-se para descobrir as melhores práticas, recursos indispensáveis e truques úteis que farão toda a diferença no seu aprendizado. Vamos embarcar nesta jornada rumo ao domínio do Flutter e explorar todo o potencial que essa incrível ferramenta tem a oferecer. Pronto para começar? Então, vamos nessa!

Aprendendo como desenvolvedor de software 📚

Existem várias maneiras de consumir conhecimento como desenvolvedor de software. Dentre elas, Lendo Documentação, Posts de Blog, Livros, Desenvolvendo Projetos Paralelos (Side Projects), Cursos/Workshops, Escrevendo e Ensinando.

O ponto chave aqui é tente descobrir o que funciona para você, qual a melhor forma que você aprende e absorve o conhecimento? Depois que descobrir isso é preciso trabalhar de forma inteligente e abordar o aprendizado de forma estratégica.

Forme bons hábitos. Ao fazer algo regularmente no mesmo horário, seu corpo e mente se acostumarão, e você perceberá que precisará de menos energia mental para completar as tarefas.

Depois de formar o hábito de estudar você vai perceber que o aprendizado vai se tornar simples e gostoso!

Por exemplo, eu gosto mais de aprender lendo posts de blog e fazendo pequenos projetos de estudo, onde sou forçado a pesquisar e procurar na web até conseguir o que quero fazer. Dessa forma, vou aprendendo! 💡

Tento encaixar isso nos meus hábitos até se tornar uma rotina estudar alguma tecnologia nova!

Por exemplo, se você almoça quase no mesmo horário todos os dias: 👇🏻

Depois de jantar todos os dias, vou praticar programação por 45 minutos, focado. 🎧 👨🏻‍💻

Eu sei que não é fácil formar hábitos de estudo, mas com esforço e dedicação você vai conseguir. Eu acredito em você! 🙏🏻

Por que Flutter?

Com o mundo se tornando cada vez mais dependente de dispositivos móveis, há uma grande demanda por novos desenvolvedores capazes de criar e manter aplicativos com qualidade.

Além disso, essa habilidade permite que você implemente suas próprias ideias de apps, e quem sabe, seu aplicativo poderá se tornar o próximo negócio de 1 bilhão de dólares.

Hoje em dia, existem diversas ferramentas que permitem o desenvolvimento de aplicativos para dispositivos móveis. Hoje, vamos focar no Flutter, que se destaca como uma das ferramentas mais populares no desenvolvimento mobile.

O Flutter transforma o processo de criação de aplicativos, permitindo que você entregue mais rápido e com qualidade.

Nesse link de outro artigo, vou citar alguns motivos pelos quais você deveria considerar iniciar sua carreira como desenvolvedor mobile usando Flutter. 💙

O que é Flutter?

Flutter é um kit de ferramentas (SDK) de interface de usuário e de código aberto criado pela Google em 2015, sendo lançado oficialmente em 2018.

Com ele, é possível criar diferentes aplicativos bonitos e multiplataformas (Android, iOS, web e desktop) usando a linguagem de programação Dart e uma única base de código, ou seja, sem precisar escrever o código separadamente para cada sistema ou plataforma.

Seu forte atrativo está baseado em alguns pilares: (a) Desenvolvimento Rápido, (b) UI Expressiva e Flexível e (c) Desempenho Nativo. (d) Multiplataforma etc. 🤙

Se quiser entender um pouco mais desses pilares visite meu outro artigo onde explico com detalhes cada um deles e também mais algumas dicas.

🛑 ‼️ Atenção!!! Se você é totalmente novo na programação não aprenda Flutter agora, comece pelos cursos abaixo iniciando por algoritmos, caso contrário siga em frente.

1 - Introdução a Algoritmos — Curso de Algoritmos #01 — Gustavo Guanabara

2 - Curso Python #01 — Seja um Programador

Iniciando os estudos com a linguagem Dart

Não pule diretamente para o Flutter sem conhecer o Dart! Além de ser a linguagem principal do Flutter, o Dart está rapidamente ganhando popularidade, sendo amplamente utilizado na criação de aplicativos web, códigos de servidor e aplicativos de IoT (Internet das Coisas).

Dart é uma linguagem moderna e poderosa, orientada a objetos, que pode ser compilada para código nativo. Ele possui um compilador Ahead-Of-Time (AOT) e Just-In-Time (JIT).

O Dart é uma linguagem relativamente fácil de aprender, principalmente se você já tiver experiência prévia com outras linguagens de programação. Há muitos materiais disponíveis e gratuitos na internet para você começar.

Abaixo, deixo alguns links de conteúdos que considero bons. 📚

Documentação oficial do Dart:

A documentação oficial do Dart é um excelente recurso para aprender a linguagem. Ela contém guias detalhados, tutoriais e exemplos de código que cobrem os conceitos fundamentais e avançados do Dart. Inicialmente, vale a pena focar nos dois principais recursos: “Language Tour” e “Language samples”.

Eles fornecem uma breve introdução baseada em exemplos da linguagem Dart, o que pode ser de grande ajuda para iniciantes. Além disso, a documentação oficial do Dart possui o recurso chamado DartPad, uma espécie de editor de código online onde você pode ver e executar exemplos de código Dart, o que pode ser muito útil para praticar.

Conceitos fundamentais da linguagem:

Abaixo, listo alguns conceitos fundamentais da linguagem Dart que você tem que aprender: 🔥

• Fundamentos do POO

• Tipos de dados

• Variáveis e constantes

• Estruturas condicionais

• Estruturas de repetição

• Funções

• Classes e objetos

• Exceções e erros

• Programação assíncrona

• Null Safety

• Bibliotecas e pacotes

Recursos – Cursos de Dart no Youtube

Se você gosta de aprender por cursos online, abaixo deixo 3 boas playlist de cursos para você aprender Dart 🎯.

Assista os 3 ou apenas o que desejar. 👇🏻

1 - Curso de Dart - Deivid Willyan

2 - Curso de Dart - Daves Tecnologia

3 - Dart - Curso Completo - Washington Developer

Aqui vai uma dica: Lembre-se de que “a prática leva à perfeição”, portanto, nenhum curso, leitura de documentação ou visualização de vídeos de tutoriais será útil se você não codificar e aprender com seus erros.

É importante praticar e aplicar o conhecimento em projetos pessoais para solidificar o aprendizado. 🫡

Iniciando os Estudos com Flutter

Depois de dominar a linguagem Dart, você pode começar com o Flutter instalando o SDK dele no seu computador e configurando todo o ambiente de desenvolvimento para dar os primeiros passos. Todo o processo é descrito aqui.

Quanto às IDEs, você pode escolher usar o Android Studio ou o Visual Studio Code. Eu particularmente gosto do Visual Studio Code por ser mais leve e simples de usar.

Você não sabe por quê o Flutter usa o Dart como linguagem? veja esse video 🔗

Abaixo, listo alguns conceitos fundamentais do Flutter que você deve aprender: 💙

Widgets

Layouts

Responsividade

Formulários

Animações

Navegação e rotas

Gestão do estado

Conceitos de banco de dados

Consumos de API REST

Arquitetura de software

Design patterns

Testes automatizados

Dicas ⚡️

Praticando Programação: 🛠️

Comece a desenvolver aplicativos simples no Flutter para colocar em prática o que você aprendeu. Inicie com projetos básicos como listar dados na tela ou codificar uma simples interface, e a medida que você ganha mais confiança, aumente a complexidade dos projetos, incorporando novos conceitos como navegação, gerenciamento de estados e integrações com APIs.

A prática contínua é essencial para consolidar seu conhecimento.

Nesse video eu dou 6 sugestões de APIS para você consumir.

Crie Projetos do Mundo Real: 👨🏻‍💻

Aplique seu conhecimento resolvendo problemas do dia a dia com a criação de novos aplicativos. Identifique uma necessidade real e desenvolva um aplicativo para isso. Trabalhar em projetos do mundo real não só solidifica suas habilidades, mas também oferece uma visão valiosa sobre os desafios e as melhores práticas de desenvolvimento.

Recentemente desenvolvi um Aplicativo para mapear ocorrências de Furtos e Roubos nas grandes cidades, uma ideia simples mas que virou uma aplicativo real e que resolve um problema.

Recursos — Onde Aprender Flutter?

Existem vários recursos gratuitos em português para aprender Flutter. Abaixo, vou listar alguns que sei que são bons e também compartilhar links de alguns roadmaps estruturados de conteúdos em Flutter que podem auxiliar no seu aprendizado.

Recursos – Cursos de Flutter no Youtube

Se você gosta de aprender por meio de cursos online, abaixo deixo 3 boas playlists de cursos para você aprender Flutter.

1 - Curso completo de Flutter 3 - Daves Tecnologia

2 - Curso de Flutter & Dart - Polimofirsmo

3 - Curso de Flutter - Flutterando

4 - Canal do Flutter oficial - Inglês

5 - Building your first Flutter App 1— with a Codelab! - Inglês

Recursos escritos - Tutoriais em blogs e sites ✍🏻

Bom, o próprio site do Flutter tem uma especie de roadmap com uma listagem conteúdos para o níveis Junior, Pleno e Senior. Apesar de tudo estar em inglês você pode usar o Google translate para entender melhor os materiais escritos.

Acesse aqui. 🔗

1 - Desenvolvendo seu primeiro app em Flutter 🔗

OBS: É importante lembrar de praticar o que foi aprendido por meio de projetos reais e experimentar diferentes recursos do Flutter é fundamental para ganhar familiaridade com o framework.

Roadmap estruturado para estudo 📆

Navegando no LinkedIn um dia desses, vi uma publicação em que um cara chamado Dinesh compartilhou uma foto de um roadmap com temas do mundo Flutter organizados de forma estruturada. Achei interessante e vou compartilhá-lo aqui.

Link do Roadmap 🔗

Criei um segundo roadmap pessoal com uma listinha de conteúdos organizados por semana em um PDF do que estudar, vou deixar o link abaixo:

Link do PDF criado por mim 🔗 ⚡️

Dicas de projetos para praticar 🛠️

Para complementar seu aprendizado, aqui estão alguns projetos de diferentes níveis de complexidade nos quais você pode criar para praticar Flutter.

1. Aplicativo de lista de tarefas com armazenamento local/em nuvem

2. Aplicativo de notícias (News API)

3. Aplicativo de filmes (TMDB API)

4. Aplicativo de clima (Weather API)

5. Aplicativo de Notas (Firebase)

Realize esses projetos para aplicar seu conhecimento, aprimorar suas habilidades e ganhar experiência prática no desenvolvimento de aplicativos Flutter.

Desejo a você boa sorte em sua jornada para se tornar um desenvolvedor de aplicativos Flutter, e qualquer dúvida me chama ou comenta ai em baixo, Ok? 😉

Conclusão ✅

Uma coisa que eu sempre digo é que a curva de aprendizado para criar bons aplicativos ficou consideravelmente reduzida com o Flutter. Não digo que seja fácil, mas as tecnologias nativas têm uma curva de aprendizado muito mais íngreme em comparação ao Flutter.

E para encerrar, mais uma dica valiosa, acredite em mim: envolva-se com a comunidade local de desenvolvedores. Aprenda com outros desenvolvedores: participar de eventos de tecnologia, palestrar e contribuir com conteúdos pode expô-lo a uma variedade de ideias, tecnologias e abordagens diferentes.

Isso pode enriquecer seu conhecimento e ampliar sua perspectiva sobre a indústria de desenvolvimento de software.

Conheça novas pessoas e faça networking nos eventos, pois isso pode abrir portas para novos contatos e oportunidades valiosas em sua carreira.

Obrigado por ler até aqui. 😁

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição me manda uma DM ou deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos sobre desenvolvimento móvel 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

Um pouco de contexto: Eu desenvolvi um aplicativo de adoção de animais para o meu TCC da pós-graduação e agora estou prestes a publicá-lo na loja de aplicativos. Achei que seria interessante documentar todo o processo de submissão para ajudar vocês quando forem passar por isso também! Vamos juntos nessa jornada! 🚀

A maravilha do Flutter é que ele é multiplataforma, ou seja, está disponível para várias plataformas, como Android, iOS, sistemas desktop e também web, tudo com apenas um único código.

Ao longo do artigo vou mostrar em algumas etapas como enviar o aplicativo que desenvolvi para a loja!

Então vem comigo. 🤏🏻 👨🏻‍💻

Requisitos Básicos para Publicar seu Aplicativo na App Store

1. Um Macbook com o Xcode instalado: O Xcode é necessário para construir e lançar seu aplicativo, pois algumas configurações importantes do app são feitas através dele.

2. Uma conta de desenvolvedor Apple: Você precisa adquirir uma licença do Apple Developer Program para acessar o painel e as ferramentas de publicação da Apple. Essa licença custa $100 dólares, o que, dependendo da cotação do dólar, pode ficar em torno de R$550 reais.

   Quando eu comprei a minha, após fazer o pedido e enviar os dados, levou em torno de uma semana para aprovação e liberação da licença.

   Dica Importante:

   Use um cartão de crédito físico ao invés de virtual. Ouvi relatos de que com o cartão virtual estava dando problemas. Para garantir, usei o cartão físico e deu tudo certo. 😎

1 - Registre seu Bundle ID no portal do desenvolvedor

Bundle ID é um identificador exclusivo associado a aplicativos iOS. Os proprietários de aplicativos definem esse ID. A Apple recomenda que os proprietários de aplicativos nomeiem o ID usando uma notação reversa de nome de domínio. Como por exemplo:

Domain: mycompany.com

Reverse domain: com.mycompany.appname.

Bundle ID: com.mycompany.myapp

Agora que vc já sabe o que é o Bundle ID, vamos prosseguir acessando o site (https://developer.apple.com) clique em Identifiers (Identificadores).

Veja a imagem abaixo:

Depois na próxima página clique no icone de + para criar um novo Bundle ID.

Agora prosseguindo vamos selecionar Apps IDS como na imagem abaixo:

Selecione o tipo App que aparecerá logo em seguida após a aba anterior. Veja a imagem abaixo:

O Bundle ID deve ser exclusivo para a app store. Se você selecionar um existente, um pop-up de aviso solicitará que você o altere.

Selecione os recursos e serviços que correspondem aos do seu aplicativo.

Insira o seu Bundle ID e a descrição sem caracteres especiais.

Mais embaixo selecione tambem quais Capabilities o seu app usa no meu caso selecionei push notifications pois o meu aplicativo recebe notificacões do Firebase.

Prossiga e clique em registrar! ✅

2 - Criando o aplicativo na Loja

Agora vamos criar o nosso aplicativo no portal, vá na página inicial do portal do apple developer e clique em Apps, vai aparecer um botão para adicionar um novo aplicativo.

Preencha os dados do seu aplicativo. Veja o print abaixo:

Clicando em criar podemos ver que o aplicativo foi criado com sucesso e registrado no portal do desenvolvedor da Apple.

3 - Revise as configurações do seu projeto no Xcode

Verifique as configurações mais importantes. Como Nome do aplicativo, Bundle Identifier e o Team que é a equipe associada à sua conta Apple Developer registrada. Se necessário, selecione Adicionar conta e atualize esta configuração.

Em iOS Deployment Target a versão mínima do iOS que seu aplicativo suporta. O Flutter suporta iOS 12 e versões posteriores. A guia Geral das configurações do seu projeto deve ser semelhante à seguinte:

Agora vamos em Signing e Capabilities

Confira o Team e o Bundle Identifier se esta correto. Deixe marcado a opção (Automatically manage signing) para o Xcode criar o perfil de provisionamento automaticamente, que é um arquivo que contém informações necessárias para que um aplicativo iOS possa ser instalado e executado em dispositivos Apple.

Ele vincula seu dispositivo a seu aplicativo, permitindo que você teste e distribua seu aplicativo em dispositivos físicos.

No meu caso deu um erro, veja o print abaixo:

Ele diz que não temos um device (iPhone) registrado na nossa conta, para resolver esse erro devemos adicionar um dispositivo iPhone no portal do desenvolvedor apple.

Voce pode plugar seu iPhone no macbook e tentar novamente e irá aparecer um botão para registrar automaticamente, veja o print abaixo:

Quando eu cliquei em registrar deu tudo certo. Foi automático!

Outra forma seria acessando o site do portal do desenvolvedor e registrar manualmente, acesse e clique em dispositivos (devices).

Agora clique para adicionar um novo:

Preecha os dados requeridos e principalmente com o seu Device ID (UDID) e pronto.

Encontrando seu UDID com Finder (macOS)

Plugue seu iPhone no seu mac e navegue até o Finder e selecione-o, você verá algumas informações sobre o celular conectado. Para mim tive que clicar algumas vezes nos dados abaixo do nome do iPhone para mostrar o UDID com sucesso!

Maneira alternativa de encontrar UDID com o Xcode

• Conecte seu dispositivo iOS ao Xcode

• Abra o menu Janela > Dispositivos e Simuladores

• Encontre o seu dispositivo exibido nesta lista e visualize-o no Identifier “identificador” que é o mesmo UDID.

Depois de inserir com sucesso o UUID e o nome, continue o processo. Em seguida, aceite e registre o dispositivo.

4 - Adicionando o Ícone ao Seu Aplicativo

Existem várias formas de adicionar o ícone ao seu aplicativo, mas hoje vou mostrar uma maneira bem prática utilizando um site chamado Appicon. Este site permite que você cole sua imagem e ele gera os arquivos de ícone tanto para Android quanto para iOS.

Passos para gerar ícones com o Appicon:

1. Acesse o site Appicon.

2. Faça o upload da sua imagem.

3. O site gerará automaticamente os arquivos necessários para ambas as plataformas.

4. Baixe os arquivos e adicione-os ao seu projeto.

Dica Importante 💡

Se tiver dúvidas sobre as diretrizes de ícones, é sempre bom revisar as guidelines específicas da Apple para garantir que seu ícone esteja em conformidade com os padrões. Você pode encontrar as diretrizes da Apple aqui.

Depois de gerado baixe os arquivos e cole na pasta Assets.xcassets dentro da Runner substituindo os icones do Flutter gerados na criação do projeto pelos novos.

Feito isso, verifique se o ícone foi substituído executando seu aplicativo usando flutter run ⚡️

5 - Atualize os números de compilação e versão do aplicativo

O número da versão padrão do aplicativo é 1.0.0. Para atualizá-lo, navegue até o arquivo pubspec.yaml e atualize a seguinte linha:

version: 1.0.0+1

O número da versão é composto por três números separados por pontos, como 1.0.0 no exemplo acima, seguidos por um número de build opcional, como 1 no exemplo acima, separados por +.

6 - Gerando o arquivo (archive) de build e enviando a loja

Bom, aqui existe duas formas de fazer isso, uma pelo Vscode em combinação com um outro programa e outra pelo Xcode!

Com o Vs code

Execute flutter build ipa para produzir um arquivo de compilação do Xcode ( .xcarchive) no diretório do seu projeto build/ios/archive/ e um pacote de aplicativos da App Store (.ipa) em build/ios/ipa.

Pronto, Archive gerado com sucesso no caminho build/ios/ipa observe que ele pede que usemos um app chamado Apple Transporter para enviar para o portal do desenvolvedor apple o nosso aplicativo em formato IPA.

Faça a instalação dele via AppStore, veja o print abaixo:

Depois de instalado, faça login e abra-o 🛠️

Agora vamos transportar nosso IPA para o TestFlight, uma ferramenta no portal do desenvolvedor Apple que possibilita aos testadores usarem seus aplicativos e concederem feedbacks antes de lançá-los na App Store.

Clique em ADD APP vá no caminho mostrado anteriormente e selecione o seu aplicativo.

Veja que obtivemos sucesso ao fazer o upload para o transporter, agora é so enviar para o portal da Apple, clique em DELIVER. 😎

Depois de carregado podemos ver que as nossas compilações aparecem no Test Flight com sucesso ✈️

7 - Finalizando a configuração e enviando para a revisão

Quando estiver pronto para lançar seu aplicativo para o mundo, siga estas etapas para enviá-lo para análise e lançamento na App Store:

Selecione a compilação desejada.

Em seguida preencha os demais dados como descrição do aplicativo, texto promocional, classificação, categoria, local de disponibilidade, preço, palavras chave e screenshots etc.

E depois clique em submeter para a revisão.

Dica importante 💡

Para os screenshots devemos emular o nosso aplicativo nos simuladores corretos e assim tirar os screenshots no tamanho ideal. 📲

Para iPhone telas 6,5 e 6,7 pol, pode usar o simulador do iPhone 15 Plus.

Para iPhone tela 5,5 pol, pode usar o simulador do iPhone 8 Plus.

Para mais detalhes sobre os diversos tamanhos de screenshots confira e acesse o link da documentação oficial.

A Apple notifica você quando o processo de revisão do aplicativo é concluído.

Outra dica importante 💡

Instale o aplicativo do apple store connect e assim ficar por dentro da revisão do seu aplicativo pois a apple também notifica tudo por lá.

Bom é isso, agora é aguardar 😉.

Seu aplicativo será lançado de acordo com as instruções que você especificou na seção Lançamento da Lançamento da versão na App Store.

Referências 🔗

Release an iOS app with Flutterin 7 steps

Build and release an iOS app

Conclusão

Bom é isso 😎.

Neste artigo, você aprendeu como fazer o deploy da sua aplicação Flutter na loja da Apple 🍏

Em artigos futuros da série, veremos como fazer o processo para a loja do Android.

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | X (Twitter) | Medium

Um pouco de contexto: estamos em junho e, no Dia dos Namorados, eu estava sem nada para fazer. Então, resolvi brincar e desenvolvi um aplicativo com Flutter para pedir uma pessoa em namoro de uma forma especial, hahaha. 🤣

A maravilha do Flutter é que ele é multiplataforma, ou seja, está disponível para várias plataformas, como Android, iOS, sistemas desktop e também web, tudo com apenas um único código. Foi aí que pensei: "Bom, a forma mais rápida de divulgar esse app e mostrá-lo ao mundo é colocando-o na web para que o público possa acessá-lo." E foi aí que me ocorreu: "Flutter e Firebase Hosting, uma combinação perfeita!" 💙🔥

Hoje, meu objetivo é abordar o uso do Firebase Hosting, que é uma maneira simples de distribuir aplicativos aos testadores ou automatizar o processo de lançamento de novas versões de forma rápida e fácil na web.

Eu tive a ideia de escrever este artigo depois que um amigo me mandou uma mensagem ontem, perguntando como e o que eu usei para hospedar o aplicativo do Dia dos Namorados. 💘📲

Ao longo do artigo vou mostrar o aplicativo de pedido de namoro que fiz de exemplo usando Flutter e Firebase, e como hospedá-lo no Firebase Hosting!

Então vem comigo. 🤏🏻 👨🏻‍💻

O que é Firebase Hosting?

Firebase Hosting é um dos serviços oferecido pelo Firebase. Este serviço permite que desenvolvedores hospedem conteúdo estático e dinâmico na web de maneira rápida e segura.

Ele é especialmente útil para hospedagem de aplicativos de página única (SPA), sites estáticos, APIs e microsserviços. Abaixo eu listo os principais recursos e benefícios do Firebase Hosting 😎.

Recursos do Firebase Hosting

1. Entrega Rápida e Segura: Firebase Hosting utiliza a rede de entrega de conteúdo (CDN) do Google para garantir que seu conteúdo seja entregue rapidamente aos usuários em todo o mundo. Isso melhora o tempo de carregamento e a experiência do usuário.

2. SSL Automático: Todas as conexões são automaticamente criptografadas com HTTPS, garantindo que os dados transmitidos entre o servidor e o cliente sejam seguros.

3. Configuração Simples: O processo de implantação é simples, facilitado por uma linha de comando (CLI) intuitiva. Com apenas alguns comandos, você pode implantar seu site ou aplicativo.

4. Suporte a Rotas Personalizadas e Redirecionamentos: Permite configurar rotas personalizadas e redirecionamentos para URLs específicas, o que é útil para gerenciar URLs e navegação dentro do seu aplicativo.

5. Integração com Outras Ferramentas Firebase: Firebase Hosting se integra perfeitamente com outras ferramentas Firebase, como Cloud Functions e Firebase Authentication, permitindo a criação de aplicações web robustas e escaláveis.

Benefícios do Firebase Hosting

1. Desempenho: A utilização da CDN global do Google garante tempos de carregamento rápidos, reduzindo a latência e melhorando a experiência do usuário final.

2. Segurança: Com SSL automático, todas as suas conexões são seguras, sem a necessidade de configuração manual de certificados.

3. Escalabilidade: O serviço é capaz de escalar automaticamente para lidar com o aumento do tráfego, sem que o desenvolvedor precise se preocupar com a infraestrutura.

4. Fácil Integração: A integração com outras ferramentas do Firebase torna o desenvolvimento de aplicativos mais eficiente, oferecendo soluções prontas para autenticação, banco de dados em tempo real, notificações push, entre outros.

5. Desenvolvimento Rápido: A simplicidade de configuração e a poderosa CLI permitem que os desenvolvedores implantem rapidamente mudanças e atualizações, facilitando o desenvolvimento ágil.

Como funciona?

Ele funciona usando a infraestrutura do Google Cloud, que é escalável e segura. Quando você faz o deploy de um site, seus arquivos são armazenados nos servidores do Google e distribuídos através de uma rede de distribuição de conteúdo (CDN).

Essa CDN tem servidores de borda espalhados pelo mundo, garantindo que os arquivos do site sejam entregues rapidamente aos usuários a partir do servidor mais próximo geograficamente.

O serviço oferece HTTPS automaticamente, gerenciando certificados SSL para garantir comunicações seguras. Além disso, ele permite o controle de acesso e segurança por meio de integrações com outros serviços do Firebase, como o Firebase Authentication.

Usando o Firebase Hosting com o Flutter web

Vou mostrar como hospedei a aplicação dos dias do namorados que desenvolvi ✍🏻.

É muito simples hospedar seu aplicativo da flutter web existente com o Firebase Hosting.

Criação do projeto e Inicialização do Firebase

Vamos utilizar o projeto valentine_day_app que criei no dia dos namorados rsrs 💕

Você já tem um projeto Firebase criado? Caso contrário, siga meu outro artigo de configuração e instalação do firebase com todas as etapas detalhadas!

No post de hoje não irei mostrar como inicializa o Firebase no Flutter pois fiz isso no artigo mencionado acima com todas as etapas detalhadas!

Nele mostro como criar um projeto Firebase do zero e como vinculá-lo ao seu aplicativo Flutter. Acesse aqui. 🔗

Instalando a CLI do firebase-tools 🛠️

Firebase Tools é uma ferramenta de linha de comando que ajuda você a implantar e gerenciar seus projetos do Firebase.

🏃‍♀ Pule esta etapa se você já tiver o firebase-tools instalado.

Se você não tiver o npm, deverá instalá-lo primeiro.

• Instale o Node.js: as ferramentas do Firebase exigem o Node.js. Baixe e instale-o do site nodejs.org.

• Instale as ferramentas do Firebase: abra o terminal e execute o seguindo comando:

    $ npm install -g firebase-tools
  

  Pronto 🎉, o firebase-tools agora está instalado!

Inicializando o Firebase Hosting

Se você não tiver inicializado o Firebase Hosting em seu projeto vamos fazer isso agora acessando o painel do Firebase console:

Depois clique em vamos começar, veja imagem abaixo:

1. 

   Acesse a pasta do seu projeto pelo terminal e com a CLI do Firebase, ative a visualização de frameworks da web com o comano abaixo:

    firebase experiments:enable webframeworks
   

   Abaixo eu mostro o resultado com sucesso do comando.

2. 

   Execute o próximo comando abaixo de inicialização do Hosting e siga as instruções:

    firebase init hosting
   

   • Responda "Sim" para a pergunta "Você quer usar uma estrutura da Web?"

   • Responda "Sim" para a pergunta "Você quer usar uma estrutura da Web?" (experimental)

   • Escolha o diretório de origem de hospedagem, que pode ser um app Flutter já usado.

   • Se necessário, escolha Flutter Web.

Veja abaixo o resultado do comando realizado 🛠️.

Implantando seu app no Firebase Hosting

1. Antes de implantar, você precisa criar uma versão de lançamento do seu aplicativo Web Flutter e para isso execute em seu terminal o comando flutter build web.

   Este comando compila seu aplicativo em um formato web implantável.

2. Com seu aplicativo criado e o Firebase configurado, você está pronto para implantar.

   No diretório do projeto, execute o comando abaixo que faz upload do seu aplicativo criado para o Firebase Hosting.

    firebase deploy

Veja o resultado do comando abaixo.

Assim que a implantação for concluída, o Firebase fornecerá um URL para acessar seu aplicativo da web.

No nosso caso teremos a aplicação hospedada nesse link gerado.

Vamos ver abaixo nosso app flutter web hospedado e funcionando na web 🤩 🎉

Aplicativo Flutter Valentine Day 💕

Adicionando um domínio personalizado ao aplicativo

Para adicionar um domínio personalizado ao seu aplicativo da web do Firebase, siga estas etapas:

No Firebase Hosting você encontrará um botão que diz “Adicionar domínio personalizado” na seção “Domínios” veja o print abaixo:

Vincular um domínio personalizado envolve informar ao Firebase sobre o domínio, comprovar a propriedade do domínio e aguardar a emissão dos certificados SSL.

• Insira o seu nome de domínio personalizado no campo “Nome de domínio” e clique em “Continuar”.

• O Firebase Hosting verificará se você é o proprietário do domínio. Para isso, será fornecido um registro TXT que você precisa adicionar às configurações de DNS do seu domínio. Acesse o site do seu registrador de domínio e insira esse registro TXT nas configurações de DNS.

• Após a adição do registro TXT, aguarde até que as configurações de DNS sejam propagadas. Isso permite que o Firebase Hosting verifique se você é o proprietário do domínio e conceda acesso ao seu site no Firebase Hosting.

• Após a verificação do proprietário do domínio, será necessário atualizar novamente as configurações de DNS do seu domínio. O Firebase Hosting fornecerá os registros A e CNAME necessários. Acesse o site do seu registrador de domínio e adicione esses registros às configurações de DNS.

• Uma vez concluídas essas etapas, seu domínio personalizado estará conectado ao site do Firebase Hosting. Lembre-se de que pode levar de 24 a 48 horas para que as alterações de DNS sejam totalmente propagadas pela Internet.

Materiais Adicionais 🔗

Deploy Flutter Web App to Firebase Hosting under 60 secs

https://docs.flutter.dev/deployment/web

Conclusão

Bom é isso 😎.

Hospedar um aplicativo web Flutter no Firebase é um processo simples que abre um mundo de possibilidades para desenvolvedores de aplicativos.

Com o Firebase, você pode não apenas hospedar seu aplicativo, mas também aproveitar outros recursos, como análises, gerenciamento de banco de dados e muito mais.

Em resumo, o Firebase Hosting é uma solução poderosa e fácil de usar para desenvolvedores que precisam hospedar conteúdo web, oferecendo segurança, desempenho e integração eficiente com outras ferramentas do Firebase.

Neste artigo, você aprendeu como configurar e preparar nossos aplicativos Flutter para serem usados ​​com o Firebase Hosting.

Em artigos futuros da série, veremos como usar recursos do Firebase, como Cloud Firestore, Authentication, Crashlytics, Remote Config e muito mais com Flutter.

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter | Medium

Depois de várias e várias tentativas e erros para fazer os flavors funcionarem, especialmente no iOS, decidi escrever este artigo com meus aprendizados. A ideia que ele seja um guia definitivo passo a passo sobre o assunto, pois pesquisando na internet não vi muitos materiais estruturados sobre o assunto.

Toda vez que eu ia configurar flavors acabava passando algumas horas na construção pois tinha que consultar vários materiais da internet, especificamente para IOS onde dava bastante problema.

O que são Flavors e por que você precisa usar

Flavors, também chamados de sabores em português é quando você tem ambientes separados para seu aplicativo usando a mesma base de código. Normalmente, os tipos mais usados ​​são dev, stag e prod.

Por exemplo você pode ter um flavor para seu aplicativo de produção que aponta para uma API de produção com o endereço meuapp.com.br/api e outra versão de desenvolvimento do app apontando para o host de API em dev.meuapp.com.br/api ou até mesmo ter ícones de aplicativos diferentes para cada configuração.

A maioria das empresas e projetos normalmente têm um ciclo de vida no processo de construção de software bem definido, onde as novas funcionalidades passam pelas mais diferentes etapas, como desenvolvimento, teste, e, finalmente, vão para a produção.

Abaixo dou uma breve explicação sobre esses ambientes/configurações.

• development (dev) : usado apenas durante a criação do aplicativo onde os desenvolvedores usam a vontade sem medo de comprometer os dados.

• staging (stg) : usado para distribuir versões de teste para a equipe QA e outras partes interessadas no teste do aplicativo. O back-end vai configurado para dados de desenvolvimento, mas não pronto para fins de produção.

• production (prod) : usado por todos os usuários que baixaram o aplicativo nas lojas onde os dados do backend já são os reais.

A grande sacada dos flavors é nos possibilitar termos vários ambientes para mexer antes de enviar pra produção nos dando uma garantia que os dados no ambiente de produção não sejam alterados por engano durante o desenvolvimento. 😄

Sem flavors teríamos que mudar os hosts das APIS manualmente em variáveis a cada build o que seria bem chato, sem falar que se quisermos mudar logo, o nome do app seria mais complicado ainda.

Mas se nosso aplicativo Flutter usar um back-end do Firebase, configurá-lo para cada ambiente (dev, stg, prod) sem flavors é também extremamente chato, trabalhoso e custoso ter que toda vez na build fazer isso.

Com a nova versão do Flutter configurar o firebase para os flavors ficou bem mais simples do que no passado, então sem mais delongas vamos lá. 💛

A abordagem para este tutorial

Vou construir um aplicativo de exemplo com duas opções: dev e prod .

Configurando Flavors no Dart para múltiplos ambientes de API.

Vamor criar um arquivo de flavors no dart e com isso poderemos disponibilizá-los em qualquer lugar do nosso código, começaremos criando o arquivo flavors.dart na pasta lib do nosso projeto.

enum FlavorTypes { dev, prod }

class Flavor {
  Flavor._instance();

  static late FlavorTypes flavorType;

  static String get flavorMessage {
    switch (flavorType) {
      case FlavorTypes.dev:
        return 'Dev';
      case FlavorTypes.prod:
        return 'Production';
      default:
        return 'Dev';
    }
  }

  static String get apiBaseUrl {
    switch (flavorType) {
      case FlavorTypes.dev:
        return 'apiUrlBaseDev';
      case FlavorTypes.prod:
        return 'apiUrlBaseProd';
      default:
        return 'apiUrlBaseDev';
    }
  }

  static bool isProduction() => flavorType == FlavorTypes.prod;
  static bool isDevelopment() => flavorType == FlavorTypes.dev;
}

Nesse arquivo configurei-o para ser um singleton, pois com isso ele será facilmente acessível em qualquer lugar já que vamos precisar.

No FlavorTypes enum declaramos os tipos de ambientes que utilizaremos, e o getApiBaseUrl será responsáveil ​​por selecionar a URL correta para a nossa API conforme o flavor setado quando a aplicação estiver rodando.

Agora para cada ambiente flavor, criamos um arquivo main+flavor onde sera o ponto de entrada usado para iniciar o aplicativo setando o flavor correto

• main_dev.dart: Nosso flavor para o ambiente de desenvolvimento .

    import 'flavors.dart';
    import 'main.dart' as main_common;
  
    Future<void> main() async {
      Flavor.flavorType = FlavorTypes.dev;
      main_common.main();
    }
  

• main_prod.dart: Do nosso flavor para o lançamento em produção .

    import 'flavors.dart';
    import 'main.dart' as main_common;
  
    Future<void> main() async {
      Flavor.flavorType = FlavorTypes.prod;
      main_common.main();
    }
  

O main_common é apenas um alias para o main padrão que ja existia antes de configuramos os flavor no projeto, apenas estamos encapsulando-o para ser chamado conforme o flavor (sabor) setado.

Veja abaixo o código do main_common:

import 'package:flutter/material.dart';

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

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo Flavor',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(),
    );
  }
}

Para rodar nosso aplicativo devemos escolher o flavor desejado e em seguida digitar o seguinte comando no terminal:

• flutter run -t lib/main_dev.dart

• flutter run -t lib/main_prod.dart

O comando acima irá executar nosso aplicativo em modo de depuração, com -t ou --target definimos o ponto inicial, ou seja o arquivo principal.

Veja abaixo o aplicativo rodando no emulador Android com o ambiente de development configurado parcialmente pois ainda precisamos fazer alguns ajustes.

Adicionando flavors para Android

Com o nosso aplicativo inicial de exemplo rodando precisamos finalizar a configuração dos nossos flavors para o android, é bem simples e rápido de configurar.

Na pasta android navegue até o arquivo em app/build.gradle e adicione o seguinte código.

O flavor dev usará o applicationId como org.cajuinaapps.br.dev com o final indicando ambiente de desenvolvimento e o flavor prod usará o applicationId padrão org.cajuinaapps.br sem prefixo no final indicando ambiente de produção.

Também definimos um recurso de string chamado app_name no resValue que estamos usando em AndroidManifest.xml isso serve para configurar o nome do aplicativo em tempo de execução conforme o flavor usado.

NOTA: Não se esqueça de adicionar android:label="@string/app_name" a applicationtag no AndroidManifest.

Vamor testar 🧪

Agora podemos executar o aplicativo usando os seguintes comandos um de cada vez e rodar os ambientes.

flutter run --flavor dev --target lib/main_dev.dart
flutter run --flavor prod --target lib/main_prod.dart

Definindo configurações de inicialização para Vs code e Android Studio

Para rodar o nosso app não queremos toda vez ter que digitar o comando no terminal não é mesmo, por isso vamos configurar o nosso editor de código para fazer isso para a gente.

No Vs code, adicione um arquivo launch.json, isso permite que você execute o comando flutter run --flavor [environment name].

Defina as configurações de inicialização da seguinte forma:

1. No diretório raiz do seu projeto, adicione uma pasta chamada .vscode .

2. Dentro da pasta .vscode , crie um arquivo chamado launch.json .

3. No arquivo launch.json , adicione uma configuração para cada variação do flavor. Cada configuração possui uma chave name , request , type , program e args.

   Veja o exemplo abaixo.

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Development",
            "request": "launch",
            "type": "dart",
            "program": "lib/main_dev.dart",
            "args": [
                "--flavor",
                "dev",
            ]
        },
        {
            "name": "Production",
            "request": "launch",
            "type": "dart",
            "program": "lib/main_prod.dart",
            "args": [
                "--flavor",
                "prod",
            ]
        },
    ]
}

Agora podemos executar com sucesso o nosso app com o ambiente escolhido.

Configurando no Android Studio 🛠️

Agora, temos a capacidade de executar nosso aplicativo tanto no VS code quanto no Android Studio.

Se o seu aplicativo utilizar uma API, você pode simplesmente utilizar o Flavor.apiBaseUrl para obter a URL Base correspondente ao ambiente, seja ele de desenvolvimento ou produção.

Fácil, não é mesmo 😅 ? Mas Ian, e se estivermos usando o Firebase? Bem, vamos explorar como configurar flavors para múltiplos projetos do Firebase mais adiante nesse artigo.

Configurando Flavors para IOS

Abra a pasta ios do seu projeto no Xcode . Sem configurar nada vamos rodar o comando flutter run --flavor dev no terminal direcionando a um simulador do IOS e veja o que acontece.

Primeiro, precisamos criar novos Schemes de produtos no XCode. Em nosso exemplo, é prod e dev. Um Scheme descreve como o Xcode executa diferentes ações.

Já temos um scheme Runner, que é o scheme padrão. Iremos renomeá-lo para prode criar mais um novo esquema dev. Vamos lá? veja o passo a passo abaixo.

Agora novamente rodando o comando flutter run --flavor dev no terminal direcionando a um simulador do IOS e veja o que acontece.

Esse erro nos diz que o Flutter espera uma configuração de build chamada Debug-dev ou similar. Vamos criar essas configurações agora. Depois que os schemes são criados, temos que duplicar as configurações de compilação:

Debug, Release, and Profile de acordo com o scheme, com o nome da configuração de compilação copiado + prefixo como nome. Duplique as configurações de build para diferenciar entre as configurações padrão que já estão disponíveis e as novas configurações do scheme dev.

Feito isso, teremos 6 configurações, 3 para cada flavor (sabor).

Agora rode flutter run --flavor dev novamente…

Ainda estamos com erro pois no momento não personalizamos nada no esquema de construção/configuração de compilação, então o aplicativo ainda não irá ser executado com sucesso. Vamos configurar isso agora. ✍🏻

Renomeie o esquema de construção padrão e as configurações de construção para prod.

Como duplicamos as configurações de build, as configurações de dev ainda estão conectadas ao scheme original (que agora se chama prod). Vamos consertar isso também…

Esse é o resultado final abaixo.

Personalizando configurações para cada scheme

Vamos primeiro alterar o identificador do pacote de aplicativos para ser diferente em ambos os esquemas. O applicationId no Android era org.cajuinaapps.br o identificador do pacote no iOS é paralelo ao applicationId do Android.

Então, vamos alterar nosso identificador de pacote de produtos para org.cajuinaapps.br conforme o flavor.

Agora, vamos adicionar o identificador do pacote para cada configuração. Em Target-> Runner, clique Build Settingse pesquise Product Bundle Identifier e altere o identificador do pacote de aplicativos para diferenciar os esquemas.

Quando terminar, você terá algo assim.

Configurando nomes diferentes para o aplicativo conforme o flavor.

No mesmo Target-> Runner-> Build Settings, clique no botão +Add User Defined Settings e crie uma nova variável definida pelo usuário.

Quando terminar, você terá algo assim.

Depois de concluir a variável definida pelo usuário, você precisa alterar Info.plist para usar esta variável.

<key>CFBundleDisplayName</key>
<string>$(APP_DISPLAY_NAME)</string>

Vamos testar 🧪

Semelhante ao Android, podemos testar o iOS executando o comando para os ambientes prod e dev.

flutter run --flavor dev --target lib/main_dev.dart
flutter run --flavor prod --target lib/main_prod.dart

Ícones diferentes no aplicativo para Android e iOS

Agora, vamos ter ícones diferentes baseados nos flavors. Teremos 2 ícones diferentes um para cada ambiente.

O ícone verdinho vai ser o de ambiente de desenvolvimento e o outro será o do aplicativo de produção.

Vamos utilizar o package flutter_launcher_icons para nos ajudar a gerar os ícones para o aplicativo. Instale-o como uma dependência de desenvolvimento.

flutter pub add flutter_launcher_icons --dev

Após a instalação vamos criar um arquivo de configuração para ícones de cada ambiente flavor.

Veja o exemplo abaixo.

• flutter_launcher_icons-dev.yaml

    flutter_launcher_icons:
      android: true
      ios: true
      remove_alpha_ios: true
      image_path: "assets/icon_dev.png"
  

• flutter_launcher_icons-prod.yaml

    flutter_launcher_icons:
      android: true
      ios: true
      remove_alpha_ios: true
      image_path: "assets/prod-icon.png"
  

Agora vamos gerar os ícones com o comando:

flutter pub run flutter_launcher_icons:main -f flutter_launcher_icons-*

Rodando o comando nossos ícones foram gerados com sucesso. No Android dentro de app/src/ foi gerado duas pastas chamadas de prod e dev e dentro delas teremos uma outra pasta chamada res com os nosso icones respectivos.

Para IOS vá em Runner -> Assets.xcassets podemos ver que temos todos os ícones necessários. Podemos remover o AppIcon, que não é utilizado.

Agora, em Target-> Runner-> Build Settings, procure por Primary App Icon. defina o sufixo correspondente para cada um.

Testando as duas compilações e o resultado final é esse abaixo:

Configurando Flavors para diferentes projetos do Firebase 🔥

Primeira coisa, você deve ter dois projetos do Firebase criados para cada ambiente flavor.

Para o nosso exemplo nesse artigo teremos um de dev e outro de prod.

A integração do Firebase em um projeto costumava ser mais complicada do que é hoje. Você tinha que integrá-lo em um nível nativo, baixar configurações separadas para Android, iOS e web e era bastante sujeito a erros mas hoje temos uma nova maneira mais prática e rápido de configurar isso graças as evoluções da integração entre times do Flutter e Firebase.

Nesse artigo vou mostrar rapidamente como adicionar e configurar seu projeto ao Firebase mas se você quiser algo mais detalhado pode consultar isso em outro artigo onde mostro todo o processo bem detalhado, você pode consultar aqui.

Integrando o Firebase

Abaixo no Firebase console já deixei criado os dois projetos para o nosso aplicativo.

Instale a lib do Firebase core em seu app

flutter pub add firebase_core

Isso adicionará uma linha como esta ao pubspec.yaml do seu pacote (e executará um comando implícito flutter pub get):

dependencies:
  firebase_core: ^2.31.0

Em seguida, como o novo processo de integração usa FlutterFire CLI, que depende do Firebase CLI, você precisa instalar o Firebase CLI em nível global e fazer login. Se você tiver dúvidas na instalação consulte o meu artigo sobre isso ou a própria documentação aqui.

Em seguida, faça login na sua conta do Firebase com o seguinte comando:

firebase login

Se você ainda não estiver logado, este comando abrirá um navegador para permitir que você faça login em sua conta. Em seguida, execute o seguinte comando no mesmo terminal para instalar o FlutterFire CLI:

dart pub global activate flutterfire_cli

Em seguida, de volta ao terminal, vamos executar o seguinte comando para criar os aplicativos para Android e IOS no console do Firebase para cada projeto.

flutterfire config \
  --project=fir-flavor-example-dev \
  --out=lib/firebase_options_dev.dart \
  --ios-bundle-id=org.cajuinaapps.br.dev \
  --android-app-id=org.cajuinaapps.br.dev

Este comando registrará um aplicativo iOS e terá org.cajuinaapps.dev como identificador de pacote. Ele também registrará um aplicativo Android com o nome do pacote sendo org.cajuinaapps.dev.

Assim que o comando for concluído, ele irá gerar uma classe de configuração em lib/firebase_options_dev.dart contendo a uma classe chamada DefaultFirebaseOptions.

Gerando a configuração para o aplicativo de produção

Com o mesmo comando utlizado anteriormente vamos configurar nossos apps no firebase de prod apenas trocando alguns dados.

Veja como ficou o novo comando abaixo:

flutterfire config \
  --project=flavor-firebase-example \
  --out=lib/firebase_options_prod.dart \
  --ios-bundle-id=org.cajuinaapps.br \
  --android-app-id=org.cajuinaapps.br

De volta ao nosso editor de código, abra o arquivo lib/flavors.dart que nós criamos no início do artigo e adicione o seguinte trecho de código apartir dos comentários abaixo.

import 'package:firebase_core/firebase_core.dart';
//Adicione esses novos imports
import 'package:flavor_example_config/firebase_options_dev.dart' as dev;
import 'package:flavor_example_config/firebase_options_prod.dart' as prod;

enum FlavorTypes { dev, prod }

class Flavor {
  Flavor._instance();

  static late FlavorTypes flavorType;

  static String get flavorMessage {
    switch (flavorType) {
      case FlavorTypes.dev:
        return 'Development';
      case FlavorTypes.prod:
        return 'Production';
      default:
        return 'Development';
    }
  }

  static String get apiBaseUrl {
    switch (flavorType) {
      case FlavorTypes.dev:
        return 'apiUrlBaseDev';
      case FlavorTypes.prod:
        return 'apiUrlBaseProd';
      default:
        return 'apiUrlBaseDev';
    }
  }

  static bool isProduction() => flavorType == FlavorTypes.prod;
  static bool isDevelopment() => flavorType == FlavorTypes.dev;
    //Adicione esse novo trecho de código abaixo
  static FirebaseOptions get firebaseConfigOptions {
    switch (flavorType) {
      case FlavorTypes.dev:
        return dev.DefaultFirebaseOptions.currentPlatform;
      case FlavorTypes.prod:
        return prod.DefaultFirebaseOptions.currentPlatform;
      default:
        return dev.DefaultFirebaseOptions.currentPlatform;
    }
  }
}

Isso nos fornecerá a configuração correta conforme o flavor que estiver rodando no aplicativo em tempo de execução.

Para demonstrar o sucesso da integração eu ativei o banco de dados Cloud Firestore para cada aplicativo onde estará exibindo dados de seu respectivo ambiente no Firebase.

Atenção!! Não irei mostrar nesse post como configurar e usar o Cloud Firestore mas tenho esse outro artigo onde explico tudo em detalhes como fazer um crud completo com ele.

Adicionei alguns dados simples de filmes ao banco de dados para ilustrar melhor. Se você quiser aprender mais sobre o assunto, confira este outro artigo onde explico todos os detalhes da integração.

Executando a aplicação podemos ver que o Firebase foi configurado com sucesso!

Nas imagens acima podemos ver nomes diferentes sobre filmes para cada aplicativo conforme cadastrado na base de dados 🎲 !

Rodando o aplicativo na web 👨🏻‍💻

O uso do Flavors com Firebase funciona perfeitamente na web. Isso ocorre porque o arquivo de configuração do Firebase, na classe DefaultFirebaseOptions, já possui uma configuração específica para o ambiente web. Portanto, ao compilar nossa aplicação Flutter para a web, não é necessário realizar nenhuma configuração adicional. Isso é ótimo, não é mesmo?

Link do projeto no github aqui. 🔗

Referências

https://medium.com/@animeshjain/build-flavors-in-flutter-android-and-ios-with-different-firebase-projects-per-flavor-27c5c5dac10b

https://codewithandrea.com/articles/flutter-flavors-for-firebase-apps/

https://github.com/invertase/flutterfire_cli/issues/14

Conclusão

Bom é isso 😎.

Autilização de Flavors no Flutter oferece uma solução elegante e eficiente para gerenciar múltiplos ambientes de desenvolvimento, teste e produção dentro de um único código-base.

Com a configuração adequada, é possível personalizar comportamentos, variáveis e até mesmo integrações específicas para cada ambiente, facilitando o desenvolvimento e a manutenção do aplicativo.

Além disso, a integração com serviços como o Firebase é simplificada, garantindo que cada Flavor possa operar com suas próprias configurações sem complicações adicionais.

Em artigos futuros, veremos como usar outros recursos combinado com os flavors para configurar apps como white-label por exemplo.

Espero que você tenha gostado e obrigado por acompanhar até aqui! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter(X) | Medium

Seja para autenticação de usuários, armazenamento de dados, envio de notificações push ou captura e análise de erros, seus produtos sempre me ofereceram a solução perfeita.

Segundo o blog oficial do Firebase “Mais de 3 milhões de desenvolvedores, de startups a empresas, usam o Firebase para alcançar e envolver bilhões de usuários”

Hoje meu objetivo é abordar o uso do App Distribution, uma ferramenta que ajuda você rapidamente a distribuir seus aplicativos para os testadores sem ter que passar pelo estresse de subir o arquivo compilado do app para duas plataformas separadas, como Testflight para iOS e Google Play Console para Android.

O Firebase App Distribution faz parte do Firebase assim como outros serviços.

Então vem comigo. 🤏🏻 👨🏻‍💻

O que é Firebase App Distribution?

Segundo a documentação oficial "O Firebase App Distribution é um serviço que facilita a distribuição dos seus aplicativos para trusted testers (testadores confiáveis). Ao disponibilizar seus apps para os testers rapidamente, é possível receber feedback com antecedência e frequência.

Além disso, se você usar o Crashlytics nos seus aplicativos, receberá automaticamente métricas de estabilidade para todos os seus builds, para saber quando está tudo pronto para o envio."

Depois de concluir a configuração, o upload e a distribuição de apps geralmente são bem rápidos.

Utilizando o Firebase App Distribution

Passo #1: Adicionando Firebase ao seu aplicativo

Nesse artigo não irei ensinar a configurar o firebase pois fiz isso em outro post, você pode ler-lo aqui.

Passo #2: Ativando a distribuição de aplicativos no Firebase Console

Acesse o Firebase Console em seu projeto e ative o App Distribution. Você pode encontrar o App Distribution no painel esquerdo em Liberar e Monitorar.

Depois de clicar em Vamos começar, você chegará à página inicial do App Distribution, que se parece com o seguinte:

Distribuindo uma compilação para Android

Para distribuir seu app aos testadores android, faça upload do arquivo APK usando o Firebase console:

1. Abra a página App Distribution do Firebase console. Selecione seu projeto do Firebase quando solicitado.

2. Na Aba Lançamentos(Releases), selecione o aplicativo que deseja distribuir no menu suspenso.

Gere o arquivo APK do seu aplicativo com o comando flutter build apk --release e depois de gerá-lo com sucesso faça o upload dele.

Com o arquivo gerado, na aba lançamentos, arraste e solte ou navegue pela compilação (APK/AAB/IPA) no Firebase App Distribution. Aguarde até que seu aplicativo seja carregado no Firebase Console. Veja o print abaixo:

Assim que a compilação for carregada com sucesso, você será convidado a adicionar quem vão ser os testadores dessa versão. A aba Testadores e Grupos pode ser usada para essa configuração onde você irá cadastrar um tester ou um grupo com vários testers.

A compilação que você carrega será distribuída a esses testadores. Você pode verificar a documentação para obter mais detalhes sobre o assunto.

A última etapa é adicionar as notas de versão e clicar em Distribuir e ele estará disponível para todos os seus testadores.

É isso. Seu aplicativo é enviado para seus testadores 👨🏼‍🔧.

OBS: Depois de distribuir seu build, ele ficará disponível no painel App Distribution do Firebase console por 150 dias. Quando faltam 30 dias para a compilação expirar, um aviso de expiração aparece no console e na lista de compilações do testador em seu dispositivo de teste.

Como testar?

Os testadores irão receber um email com um convite enviado pelo Firebase App Distribution, abra o email e clique no link. Você será redirecionado para o aplicativo da Web do testador do Firebase App Distribution, faça login com sua conta do Google e toque em Aceitar convite.

Agora você pode ver o aplicativo para o qual foi convidado a testar.

Se você quiser também pode de forma opcional instalar e utilizar o Firebase App Tester, que evita que as versões baixadas sejam adicionadas à pasta Downloads do seu celular.

Toque em Fazer o download e assim que o download for concluído, seu lançamento aparecerá automaticamente como um atalho na tela inicial do seu dispositivo.

Distribuindo uma compilação para IOS

Para distribuir seu app aos testadores IOS, teremos que fazer algumas configurações extras no portal do desenvolvedor Apple. A primeira coisa é registrar os dispositivos do testador.

Um build ad-hoc não é assinado com um perfil Enterprise. Um dispositivo só vai conseguir instalar um build ad-hoc se o identificador exclusivo do dispositivo (UDID, na sigla em inglês) estiver incluído no perfil de provisionamento do build.

Faça login em sua conta de desenvolvedor Apple e selecione Certificados, identificadores e perfis . Em seguida, selecione a seção Dispositivos à esquerda.

Clique em registrar um novo dispositivo e você chegará a uma tela parecida com essa abaixo:

Encontrando seu UDID com Finder (macOS)

Plugue seu Iphone no seu mac e navegue até o Finder e selecione-o, você verá algumas informações sobre o celular conectado. Para mim tive que clicar algumas vezes nos dados abaixo do nome do Iphone para mostrar o UDID com sucesso!

Maneira alternativa de encontrar UDID com o Xcode

• Conecte seu dispositivo iOS ao Xcode

• Abra o menu Janela > Dispositivos e Simuladores

• Encontre o seu dispositivo exibido nesta lista e visualize-o no Identifier “identificador” que é o mesmo UDID.

Depois de inserir com sucesso o UUID e o nome, continue o processo. Em seguida, aceite e registre o dispositivo.

Aceitando o convite e Instalando o Certificado

1. Em seu dispositivo iOS de teste, abra o e-mail enviado pelo Firebase App Distribution e toque no link Get Started. Certifique-se de abrir o link no Safari.

2. No aplicativo da Web do testador do Firebase App Distribution exibido, faça login com sua conta do Google e toque em Aceitar convite.

3. Toque em Registrar dispositivo para compartilhar seu UDID com o Firebase para que você possa atualizar o perfil de provisionamento do seu aplicativo posteriormente.

4. Siga as instruções e vá para configurações para baixar o perfil e compartilhar seu UDID.

5. 

   Quando seu dispositivo for registrado com sucesso deve aparecer um popup como esse abaixo.

6. 

   Agora envie uma nova versão do aplicativo para o testador e ele poder baixar e instalar com sucesso.

Gerando o IPA de compilação

Para criar um arquivo IPA, abra o Xcode, navegue até Assinatura e Recursos e selecione uma equipe de desenvolvimento.

Quando estiver pronto para distribuir uma versão de pré-lançamento de seu aplicativo para testadores, selecione "Qualquer dispositivo iOS (arm64)" como destino de compilação e Produto->Arquivo. Depois que o arquivo for criado, crie uma distribuição assinada com o perfil de distribuição de desenvolvimento.

Quando a compilação for concluída, será mostrado uma tela como essa abaixo onde contém o arquivo de compilação gerado:

Clique em Distribute App.

Selecione o método de distribuição correto que para o nosso caso será Debugging e em seguida prossiga para distribuição. Espere o processamento.

Será salvo um arquivo IPA e alguns arquivos de log na pasta especificada.

Agora você distribui o arquivo IPA para seus testadores fazendo o upload no Firebase e selecionando os testadores para essa compilação. 🛠️🎉

Ufa, é isso, chegamos ao fim de mais um super tutorial 😎📲

Conclusão

Bom é isso 😎.

O Firebase App Distribution se destaca como uma ferramenta robusta e completa para a distribuição de aplicativos móveis, oferecendo diversos benefícios para desenvolvedores e testadores além da rapidez e eficiência para simplificar o processo de distribuição de aplicativos.

Em última análise, ao adotar o Firebase App Distribution, as equipes de desenvolvimento estão posicionadas para alcançar maior produtividade.

Onde eu trabalho usamos o Firebase App Distribution ativamente para enviar compilações para os QAs.

Em artigos futuros da série, veremos como usar outros recursos do Firebase como: Authentication, Crashlytics, Remote Config e muito mais com Flutter.

Espero que você tenha gostado e obrigado por acompanhar até aqui! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter(X) | Medium

Seja para autenticação de usuários, armazenamento de dados, envio de notificações push ou captura e análise de erros, seus produtos sempre me ofereceram a solução perfeita.

Segundo o blog oficial do Firebase "Mais de 3 milhões de desenvolvedores, de startups a empresas, usam o Firebase para alcançar e envolver bilhões de usuários"

Hoje meu objetivo é abordar o uso do Cloud Firebase um banco de dados NoSQL flexível e escalonável, criado com a infraestrutura do Google Cloud, para armazenar e sincronizar dados no desenvolvimento do cliente e do servidor.

Construiremos um aplicativo de lista de tarefas de exemplo usando o Flutter e Firebase onde executaremos algumas operações com dados.

Vamos usar o design criado por Diaa Mohamed disponível no Dribbble para nos inspirar na construção do nosso app usando firebase.

Então vem comigo. 🤏🏻 👨🏻‍💻

O que é um Crud?

CRUD é um acrônimo que representa as quatro operações básicas usadas em sistemas de gerenciamento de banco de dados relacionais ou em serviços de API que interagem com recursos. As operações são:

1. Create (Criar): Envolve a criação de novos registros ou recursos no banco de dados ou sistema.

2. Read (Ler): Envolve a recuperação de dados existentes do banco de dados ou sistema.

3. Update (Atualizar): Envolve a modificação dos dados existentes no banco de dados ou sistema.

4. Delete (Excluir): Envolve a remoção de registros ou recursos existentes do banco de dados ou sistema.

Essas operações são essenciais em muitas aplicações de software para realizar operações básicas de manipulação de dados. Quando se fala em desenvolvimento web, por exemplo, CRUD é uma abordagem comum para a implementação de funcionalidades de back-end que permitem aos usuários criar, ler, atualizar e excluir dados em um sistema.

No contexto do Firebase, um CRUD refere-se às operações básicas que podem ser realizadas em seu banco de dados em tempo real, que geralmente é o Firebase Realtime Database ou o Firestore 🔥.

O que é Cloud Firestore?

O Cloud Firestore é um banco de dados flexível e escalonável para desenvolvimento focado em dispositivos móveis, Web e servidores pelo Firebase e do Google Cloud.

Ele mantém seus dados sincronizados entre aplicativos clientes por meio de ouvintes em tempo real e oferece suporte off-line para que você possa criar aplicativos responsivos que funcionam independentemente da latência da rede ou da conectividade com a Internet.

Alguns dos principais recursos são:

Sincronização em tempo real: O Firestore oferece atualizações em tempo real para os clientes conectados. Isso significa que os dados são sincronizados automaticamente entre os diferentes dispositivos e plataformas em tempo real, permitindo uma experiência de usuário fluida e em tempo real.

Consultas ricas: O Firestore suporta uma variedade de consultas, incluindo consultas simples, consultas compostas e ordenação. Isso permite que os desenvolvedores recuperem dados de maneira eficiente e flexível.

Estrutura de dados escalável: O Firestore organiza os dados em coleções e documentos. Ele permite uma estrutura hierárquica flexível, o que facilita a organização e a consulta de dados.

Escalabilidade automática: O Firestore é altamente escalável e gerenciado pelo Google Cloud Platform. Ele escala automaticamente para atender às demandas de tráfego e armazenamento, garantindo alta disponibilidade e desempenho.

Suporte off-line: Armazena em cache os dados ativamente usados pelo aplicativo. Dessa maneira, o aplicativo poderá escrever, ler, detectar e consultar dados, mesmo que o dispositivo esteja desconectado. Quando o dispositivo retorna ao estado on-line, as alterações locais são sincronizadas novamente no Cloud Firestore.

Se você quiser se aprofundar um pouco mais no funcionamento deixo essa playlist muito completa sobre o assunto.

Modelo de dados do Cloud Firestore

O Cloud Firestore utiliza um modelo de dados NoSQL orientado a documentos, o que significa que ele difere de um banco de dados relacional SQL. Ao invés de tabelas e linhas, você armazena dados em documentos que posteriormente são organizados em coleções.

Veja alguns pontos-chave sobre o modelo de dados do Firestore:

• Documentos: Cada documento age como uma unidade de dados auto-contida, similar a uma linha em uma tabela relacional. Documentos contêm pares chave-valor, onde a chave é uma string que identifica o dado e o valor pode ser de diversos tipos como strings, números, booleanos, objetos, arrays, referências a outros documentos, entre outros.

  

• Coleções: Documentos relacionados logicamente são agrupados em coleções. Pense em coleções como pastas que organizam seus documentos. Por exemplo, você pode ter uma coleção "usuarios" para armazenar documentos de usuários do sistema, e cada documento representaria um usuário individual

• 

• Sem Esquema: Firestore é schemaless, ou seja, não possui um esquema rígido que define a estrutura dos dados. Isso oferece flexibilidade, pois você pode adicionar novos campos a documentos existentes sem precisar modificar toda a coleção.

• Hierarquia: Documentos podem conter subcoleções, permitindo uma modelagem hierárquica dos seus dados. Por exemplo, a coleção "usuarios" poderia conter uma subcoleção "pedidos" para armazenar os pedidos realizados por cada usuário.

Cloud Firestore X Realtime Database: qual devo usar?

O Realtime Database é um banco de dados que usa documentos JSON para armazenar os dados em pares de chave-valor enquanto o Cloud Firestore é uma versão mais recente do banco de dados que usa coleções de documentos para armazenar dados.

Existe algumas diferenças entre eles e abaixo vou citar 2 dos principais.

• Modelo de Dados:

  • Realtime Database: Utiliza um modelo de dados JSON em tempo real. Isso significa que os dados são sincronizados em tempo real entre todos os clientes que estão conectados ao banco de dados.

  • Cloud Firestore: Usa um modelo de dados de documentos coleções. Isso permite uma estrutura hierárquica mais flexível para dados, onde os documentos podem conter coleções aninhadas.

• Preço:

  • Realtime Database: O modelo de preços é baseado na largura de banda e no espaço de armazenamento utilizados.

  • Cloud Firestore: O modelo de preços é baseado na quantidade de leituras, gravações, exclusões e largura de banda utilizadas. Nesse caso um ponto de atenção ao modelar sua base 🚨🚨.

OBS. Qual usar depende muito das necessidades específicas do seu projeto:

• Realtime Database é uma boa escolha se você precisa de sincronização em tempo real de dados simples e tem requisitos de escalabilidade moderados.

• Cloud Firestore é preferível para aplicativos que requerem uma estrutura de dados mais complexa, consultas flexíveis e alta escalabilidade.

Em resumo, se você precisa de uma estrutura de dados mais flexível, consultas poderosas e escalabilidade robusta, o Cloud Firestore é provavelmente a melhor opção. Se você precisa de uma sincronização em tempo real simples e não tem requisitos de consulta muito complexos, o Realtime Database pode ser mais adequado.

Se você quiser se aprofundar um pouco mais nesse assunto acesse os links abaixo.

1. https://firebase.google.com/docs/firestore/rtdb-vs-firestore?hl=pt-br

2. https://stackoverflow.com/questions/46549766/whats-the-difference-between-cloud-firestore-and-the-firebase-realtime-database

Ativando o Firestore

Vamos utilizar o projeto flutter-firebase-app que criamos e configuramos no artigo passado, se você é novo acesse aqui.

1 - Vá até o console do Firebase e clique no seu projeto. No menu Criação , clique em Firestore Database > Criar banco de dados.

2 - A próxima tela aparecerá solicitando que você selecione o local que será hospedado o banco de dados. Você pode usar o padrão mas fique certo que não poderá alterar o local posteriormente.
Selecionar o local do banco de dados do Firestore durante a ativação é crucial por várias razões como:

1. Latência: Escolher um local próximo aos usuários finais reduz a latência e melhora a experiência do usuário.

2. Conformidade: Pode ser necessário garantir que os dados estejam armazenados em uma região específica devido a requisitos legais ou regulatórios.

3. Resiliência: Distribuir os dados em vários locais aumenta a resiliência da aplicação, garantindo disponibilidade mesmo em caso de falhas em um data center.

4. Custo: Escolher o local mais econômico pode reduzir os custos operacionais, já que alguns provedores de nuvem podem cobrar taxas diferentes com base na localização dos servidores.

3 - Selecione Iniciar em modo de teste e leia a isenção de responsabilidade sobre as regras de segurança. O modo de teste garante que você possa gravar livremente no banco de dados durante o desenvolvimento. Em seguida, clique no botão Criar para prosseguir.

🚨 Para seus aplicativos, especialmente aplicativos de produção, é importante proteger seu banco de dados com regras de segurança. Para saber mais sobre regras de segurança, consulte Regras de segurança do Firebase .

Fazendo o CRUD no Firestore

Adicione o package do cloud firestore no seu projeto

dependencies:
  cloud_firestore: ^4.15.10

No Firestore teremos uma coleção chamada todos que seria usada para armazenar dados relacionados a cada um dos itens de tarefas que os usuários podem adicionar, editar ou remover.

Cada item consistirá nos seguintes campos (os tipos de dados são escritos entre colchetes):

• title (String): armazena o nome da tarefa pendente

• createdAt (Timestamp): data de criação da pendência

• completed (Booleano): se a tarefa pendente foi concluída

• id(String): identificador exclusivo de uma tarefa

No Dart, vamos desenvolver um objeto para manipular esses dados e facilitar a integração com o Firestore. No entanto, os dados são intercambiados com o Firestore no formato JSON. Portanto, nosso modelo deve incluir uma funcionalidade para converter os dados de e para um objeto Dart.

Para essa conversão, podemos implementar um método toMap() que será responsável por retornar um Map quando dado um objeto Dart, e também podemos utilizar um construtor de fábrica fromJson para facilitar a conversão de JSON para objetos Dart. Aqui está um exemplo de como isso pode ser feito:

Com esse código, você pode facilmente criar objetos Todo a partir de dados JSON usando o construtor fromJson, e também pode converter objetos Todo em um formato que pode ser armazenado ou transmitido como JSON usando o método toMap().

import 'package:cloud_firestore/cloud_firestore.dart';

class TodoModel {
  String? id;
  final String title;
  final bool completed;
  final DateTime createdAt;

  TodoModel({
    this.id,
    required this.title,
    this.completed = false,
    required this.createdAt,
  });

  // Construtor Factory para converter JSON em objeto Dart
  factory TodoModel.fromJson(Map<String, dynamic> json) {
    return TodoModel(
      id: json['id'],
      title: json['title'],
      completed: json['completed'],
      createdAt: DateTime.fromMicrosecondsSinceEpoch(
        (json['createdAt'] as Timestamp).microsecondsSinceEpoch,
      ),
    );
  }
  // Método para converter objeto Dart em um Map
  Map<String, dynamic> toMap() {
    return {
      'title': title,
      'completed': completed,
      'createdAt': createdAt,
    };
  }

  TodoModel copyWith({
    String? id,
    String? title,
    bool? completed,
    DateTime? createdAt,
  }) {
    return TodoModel(
      id: id ?? this.id,
      title: title ?? this.title,
      completed: completed ?? this.completed,
      createdAt: createdAt ?? this.createdAt,
    );
  }
}

Gravando dados

• Create (Criar): No Firebase, você pode criar novos registros no banco de dados usando uma operação de escrita, como .set() ou .add() dependendo do tipo de banco de dados que você está usando.

  Ao usar set() para criar um documento, você precisa especificar um ID para ele. Exemplo:

    db.collection("cities").doc("new-city-id").set({"name": "Chicago"});
  

  No entanto, às vezes não há um ID significativo para o documento. É mais prático que o Cloud Firestore gere um automaticamente para você. Para fazer isso, podemos usar o add() na hora de criar o novo registro. Em nosso aplicativo de exemplo vamos utilizar-lo.

  Adicionar uma tarefa (todo) (CRIAR):

  O método addTodo é definido para adicionar uma nova tarefa à coleção ‘todos’ no Firestore. Veja o exemplo abaixo.

  Future<String> addTodo(TodoModel model) async {
     try {
          var snapshot = await firestore.collection('todos').add(model.toMap());
          return snapshot.id;
        } on FirebaseException catch (e) {
          debugPrint("Failed with error '${e.code}': ${e.message}");
          throw Exception(e.message);
        }
   }

• Read (Ler): Você pode ler dados do banco de dados usando operações de leitura, como .get() para Futures ou .snapshots() para Streams, que permitem recuperar dados de um caminho específico no banco de dados em tempo real.

  Obtenha tarefas (LER):

  O método getTodos é implementado para recuperar a lista de dados da coleção de 'todos'.

  •     Future<List<TodoModel>> getTodos() async {
            try {
              var snapshot = firestore.collection('todos').get();
              return snapshot.then(
                (querySnapshot) {
                  return querySnapshot.docs.map((todo) {
                    var mapData = todo.data();
                    mapData['id'] = todo.id;
                    return TodoModel.fromJson(mapData);
                  }).toList();
                },
              );
            } on FirebaseException catch (e) {
              debugPrint("Failed with error '${e.code}': ${e.message}");
              throw Exception(e.message);
            }
          }
    

• Update (Atualizar): Para atualizar dados existentes no Firebase, você pode usar a função .update() para fazer alterações em campos específicos de um registro, ou a função .set() com a opção merge: true para mesclar dados novos e existentes.

  Para atualizar alguns campos de um documento sem substituir o documento inteiro, o update() é o ideial pois em nosso app atualizaremos o campo completed quando finalizarmos uma task em nosso aplicativo.

  É possível configurar um campo no documento como um carimbo de data/hora do servidor que detecta quando o servidor recebe a atualização basta usar o FieldValue.serverTimestamp(). Veja o exemplo abaixo.

  Atualização de um todo (ATUALIZAÇÃO):

  O método updateTodo é definido para atualizar um todo existente na coleção 'todos'. O método *.*doc(docId) : Obtém uma referência a um documento específico usando seu ID.

    Future<void> updateTodo(String id) async {
        try {
          var snapshot = firestore.collection('todos').doc(id);
          await snapshot.update({
            'completed': true,
            'updateAt': FieldValue.serverTimestamp(),
          });
        } on FirebaseException catch (e) {
          debugPrint("Failed with error '${e.code}': ${e.message}");
          throw Exception(e.message);
        }
      }
  

  

• Delete (Excluir): Para excluir dados do Firebase, você pode usar a função .delete() para remover um registro específico do banco de dados.

  Excluir todo (DELETE):

  O método deleteTodo é implementado para excluir um registro da coleção ‘todos’.

•          Future<void> deleteTodo(String id) async {
              try {
                final snapshot = firestore.collection('todos').doc(id);
                return await snapshot.delete();
              } on FirebaseException catch (e) {
                debugPrint("Failed with error '${e.code}': ${e.message}");
                throw Exception(e.message);
              }
            }
  

Essas operações CRUD são fundamentais para interagir com o banco de dados do Firestore e são usadas para criar, recuperar, atualizar e excluir dados em aplicativos desenvolvidos com o Firebase.

No nosso app de exemplo criamos uma classe chamada FirestoreService que fornece uma forma estruturada e modular de interagir com o banco de dados Firestore, implementando todas as operações necessárias.

Para mais informações sobre gerenciar dados no Firestore clique aqui.

Excluir coleções?

O Firebase não nos dá um método diretamente para excluir toda uma coleção de dados. Uma forma que temos de excluir uma coleção ou subcoleção completa no banco, seria recuperar (leia) todos os documentos dentro da coleção ou subcoleção e os excluir. Abaixo deixo um exemplo de como fazer isso 😎.

OBS: Esse processo gera custos de leitura e exclusão.

 Future<void> deleteAllData() async {
    try {
      final snapshot = await firestore.collection('todos').get();
      final List<DocumentSnapshot> docs = snapshot.docs;
      for (DocumentSnapshot doc in docs) {
        await doc.reference.delete();
      }
    } on FirebaseException catch (e) {
      debugPrint("Failed with error '${e.code}': ${e.message}");
      throw Exception(e.message);
    }
  }

Para explorar o código completo do aplicativo de exemplo e se aprofundar nos detalhes da implementação, você pode encontrar o projeto completo no GitHub. Fique à vontade para acessar o repositório através do seguinte link:

Minha recomendação é que você baixe o projeto e dê uma olhada em toda a implementação pois além de Firebase, usei coisas como provider e change notifier para termos um aplicativo mais completo.

Conclusão

Bom é isso 😎.

Neste artigo, você aprendeu como utilizar o Firestore em um aplicativo real realizando operações na base de dados.

Em artigos futuros da série, veremos como usar outros recursos do Firebase como: Authentication, Crashlytics, Remote Config e muito mais com Flutter.

Espero que você tenha gostado e obrigado por acompanhar até aqui! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter | Medium

O Firebase realmente é uma ferramenta muito boa e que acelera muito o desenvolvimento de novos aplicativos, ele é de fácil integração com o Flutter.

Seja para autenticação de usuários, armazenamento de dados, envio de notificações push ou captura e análise de erros, seus produtos sempre me ofereceram a solução perfeita.

Segundo o blog oficial do Firebase "Mais de 3 milhões de desenvolvedores, de startups a empresas, usam o Firebase para alcançar e envolver bilhões de usuários"

Hoje meu objetivo é abordar a instalação do Firebase da maneira certa. Então vem comigo. 🤏🏻 👨🏻‍💻

Criando um novo projeto Flutter

Antes de instalar o Firebase vamos criar uma aplicação Flutter nova do zero para esse tutorial. Caso você não tenha ainda o SDK do Flutter instalado clique aqui. Depois de configurar seu ambiente para desenvolder em Flutter, você pode executar o seguinte comando para criar um novo aplicativo:

flutter create --org com.labs flutterfirebaseapp --platform=ios,android

No comando acima o --org é o nome da sua organização responsável pelo seu novo projeto Flutter, em notação reversa de nome de domínio. Essa string é usada em nomes de pacotes Java e como prefixo no identificador de pacote configurável do iOS. (o padrão é "com.example") mas nós nomeamos para com.labs como nome de exemplo de domínio para esse app.

💡 Outra coisa que fiz para minimizar o tamanho do projeto é definir apenas as plataformas para as quais vamos construir o aplicativo. Nesse caso especifiquei android/ios. Esse comando --platform=ios,android impedirá a criação de dependências de aplicativos em outras plataformas como Web, Desktopetc.

Instalação do Firebase 🔥

Para instalar o Firebase em um aplicativo Flutter costumava envolver muitas etapas de configuração manual específicas para cada plataforma, mas apartir da versão 2.8 do Flutter agora podemos inicializar o Firebase de uma nova forma diretamente do Dart.

Isso é possível graças à nova ferramenta FlutterFire CLI , que pode gerar a configuração correta do Firebase para o nosso projeto.

Nesse post vamos ver a forma nova que é mais prática e rápida mas se você ainda quiser usar a maneira antiga clique aqui. Bora?

Antes de qualquer serviço do Firebase poder ser usado, você deve primeiro instalar o firebase_core plugin, que é responsável por conectar seu aplicativo ao Firebase.

Adicione o plugin no pubspec.yaml do seu app e depois execute o comando flutter pub get basta salvar o arquivo e ele executará automaticamente o download da dependência.

dependencies:
  firebase_core: ^2.27.0

1 - Instalando as ferramentas de linha de comando necessárias

1. Como o FlutterFire CLI é uma ferramenta de linha de comando, precisamos instalá-lo primeiro: Instale aqui, caso ainda não tenha feito isso.

2. Agora no terminal faça login no Firebase com sua Conta do Google executando o seguinte comando:

    firebase login
   

3. Depois de ter feito login com sucesso instale também para o Flutter com o comando:

    dart pub global activate flutterfire_cli
   

2 - Criando um novo projeto do Firebase

1. Acesse o site do firebase console e faça login com a sua conta do Google e então, vamos criar um novo projeto.

2. No console, clique em Adicionar projeto.

3. 

   No campo Nome do projeto, insira flutter-firebase-app e clique em Continuar .

4. Clique nas opções de criação do projeto. Se solicitado, aceite os termos do Firebase, mas ignore a configuração do Google Analytics porque você não o usará neste aplicativo.

5. 

   No diretório do projeto do Flutter que criamos, execute o seguinte comando para iniciar o fluxo de trabalho de configuração do app:

6.     flutterfire configure
   

7. Supondo que já tenhamos feito login por meio da CLI do Firebase ( firebase loginse não, execute-o), isso listará todos os projetos do Firebase disponíveis:

8. 

   Depois de escolher o projeto correto vamos selecionar para quais plataformas queremos configurar o firebase, no nosso caso escolha Android e IOS. A CLI registra automaticamente o aplicativo para essas plataformas no console do FIrebase.

   

   Depois de escolher e apertar Enter podemos ver que a configuração foi feita com sucesso 😎.

9. 

   Para confirmar abra o console do Firebase e navegue até configurações veja que dois aplicativos foram criados para o nosso projeto.

10. 

3 - Inicializando o Firebase no seu aplicativo

Após a conclusão da etapa anterior, navegue até o seu código da pasta lib e veja que foi criado um arquivo novo firebase_options.dart .

Esse arquivo geralmente contém informações como o ID do projeto do Firebase, a chave de API, o ID do aplicativo, a URL do banco de dados em tempo real, entre outros detalhes de configuração necessários para estabelecer a conexão entre o aplicativo e os serviços do Firebase.

Para finalizar a integração vamos inicializar o Firebase apartir do nosso método main.

import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
import 'firebase_options.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  runApp(MyApp());
}

o WidgetsFlutterBinding é uma parte importante do ciclo de vida do aplicativo Flutter e pode ser usado para inicializar o Firebase juntamente com o aplicativo Flutter.

O DefaultFirebaseOptions.currentPlatformé importado do nosso firebase_options.dartarquivo que foi gerado.

Agora rodando nosso aplicativo no simulador deu tudo certo ✅

Depois de inicializado, você estará pronto para começar a usar as funcionalidades do Firebase 🤩.

Se quiser conferir o código esse é o link do repositório no github!

Conclusão

Bom é isso 😎.

Neste artigo, você aprendeu como configurar e preparar nossos aplicativos Flutter para serem usados ​​com o Firebase.

Em artigos futuros da série, veremos como usar recursos do Firebase, como Cloud Firestore, Authentication, Crashlytics, Remote Config e muito mais com Flutter.

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter | Medium

O Firebase realmente é uma ferramenta muito boa e que acelera muito o desenvolvimento de novos aplicativos, ele é de fácil integração com o Flutter pois os dois são mantidos pelo o Google.

Eu trabalho com Desenvolvimento Mobile desde de 2018 e pelo que o me lembro não teve um só app que não o utilizei rsrs. Em cada projeto, do mais simples ao mais complexo, essa plataforma robusta e versátil tornou-se minha parceira inseparável.

Seja para autenticação de usuários, armazenamento de dados, envio de notificações push ou captura e análise de erros, seus produtos sempre me ofereceram a solução perfeita.

Segundo o blog oficial do Firebase "Mais de 3 milhões de desenvolvedores, de startups a empresas, usam o Firebase para alcançar e envolver bilhões de usuários"

Nessa série de posts meu objetivo é abordar separadamente cada funcionalidade/produto da ferramenta e ensiná-los como usar em seus aplicativos. Então vem comigo. 🤏🏻 👨🏻‍💻

Introdução

O Google Firebase é uma poderosa plataforma de back-end como serviço (BaaS) que oferece um conjunto de ferramentas e serviços para ajudar os desenvolvedores a criar, dimensionar e manter aplicativos da web e móveis.

É suportado por várias linguagens de programação populares como: Dart/Flutter, JavaScript/Node.js, Java/Kotlin, Swift/Objective-C e Unity (C#) para o desenvolvimento de jogos.

Ele pode prover serviços de backend hospedados, como banco de dados em tempo real, armazenamento em nuvem, autenticação, relatórios de falhas, aprendizado de máquina, configuração remota e hospedagem para seus arquivos estáticos e muito mais 🔥.

Um pouco da História…

O Firebase nasceu em 2011 como uma startup independente fundada por Andrew Lee e James Tamplin. Inicialmente, oferecia hospedagem de arquivos estáticos e um banco de dados em tempo real para aplicativos móveis.

Após participar do programa de incubação Y Combinator em 2012, a empresa expandiu sua visão para facilitar o desenvolvimento de aplicativos em tempo real.

Em 2012, lançaram o Firebase 2.0 com o Firebase Realtime Database e outras ferramentas.

Em 2014, o Google adquiriu o Firebase, impulsionando sua evolução. Desde então, a ferramenta cresceu com uma ampla gama de recursos para desenvolvedores, incluindo autenticação de usuários, análise, mensagens em nuvem e muito mais, tornando-se uma das principais plataformas para o desenvolvimento de aplicativos móveis e web.

Como funciona?

A abordagem do Firebase se diferencia do método convencional de desenvolvimento de aplicativos, onde geralmente é necessário desenvolver um software tanto para o front-end quanto para o back-end.

No desenvolvimento tradicional, o front-end simplesmente chama os endpoints de API fornecidos pelo back-end, que é responsável por executar as operações e a regra de negócio.

No entanto, ao utilizar os produtos Firebase, o modelo de back-end convencional é contornado, e parte do trabalho é transferido para o cliente. A gestão administrativa desses produtos é facilitada pelo console do Firebase, fornecendo acesso direto e simplificado.

Como o Firebase pode ajudar você desenvolvedor? 🛠️

• Grátis para iniciar: O Firebase oferece um plano gratuito com 1 GB de armazenamento de banco de dados em tempo real, o que lhe dá a chance de iniciar um MVP de alguma ideia sua de app sem nenhum custo.

• Velocidade: Acelere o desenvolvimento de aplicativos e chegue ao mercado mais rapidamente. Com tantos recursos prontos como por exemplo (Autenticação e Banco de dados), o Firebase permite que você se concentre mais na regra de negócios e na experiência do usuário, em vez de lidar com a complexidade da infraestrutura de backend.

Pontos negativos

• Custos: Embora o Firebase ofereça um plano básico gratuito, o uso extensivo dos recursos do Firebase como escrita e leitura em banco de dados pode se tornar caro, especialmente em aplicativos com muitos usuários ativos ou que exigem grande quantidade de armazenamento e largura de banda.

• Apenas NoSQL: O Firebase oferece suporte apenas a bancos de dados NoSQL, que podem não ser adequados para todos os tipos de aplicativos, especialmente aqueles que exigem consultas e transações complexas. Isso pode ser uma limitação ao lidar com certos tipos de dados ou requisitos em um app.

• A migração de dados: Com o Firebase, você não pode lidar facilmente com a migração de dados como faria com um banco de dados SQL simples.

"Minha opinião é que se você estiver desenvolvendo um aplicativo e não estiver utilizando todos os recursos do Firebase, aproveitar os recursos totalmente gratuitos, como o remote config, analytics e as notificações, pode ser uma ótima estratégia. Isso permite otimizar seus custos enquanto ainda aproveita os benefícios desses recursos para melhorar a experiência do usuário."

Principais Produtos

Vou comentar abaixo os principais.

1. Autenticação (Firebase Auth): Oferece uma maneira fácil e segura para os usuários fazerem login em seus aplicativos. Suporta autenticação usando senhas, números de telefone, Google, Facebook, Twitter e muito mais.

2. Banco de dados em tempo real (Cloud Firestore/ Realtime Database): Os dados são sincronizados em tempo real entre todos os clientes. Isso facilita a criação de aplicativos sempre atualizados, mesmo quando os usuários estão offline.

3. Hospedagem: Com o Firebase Hosting, você pode implantar facilmente um app da Web de uma só página, uma página de destino de apps para dispositivos móveis ou um Progressive Web App.

4. Laboratório de testes: O aplicativo é testado em dispositivos virtuais e físicos localizados nos data centers do Google.

5. Notificações (Cloud Messaging)

   As notificações podem ser enviadas com o Firebase sem codificação adicional.

6. Remote Config : a Configuração remota do Firebase permite que os desenvolvedores modifiquem o comportamento e a aparência do aplicativo sem exigir atualizações do aplicativo.

7. Crashlytics : Firebase Crashlytics é um repórter de falhas em tempo real que ajuda os desenvolvedores a identificar e corrigir problemas de estabilidade.‍

8. Analytics : o Google Analytics é integrado ao Firebase, fornecendo informações valiosas sobre o comportamento do usuário e o desempenho do aplicativo.

9. Teste A/B : O teste A/B do Firebase ajuda os desenvolvedores a otimizar experiências de aplicativos testando diferentes variações de interface do usuário, recursos e campanhas.

10. Cloud functions: Uma ferramenta que permite executar código automaticamente em resposta a eventos acionados em seu aplicativo Firebase.

11. ML Kit: SDK para tarefas comuns de Machine learning.

Alguns aplicativos que usam o Firebase

Duolingo: É um aplicativo popular de aprendizagem de idiomas que usa infraestrutura Firebase para fornecer armazenamento, e funções em nuvem.

Lyft: Oferece uma alternativa aos serviços convencionais de táxi. Os passageiros podem solicitar uma viagem em seus smartphones .

O jornal New York Times: É uma organização de mídia americana que distribui e coleta notícias por meio de jornais, produtos digitais e aplicativos móveis.

Conclusão

Bom é isso 😎.

Hoje foi o primeiro artigo da série, vou tentar publicar os demais nas próximas semanas. Será algo mais prático com exemplos reais em Flutter.

O Firebase oferece um caminho fácil para desenvolver e construir um aplicativo móvel ou web escalável. O principal objetivo é simplificar o desenvolvimento full stack, reduzir a complexidade para ajudá-lo a ser mais produtivo e oferecer o caminho mais rápido para o sucesso do seu projeto.

Com o Firebase, você não precisa investir tempo e energia para desenvolver um backend do zero para sua aplicação. Você pode simplesmente usar a estrutura do Firebase e personalizá-la de acordo com suas necessidades.

Se você é do tipo que tem várias ideias de aplicativos e quer testar rapidamente em ação, acredito que o Firebase e Flutter juntos é uma dupla perfeita 🤩.

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Juntos, vamos construir apps incríveis que transformam o mundo!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 📲 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter | Medium

O que diferencia os desenvolvedores de software bem-sucedidos dos demais?

Como você pode conquistar não apenas um emprego, mas uma carreira sólida neste campo em constante evolução? Para responder a essas perguntas, vou te dar algumas dicas valiosas e essenciais, 10 dicas que o guiarão na jornada para se destacar como desenvolvedor de software.

A maioria delas eu aprendi sozinho ao longo da minha carreira, mas queria muito que alguém tivesse me dito isso lá atrás quando iniciei em 2016.

1 - Domine a base e os fundamentos da programação.

No início de carreira não tem problema focar rapidamente em uma tecnologia ou framework.

Muitos desenvolvedores aprendem o básico de tecnologias como Flutter ou React, por exemplo, para entrar no mercado. Depois de conseguirem emprego, passam a utilizá-las como parte de seu trabalho cotidiano, mas acabam se esquecendo de retornar e continuar aprendendo os fundamentos de forma constante.

No entanto, quando essas tecnologias passam por mudanças significativas ou perdem relevância no mercado, esses profissionais frequentemente se veem em situações desesperadas para aprender algo novo rapidamente.

É importante lembrar que, embora as tecnologias possam mudar, os fundamentos e as bases da programação dificilmente sofrerão alterações significativas.

Se você souber a base e entender como as coisas funcionam, aprender qualquer ferramenta ou tecnologia será mais simples pois os fundamentos são os mesmos, o que varia é a sintaxe de linguagem para linguagem.

Bons desenvolvedores aprendem os princípios por trás das ferramentas e frameworks que utilizam, estude estrutura de dados, algoritmos, programação orientada a objetos, testes e design de software.

2 - Escreva testes automatizados.

Software é importante. Sempre que você entregar código escreva os testes juntos, pois isso vai garantir que sua solução é confiável e que funciona.

Um código sem testes nada vai garantir que funcionará e isso poderá gerar sérios problemas para você ou quem usará o software.

Entenda que os sistemas que construímos podem afetar o bem estar e o rendimento das pessoas.

Leia sobre Lista de bugs em Software.

Escreva testes não por obrigação, mas porque você acredita que um bom código deve ser testado. Fazer testes ajuda a pensarmos melhor na hora que formos construir o código.

Bons desenvolvedores aprendem sobre testes automatizados onde incluem unitários, testes de integração e testes de UI e muitos outros.

3 - Leia livros técnicos.

Os livros são verdadeiros poços de conhecimentos acessíveis para as pessoas. Na maioria das vezes os autores são grandes desenvolvedores e os livros são uma forma fácil de aprender como a experiência dessas pessoas.

Crie o hábito de ler pelo menos um livro a cada 2 meses, se você seguir o ritmo terá lido 6 livros em um ano, o que eu acho excelente. Os livros contêm conhecimentos incríveis.

Recomendo a leitura de alguns livros clássicos no mundo da programação que te farão evoluir muito na carreira.

• Código Limpo.

• Codificador Limpo

• Refatoração

• Programador Pragmático

• Engenharia de software moderna.

4 - Pratique e aprenda coisas novas constantemente.

Uma coisa essencial para se tornar um desenvolvedor melhor é praticar. Programação é uma área que exige muita prática, assim como, Música, Futebol ou qualquer outro esporte.

Reserve um tempo para praticar e aprender coisas novas sempre que possível, quanto mais você treinar melhor ficará na tecnologia que você escolheu.

Tenha pequenas metas de estudo ou projetos paralelos que o incitem a estudar e praticar cada vez mais. O mercado de desenvolvimento de software está em constante mudança e sempre haverá novas tecnologias para aprender.

Uma boa ideia é trabalhar em projetos pessoais que permitem que você aplique tudo que está estudando e vá testando o que funciona e o que não funciona, isso pode incluir aplicativos, sites ou projetos de código aberto.

O legal de projetos próprios é que você pode errar à vontade sem ter medo, o importante é aprender com os erros e não desistir, estude um pouco todo dia e logo você verá que já avançou bastante.

5 - Tenha foco e se organize.

Gerencie seu tempo para estudar e tenha foco, não tente aprender tudo logo de início, aprenda conforme a demanda, profundidade é melhor que velocidade.

Defina metas claras e prioridades: Saiba o que você precisa fazer e o que é mais importante ao longo prazo.

Para usar essa dica, considere usar ferramentas como aplicativos de lista de tarefas, calendários etc.

6 - Arquitetura de Software e Princípios SOLID.

Aprender sobre arquitetura de software e princípios SOLID é fundamental para qualquer desenvolvedor de software pois estes nos ajudam a projetar sistemas escaláveis, manuteníveis e testáveis além de promover a reutilização de código.

Praticamente todas as entrevistas para cargos de desenvolvedor esses assuntos são bastante cobrados, então aprenda sobre eles todos os dias.

Profissionais que dominam os conceitos de arquiteturas de software e aplicam os princípios SOLID geralmente são mais valorizados no mercado de trabalho.

7 - Participe ativamente de eventos e comunidades de tecnologia.

Construir uma sólida rede profissional é essencial para o sucesso na área de engenharia de software.

Uma maneira eficaz de fazer isso é engajando-se ativamente em eventos como meetups, hackathons e conferências, bem como integrando-se a comunidades de desenvolvimento de software onde você poderá ajudar ou ser ajudado pelos membros da mesma.

Ao participar dessas oportunidades, você terá a chance de interagir com outros profissionais, o que não apenas proporcionará insights valiosos, mas também permitirá que você estabeleça conexões significativas que podem ser extremamente benéficas para o avanço de sua carreira.

8 - Invista em Soft Skills

Desenvolva suas habilidades interpessoais, como comunicação, resolução de problemas e pensamento crítico. Isso vale para qualquer carreira.

Uma das principais que eu considero é comunicação, ser um bom desenvolvedor é saber também se comunicar com as pessoas que você trabalha de forma eficaz.

Quanto mais sênior você for na carreira, mais comunicação será exigido de você.

9 - Estude inglês

Ter conhecimento em inglês é de extrema importância, não apenas porque a maioria da documentação e recursos de programação estão disponíveis nesse idioma, mas também porque a fluência em inglês pode abrir portas para oportunidades de emprego mais amplas e melhor remuneradas em todo o mundo.

Em resumo é uma habilidade crucial para os desenvolvedores de software, não apenas para melhorar as oportunidades de carreira, mas também para o desenvolvimento contínuo de habilidades e conhecimento na área.

10 - Contribuir com a comunidade

Você aprende muito vendo o código de outras pessoas, criando conteúdo ou palestrando em eventos de tecnologia.

Pessoalmente, tive muitas experiências excelentes enquanto palestrei em eventos ou criei conteúdos que ajudaram novas pessoas que estavam iniciando.

Conclusão 🔥

Bom espero que essas dicas o ajude a ser um desenvolvedor melhor.

Gostaria de ressaltar que existem muitas outras dicas legais, mas acredito que essas são as principais e lembre se não existe fórmula pronta, aplique as dicas e veja o que melhor funciona para você.

O sucesso na engenharia de software não acontece da noite para o dia. Leva tempo e esforço contínuo para se destacar nesta carreira em constante evolução.

Espero que você tenha gostado! Compartilhe-o com seus amigos e colegas!

Se tiver alguma dúvida ou contribuição, deixe nos comentários!

Me siga para estar sempre por dentro dos próximos artigos 🚀

🌐 Minhas redes sociais 🌐

GitHub | LinkedIn | Instagram | Twitter