Partilhar: Classroom Teams WhatsApp
aulify · Sebenta
UC · Unidade de Competência · UC03815

Conceber e desenvolver aplicações móveis no-code (UC03815)

Lógica, UX/UI, wireframes, blocos, dados, APIs, sensores e testes
25h · 2.25 pontos crédito Curso: T. Inform. Gestão, T. Eletrónica ↗ Referencial oficial SNQ

Atualizado em

Índice

Há um pacote premium desta unidade: um PowerPoint editável de 100 ou mais diapositivos, um manual em PDF e dois testes com correção. Esta sebenta continua gratuita.

Introdução

Esta sebenta ensina a criar aplicações móveis sem escrever código de texto, usando plataformas no-code de programação por blocos, como o MIT App Inventor ou o Thunkable. «Sem código» não significa «sem lógica»: vais usar exatamente os mesmos conceitos de qualquer linguagem (variáveis, condições, ciclos, listas, funções), só que sob a forma de peças visuais que se encaixam.

O percurso é o de quem constrói uma app a sério. Primeiro planeia-se a estrutura e os fluxos, depois desenha-se a interface (UX/UI e wireframes), a seguir programa-se a funcionalidade com blocos, integram-se dados, serviços e sensores, e por fim testa-se num emulador antes de entregar. No fim, deves conseguir levar uma ideia de app do papel a um ficheiro instalável a funcionar, e explicar cada decisão que tomaste.

Esta unidade organiza-se em quatro realizações, e a sebenta segue-as pela mesma ordem:

Realização Capítulos desta sebenta
Planear a estrutura lógica da app e fluxos de interação 1 a 5
Desenvolver o design da interface 6 a 8
Integrar dados e programar a funcionalidade 9 a 14
Testar a app 15 a 17

O capítulo 18 junta tudo num caso prático completo, do pedido do cliente à app testada. Os exemplos resolvidos usam sobretudo a nomenclatura do MIT App Inventor; onde o Thunkable difere de forma relevante, isso é dito. Os nomes exatos de menus e blocos mudam de versão para versão, por isso o que importa é perceber o conceito e saber procurá-lo na ferramenta que tiveres à frente.

Como estudar: abre a plataforma ao lado desta sebenta e reproduz cada exemplo resolvido. Ler blocos é fácil, montá-los é que ensina.

1. O que é o no-code e quando faz sentido

No-code é criar software arrastando componentes para um ecrã e ligando blocos de lógica visual, em vez de escrever texto numa linguagem de programação. Existe também o low-code, que mistura blocos com pequenos troços de código para os casos que a ferramenta não cobre. Nesta unidade trabalhamos em no-code puro.

Vantagens e limites

Aspeto Vantagem Limite
Velocidade Um protótipo funcional em horas Projetos grandes ficam difíceis de organizar
Acessibilidade de aprendizagem Não é preciso decorar sintaxe A lógica continua a ter de ser dominada
Foco Atenção na experiência e na lógica Menos controlo fino sobre o que a plataforma faz por baixo
Custo inicial Ferramentas gratuitas ou com plano gratuito Planos pagos para publicar, escalar ou remover limites
Manutenção Alterações rápidas Dependência da plataforma (se mudar ou fechar, a app é afetada)

Quando usar no-code

O no-code é uma boa escolha para protótipos e MVPs (a versão mínima de um produto, para testar uma ideia), ferramentas internas de uma empresa (registo de visitas, inventário, pedidos de manutenção), apps de eventos e apps escolares. É menos indicado para jogos exigentes em gráficos, apps com milhões de utilizadores ou com requisitos de segurança muito específicos.

A lógica de programação (fluxos lógicos com condicionais, ciclos e variáveis, estruturação de processos e tomada de decisão) continua a ser necessária. O no-code muda a forma (blocos em vez de texto), não o raciocínio. Quem não sabe decompor um problema em passos também não consegue montá-lo em blocos.

Exemplo resolvido · Escolher no-code ou código

Enunciado. Três pedidos chegam ao departamento de TI de uma empresa: (a) uma app interna para os técnicos registarem as visitas a clientes, com fotografia; (b) um jogo 3D multijogador; (c) um catálogo de eventos para uma feira de dois dias. Para cada um, no-code serve?

Resolução.

  1. Para (a), sim: formulário, lista, câmara e base de dados são componentes típicos de qualquer plataforma no-code, e o uso é interno, com poucos utilizadores.
  2. Para (b), não: um jogo 3D exige motor gráfico e desempenho que as plataformas de blocos não oferecem.
  3. Para (c), sim: é uma app de vida curta, com conteúdos simples, em que a rapidez de entrega vale mais do que a sofisticação.

Conclusão. Escolhe-se no-code quando os componentes necessários existem na plataforma, a escala é moderada e o prazo é curto.

2. As plataformas e a interação entre ferramentas de blocos

Principais plataformas

Plataforma Perfil Notas
MIT App Inventor Blocos, muito usada em ensino Corre no browser; testa-se numa app de companhia no telemóvel ou num emulador; gera ficheiro instalável Android
Thunkable Blocos, mais próxima do aspeto de apps modernas Testa-se em direto num telemóvel Android ou iOS; tem planos gratuito e pagos
Glide, Adalo, AppSheet Orientadas a dados Constroem a app a partir de uma folha de cálculo ou base de dados, com menos lógica por blocos

Para esta unidade usamos as de blocos, porque obrigam a trabalhar a lógica. A escolha da plataforma é uma decisão técnica: adequar a plataforma aos objetivos pretendidos (a app precisa de GPS? de funcionar sem internet? de ser publicada na loja? de dados partilhados entre vários utilizadores?).

Critérios para selecionar uma plataforma

  1. Componentes disponíveis: tem os sensores e serviços de que a app precisa?
  2. Sistemas operativos alvo: só Android, ou também iOS?
  3. Dados: oferece base de dados local e de nuvem? Liga a serviços externos?
  4. Limites do plano gratuito: número de ecrãs, de utilizadores, de pedidos, publicação em lojas.
  5. Comunidade e documentação: há tutoriais, fóruns, exemplos? Interpretar manuais, guiões e tutoriais técnicos faz parte do trabalho.
  6. Exportação: é possível levar a app para fora da plataforma?

Dois espaços de trabalho

Em qualquer das plataformas há dois espaços:

Interação de diferentes ferramentas de blocos

Uma app raramente vive de uma só ferramenta. É preciso perceber a interação de diferentes ferramentas de programação por blocos: por exemplo, uma app em App Inventor que guarda dados numa folha de cálculo, que por sua vez dispara um fluxo automático noutra ferramenta que envia um e-mail. Cada ferramenta tem a sua zona:

Ferramenta Papel típico
Plataforma da app (App Inventor, Thunkable) Interface e lógica do lado do utilizador
Folha de cálculo ou base de dados Guarda os dados partilhados
Ferramenta de automatização Encadeia tarefas entre serviços
Ferramenta de design (Figma, editor de imagem) Wireframes, ícones, imagens

O princípio é sempre o mesmo: cada ferramenta faz bem uma coisa, e a app liga-as por pedidos (a app pede ou envia dados) e respostas.

Exemplo resolvido · Escolher a plataforma

Enunciado. O Clube de Orientação do Vale quer uma app para registar as provas e mostrar a classificação a todos os sócios, no Android e no iPhone. Que critérios pesam na escolha?

Resolução.

  1. Dados partilhados entre vários utilizadores: a plataforma tem de ligar a uma base de dados de nuvem ou folha de cálculo partilhada.
  2. Dois sistemas operativos: o teste em iPhone tem de ser possível na plataforma escolhida; se o plano gratuito só permitir um, regista-se a limitação.
  3. Poucos ecrãs e componentes simples: qualquer plataforma de blocos serve.

Conclusão. Escolhe-se a plataforma que cumpra os dois primeiros critérios no plano disponível; se nenhuma cumprir, o requisito «iPhone» passa a decisão a discutir com o cliente.

3. Anatomia de uma app móvel: ecrãs e componentes

Uma app organiza-se em ecrãs (screens), e cada ecrã contém componentes. Um ecrã é o equivalente a uma «página»: tem um objetivo (mostrar a lista, receber um formulário, apresentar o detalhe).

Principais componentes das apps

Os elementos habituais são: screens, design e acessibilidade, multimédia, autenticação e acesso, conteúdos, navegação, ligações e sensores. Na prática:

Grupo Exemplos de componentes Para que servem
Interface Label, Button, TextBox, CheckBox, Switch, Slider Mostrar texto, receber toques e entradas
Organização HorizontalArrangement, VerticalArrangement, TableArrangement Dispor outros componentes em linha, coluna ou grelha
Listas ListView, ListPicker, Spinner Mostrar e escolher entre vários itens
Multimédia Image, Player, Sound, VideoPlayer Imagem, som e vídeo
Dados TinyDB, CloudDB, Spreadsheet, Web Guardar e obter informação
Sensores LocationSensor, AccelerometerSensor, Camera, BarcodeScanner Reagir ao dispositivo
Avisos Notifier Mensagens e diálogos
Tempo Clock Temporizadores e datas

Alguns componentes são visíveis (aparecem no ecrã) e outros não visíveis (existem na app mas não se veem, como o Clock ou o TinyDB). Os não visíveis aparecem listados por baixo do ecrã no Designer.

Propriedades, eventos e métodos

Todo o componente tem três coisas:

Programar a app é, essencialmente, reagir a eventos: «quando acontecer X, fazer Y». Os eventos são os blocos de cabeça em arco, que não se ligam por cima de nada; tudo o resto se encaixa por baixo deles.

A navegação faz-se com um bloco que abre outro ecrã pelo nome. Cada ecrã tem o seu próprio Designer e o seu próprio conjunto de blocos. O que é guardado em variáveis de um ecrã não está visível nos outros, a não ser que se passe como valor ao abrir o ecrã seguinte ou se guarde numa base de dados. Este pormenor causa muitos erros (ver «Erros comuns»).

Exemplo resolvido · Identificar os componentes de um ecrã

Enunciado. Descreve o ecrã «Nova tarefa» de uma app de estudo: tem um título, uma caixa para escrever a tarefa, um botão para guardar e outro para voltar.

Resolução.

Elemento Componente Propriedade relevante Evento
Título Label Texto: «Nova tarefa» (nenhum)
Caixa de escrita TextBox Dica: «O que tens de estudar?» (nenhum, lê-se ao clicar em Guardar)
Guardar Button Texto: «Guardar» Clicado
Voltar Button Texto: «Voltar» Clicado
Armazenamento TinyDB (não visível) Namespace da app (usado nos blocos)

Conclusão. Quatro componentes visíveis e um não visível. A lógica vive em dois eventos, os dois cliques.

4. Lógica de programação: fluxos, decisão e repetição

A lógica de programação é a mesma em qualquer linguagem. Assenta em três estruturas de controlo:

  1. Sequência: os passos executam-se por ordem, de cima para baixo.
  2. Decisão (condicional): executa-se um troço se uma condição for verdadeira, e outro caso contrário.
  3. Repetição (ciclo): repete-se um troço várias vezes ou até uma condição mudar.

Algoritmo antes de blocos

Um algoritmo é uma sequência finita de passos que resolve um problema. Antes de arrastar blocos, escreve-se em linguagem corrente. Por exemplo, para a regra «desconto de 10% em compras acima de 50 euros»:

1. Ler o total da compra
2. Se o total for maior que 50
3.    desconto = total x 0,10
4. Senão
5.    desconto = 0
6. A pagar = total - desconto

Fluxogramas

O fluxograma desenha o algoritmo com símbolos: oval para início e fim, retângulo para uma ação, losango para uma decisão, setas para o sentido. Serve para validar o raciocínio com quem não programa.

Condições e operadores

Uma condição é uma pergunta com resposta «verdadeiro» ou «falso». Constrói-se com comparações (=, ≠, <, >, ≤, ≥) e combina-se com operadores lógicos:

Operador Significado Exemplo Resultado
e As duas condições verdadeiras idade ≥ 18 e tem_conta Só se ambas forem verdadeiras
ou Pelo menos uma verdadeira dia = «sábado» ou dia = «domingo» Verdadeiro ao fim de semana
não Inverte não (lista vazia) Verdadeiro se a lista tiver itens

Tabela de verdade para e e ou

A B A e B A ou B
Verdadeiro Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Falso Verdadeiro
Falso Verdadeiro Falso Verdadeiro
Falso Falso Falso Falso

Ciclos

Os ciclos repetem passos. Há os que repetem para cada item de uma lista, os que repetem um número de vezes (para n de 1 a 10) e os que repetem enquanto uma condição for verdadeira. O perigo do «enquanto» é a condição nunca mudar e o ciclo nunca acabar, bloqueando a app.

Tomada de decisão e estruturação de processos

Estruturar um processo é dividi-lo em partes que se possam testar separadamente. Uma app de pedidos, por exemplo, divide-se em «escolher produto», «confirmar quantidade», «calcular total» e «enviar pedido». Cada parte tem entradas, decisões e saídas, e pode tornar-se um procedimento reutilizável. Para a app poder crescer sem se tornar confusa, dão-se nomes claros aos componentes e variáveis, reúnem-se os blocos repetidos em procedimentos e separam-se as funções por ecrãs.

Exemplo resolvido · Do problema ao algoritmo

Enunciado. Uma app de lavandaria cobra 1,50 € por quilo, com 2 € de taxa de recolha se o cliente pedir recolha ao domicílio. Escreve o algoritmo.

Resolução.

  1. Entradas: peso (kg) e recolha (sim ou não).
  2. Cálculo base: valor = peso x 1,5.
  3. Decisão: se recolha = sim, valor = valor + 2.
  4. Saída: mostrar valor.

Teste de mesa com peso = 4 e recolha = sim: 4 x 1,5 = 6; mais 2 = 8 €. Com recolha = não: 6 €.

Conclusão. Um teste de mesa com valores simples confirma o algoritmo antes de qualquer bloco ser montado.

5. Planear a estrutura lógica e os fluxos de interação

Antes de construir, define-se o que a app faz e como o utilizador se move nela. Aqui nasce a realização «planear a estrutura lógica da app e fluxos de interação».

Do pedido aos requisitos

Começa-se por perceber o pedido: quem vai usar a app, para fazer quê, em que situação. Do pedido saem os requisitos:

Os requisitos de desempenho que a app deve assegurar escrevem-se desde aqui, porque condicionam as escolhas seguintes (por exemplo, se a app tem de funcionar sem internet, os dados têm de ser locais).

Utilizadores e histórias de utilizador

Uma forma simples de recolher requisitos é a história de utilizador: «Como [papel], quero [ação] para [objetivo]». Exemplo: «Como técnico, quero tirar uma fotografia da instalação para provar o estado em que a deixei.» Cada história dá origem a um ou mais ecrãs e eventos.

Estrutura lógica e fluxo de interação

Dois artefactos organizam o planeamento:

[Início] → [Login] → [Lista de visitas] → [Detalhe da visita]
                           │
                    [Nova visita] → (guardar) → volta à Lista

Para cada tarefa importante desenha-se o fluxo completo, incluindo os caminhos alternativos (e se a ligação falhar? e se o campo estiver vazio? e se o utilizador cancelar?).

Mapa de ecrãs e inventário de dados

Uma tabela simples ajuda a não esquecer nada:

Ecrã Objetivo Entradas Saídas Dados usados
Login Identificar o utilizador e-mail, palavra-passe Entra ou mostra erro Contas
Lista Ver visitas (nenhuma) Lista de visitas Visitas
Nova visita Registar visita cliente, notas, foto Visita guardada Visitas
Detalhe Ver uma visita visita escolhida Dados da visita Visitas

Exemplo resolvido · Planear a app «Reservas do Campo de Padel»

Enunciado. Um clube de padel quer uma app em que os sócios veem os horários livres e reservam um campo. O administrador cancela reservas. Planeia ecrãs e fluxo.

Resolução.

  1. Utilizadores: sócio e administrador.
  2. Requisitos funcionais: ver horários, reservar, ver as minhas reservas, cancelar (administrador).
  3. Requisitos não-funcionais: dados partilhados em tempo útil, leitura fácil no exterior.
  4. Ecrãs: Login, Horários, Confirmar reserva, As minhas reservas, Administração.
  5. Fluxo principal: Login → Horários → Confirmar reserva → As minhas reservas.
  6. Caminhos alternativos: horário já ocupado (mensagem e regresso a Horários); utilizador sem sessão (volta a Login).
  7. Dados: tabela de reservas (campo, data, hora, sócio).

Conclusão. Cinco ecrãs, um fluxo principal e dois desvios. Já se sabe que são precisos dados partilhados, o que condiciona a plataforma.

Exemplo resolvido · Detetar um erro no fluxo

Enunciado. O fluxo desenhado é Lista → Detalhe → Editar. Não há seta de regresso. Qual é o problema?

Resolução. O ecrã Editar é um beco sem saída: o utilizador só consegue sair fechando a app. Acrescenta-se Editar → (guardar) → Detalhe e Editar → (cancelar) → Detalhe. Corrigir um fluxo no papel custa um minuto; corrigi-lo com a app feita custa horas.

6. Design e usabilidade: princípios de UX/UI

UX (experiência do utilizador) responde a «é fácil e faz sentido usar?». UI (interface do utilizador) é o aspeto: cores, tipografia, botões, ícones. Uma interface bonita com má UX falha; uma interface simples com boa UX funciona. O objetivo é cumprir os princípios de experiência e de interface do utilizador para uma interação fácil e agradável.

Princípios de usabilidade

Princípio Significa Exemplo prático
Simplicidade Um ecrã, um objetivo Ecrã de login só com e-mail, palavra-passe e botão
Consistência Os mesmos elementos comportam-se igual O botão «Guardar» tem sempre a mesma cor e posição
Feedback O utilizador percebe que a ação aconteceu Mensagem «Reserva confirmada» depois de reservar
Visibilidade do estado A app mostra onde se está e o que está a fazer Indicador de carregamento enquanto espera uma resposta
Prevenção de erros Evitar que o erro aconteça Desativar «Enviar» enquanto o campo está vazio
Reconhecer em vez de recordar Mostrar opções em vez de pedir que se lembrem Lista de escolha em vez de escrever o nome da equipa
Liberdade e controlo Dar forma de voltar atrás Botão «Voltar» e confirmação antes de apagar

Organização visual

A organização visual guia o olhar:

Zona do polegar

Em telemóveis usa-se muito uma só mão. As ações frequentes ficam na metade inferior do ecrã, ao alcance do polegar; as destrutivas (apagar) ficam afastadas das frequentes, para não serem tocadas por engano.

Acessibilidade

A acessibilidade garante que a app é utilizável por todos, incluindo pessoas com baixa visão, daltonismo, dificuldade motora ou que usam leitor de ecrã.

Regra prática Porquê
Contraste elevado entre texto e fundo (as orientações WCAG recomendam pelo menos 4,5:1 para texto normal) Legibilidade ao sol e com baixa visão
Não usar só a cor para transmitir informação Daltónicos não distinguem verde de vermelho
Alvos de toque grandes (cerca de 44 a 48 unidades de ecrã de lado, segundo as orientações das plataformas) Toques precisos e menos erros
Letra legível e ajustável Pessoas com baixa visão
Descrições alternativas nas imagens Leitores de ecrã descrevem a imagem
Linguagem clara Evita confusão e erros

Exemplo resolvido · Rever uma interface

Enunciado. Um ecrã tem texto cinzento-claro sobre fundo branco, dois botões «Apagar» e «Guardar» lado a lado, do mesmo tamanho e da mesma cor, e o estado de erro só aparece como um sublinhado vermelho. Que problemas tem?

Resolução.

Problema Princípio violado Correção
Cinzento-claro sobre branco Contraste (acessibilidade) Texto escuro ou fundo mais escuro
Apagar e Guardar iguais e juntos Prevenção de erros, hierarquia Guardar em destaque; Apagar afastado, de cor de aviso e com confirmação
Erro só por cor Não usar só a cor Acrescentar texto («Falta o e-mail») e ícone

Conclusão. Três problemas, três princípios, três correções simples. Esta é a lógica de uma revisão heurística: percorrer a lista de princípios ecrã a ecrã.

7. Wireframing e protótipo

O wireframe é o esboço de um ecrã que mostra a posição de títulos, listas, imagens e botões sem cores nem conteúdo real. O protótipo liga os wireframes para simular a navegação. É a criação do protótipo de layouts de ecrãs e a organização dos conteúdos e ligações (wireframing).

Níveis de fidelidade

Nível Aspeto Para que serve Ferramenta
Baixa fidelidade Esboço a lápis ou caixas cinzentas Discutir a estrutura rapidamente Papel, quadro, diagrams.net
Média fidelidade Caixas com texto real e navegação Validar fluxos com utilizadores Figma, Penpot
Alta fidelidade Cores, imagens, tipografia finais Aprovar o aspeto com o cliente Figma, plataforma no-code

O que mostra um bom wireframe

Organização de conteúdos e ligações

Para cada ecrã, decide-se o tipo de conteúdo (texto, lista, imagem, formulário, mapa) e a ligação a outros ecrãs (botão, item de lista, separador, menu). A navegação pode ser por:

Protótipo e teste de papel

Antes de programar, pode testar-se o protótipo: pede-se a alguém que cumpra uma tarefa («reserva um campo para amanhã às 18h») e observa-se onde hesita. Se se perder num wireframe, perder-se-á na app.

Exemplo resolvido · Wireframe do ecrã «Horários»

Enunciado. Esboça o ecrã de horários da app de padel.

Resolução.

+--------------------------------+
| [<]  Reservas            [Perfil] |
+--------------------------------+
|  Data:  [ 12 jun ▼ ]            |
+--------------------------------+
|  18:00  Campo 1   [Reservar]    |
|  18:00  Campo 2   (ocupado)     |
|  19:00  Campo 1   [Reservar]    |
|  19:00  Campo 2   [Reservar]    |
+--------------------------------+
|  [Horários] [As minhas] [Conta] |
+--------------------------------+

Cada linha é um item de lista; «Reservar» leva a Confirmar reserva; «ocupado» não é clicável; a barra inferior liga aos três destinos principais.

Conclusão. O wireframe responde a: o que há no ecrã, para onde se vai a partir dele e que estados existem.

8. Desenvolver o design da interface: layout, cor, imagem e responsividade

Com wireframes aprovados, passa-se à construção da interface no Designer. Esta é a realização «desenvolver o design da interface» e inclui definir e executar o design e verificar a responsividade.

Layout com contentores

Em vez de posições fixas em píxeis, usam-se contentores (arrangements): linhas, colunas e tabelas dentro das quais os componentes se organizam. Um ecrã típico é uma coluna vertical com uma barra de título, uma zona de conteúdo e uma barra de ações.

Boa prática Em vez de
Largura em percentagem ou «preencher o contentor» Largura fixa de 320 píxeis
Contentores aninhados (linha dentro de coluna) Componentes soltos com posições absolutas
Margens e espaçamentos consistentes Cada elemento com o seu espaço

Responsividade

Os telemóveis têm tamanhos e proporções muito diferentes, e há tablets e modo horizontal. Uma interface responsiva adapta-se. Verifica-se:

  1. Os componentes cabem sem cortar nem sair do ecrã.
  2. O texto não corta nem sobrepõe.
  3. Os botões continuam a ser fáceis de tocar.
  4. O ecrã pode rolar quando o conteúdo é maior do que o espaço.

Cores e tipografia

Define-se uma paleta curta: cor principal, cor de destaque, cor de fundo, cores de texto e de estado (sucesso, aviso, erro). Escolhe-se um tamanho de título, um de texto e um de legenda, e mantêm-se em todos os ecrãs. Uma app com cores e tamanhos diferentes em cada ecrã parece várias apps coladas.

Multimédia

As imagens devem ser tratadas antes de entrarem na app: recortar, redimensionar para o tamanho em que serão mostradas e comprimir. Uma fotografia de vários megabytes num ícone de 64 píxeis desperdiça espaço e torna a app lenta. Formatos habituais: PNG (gráficos, transparência) e JPEG (fotografias). Som e vídeo seguem a mesma lógica: ficheiros curtos e comprimidos, ou então transmitir a partir de uma ligação.

Para editar imagens usam-se aplicações de edição (como o GIMP ou o Photopea) ou as funcionalidades da própria plataforma. Para ícones, conta o formato quadrado e um desenho legível em tamanho pequeno.

Direitos sobre a multimédia

Só se usam imagens, sons e letras de tipo que se tenha o direito de usar: material próprio, de bancos com licença adequada ou de licenças abertas (como as Creative Commons, respeitando as condições de cada uma, por exemplo a atribuição de autoria).

Exemplo resolvido · Tornar um ecrã responsivo

Enunciado. Um ecrã tem um botão «Reservar» com largura de 350 píxeis, que sai do ecrã num telemóvel pequeno. Corrige.

Resolução.

  1. Colocar o botão dentro de uma coluna que preenche a largura do ecrã.
  2. Definir a largura do botão como percentagem (por exemplo 90%) ou «preencher o contentor».
  3. Testar no emulador com um ecrã pequeno e um ecrã grande.
  4. Se ainda houver cortes, ativar o deslocamento (scroll) vertical do ecrã.

Conclusão. Larguras relativas e contentores resolvem a maior parte dos problemas; o teste em dois tamanhos confirma.

9. Programação por blocos: eventos, controlo, lógica e matemática

No espaço Blocks, tudo reage a eventos: «Quando Botão.Clicado, fazer…». Os blocos organizam-se por categorias, segundo a organização habitual: controlo, lógica, matemática, texto, listas, tempo, cores, procedimentos e variáveis. Neste capítulo vemos as quatro primeiras.

Formas dos blocos

As peças têm formas que só encaixam onde faz sentido: blocos de evento (cabeça), blocos de instrução (encaixam em cima e em baixo), blocos de valor (ligam-se a «encaixes» redondos ou hexagonais) e blocos de condição (valores verdadeiro ou falso, hexagonais). Se uma peça não encaixa, geralmente o tipo está errado.

Controlo

Bloco Função Exemplo
se / então / senão Decisão Se saldo ≥ preço então comprar
para cada item em lista Repetir para cada elemento Somar todos os preços
para cada número de 1 a n Repetir n vezes Criar 10 linhas
enquanto Repetir enquanto a condição for verdadeira Esperar até haver resposta
abrir outro ecrã Navegação Ir para «Detalhe»
fechar ecrã Voltar Regressar ao anterior

Lógica

Valores verdadeiro e falso, comparações e os operadores e, ou e não. Uma condição composta lê-se em voz alta: «se a caixa não estiver vazia e o valor for maior que zero».

Matemática

Operações (+ − × ÷), resto da divisão, arredondamento, mínimo e máximo, valor aleatório, e conversões. Úteis para totais, médias, descontos e para gerar um número aleatório (um sorteio ou um dado).

Exemplo resolvido · Calculadora de gorjeta e divisão da conta

Enunciado. Cria uma app com duas caixas (valor da conta e número de pessoas) e um botão «Calcular» que mostra o valor por pessoa com 10% de serviço.

Resolução.

  1. Designer: Caixa_Conta (só números), Caixa_Pessoas (só números), Botão_Calcular, Label_Resultado.
  2. Blocos:
Quando Botão_Calcular.Clicado
  se Caixa_Conta.Texto ≠ "" e Caixa_Pessoas.Texto ≠ "" e Caixa_Pessoas.Texto > 0 então
    total = Caixa_Conta.Texto × 1,10
    por_pessoa = total ÷ Caixa_Pessoas.Texto
    Label_Resultado.Texto = juntar("Cada pessoa paga ", arredondar(por_pessoa x 100) ÷ 100, " €")
  senão
    Label_Resultado.Texto = "Preenche os dois campos"
  1. Teste de mesa: conta 50, pessoas 4. Total = 55; por pessoa = 13,75. A condição evita a divisão por zero e campos vazios.

Conclusão. Decisão + matemática + texto num só evento; a condição garante entradas válidas.

10. Blocos de texto, listas, tempo e cores

Texto

Texto entre aspas é um valor. Blocos úteis: juntar (concatenar), comprimento, maiúsculas e minúsculas, remover espaços, conter (verificar se um texto contém outro), dividir (cortar um texto por um separador) e substituir.

Operação Entrada Resultado
juntar(«Olá, », nome) nome = «Rita» «Olá, Rita»
comprimento(«abc») 3
maiúsculas(«estudo») «ESTUDO»
dividir(«a,b,c», «,») lista com a, b, c

Listas

Uma lista guarda vários itens por ordem. Blocos: criar lista vazia ou com itens, adicionar item, inserir numa posição, remover, obter item (por posição, a contar de 1 nas plataformas de blocos mais comuns), tamanho, a lista está vazia?, contém?, posição do item, ordenar (nalgumas plataformas).

Listas de listas servem para dados em tabela, por exemplo uma lista de pares «nome, preço». Ligam-se a componentes como o ListView para mostrar dados que mudam: sempre que a lista mudar, atualiza-se o componente.

Ciclo sobre uma lista

total = 0
para cada preço em lista_precos
  total = total + preço

Tempo

O componente de relógio (Clock) dá a hora e a data atuais, formata datas, calcula diferenças e dispara um evento a intervalos (um temporizador). Aplicações: cronómetro, contagem decrescente, lembretes e atualização periódica de dados. Atenção a que um temporizador muito rápido gasta bateria; ajusta-se o intervalo ao necessário.

Cores

As cores são valores (vermelho, verde, azul, ou ainda código hexadecimal) que se atribuem a propriedades como fundo e texto. Mudar a cor por programação serve para dar feedback (botão que fica verde se a resposta estiver certa, vermelho se errada), desde que não seja o único sinal (ver acessibilidade).

Exemplo resolvido · Lista de compras com total

Enunciado. Uma app guarda produtos e preços em duas listas paralelas. Calcula o total e mostra os itens em texto.

Resolução.

inicializar global produtos = ["Pão", "Leite", "Ovos"]
inicializar global precos   = [0,60; 0,95; 2,40]

Quando Botão_Total.Clicado
  total = 0
  texto = ""
  para cada n de 1 até tamanho(produtos)
    total = total + obter item(precos, n)
    texto = juntar(texto, obter item(produtos, n), ", ")
  Label_Itens.Texto = texto
  Label_Total.Texto = juntar("Total: ", total, " €")

Resultado: «Pão, Leite, Ovos,» e Total: 3,95 € (0,60 + 0,95 + 2,40).

Conclusão. Com duas listas paralelas, o mesmo índice n liga produto e preço. Se as listas tiverem tamanhos diferentes, o programa falha: validar isso é um teste a fazer.

11. Variáveis e procedimentos

Variáveis

Uma variável é um nome que guarda um valor que pode mudar. Há dois âmbitos:

Âmbito Onde existe Quando usar
Global Em todo o ecrã, em todos os eventos Contadores, listas, estado da app
Local Só dentro do bloco onde foi criada Valores intermédios de um cálculo

Regras de boa prática: nomes claros (total_compra, não x), inicializar sempre com um valor sensato e não reaproveitar o mesmo nome para duas coisas.

Configurar variáveis para guardar e manipular dados na aplicação é a competência central: ler, calcular, atualizar e mostrar.

inicializar global contador = 0

Quando Botão_Mais.Clicado
  contador = contador + 1
  Label_Valor.Texto = contador

Procedimentos

Um procedimento é um bloco de lógica com nome, que se pode chamar de vários sítios. Evita repetir blocos iguais e facilita corrigir: altera-se em um sítio e o efeito é geral. Pode ter parâmetros (valores de entrada) e devolver um resultado.

procedimento preco_com_iva(valor) devolve valor × 1,23   (taxa normal do Continente, 23%)

Exemplo resolvido · Contador com limites

Enunciado. Uma app de contagem de pessoas à entrada de uma sala tem botões «+1» e «-1». O contador nunca pode ficar abaixo de 0 nem acima da lotação de 50. Se chegar a 50, o texto fica a vermelho com a mensagem «Lotação completa».

Resolução.

inicializar global contador = 0

procedimento atualizar()
  Label_Valor.Texto = contador
  se contador = 50 então
    Label_Aviso.Texto = "Lotação completa"
    Label_Valor.CorTexto = vermelho
  senão
    Label_Aviso.Texto = ""
    Label_Valor.CorTexto = preto

Quando Botão_Mais.Clicado
  se contador < 50 então contador = contador + 1
  chamar atualizar()

Quando Botão_Menos.Clicado
  se contador > 0 então contador = contador - 1
  chamar atualizar()

Teste: com contador a 49, «+1» leva a 50 e mostra o aviso; mais um «+1» não faz nada. Com 0, «-1» não faz nada.

Conclusão. O procedimento atualizar concentra a apresentação; as condições nos eventos protegem os limites. A cor vermelha não é o único sinal, porque há também texto.

12. Integração de dados: bases de dados locais e de nuvem

Uma app útil precisa de memória: guardar dados entre sessões e, muitas vezes, partilhá-los. Configurar bases de dados para armazenar e recuperar informações é uma das aptidões centrais da unidade.

Onde guardar

Tipo Exemplos Vantagens Limites
Local TinyDB (App Inventor), armazenamento local (Thunkable) Funciona sem internet, rápido, simples Fica só naquele telemóvel; perde-se se a app for desinstalada
Folha de cálculo Google Sheets, Airtable Fácil de ver e editar, partilhado Menos rápido, limites de pedidos, requer ligação
Base de dados de nuvem Firebase, CloudDB Tempo real, partilhado, escalável Requer configuração, ligação e cuidado com a segurança

Chave e valor

Os armazenamentos simples funcionam com etiqueta (chave) e valor: guarda-se o valor com um nome (tarefas) e depois pede-se pelo nome. Duas operações bastam:

guardar valor = lista_tarefas  com etiqueta = "tarefas"
lista_tarefas = obter valor com etiqueta = "tarefas"   (valor se não existir = lista vazia)

O «valor se não existir» é essencial na primeira utilização, quando ainda nada foi guardado.

Quando guardar e quando ler

Modelar dados

Antes de configurar, decide-se que dados existem e como se relacionam. Uma tabela de reservas pode ter: identificador, campo, data, hora, sócio. Escolhem-se nomes de colunas curtos e consistentes e um identificador único por registo.

Privacidade e segurança dos dados

Dados pessoais exigem cuidado: guardar só o necessário, não deixar a base de dados de nuvem aberta a toda a gente e informar o utilizador (ver capítulo 17).

Exemplo resolvido · Persistir a lista de tarefas

Enunciado. A app de tarefas perde tudo ao fechar. Corrige.

Resolução.

  1. Acrescentar o componente TinyDB (não visível) ao ecrã.
  2. Ao iniciar o ecrã, ler:
Quando Ecrã_Lista.Inicia
  lista_tarefas = TinyDB.obter("tarefas", lista vazia)
  ListView.Elementos = lista_tarefas
  1. Ao adicionar, guardar:
Quando Botão_Adicionar.Clicado
  se Caixa.Texto ≠ "" então
    adicionar Caixa.Texto à lista_tarefas
    TinyDB.guardar("tarefas", lista_tarefas)
    ListView.Elementos = lista_tarefas
    Caixa.Texto = ""
  1. Testar: adicionar duas tarefas, fechar a app, reabrir; as duas continuam lá.

Conclusão. Padrão universal: ler ao abrir, guardar ao alterar.

Exemplo resolvido · Escolher onde guardar

Enunciado. Para cada app, decide local ou nuvem: (a) diário pessoal; (b) lista de compras partilhada pela família; (c) classificação de um torneio visível a todos.

Resolução. (a) local, é privado e funciona sem rede; (b) nuvem ou folha partilhada, porque várias pessoas escrevem; (c) nuvem, com leitura para todos e escrita só para o organizador.

13. Integrar serviços externos por API e automatizar fluxos

O que é uma API

Uma API (interface de programação de aplicações) é uma porta que um serviço abre para outras aplicações lhe pedirem dados ou ações. A app faz um pedido e recebe uma resposta. Exemplos: meteorologia, câmbios, mapas, pagamentos, dados abertos de uma câmara municipal.

Anatomia de um pedido

Parte Significado Exemplo
URL (endereço) Para onde vai o pedido Endereço do serviço com o caminho do recurso
Método O que se quer fazer GET para obter, POST para enviar
Parâmetros Detalhes do pedido Cidade, moeda, data
Chave de acesso Identifica quem pede Fornecida pelo serviço; é secreta
Resposta O que volta Normalmente em formato JSON
Código de estado Se correu bem 200 significa sucesso; 4xx erro do pedido; 5xx erro do serviço

JSON

O JSON é um formato de texto para dados: pares «nome: valor», listas entre parênteses retos e objetos entre chavetas. Exemplo de resposta de uma API de tempo:

{ "cidade": "Porto", "temperatura": 17, "condicao": "nublado" }

Nas plataformas de blocos, a resposta chega como texto e converte-se para estruturas (listas de pares) que se consultam por nome.

Fluxo de uma chamada por blocos

  1. Definir o URL (juntando os parâmetros).
  2. Mandar fazer o pedido (por exemplo, o método Get do componente Web).
  3. À espera, mostrar um indicador de carregamento.
  4. No evento «recebeu resposta», verificar o código de estado.
  5. Se for sucesso, extrair os campos e mostrá-los; senão, mostrar uma mensagem de erro útil.

Cuidados com APIs

Automatização de fluxos

Automatizar é encadear serviços para que tarefas repetitivas aconteçam sozinhas. Ferramentas como o Make, o Zapier ou o n8n ligam um gatilho (algo acontece) a uma ou mais ações. A integração faz-se muitas vezes por um webhook: um endereço que a ferramenta de automatização expõe e que a app chama.

Gatilho Ações encadeadas
Nova linha na folha de inscrições Enviar e-mail de confirmação; avisar o organizador
Reserva criada Guardar na folha; enviar mensagem ao sócio
Fim do mês Gerar o resumo e enviá-lo à direção

Exemplo resolvido · App de tempo com API

Enunciado. Mostra a temperatura de uma cidade escrita pelo utilizador.

Resolução.

Quando Botão_Ver.Clicado
  se Caixa_Cidade.Texto ≠ "" então
    Web.Url = juntar("https://servico-tempo.exemplo/atual?cidade=", Caixa_Cidade.Texto)
    Web.Get
  senão
    Label_Estado.Texto = "Escreve uma cidade"

Quando Web.RecebeuTexto(codigo, conteudo)
  se codigo = 200 então
    dados = converter JSON(conteudo)
    Label_Temp.Texto = juntar(obter "temperatura" em dados, " °C")
  senão
    Label_Estado.Texto = "Não foi possível obter o tempo"

O endereço é fictício e serve só de modelo, e o evento está simplificado: no App Inventor, Web.GotText recebe também o endereço e o tipo de resposta, aqui omitidos. Numa app real usa-se o endereço e os parâmetros da documentação do serviço.

Conclusão. Pedido, verificação do código e tratamento da falha. A falha é tão importante como o sucesso.

Exemplo resolvido · Fluxo automático para inscrições

Enunciado. Quando alguém se inscreve num torneio, o organizador quer a inscrição numa folha e o inscrito quer um e-mail de confirmação.

Resolução. A app envia os dados (nome, e-mail) por um pedido POST para o webhook da ferramenta de automatização. O fluxo tem três passos: (1) receber os dados; (2) acrescentar uma linha à folha; (3) enviar o e-mail ao endereço recebido. A app mostra «Inscrição enviada» ao receber o código de sucesso. Testa-se com um endereço de e-mail próprio e verifica-se que a linha e a mensagem chegam.

14. Sensores, autenticação e acesso

Sensores

Os sensores distinguem uma app móvel de um site:

Sensor Dá Exemplo de uso Cuidado
GPS (localização) Latitude, longitude «Lojas perto de mim» Pede permissão; gasta bateria
Câmara Fotografia, vídeo Foto de uma ocorrência Pede permissão; imagens grandes
Leitor de códigos Texto de um QR ou código de barras Check-in num evento Validar o conteúdo lido
Acelerómetro Movimento e orientação Contar abanões, deteção de queda Valores ruidosos
Microfone Som Notas de voz Permissão e privacidade

A app reage aos sensores por eventos: «quando a localização mudar», «quando o dispositivo for abanado», «depois de tirar a fotografia».

Permissões

Cada sensor exige a permissão do utilizador. Pede-se no momento em que faz sentido, explicando para quê («Para mostrar as lojas mais próximas»). Se for recusada, a app deve continuar a funcionar com uma alternativa (escrever a localidade à mão).

Autenticação e acesso

A autenticação confirma quem é o utilizador (e-mail e palavra-passe, código, conta Google). O acesso define o que pode fazer (um sócio só vê as suas reservas; o administrador vê todas). Regras:

  1. Nunca guardar palavras-passe em texto simples no dispositivo; delegar a autenticação num serviço próprio sempre que a plataforma o ofereça.
  2. Nunca escrever uma palavra-passe fixa nos blocos, porque quem tiver a app consegue vê-la.
  3. Decidir os perfis (sócio, administrador) e validar o acesso em cada ecrã sensível.
  4. Prever «terminar sessão» e recuperação de acesso.

Exemplo resolvido · «Lojas perto de mim»

Enunciado. Mostra ao utilizador a sua localização e a distância a uma loja fixa.

Resolução.

Quando Ecrã_Mapa.Inicia
  LocationSensor.Ativo = verdadeiro

Quando LocationSensor.LocalizaçãoMudou(lat, lon)
  Label_Coordenadas.Texto = juntar(lat, ", ", lon)
  distancia = calcular_distancia(lat, lon, lat_loja, lon_loja)
  Label_Distancia.Texto = juntar("A ", arredondar(distancia), " metros")

O evento está simplificado: no App Inventor, LocationChanged recebe também a altitude e a velocidade, aqui omitidas. O procedimento calcular_distancia pode usar a fórmula da distância entre duas coordenadas ou uma API de rotas. Testa-se no emulador simulando a localização; num telemóvel real, é preciso estar ao ar livre ou perto de uma janela.

Conclusão. O sensor dispara eventos; a lógica é de leitura, cálculo e apresentação. Se o utilizador recusar a permissão, mostra-se uma caixa para escrever a localidade.

15. O emulador e os testes

O emulador

O emulador simula um telemóvel no computador, para testar sem dispositivo físico. Tem vantagens e limites:

Aspeto Emulador Telemóvel real
Tamanhos e versões Muitos, por configuração Só o que se tem
Sensores Simulados (localização, movimento) Reais
Desempenho Pode ser lento no computador Representativo
Câmara e toques Aproximados Reais

Por isso o emulador não substitui um teste final num dispositivo real, mas permite muito rapidamente cobrir tamanhos de ecrã e versões. Instalar o emulador e usar as suas funcionalidades (rodar o ecrã, simular localização, mudar o tamanho) é uma aptidão a dominar. Em muitas plataformas há alternativas: uma app de companhia que mostra em direto no telemóvel as alterações feitas no computador.

O que testar

Há que fazer testes ao comportamento da app em diferentes sistemas operativos e tamanhos de ecrã e à verificação do funcionamento de botões, fluxos e ações.

Categoria Perguntas
Funcional Cada botão faz o que deve? Cada fluxo chega ao fim?
Dados Os dados guardam-se, leem-se e sobrevivem ao fechar a app?
Validação O que acontece com campos vazios, texto no lugar de número, valores extremos?
Interface Tudo se vê em ecrãs pequenos e grandes, na vertical e na horizontal?
Sistemas operativos Comporta-se igual em Android e iOS (onde aplicável)?
Desempenho Abre depressa? Responde sem encravar?
Rede E se não houver ligação ou for lenta?
Permissões E se o utilizador as recusar?

Plano de testes

Um plano de testes é uma tabela com caso, passos, resultado esperado, resultado obtido e estado:

N.º Caso Passos Esperado Obtido Estado
1 Adicionar tarefa válida Escrever «Estudar», clicar Adicionar Aparece na lista Aparece OK
2 Adicionar em branco Clicar Adicionar sem escrever Nada acontece Adiciona linha vazia Falha
3 Persistência Adicionar, fechar, reabrir Tarefa mantém-se Mantém-se OK
4 Ecrã pequeno Abrir em ecrã de 5" Botões visíveis Botão cortado Falha

Testar a experiência do utilizador

Além de «funciona?», pergunta-se «é fácil?». Pede-se a três ou cinco pessoas para cumprirem uma tarefa, sem ajuda, e observa-se: onde hesitam, o que clicam por engano, o que não percebem. Melhora-se com base no que se vê. Os testes servem para testar e melhorar a experiência do utilizador, não só para caçar erros.

Exemplo resolvido · Executar um plano de testes e priorizar

Enunciado. Na tabela acima, os casos 2 e 4 falharam. Qual se corrige primeiro e como?

Resolução.

  1. O caso 2 afeta os dados (acumulam-se linhas vazias) em todos os dispositivos, por isso é mais grave. Corrige-se com a condição se Caixa.Texto ≠ "" antes de adicionar.
  2. O caso 4 afeta só ecrãs pequenos. Corrige-se com larguras relativas.
  3. Depois de cada correção, repetem-se os casos afetados e um conjunto básico dos que já passavam, para garantir que a correção não estragou outra coisa.

Conclusão. Prioriza-se por gravidade e abrangência, e testa-se de novo (teste de regressão).

16. Debugging: encontrar e corrigir erros

O debugging é o processo de identificar, isolar e corrigir erros e falhas.

Tipos de erro

Tipo Sintoma Exemplo
Lógico A app corre mas faz a coisa errada Condição com > em vez de ≥
De execução A app mostra erro ou fecha Obter item de uma lista vazia
De dados Valor inesperado Texto em vez de número
De interface Algo fora do sítio Botão escondido atrás de outro
De integração Falha com o serviço externo Chave inválida, sem rede

Método

  1. Reproduzir: descobrir os passos exatos que provocam o erro.
  2. Isolar: reduzir ao menor troço de blocos que falha (desativar blocos para testar por partes).
  3. Observar: mostrar valores intermédios num Label temporário ou numa notificação (o «print» do no-code) e ler as mensagens de erro.
  4. Formular uma hipótese e corrigir uma coisa de cada vez.
  5. Voltar a testar, incluindo o que antes funcionava.
  6. Limpar os Labels temporários.

Erros frequentes

Exemplo resolvido · Descobrir o erro do total

Enunciado. A app de compras mostra «Total: 0» sempre que se carrega em «Calcular». Os preços estão corretos na lista.

Resolução.

  1. Reproduz-se: com preços 2 e 3, mostra 0.
  2. Isola-se o troço do ciclo e acrescenta-se um Label temporário a mostrar total dentro do ciclo: mostra sempre 0.
  3. Observa-se que os blocos fazem total = 0 + preço num bloco local diferente do global: o valor acumulado nunca é guardado na variável global.
  4. Corrige-se atribuindo ao global total, não a um local com o mesmo nome.
  5. Testa-se de novo: Total = 5. Remove-se o Label temporário.

Conclusão. Mostrar valores intermédios foi o que revelou o problema. Dois nomes iguais em âmbitos diferentes são uma fonte clássica de erro.

17. Normas, legislação e publicação

Preparar a entrega

Terminada e testada, a app exporta-se. No Android, gera-se um ficheiro instalável (APK, ou o formato AAB exigido pelas lojas); a publicação em lojas segue as regras de cada loja (Google Play, Apple App Store), que incluem conta de programador, ícone, capturas de ecrã, descrição, classificação etária e informação sobre dados recolhidos. As regras e custos das lojas mudam; consultam-se na altura.

Checklist antes de entregar

  1. Nome, ícone e versão definidos.
  2. Testes funcionais e de ecrã concluídos.
  3. Permissões reduzidas ao necessário.
  4. Chaves de serviços restritas e sem dados de teste reais.
  5. Política de privacidade acessível, se se recolhem dados pessoais.
  6. Multimédia com direito de uso.
  7. Instruções de instalação e de utilização.

Normas, regulamentos e legislação aplicável

Matéria O que implica na prática
Proteção de dados (RGPD) Recolher só os dados necessários (minimização), dizer ao utilizador quem recolhe, para quê e durante quanto tempo, ter base legal (como o consentimento), garantir segurança e permitir o exercício de direitos (acesso, retificação, apagamento). A autoridade de controlo em Portugal é a Comissão Nacional de Proteção de Dados (CNPD).
Direitos de autor Só usar imagens, sons, tipos de letra e código de que se tenha licença; respeitar a atribuição.
Acessibilidade Seguir boas práticas (contraste, alvos de toque, alternativas ao som e à cor); existem orientações internacionais (WCAG) e legislação europeia e nacional aplicável a certos serviços.
Termos das lojas e das APIs Cumprir as políticas de cada loja e de cada serviço usado.
Defesa do consumidor e comércio eletrónico Se a app vende, aplicam-se regras de informação e de pagamento.

Os diplomas concretos, os prazos e os valores consultam-se no Diário da República e nas entidades competentes, na redação em vigor, porque mudam.

Conduta ética

Não manipular o utilizador para aceitar o que não quer; não recolher dados «por via das dúvidas»; não esconder o que a app faz. A conduta ética e o respeito pelas regras definidas fazem parte do perfil profissional.

Exemplo resolvido · Auditoria de permissões

Enunciado. Uma app de lista de tarefas pede câmara, localização, contactos e microfone. Só usa uma câmara para anexar uma fotografia opcional. O que fazer?

Resolução.

Permissão Necessária? Decisão
Câmara Sim, para a foto opcional Manter e pedir só quando o utilizador tocar em «Anexar foto»
Localização Não Remover
Contactos Não Remover
Microfone Não Remover

Acrescenta-se uma frase na política de privacidade a dizer que as fotografias ficam no dispositivo.

Conclusão. Menos permissões significa menos riscos e mais confiança.

18. Caso prático integrado · App «Visitas Técnicas»

Pedido. A empresa de climatização Brisa Norte quer uma app interna para os técnicos registarem as visitas a clientes: cliente, data, notas e fotografia, sem depender de papel. A chefia quer ver a lista no escritório.

Fase 1 · Planear

  1. Requisitos funcionais: iniciar sessão, listar visitas, registar visita (cliente, notas, fotografia), ver o detalhe.
  2. Não-funcionais: funcionar com sinal fraco (guardar localmente e sincronizar), usar-se com uma mão, resposta em menos de 3 segundos ao abrir.
  3. Fluxo: Login → Lista → Nova visita → (guardar) → Lista; Lista → Detalhe.
  4. Dados: folha de cálculo partilhada, com uma linha por visita (cliente, data, notas, ligação da fotografia, técnico).

Fase 2 · Design

  1. Wireframes dos quatro ecrãs, validados com um técnico.
  2. Paleta com uma cor principal e uma cor de aviso; letra grande; botão «Guardar» em destaque na zona do polegar.
  3. Contentores com larguras relativas; teste em dois tamanhos de ecrã.

Fase 3 · Programação

  1. Variável global visitas (lista de listas).
  2. Ao iniciar a Lista: ler do armazenamento local; se houver rede, atualizar a partir da folha.
  3. Em «Guardar»: validar cliente não vazio; adicionar à lista; guardar localmente; enviar à folha; mostrar «Visita guardada».
  4. Câmara: botão «Anexar foto» que tira a fotografia e guarda a ligação.

Fase 4 · Testes

Caso Esperado
Guardar sem cliente Mensagem «Falta o cliente»; nada é guardado
Guardar sem rede Guarda localmente e avisa «Sincroniza mais tarde»
Recusar permissão da câmara A app continua; a foto é opcional
Ecrã pequeno Botão Guardar visível
Fechar e reabrir Visitas mantêm-se

Fase 5 · Entrega

Ícone e nome; permissões reduzidas à câmara; nota de privacidade a dizer que os dados dos clientes só são vistos pela empresa; manual de uma página para os técnicos.

Conclusão. O caso cruza as quatro realizações: planear, desenhar, programar com dados e testar. Cada decisão tem um porquê que se consegue explicar a um cliente.

Erros comuns

Glossário

Síntese

Fazer uma app no-code segue o método de qualquer software. Planear (requisitos, fluxos, estrutura) evita retrabalho. Desenhar a interface (UX/UI, wireframes, responsividade, acessibilidade, multimédia) torna a app fácil de usar. Programar com blocos (eventos, decisões, ciclos, variáveis, listas, procedimentos) dá-lhe comportamento. Integrar dados, APIs, automatizações e sensores dá-lhe utilidade. Testar no emulador e em dispositivo real, depurar e repetir os testes dá-lhe qualidade. Publicar com atenção a permissões, privacidade e direitos de autor dá-lhe legitimidade. A ferramenta é visual; o raciocínio é o de sempre, e quem o domina adapta-se a qualquer plataforma.

Exercícios resolvidos

1. Verdadeiro ou falso: «no-code não usa lógica de programação». Justifica.

Resolução: Falso. O no-code usa a mesma lógica (condições, ciclos, variáveis, listas), só que sob a forma de blocos visuais.

2. Desenha o fluxo de uma app de lista de compras: abrir, ver lista, adicionar item, o item aparece na lista.

Resolução: [Lista] → [Adicionar item] → (volta a) [Lista]. O botão «+» abre Adicionar; ao confirmar, o item é acrescentado e volta-se à Lista.

3. Escreve, em pseudo-blocos: «quando se clica em Adicionar, se a caixa não estiver vazia, junta o texto à lista e limpa a caixa».

Resolução: Quando Botão_Adicionar.Clicado se Caixa.Texto ≠ "" então adicionar Caixa.Texto à lista_compras Caixa.Texto = ""

4. Que sensor e que serviço usarias para uma app de «lojas perto de mim»?

Resolução: o sensor GPS para a localização, um componente de mapa e uma API de mapas ou de pontos de interesse para obter as lojas.

5. Num ecrã pequeno os botões saem do sítio. Qual é o problema e como se resolve?

Resolução: falta de responsividade. Usam-se contentores e larguras relativas em vez de posições fixas, e testa-se em vários tamanhos no emulador.

6. Um ciclo percorre uma lista de 4 preços (2, 3, 5, 10) e soma-os. Qual é o total e que variável tem de existir antes do ciclo?

Resolução: o total é 20. Tem de existir uma variável total inicializada a 0 antes do ciclo.

7. A resposta de uma API chegou com código 404. O que deve a app fazer?

Resolução: o 404 indica que o recurso pedido não foi encontrado. A app mostra uma mensagem clara («Cidade não encontrada») e deixa o utilizador tentar de novo, sem rebentar.

8. Indica três itens da checklist antes de entregar uma app que recolhe nomes e e-mails.

Resolução: permissões reduzidas ao necessário; política de privacidade que diga que dados se recolhem, para quê e por quanto tempo; segurança do local onde os dados ficam guardados. Também: multimédia com direito de uso e testes concluídos.