Conceber e desenvolver aplicações móveis no-code (UC03815)
Atualizado em
- Introdução
- 1. O que é o no-code e quando faz sentido
- 2. As plataformas e a interação entre ferramentas de blocos
- 3. Anatomia de uma app móvel: ecrãs e componentes
- 4. Lógica de programação: fluxos, decisão e repetição
- 5. Planear a estrutura lógica e os fluxos de interação
- 6. Design e usabilidade: princípios de UX/UI
- 7. Wireframing e protótipo
- 8. Desenvolver o design da interface: layout, cor, imagem e responsividade
- 9. Programação por blocos: eventos, controlo, lógica e matemática
- 10. Blocos de texto, listas, tempo e cores
- 11. Variáveis e procedimentos
- 12. Integração de dados: bases de dados locais e de nuvem
- 13. Integrar serviços externos por API e automatizar fluxos
- 14. Sensores, autenticação e acesso
- 15. O emulador e os testes
- 16. Debugging: encontrar e corrigir erros
- 17. Normas, legislação e publicação
- 18. Caso prático integrado · App «Visitas Técnicas»
- Erros comuns
- Glossário
- Síntese
- Exercícios resolvidos
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.
- 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.
- Para (b), não: um jogo 3D exige motor gráfico e desempenho que as plataformas de blocos não oferecem.
- 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
- Componentes disponíveis: tem os sensores e serviços de que a app precisa?
- Sistemas operativos alvo: só Android, ou também iOS?
- Dados: oferece base de dados local e de nuvem? Liga a serviços externos?
- Limites do plano gratuito: número de ecrãs, de utilizadores, de pedidos, publicação em lojas.
- Comunidade e documentação: há tutoriais, fóruns, exemplos? Interpretar manuais, guiões e tutoriais técnicos faz parte do trabalho.
- Exportação: é possível levar a app para fora da plataforma?
Dois espaços de trabalho
Em qualquer das plataformas há dois espaços:
- O Designer, onde se arrastam os componentes para o ecrã e se configuram as propriedades.
- O Blocks (Blocos), onde se programa a lógica: o que cada componente faz quando acontece algo.
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.
- Dados partilhados entre vários utilizadores: a plataforma tem de ligar a uma base de dados de nuvem ou folha de cálculo partilhada.
- 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.
- 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:
- Propriedades: o que ele é (texto, cor, tamanho, visibilidade).
- Eventos: o que acontece com ele (foi clicado, mudou o texto, recebeu resposta).
- Métodos (ações): o que ele sabe fazer (abrir o ecrã, tirar a fotografia, guardar um valor).
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.
Navegação entre ecrãs
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:
- Sequência: os passos executam-se por ordem, de cima para baixo.
- Decisão (condicional): executa-se um troço se uma condição for verdadeira, e outro caso contrário.
- 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.
- Entradas: peso (kg) e recolha (sim ou não).
- Cálculo base:
valor = peso x 1,5. - Decisão: se recolha = sim,
valor = valor + 2. - 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:
- Funcionais: o que a app tem de fazer («registar uma visita», «mostrar a classificação»).
- Não-funcionais: como o deve fazer («responder em menos de 3 segundos», «ler-se ao sol», «funcionar sem rede»).
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:
- A estrutura lógica diz que ecrãs existem e como se ligam.
- O fluxo de interação diz o caminho que o utilizador faz para cumprir cada tarefa.
[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.
- Utilizadores: sócio e administrador.
- Requisitos funcionais: ver horários, reservar, ver as minhas reservas, cancelar (administrador).
- Requisitos não-funcionais: dados partilhados em tempo útil, leitura fácil no exterior.
- Ecrãs: Login, Horários, Confirmar reserva, As minhas reservas, Administração.
- Fluxo principal:
Login → Horários → Confirmar reserva → As minhas reservas. - Caminhos alternativos: horário já ocupado (mensagem e regresso a Horários); utilizador sem sessão (volta a Login).
- 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:
- Hierarquia: o mais importante é maior, mais contrastado ou está no topo.
- Alinhamento e espaço: elementos alinhados e com espaço entre si respiram; encostados cansam.
- Agrupamento: elementos relacionados ficam juntos (por exemplo, os campos de morada).
- Cor com função: uma cor de destaque para a ação principal, outra para avisos. Evitar mais de duas ou três cores base.
- Tipografia: um ou dois tipos de letra, tamanhos distintos para título, texto e legendas.
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
- A posição de cada elemento e a sua dimensão relativa.
- Um rótulo em cada caixa (título, lista, botão, imagem).
- As ligações: que botão leva a que ecrã (setas).
- Os estados: lista vazia, lista com itens, erro, carregamento.
- As dimensões do ecrã em que foi pensado.
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:
- Botões: simples, adequada a poucos ecrãs.
- Separadores (barra inferior): para 3 a 5 destinos principais sempre acessíveis.
- Menu lateral: para muitos destinos, menos frequentes.
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:
- Os componentes cabem sem cortar nem sair do ecrã.
- O texto não corta nem sobrepõe.
- Os botões continuam a ser fáceis de tocar.
- 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.
- Colocar o botão dentro de uma coluna que preenche a largura do ecrã.
- Definir a largura do botão como percentagem (por exemplo 90%) ou «preencher o contentor».
- Testar no emulador com um ecrã pequeno e um ecrã grande.
- 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.
- Designer:
Caixa_Conta(só números),Caixa_Pessoas(só números),Botão_Calcular,Label_Resultado. - 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"
- 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
- Guardar logo que os dados mudem (depois de adicionar, editar ou remover), não só quando a app fecha, porque a app pode ser fechada à força.
- Ler quando o ecrã inicia (evento de inicialização do ecrã).
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.
- Acrescentar o componente TinyDB (não visível) ao ecrã.
- Ao iniciar o ecrã, ler:
Quando Ecrã_Lista.Inicia
lista_tarefas = TinyDB.obter("tarefas", lista vazia)
ListView.Elementos = lista_tarefas
- 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 = ""
- 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
- Definir o URL (juntando os parâmetros).
- Mandar fazer o pedido (por exemplo, o método Get do componente Web).
- À espera, mostrar um indicador de carregamento.
- No evento «recebeu resposta», verificar o código de estado.
- Se for sucesso, extrair os campos e mostrá-los; senão, mostrar uma mensagem de erro útil.
Cuidados com APIs
- A chave de acesso é secreta: numa app distribuída pode ser extraída, por isso usa-se a chave com os limites e restrições que o serviço oferece.
- Os serviços têm limites de pedidos e podem ser pagos acima de certo volume.
- O serviço pode mudar ou falhar: a app deve tratar a falha sem rebentar.
- Ler os termos de utilização do serviço, incluindo o que pode ser mostrado e guardado.
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:
- 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.
- Nunca escrever uma palavra-passe fixa nos blocos, porque quem tiver a app consegue vê-la.
- Decidir os perfis (sócio, administrador) e validar o acesso em cada ecrã sensível.
- 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.
- 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. - O caso 4 afeta só ecrãs pequenos. Corrige-se com larguras relativas.
- 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
- Reproduzir: descobrir os passos exatos que provocam o erro.
- Isolar: reduzir ao menor troço de blocos que falha (desativar blocos para testar por partes).
- Observar: mostrar valores intermédios num Label temporário ou numa notificação (o «print» do no-code) e ler as mensagens de erro.
- Formular uma hipótese e corrigir uma coisa de cada vez.
- Voltar a testar, incluindo o que antes funcionava.
- Limpar os Labels temporários.
Erros frequentes
- Variável não inicializada, ou com o nome parecido de outra.
- Ordem errada: usar o valor antes de o calcular.
- Âmbito: variável local usada fora do bloco onde existe.
- Eventos em falta: o botão não tem bloco de clique.
- Índices: lista a contar de 1, ciclo a começar em 0.
- Operadores trocados:
eonde devia serou.
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.
- Reproduz-se: com preços 2 e 3, mostra 0.
- Isola-se o troço do ciclo e acrescenta-se um Label temporário a mostrar
totaldentro do ciclo: mostra sempre 0. - Observa-se que os blocos fazem
total = 0 + preçonum bloco local diferente do global: o valor acumulado nunca é guardado na variável global. - Corrige-se atribuindo ao global
total, não a um local com o mesmo nome. - 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
- Nome, ícone e versão definidos.
- Testes funcionais e de ecrã concluídos.
- Permissões reduzidas ao necessário.
- Chaves de serviços restritas e sem dados de teste reais.
- Política de privacidade acessível, se se recolhem dados pessoais.
- Multimédia com direito de uso.
- 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
- Requisitos funcionais: iniciar sessão, listar visitas, registar visita (cliente, notas, fotografia), ver o detalhe.
- 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.
- Fluxo:
Login → Lista → Nova visita → (guardar) → Lista;Lista → Detalhe. - Dados: folha de cálculo partilhada, com uma linha por visita (cliente, data, notas, ligação da fotografia, técnico).
Fase 2 · Design
- Wireframes dos quatro ecrãs, validados com um técnico.
- Paleta com uma cor principal e uma cor de aviso; letra grande; botão «Guardar» em destaque na zona do polegar.
- Contentores com larguras relativas; teste em dois tamanhos de ecrã.
Fase 3 · Programação
- Variável global
visitas(lista de listas). - Ao iniciar a Lista: ler do armazenamento local; se houver rede, atualizar a partir da folha.
- Em «Guardar»: validar cliente não vazio; adicionar à lista; guardar localmente; enviar à folha; mostrar «Visita guardada».
- 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
- Começar a arrastar componentes sem planear os fluxos e os wireframes.
- Achar que o no-code dispensa a lógica: não dispensa.
- Fluxos com becos sem saída (ecrãs sem forma de voltar).
- Usar posições e larguras fixas e esquecer a responsividade.
- Usar só a cor para transmitir informação, ou texto com pouco contraste.
- Não guardar os dados, ou guardar sem ler ao abrir.
- Não usar o valor por defeito ao ler pela primeira vez, e a app rebentar.
- Não validar entradas (campos vazios, texto no lugar de números, divisão por zero).
- Usar variáveis com o mesmo nome em âmbitos diferentes.
- Imagens enormes que tornam a app lenta.
- Esquecer-se de tratar a falha de uma API ou da rede.
- Chaves de acesso à vista ou palavras-passe escritas nos blocos.
- Testar só num ecrã e num dispositivo.
- Pedir permissões a mais e esquecer a política de privacidade.
- Corrigir um erro e não repetir os testes anteriores.
Glossário
- No-code: criar software sem escrever código de texto.
- Low-code: mistura de blocos com pequenos troços de código.
- Componente: elemento de um ecrã (botão, lista, imagem).
- Bloco: peça visual de lógica que se encaixa.
- Evento: algo que dispara uma ação, como um clique.
- Screen (ecrã): uma «página» da app.
- Propriedade: característica de um componente, como texto ou cor.
- Variável: nome que guarda um valor que pode mudar.
- Lista: conjunto ordenado de itens.
- Procedimento: bloco de lógica com nome, reutilizável.
- Algoritmo: sequência finita de passos que resolve um problema.
- UX / UI: experiência de utilização / interface visual.
- Wireframe: esboço de um ecrã sem cores nem conteúdo real.
- Protótipo: wireframes ligados que simulam a navegação.
- Responsividade: capacidade de a interface se adaptar a vários tamanhos de ecrã.
- Acessibilidade: utilização por todas as pessoas, incluindo com limitações.
- API: serviço externo a que a app faz pedidos.
- JSON: formato de texto para dados estruturados.
- Webhook: endereço que recebe um pedido e dispara uma automatização.
- TinyDB / Firebase: base de dados local / de nuvem.
- Sensor: GPS, câmara, acelerómetro e afins.
- Emulador: telemóvel simulado no computador.
- Debugging: identificar, isolar e corrigir erros.
- APK / AAB: ficheiros de instalação e de publicação de uma app Android.
- RGPD: regulamento europeu de proteção de dados pessoais.
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
totalinicializada 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.