Aplicações Android com o Delphi XE5

Prévia do material em texto

Aplicações Android com 
o Delphi XE5 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fernanda Dávida Vila Verde 
Flávia Paschoal Duarte 
 
Orientação: Prof. Murilo Zanini de Carvalho 
Organização: Prof. Roberto Scalco 
 
 
 
2014 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
22 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
33 
 
 
Sumário 
 
CAPÍTULO 1 – COMO UTILIZAR O EMULADOR DO ANDROID ............................................................................ 4 
1. INTRODUÇÃO AO EMULADOR ........................................................................................................................... 4 
1.1. INICIANDO O EMULADOR ................................................................................................................................. 4 
2. CRIANDO UM NOVO PROJETO MOBILE NO DELPHI XE5 .......................................................................................... 6 
2.1. COMPILANDO PARA O EMULADOR ANDROID ........................................................................................................ 8 
2.2. COMPILANDO PARA UM DISPOSITIVO ANDROID .................................................................................................... 8 
2.3. COMPILANDO PARA UMA JANELA WINDOWS ....................................................................................................... 9 
2.4. INSTALANDO A APLICAÇÃO EM UM DISPOSITIVO MÓVEL ....................................................................................... 10 
CAPÍTULO 2 – COMPONENTES ........................................................................................................................ 11 
1. PRINCIPAIS COMPONENTES E SUAS PROPRIEDADES .............................................................................................. 11 
1.1. BUTTON ..................................................................................................................................................... 12 
1.2. EDIT .......................................................................................................................................................... 12 
1.3. LABEL ........................................................................................................................................................ 13 
1.4. SWITCH ...................................................................................................................................................... 13 
1.5. TABCONTROL .............................................................................................................................................. 14 
1.6. TOOLBAR ................................................................................................................................................... 15 
1.7. COMBOBOX ................................................................................................................................................ 15 
1.8. MEMO ....................................................................................................................................................... 16 
1.9. STRINGGRID ............................................................................................................................................... 17 
1.10. LISTBOX ..................................................................................................................................................... 18 
1.11. TRACKBAR .................................................................................................................................................. 20 
2. COMPONENTES GRÁFICOS .............................................................................................................................. 21 
2.1. IMAGE ....................................................................................................................................................... 21 
2.2. TCHART ..................................................................................................................................................... 22 
2.3. WEBBROWSER ............................................................................................................................................ 24 
2.4. ANIINDICATOR ............................................................................................................................................ 24 
3. COMPONENTES NÃO VISUAIS .......................................................................................................................... 25 
3.1. TIMER ........................................................................................................................................................ 25 
3.2. LOCATIONSENSOR ........................................................................................................................................ 25 
3.3. MOTIONSENSOR .......................................................................................................................................... 26 
3.4. ACTIONLIST ................................................................................................................................................ 27 
CAPÍTULO 3 – EXERCÍCIOS RESOLVIDOS (PARA TODOS OS GOSTOS) .............................................................. 29 
1. COMPONENTES BÁSICOS DO DELPHI ................................................................................................................ 29 
2. NAVEGADOR COM O COMPONENTE WEBBROWSER ............................................................................................ 32 
3. MOSTRANDO A LOCALIZAÇÃO DO SMARTPHONE EM UM MAPA .............................................................................. 34 
4. COMPARTILHANDO FOTOS DA CÂMERA ............................................................................................................. 36 
REFERÊNCIAS.................................................................................................................................................. 40 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
44 
 
Capítulo 1 – Como utilizar o Emulador do Android 
 
Este capítulo apresenta como criar uma máquina virtual com o sistema operacional Android 
no emulador para que os aplicativos que iremos desenvolver possam ser testados. Além 
disso, será apresentado como executar os testes diretamente no smartphone. 
 
 
1. Introdução ao Emulador 
 
O Android Virtual Device (AVD) é um programa que simula a funcionalidade do aplicativo 
em um smartphone Android. Nele, você poderá definir as características do celular que 
deseja simular, bem como sua resolução, memória disponível, entre outros. Utilizando esse 
emulador, você poderá analisar o funcionamento do aplicativo e corrigir possíveis erros no 
código ou na interface do programa antes de utilizá-lo em um smartphone. 
Veremos como abrir o emulador AVD e configurá-lo de acordo com as necessidades do seu 
aplicativo e as características do celular, além da sincronização entre o emulador e o 
Delphi XE5 para testar o código elaborado. 
 
 
1.1. Iniciando o Emulador 
 
Para iniciar o emulador você deverá abrir o Android AVD Manager no menu Iniciar, como 
indica a Figura 1. 
 
Figura 1: Executando o Android AVD Manager. 
 
 
A janela da Figura 2 será aberta e nela você deverá selecionar o botão New para criação de 
um novo dispositivo virtual. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
55 
 
Figura 2: Criando um nova máquina virtual. 
 
 
Você pode criar uma máquina virtual com as características que desejar. Para os exemplos 
apresentados neste material, foram utilizadas as seguintes configurações: em AVD Name, escolha um nome para o seu dispositivo. Use um nome simples, sem 
espaços, números ou símbolos, apenas letras; 
 escolha o modelo do dispositivo no campo Device, selecionamos Nexus 4 
(4,7’’,768 x 1280: xhdpi); 
 no campo Target, escolhemos Android 4.2.2 – API Level 17; 
 para memória recomenda-se sua alteração para RAM: 768 e VM Heap: 64; 
 selecione a opção Use Host GPU no canto inferior direito. 
 
Figura 3: Parâmetros da nova máquina virtual. 
 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
66 
 
Selecione o dispositivo virtual criado, clique em Start e em seguida em Launch. 
 
Figura 4: Iniciando o emulador. 
 
 
Espere carregar. Todas as janelas de configurações serão minimizadas e o emulador será 
exibido, como mostra o exemplo apresentado na Figura 5. 
 
Figura 5: Tela inicial do emulador do Android. 
 
 
 
2. Criando um novo projeto mobile no Delphi XE5 
 
Abra o Delphi XE5 no menu Iniciar e crie um novo projeto, clicando no menu File no canto 
superior esquerdo, depois em New e, por fim, FireMonkey Mobile Application – Delphi. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
77 
 
Figura 6: Criando novo projeto mobile. 
 
 
Para desenvolver uma aplicação mobile completamente personalizada, recomenda-se o uso 
do tipo Blank Application, uma das opções dentre os modelos de projetos mobile 
disponibilizados. 
 
Figura 7: Escolha do modelo do projeto mobile. 
 
 
Recomenda-se salvar o projeto e todos os arquivos que o compõe em uma pasta do seu 
computador clicando em File e escolhendo a opção Save All. Em seguida, ajuste o modelo 
visual do smartphone para o mesmo tipo de dispositivo escolhido anteriormente, no caso 
Google Nexus 4. 
 
Figura 8: escolhendo o modelo visual do smartphone. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
88 
 
2.1. Compilando para o emulador Android 
 
Para estabelecer uma conexão entre o emulador e o Delphi, clique na janela Project 
Manager no canto superior direito no sinal de “+” ao lado de Target Plataforms, em seguida 
abra a aba Android – Android SDK 22.0.1 32 bit, clique em Target e por fim dê dois cliques 
no emulador criado anteriormente que já se encontra sincronizado, no exemplo 
apresentado pela Figura 9, o “Ex1 (5554)”. Caso o emulador não apareça automaticamente, 
clique com o botão direito em Target e em Refresh. 
 
Figura 9: Escolhendo o emulador. 
 
 
 
2.2. Compilando para um dispositivo Android 
 
Antes de conectar o aparelho no computador através do cabo USB, clique em Configurações 
do aparelho, acesse a opção Sobre o Telefone e clique diversas vezes sobre o item Número 
de Compilação ou Número do Sistema ou Número da Versão. Com isso, você terá ativado a 
opção de desenvolvedor do seu celular. Depois, volte para Configurações e em Opções de 
Desenvolvedor ou Programador ative a opção Depuração de USB. 
 
Figura 10: Habilitando a Depuração de USB no celular. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
99 
 
Na janela Project Manager do Delphi clique no sinal de “+” ao lado de Target Plataforms, em 
seguida abra a aba Android – Android SDK 22.0.1 32 bit, clique em Target e por fim dê dois 
cliques no dispositivo conectado que já se encontra sincronizado, no exemplo apresentado 
pela Figura 11, o “GT-I9505”. 
 
Figura 11: Escolhendo o dispositivo conectado. 
 
 
Observação: o driver do dispositivo Android deve ser previamente instalado no computador. 
 
 
2.3. Compilando para uma janela Windows 
 
Você perceberá que quando compilar e executar um aplicativo para o emulador ou para o 
dispositivo conectado na USB haverá certa demora em que o aplicativo apareça. Uma 
alternativa para fazer os primeiros testes, de leiaute dos componentes, entrada de dados via 
teclado, eventuais cálculos e exibição dos resultados, consiste em definir uma janela do 
Windows como Target da compilação. Mas lembre-se dos limites dessa plataforma que não 
contemplas os principais recursos do emulador ou do dispositivo conectado, como o acesso 
aos sensores, câmera, entre outros. 
Para criar esse ambiente para os testes preliminares do seu aplicativo, clique no sinal de “+” 
ao lado de Target Plataforms, em seguida clique com o botão direito sobre o Target 
Plataforms e escolha o item Add Plataform. Selecione a plataforma 32-bits Windows, como 
mostrado na Figura 12. 
 
Figura 12: Adicionando uma janela Windows. 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1100 
 
2.4. Instalando a aplicação em um dispositivo móvel 
 
Quando executamos o programa (no botão play verde ou usando a tecla F9) é gerado um 
arquivo de instalação (.apk) que pode ser copiado para o dispositivo com o sistema 
operacional Android (via cabo ou enviado por e-mail) e instalado. 
Para poder instalar o aplicativo no smartphone com Android de qualquer pessoa, é 
necessário acessar as Configurações e, em seguida, localize o item Segurança. Habilite a 
opção Fontes Desconhecidas., como mostrado na Figura 13. 
 
Figura 13: Autorizando os aplicativos em smartphones. 
 
 
A partir da pasta onde o projeto foi gravado, podemos acessar o arquivo de instalação que 
está na pasta bin, como mostra a Figura 14 com o exemplo do projeto denominado 
MeuAplicativo. 
 
Figura 14: O arquivo de instalação .apk. 
 
 
Basta enviar o arquivo MeuAplicativo.apk para o dispositivo móvel e, utilizando um 
gerenciador de arquivos, localizar o arquivo apk e instalá-lo. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1111 
 
Capítulo 2 – Componentes 
 
Neste capítulo serão apresentados alguns dos componentes que podem ser utilizados nas 
aplicações, suas principais propriedades, além de exemplos de aplicações simples para 
garantir um melhor e mais completo entendimento. 
 
 
1. Principais componentes e suas propriedades 
 
Quando desenvolvendo aplicativos para dispositivos que possuem uma tela muito menor do 
que o monitor, temos que considerar o uso de representações gráficas para a identificação 
das funcionalidades dos componentes. 
Para evitar ter que copiar as imagens dos ícones ou formatar linhas e cores dos 
componentes, podemos alterar a propriedade StyleLookUp, presente na maioria dos 
componentes visuais que utilizaremos. Essa propriedade contempla a formatação ou um 
conjunto de ícones associados às principais funcionalidades dos objetos que se adaptam ao 
padrão visual do sistema operacional. 
A Figura 15 mostra diferentes identidades visuais para um botão que possui o valor 
cameratoolbutton associado à propriedade StyleLookUp, sendo executado em um 
dispositivo com o sistema operacional Android ou iOS. 
 
Figura 15: Identidade visual definida pela propriedade StyleLookUp. 
 
Android 
 
iOS 
 
A Figura 16 mostra alguns exemplos de ícones associados à propriedade StyleLoopUp do 
botão. Cada componente terá características visuais distintas. 
 
Figura 16: Valores da propriedade StyleLoopUp de um botão. 
 
actiontoolbutton 
 
 
backtoolbutton 
 
bookmarkstoolbutton 
 
cameratoolbutton 
 
 
cleareditbutton 
 
composetoolbutton 
 
detailstoolbutton 
 
infotoolbutton 
 
 
nexttoolbutton 
 
priortoolbutton 
 
refreshtoolbutton 
 
searchtoolbutton 
 
Note que se, por exemplo, for atribuído o valor cameratoolbutton à propriedade 
StyleLoopUp de um botão, ele apenas terá o ícone de uma câmera, você deverá 
implementar o código para que a câmera seja acessada. 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1122 
 
11..11.. BBuuttttoonn 
 
Aba: Standard.Botão que receberá o procedimento ou função a ser codificado com sua ação específica. 
 
Figura 17: Button. 
 
 
Propriedades: 
 Text: texto que será exibido no componente. 
ATENÇÃO!!! Para o componente mobile a propriedade não se chama mais “Caption”! 
 StyleLookUp: determina a aparência do componente. 
 
 
11..22.. EEddiitt 
 
 
Aba: Standard. 
Caixa de edição, onde serão inseridos os dados de entrada de texto fornecidos pelo usuário. 
 
Figura 18: Edit. 
 
 
Propriedades: 
 Text: texto digitado pelo usuário. 
 Password: quando habilitado, o texto que o usuário digitar será substituído por 
caracteres como, por exemplo, “*” ou “”. 
 KeyBoardType – tipo do teclado que será exibido quando o usuário clicar sobre o Edit. 
Veja alguns dos tipos de teclado que podem ser utilizados: 
 vktDefault: Teclado padrão do sistema; 
 vktURL: Teclado para digitar endereços de sites. Símbolos como “www.” e “.com” 
possuem botão próprio para facilitar a digitação; 
 vktEmailAddress: Teclado para digitar endereços de e-mail. Símbolos como “@” e 
“.com” possuem botão próprio para facilitar a digitação; 
 vktPhonePad: Teclado para digitar telefones; 
 vktNumberPad: Teclado para digitar valores numéricos. 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1133 
 
Figura 19: Tipos de teclado. 
 
vktDefault 
 
 
vktURL 
 
vktEmailAddress 
 
vktPhonePad 
 
vktNumberPad 
 
 
11..33.. LLaabbeell 
 
 
Aba: Standard. 
Componente utilizado para exibir textos na interface do aplicativo. 
 
Figura 20: Label. 
 
 
Propriedades: 
 Text: propriedade que contém o texto que será exibido no Label. 
ATENÇÃO!!! Para o componente mobile a propriedade não se chama mais “Caption”! 
 StyleLookUp: determina a aparência do componente. 
 
 
11..44.. SSwwiittcchh 
 
Aba: Standard. 
Componente utilizado para indicar se alguma opção do aplicativo está ou não ativa. 
 
Propriedades: 
 IsChecked: é um valor booleano que indica se o componente está ligado ou não. 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1144 
 
Figura 21: Switch. 
 
 
 
11..55.. TTaabbCCoonnttrrooll 
 
Aba: CommonControls. 
Componente que propicia a criação de abas. Muito utilizado para organizar os demais 
componentes nas abas separadas por assunto. 
Adicione-o no formulário e depois de posicioná-lo corretamente, clique com o botão direito 
sobre o componente e escolha a opção Items Editor. Adicione a quantidade de TabItem que 
desejar clicando em Add Item. Cada TabItem é um componente distinto, associado ao 
TabControl. 
 
Figura 22: TabControl. 
 
 
 
Propriedades do TabControl: 
 Align: normalmente, aplicações que usam TabControl usa toda a tela para mostrar as 
páginas. Para isso, troque a propriedade Align para a opção AlClient; 
 TabPosition: usada para escolher qual posição que deseja que suas abas estejam, como 
na parte superior (tpTop), inferior (tpBottom). Nesses casos, o texto de cada TabItem é 
exibido no TabControl. 
As páginas podem ser representadas apenas por pontos na interface (tpDots). Além 
disso, o TabControl pode ocultar qualquer indicação das abas (tpNone) de maneira que a 
aba ativa seja especificada via código, alterando a propriedade TabIndex. Isso pode dar a 
impressão ao usuário que o aplicativo possui diversos formulários; 
 TabIndex: indica qual aba está ativa no momento, começando a contagem a partir do 
número zero; 
 StyleLookUp: determina a aparência do componente. Eventuais alterações devem ser 
aplicadas a cada TabItem criado. 
 
Propriedade do TabItem: 
 Text: altera o texto de cada TabItem, se estiverem visíveis. 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1155 
 
11..66.. TToooollBBaarr 
 
Aba: Standard. 
Serve como uma barra de ferramentas alinhada geralmente no topo ou na parte inferior da 
interface do aplicativo, com botões que representam atalhos ou maneiras de acessar a 
funcionalidade embutida em sua aplicação. Normalmente, correspondem também a itens do 
menu em um aplicativo e dá ao usuário acesso direto aos comandos do aplicativo. 
No exemplo apresentado na Figura 23, um Label e um Button foram colocados sobre um 
ToolBar. A propriedade StyleLookUp, foi alterada para ToolLabel e o botão teve a mesma 
propriedade alterada para AddToolButton. 
 
Figura 23: ToolBar. 
 
 
Propriedades: 
 StyleLookUp: determina a aparência do componente. 
 
Exemplo: 
O ToolBar está atuando como um container para os demais objetos. Assim, se a propriedade 
Align do Label for alterada para AlCenter, o Label será centralizado na ToolBar. 
 
 
11..77.. CCoommbbooBBooxx 
 
 
Aba: Standard. 
Trata-se de uma caixa de opções com uma lista pré-definida, podendo selecionar várias 
opções. Possui as principais propriedades do RadioGroup. 
 
Figura 24: ComboBox. 
 
 
 
Propriedades: 
 ItemIndex: valor inteiro que representa qual dos itens foi selecionado pelo usuário. O 
primeiro item possui valor 0, o segundo 1 e assim por diante. Caso nenhum item esteja 
selecionado, a propriedade vale -1; 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1166 
 
 Items: usado para definir quais as opções que aparecerão na sua lista. Selecione as 
reticências no espaço em branco ao lado de Items e, na janela que abrirá, escreva em 
cada linha uma opção. Por fim, clique em OK. 
 
Figura 25: Preenchimento da propriedade Items. 
 
 
 
11..88.. MMeemmoo 
 
 
Aba: Standard. 
Usado para exibir um texto em linhas distintas, manipuladas de forma independente. As 
linhas podem ser manipuladas pela propriedade Lines. Essa propriedade permite acessar 
cada uma das linhas como um vetor de textos, cuja posição inicial é 0. 
 
Propriedade de Lines: 
 Count: valor inteiro que representa a quantidade de linhas do Memo; 
 
Métodos de Lines: 
 Add: possui um texto que é passado por parâmetro. Esse texto será adicionado após a 
última linha existente; 
 Delete: remove a linha que foi informada via parâmetro (valor inteiro correspondente 
ao número da linha); 
 Clear: elimina todas as linhas do Memo; 
Atenção!! Para apagar o Memo não se usa Memo1.Clear. 
 SaveToFile: o conteúdo das linhas do Memo será salvo em um arquivo texto cujo 
caminho é dado pelo parâmetro desse método; 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1177 
 
 LoadFomFile: o conteúdo das linhas do Memo será preenchido com as informações de 
um arquivo texto cujo caminho é dado pelo parâmetro desse método. 
 
O exemplo a seguir mostra o trecho de um aplicativo que irá salvar em um arquivo o RA e a 
média de 40 alunos, separados pelo caracteres “;”, armazenadas em dois vetores globais, 
preenchidos previamente. No Android a pasta raiz não é C:\, mas /sdcard/. Para acessar 
o cartão de memória externo, utilize /storage/extSdCard/. 
 
procedure TForm1.Button2Click(Sender: TObject); 
var i: Integer; 
begin 
 Memo1.Lines.Clear; 
 Memo1.Lines.Add('RA;Media'); 
 
 for i := 1 to 40 do 
 Memo1.Lines.Add(RA[i] + ';' + FloatToStr(media[i])); 
 
 Memo1.Lines.SaveToFile('/sdcard/medias.csv'); 
 ShowMessage('Notas exportadas em: /sdcard/medias.csv'); 
end; 
 
Note que esse arquivo possui a estrutura “RA;Media”, permitindo que seja aberto em uma 
planilha eletrônica (seja o Microsoft Excel no computador ou alguma planilha eletrônica no 
smartphone) para posterior análise. Embora o arquivo possua apenas dados de texto, sua 
extensão, normalmente, é .csv (comma-separated values). 
 
Figura 26: Dados exportados pelo aplicativo abertos no Excel. 
 
 
 
 
11..99.. SSttrriinnggGGrriiddAba: Grids. 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1188 
 
O StringGrid permite a entrada ou exibição de dados na forma de texto. Estes dados podem 
ser, normalmente, vetores ou matrizes na forma de uma tabela. Assim como todos os 
componentes que possuem mais do que um item, o primeiro possui índice 0, no caso, a 
primeira linha e a primeira coluna possuem o índice 0. 
Há uma diferença significativa entre o StringGrid para o dispositivo móvel e da aplicação 
para Windows. O componente se comporta com um contêiner de colunas, que devem ser 
adicionadas em tempo de desenvolvimento, clicando com o botão direito sobre o 
componente, Add Item e TStringColumn. 
As colunas StringColumns possuem um cabeçalho (header), destacado em cinza, que não faz 
parte da contagem de células. Esse cabeçalho pode ser exibido ou não. 
 
Figura 27: Adicionando colunas no StringGrid. 
 
 
Propriedades do StringGrid: 
 Cells: representa uma matriz de strings cujos índices são, respectivamente, a coluna e a 
linha da tabela. O cabeçalho não faz parte da contagem de células; 
 RowCount: valor inteiro que armazena o número de linhas dos StringColumns. Pode ser 
para saber o número de linhas ou definir essa quantidade; 
 ColumnCount: valor inteiro que armazena o número de colunas do StringGrid. Essa 
propriedade não pode ser alterada pelo código, somente lida; 
Atenção! Não existe a propriedade ColCount. 
 ReadOnly: valor lógico que indica se as células poderão ser editadas ou não. Essa 
propriedade substitui o goEditing; 
 ShowHeader: valor lógico que indica se o cabeçalho será ou não exibido. 
 
Propriedade do StringColumn: 
 Header: texto que será exibido na primeira linha, de cor cinza, se estiver visível. 
 
 
11..1100.. LLiissttBBooxx 
 
 
Aba: CommonControls. 
Usado para apresentar uma lista de opções. Para adicionar itens à sua lista, clique com o 
botão direito sobre o componente e selecione Items Editor. Na janela Items Designer, 
escolha a opção TListBoxItem e clique no botão Add Item quantas vezes forem necessárias. 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
1199 
 
Figura 28: ListBox. 
 
 
Existem situações em que seria interessante adicionar um cabeçalho e/ou um rodapé ao 
redor dos itens. Para tal, altere a opção TListBoxItem para TListBoxGroupHeader ou 
TListBoxGroupFooter e clique em Add Item. Organize a posição do cabeçalho e do rodapé 
para os extremos da lista, como mostra a Figura 29. 
 
Figura 29: ListBoxGruopHeader e ListBoxGruopFooter. 
 
 
Após fechar a janela, é possível configurar as propriedades do ListBox e de cada um dos 
itens (ListBoxItem, ListBoxGroupHeader e ListBoxGroupFooter) separadamente. Veja as 
propriedades desses objetos: 
 
Propriedades do ListBox: 
 Sorted: quando o aplicativo for executado, os itens serão exibidos em ordem alfabética; 
 MultiSelect: propriedade booleana que indica se mais do que um item pode ser 
selecionado por vez; 
 ShowCheckBoxes: mostra caixas de seleção ao lado dos itens, permitindo com que o 
componente se parece com um CheckListBox; 
 StyleLookUp: determina a aparência do componente. O ListBox pode ficar transparente 
se o valor transparentlistboxstyle for selecionado. 
 
Propriedades do ListBoxItem, ListBoxGroupHeader e ListBoxGroupFooter: 
 IsChecked: é um valor booleano que indica se a caixa de seleção do componente está 
marcada ou não. Essa propriedade deve ser utilizada quando propriedade 
ShowCheckBoxes do ListBox estiver ativa; 
 IsSelected: é um valor booleano que indica se o componente está selecionado ou não. 
 TextAlign: alinhamento do texto principal; 
 Text: texto que será exibido do item da lista; 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2200 
 
 ItemData: Os itens podem apresentar ícones e imagens. Para tal, devemos alterar essas 
propriedades. Veja o resultado na Figura 30: 
 Acessory: ícone que será usado no item, ou seja, tipo de marcação que poderá 
ser visualizada quando determinado item for selecionado. Opções: aCheckmark, 
aDetail, aMore e aNone; 
 Bitmap: imagem que será exibida; 
 Detail: texto secundário do item que fica abaixo do Text; 
 Text: texto que será exibido do item da lista. Essa propriedade é a mesma 
apresentada fora do ItemData. 
 
Observação: na imagem apresentada na Figura 30, cada um dos itens está utilizando um 
valor diferente na propriedade Accessory. 
 
Figura 30: Opções da lista com a propriedade ItemData. 
 
 
 
 
11..1111.. TTrraacckkBBaarr 
 
Aba: Standard. 
O TrackBar é um componente que pode ser utilizado para que o usuário informe um valor 
numérico real movimentando uma barra linear. 
 
Figura 31: TrackBar. 
 
 
Propriedades: 
 Frequency: se estiver em 0, o cursor se move livremente. Pode-se definir outro valor 
para que o cursor se movimente apenas em múltiplos desse número. Para fazer uma 
barra de números inteiros, utilize o valor 1; 
 Min: valor numérico quando o cursor estiver totalmente à esquerda da barra; 
 Max: valor numérico quando o cursor estiver totalmente à direita da barra; 
 Value: valor da posição do cursor, no intervalo [Min, Max]; 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2211 
 
2. Componentes gráficos 
 
Apresentaremos aqui alguns componentes para exibir imagens, gráficos e sites em seus 
aplicativos. 
 
22..11.. IImmaaggee 
 
Aba: Shapes. 
Permite armazenar e exibir imagens. 
 
Figura 32: Image. 
 
 
Para exibir uma imagem, ainda em tempo de execução, selecione o Image, procure pela 
propriedade MultiResBitmape clique no botão com os três pontinhos. Na janela que 
apareceu clique sobre o botão Fill all from file e, em seguida, escolha uma imagem que será 
utilizada para preencher o Image. 
 
Figura 33: Inserir uma imagem. 
 
 
Propriedades: 
 WrapMode: propriedade altera a posição ou proporção da imagem em relação ao 
Image. A imagem pode ficar centralizada (iwCenter), no canto superior esquerdo 
(iwOriginal), esticada (iwStretch), ocupando todo o componente, ou desenhada 
repetidas vezes (iwTile); 
 Bitmap: permite armazenar uma imagem. A propriedade Bitmap não está no Object 
Inspector e deve ser manipulada diretamente em seu código-fonte. Para tal, devemos 
associar uma imagem utilizando um dos métodos apresentados a seguir: 
 Assign: esse método recebe como parâmetro um Bitmap que será exibido no 
Image. Normalmente utilizado para exibir uma imagem capturada pela câmera ou 
gerada por algum algoritmo; 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2222 
 
 LoadFromFile: esse método recebe como parâmetro um texto com o caminho de 
uma imagem salva no dispositivo. Normalmente utilizado para exibir imagens 
previamente existentes. 
No Android a pasta raiz não é C:\, mas /sdcard/. Para acessar o cartão de 
memória externo, utilize /storage/extSdCard/. 
 
 
22..22.. TTCChhaarrtt 
 
Aba: TeeChart Lite. 
Esse componente permite desenhar gráficos de diversos tipos, como linhas, barras, colunas, 
pizza etc. 
 Figura 34: TChart. 
 
 
Como exemplo, vamos criar um gráfico de linhas, adicionando uma nova série ao 
componente. Dê um duplo clique sobre o TChart para abrir a janela Editing Chart e clique 
sobre o botão Add. Escolha a opção Lines, configure o estilo das cores para Android e 
confirme. O processo pode ser repetido para adicionar novas curvas ao TChart. 
 
Figura 35: Editing Chart. 
 
 
Com a série criada, podemos configurar o ambiente do gráfico. A Figura 36 mostra como 
editar o título do gráfico, exibir o nome dos eixos, remover a legenda e o efeito 3D. 
 
AApplliiccaaççõõeess AAnnddrrooiiddccoomm oo DDeellpphhii XXEE55 
2233 
 
Figura 36: Configurações do ambiente. 
 
 
 
 
 
 
Para inserir as informações que será exibidas graficamente, não manipularemos diretamente 
o TChart, mas a Series inserida. 
 
Propriedade da Series: 
 Clear: elimina as informações armazenadas na Series, dando a impressão de limpar o 
gráfico; 
 Add: método que adiciona uma informação à Series, consequentemente deve ser 
executado diversas vezes para que o gráfico todo seja traçado. O primeiro parâmetro é 
um valor real (eixo Y). O segundo parâmetro é opcional e consiste em um texto (eixo X), 
uma vez que a abscissa pode ser uma escala de tempo, distância, nome do dia da 
semana ou sigla do estado em um gráfico de vendas. Veja alguns exemplos: 
 
 
O eixo X será numerado sequencialmente: Series1.Add(valor); 
Exibe os valores nos eixos X e Y: Series1.Add(sqr(x), FloatToStr(x)); 
Exibir o valor do lucro em Y e o nome do estado em X: Series1.Add(lucro, ‘SP’). 
 
 
Veja um exemplo de como traçar uma curva y=sin(x) quando o usuário clicar sobre o 
Button1. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2244 
 
procedure TForm1.Button1Click(Sender: TObject); 
var x: real; 
begin 
 Series1.Clear; // apaga a curva 
 x := 0; // do valor inicial 
 while x <= 2*pi do // até o valor final 
 begin 
 Series1.Add(sin(x),FloatToStr(x)); // adiciona um ponto 
 x := x + 0.01; // próximo valor de x 
 end; 
end; 
 
Figura 37: Função y=sin(x) no TChart. 
 
 
 
22..33.. WWeebbBBrroowwsseerr 
 
 
Aba: Internet. 
Com esse componente podemos abrir páginas da internet em uma área do aplicativo. 
 
Métodos: 
 GoBack: mostra a página anterior; 
 GoForward: mostra a página seguinte; 
 Navigate: acessa o endereço que deve ser passado por parâmetro. Por exemplo: 
 
WebBrowser1.Navigate('www.maua.br'); 
 
 
22..44.. AAnniiIInnddiiccaattoorr 
 
 
Aba: Additional. 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2255 
 
Esse componente é utilizado como representação gráfica ao usuário de que o aplicativo está 
aguardando ou processando alguma informação. Isso dá a impressão ao usuário de que o 
aplicativo não está travado. 
 
Propriedades 
 Enabled: valor booleano que indica se a animação está habilitada ou não; 
 Visible: valor booleano que define se o objeto está visível ou não. 
 
Para um bom efeito visual, recomenda-se que essas duas propriedades possuam sempre o 
mesmo valor True ou False. 
 
 
3. Componentes não visuais 
 
Apresentaremos aqui alguns componentes que não aparecerão no formulário quando o 
programa for executado, mas faremos usos de suas propriedades e métodos. 
 
 
33..11.. TTiimmeerr 
 
 
Aba: System. 
O Timer é utilizado quando desejamos que uma sub-rotina seja executada de tempos em 
tempos. Pode ser utilizado para fazer animações, leitura dos sensores etc. 
 
Evento: 
 OnTime: evento que dispara o procedimento Timer1Time. Nesse procedimento você 
deverá informar o código-fonte do que deve ser feito. 
 
Propriedades: 
 Enabled: valor booleano que indica se o componente fará a contagem do tempo ou não; 
 Interval: valor inteiro que representa quantos milissegundos devem se passar para que o 
Timer execute novamente o procedimento Timer1Time. 
 
 
33..22.. LLooccaattiioonnSSeennssoorr 
 
 
Aba: Sensors. 
Esse componente permite que nossos aplicativos acessem os dados de posicionamento 
geográfico do dispositivo. Essas coordenadas podem ser obtidas pelo dispositivo utilizando o 
sinal de GPS, torres da operadora ou rede Wi-Fi. 
 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2266 
 
Evento: 
 OnLocationChanged: quando o dispositivo se desloca é chamado o procedimento 
LocationSensor1LocationChanged. Esse procedimento possui os parâmetros 
OldLocation e NewLocation, que contém as coordenadas geográficas do ponto atual do 
último registrado. Essas duas propriedades possuem os campos Latitude e Longitude. 
 
Propriedades: 
 Active: valor booleano que indica se o sensor está ou não ativo; 
 
Veja um exemplo de um aplicativo que exibe em dois Labels a localização do dispositivo. A 
atualização é automática, quando o usuário se movimenta: 
 
procedure TForm1.LocationSensor1LocationChanged(Sender: TObject; 
 const OldLocation, NewLocation: TLocationCoord2D); 
begin 
 Label1.Text := 'Latitude: ' + FloatToStr(NewLocation.Latitude); 
 Label2.Text := 'Longitude: ' + FloatToStr(NewLocation.Longitude); 
end; 
 
Figura 38: Exibindo a localização do dispositivo. 
 
 
 
33..33.. MMoottiioonnSSeennssoorr 
 
 
Aba: Sensors. 
Esse componente permite acessar as informações do movimento do dispositivo utilizando as 
informações do acelerômetro. A partir dos valores da aceleração nos eixos x, y e z é possível, 
por meio de integrações numéricas, obter a velocidade e o deslocamento do dispositivo no 
espaço. 
 
Propriedades: 
 Active: valor booleano que indica se o sensor está ou não ativo; 
 Sensor: essa propriedade possui as informações do acelerômetro. As componentes da 
aceleração podem ser obtidas, em m/s², utilizando os campos AccelerationX, 
AccelerationY e AccelerationZ. 
 
Veja um exemplo de um aplicativo que exibe em três Labels as componentes da aceleração 
medida pelo sensor. A atualização deve ser feita pelo componente Timer. O componente 
Switch deve habilitar/desabilitar o MotionSensor e, em seguida, o Timer. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2277 
 
procedure TForm1.Timer1Timer(Sender: TObject); 
begin 
 Label1.Text := 'Aceleração X: ' + 
 FloatToStr(MotionSensor1.Sensor.AccelerationX); 
 Label2.Text := 'Aceleração Y: ' + 
 FloatToStr(MotionSensor1.Sensor.AccelerationY); 
 Label3.Text := 'Aceleração Z: ' + 
 FloatToStr(MotionSensor1.Sensor.AccelerationZ); 
end; 
 
Figura 39: Exibindo as acelerações. 
 
 
 
33..44.. AAccttiioonnLLiisstt 
 
Aba: Standard. 
A ActionList permite criar uma lista de sub-rotinas para que os demais objetos possam 
acessá-las e executá-las. Essas sub-rotinas podem ser predefinidas ou criadas pelo 
programador. 
Inicialmente a ActionList está vazio. Para adicionar um procedimento à lista, dê um duplo 
clique sobre o componente para abrir a janela Editing Form1.ActionList1. Embora o uso mais 
comum seja para acessar rotinas predefinidas que realizam troca de páginas, acesso à 
câmera ou galeria de fotos, também é possível escrever um algoritmo de acordo com a 
necessidade em uma nova ação. 
 
Para criar uma nova ação: 
Selecione a opção New Action no menu para adicionar uma nova ação à lista. 
 
Figura 40: Criando uma nova ação. 
 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2288 
 
Evento da ação: 
 OnExecute: utilize o método criado para escrever o código-fonte da rotina. 
 
Para inserir uma nova ação predefinida: 
Selecione a opção New Standard Action no menu para adicionar uma nova ação à lista. Na 
janela Standard Action Classes selecione uma das ações disponíveis e clique no botão OK. 
 
Figura 41: Adicionando ações predefinidas. 
 
 
 
Selecione no Object Inspector a ação predefinida que está na ActionList e verifique as 
particularidades das propriedades e eventos de cada uma. 
 
Associando ações aos objetos: 
Uma vez que a ActionList possui todas as ações (novas e predefinidas) que serão utilizadas 
pelos componentes do aplicativo, devemos associara propriedade Action com os 
componentes que irão disparar a respectiva ação da ActionList. 
 
Figura 42: Adicionando ações predefinidas. 
 
 
Veja no exemplo que o componente Button1 teve a ação TakePhotoFromCameraAction1 
associada à propriedade Action. Assim, quando o usuário clicar sobre o Button1, o aplicativo 
da câmera será aberto para que o usuário utilize-o. 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
2299 
 
Capítulo 3 – Exercícios resolvidos (para todos os gostos) 
 
Agora que conhecemos alguns poucos recursos disponíveis para programação de 
dispositivos móveis com o Delphi XE5, podemos fazer alguns exemplos de aplicativos que 
resolvem simples cálculos aos mais complexos, que podem acessar recursos como a câmera 
ou o GPS do smartphone. 
 
1. Componentes Básicos do Delphi 
 
1) Elabore um aplicativo para calcular o volume de uma esfera a partir do valor do raio 
digitado. 
 
Em um formulário, adicione um Button, um Edit e um Label. No evento OnClick do Button1, 
escreva o código que faz a leitura do valor do raio, calcula e exibe o volume da esfera, como 
apresentado a seguir: 
 
procedure TForm1. Button1Click(Sender: TObject); 
var r, v: real; 
begin 
 r := StrToFloat(Edit1.Text); 
 v := 4 / 3 * pi * exp(3*ln(r)); 
 Label3.Text := 'Volume: ' + FloatToStr(v); 
end; 
 
Figura 43: Volume da esfera. 
 
 
2) Elabore um aplicativo de uma calculadora simples que permita ao usuário escolher qual 
operação (soma, subtração, multiplicação ou divisão) será executada com os valores 
digitados. Cada operação deve ser realizada por um botão distinto. 
 
Vamos precisar de dois Edits, quatro botões e um Label para apresentar o resultado. Após 
configurar a propriedade Text desses componentes, vamos escrever o código-fonte de cada 
um deles. Note que para os botões da soma, subtração e multiplicação os códigos são muito 
semelhantes. Não se esqueça de impedir o cálculo da divisão por zero, informando ao 
usuário sobre o problema: 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3300 
 
procedure TForm1.Button1Click(Sender: TObject); 
var a, b, c: real; 
begin 
 a := StrToFloat(Edit1.Text); 
 b := StrToFloat(Edit2.Text); 
 c := a + b; 
 Label1.Text := FloatToStr(c); 
end; 
 
procedure TForm1.Button2Click(Sender: TObject); 
var a, b, c: real; 
begin 
 a := StrToFloat(Edit1.Text); 
 b := StrToFloat(Edit2.Text); 
 c := a - b; 
 Label1.Text := FloatToStr(c); 
end; 
 
procedure TForm1.Button3Click(Sender: TObject); 
var a, b, c: real; 
begin 
 a := StrToFloat(Edit1.Text); 
 b := StrToFloat(Edit2.Text); 
 c := a * b; 
 Label1.Text := FloatToStr(c); 
end; 
 
procedure TForm1.Button4Click(Sender: TObject); 
var a, b, c: real; 
begin 
 a := StrToFloat(Edit1.Text); 
 b := StrToFloat(Edit2.Text); 
 if b <> 0 then 
 begin 
 c := a / b; 
 Label1.Text := FloatToStr(c); 
 end 
 else Label1.Text := 'Divisão por zero!!'; 
end; 
 
Figura 44: Calculadora. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3311 
 
3) Elabore um aplicativo que converte um valor de temperatura digitado em °C, °F ou K para 
°C, °F ou K. 
Vamos utilizar um Button, um Edit para digitar o valor, dois ComboBox para que o usuário 
escolha a unidade referente ao valor digitado e a unidade desejada. A resposta será exibida 
em um Label. Preencha igualmente a propriedade Items dos dois ComboBox com as três 
unidades de temperatura. 
O algoritmo consiste em converter a unidade do valor digitado para um padrão, por 
exemplo, °C e em seguida converter esse valor de °C para a unidade desejada. Lembre-se 
que o ComboBox possui as mesmas funcionalidades de um RadioGroup, dessa maneira 
utilizaremos a estrutura Caso para tratar das opções selecionadas. 
 
procedure TForm1.Button1Click(Sender: TObject); 
var valor, tempC, resp: real; 
 opDe, opPara: integer; 
begin 
 valor := StrToFloat(Edit1.Text); 
 opDe := ComboBox1.ItemIndex; 
 opPara := ComboBox2.ItemIndex; 
 case opDE of 
 0: tempC := valor; // °C -> °C (desnecessário) 
 1: tempC := (valor–32)*5/9; // °F -> °C 
 2: tempC := valor – 273.15; // K -> °C 
 end; // fim do case 
 case opPara of 
 0: resp := tempC; // °C -> °C (desnecessário) 
 1: resp := tempC * 9/5 + 32; // °C -> °F 
 2: resp := tempC + 273.15; // °C -> K 
 end; // fim do case 
 Label1.Text := FloatToStr(resp) + ' ' + 
 ComboBox2.Items[ComboBox2.ItemIndex]; // para exibir a unidade 
end; 
 
Figura 45: Conversão de temperatura. 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3322 
 
2. Navegador com o componente WebBrowser 
 
Vamos fazer um navegador para internet. A interface deve conter um ToolBar (com Align 
em alTop) e um WebBrowser (com Align em alClient para ocupar o restante da tela). Sobre 
o ToolBar, adicione dois componentes do tipo Button (ambos com alLeft) e um Edit (com 
alHorizontal). 
Configure a propriedade StyleLookUp do Button1 como PriorToolButton e a do Button2 
como NextToolButton. Além disso, clique com o botão direito sobre o Edit1 e, em Add Item, 
escolha a opção TSearchEditButton. Seu formulário deverá se parecer com o da Figura 46. 
 
Figura 46: Interface do navegador. 
 
 
Para facilitar a digitação do endereço do site, altere o tipo do teclado do Edit1 indicando o 
valor vktURL na propriedade KeybordType. 
Para implementar os botões voltar e avançar do navegador utilize os métodos GoBack e 
GoForward do WebBrowser: 
 
procedure TForm1.Button1Click(Sender: TObject); 
begin 
 WebBrowser1.GoBack; 
end; 
 
procedure TForm1.Button2Click(Sender: TObject); 
begin 
 WebBrowser1.GoForward; 
end; 
 
Para abrir a página informada pelo usuário, vamos escrever o código do botão 
SerarchEditButton1, informando que o WebBrowser dever navegar para o endereço 
digitado no Edit. 
 
procedure TForm2.SearchEditButton1Click(Sender: TObject); 
begin 
 WebBrowser1.Navigate(Edit1.Text); 
end; 
 
 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3333 
 
Figura 47: Acessando um site. 
 
 
Nas situações em que a conexão estiver lenta, seria interessante informar ao usuário que o 
programa não travou, mas está esperando os dados da página. Para isso, adicione um 
componente AniIndicator com alinhamento alCenter e atribua o valor False na 
propriedade Visible. Vamos fazer a animação aparecer antes da requisição da página 
(alterando o código do SerarchEditButton1Click). O componente deverá ficar invisível 
quando o WebBrowser terminar de carregar a página (esse código dever ser escrito no 
evento OnDidFinishLoad). 
 
procedure TForm2.SearchEditButton1Click(Sender: TObject); 
begin 
 AniIndicator1.Enabled := true; 
 AniIndicator1.Visible := true; 
 WebBrowser1.Visible := false; 
 WebBrowser1.Navigate(Edit1.Text); 
end; 
 
procedure TForm2.WebBrowser1DidFinishLoad(ASender: TObject); 
begin 
 AniIndicator1.Enabled := false; 
 AniIndicator1.Visible := false; 
 WebBrowser1.Visible := true; 
end; 
 
Figura 48: Esperando carregar o moodle... 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3344 
 
3. Mostrando a localização do smartphone em um mapa 
 
Elabore um aplicativo que apresente em um mapa a localização geográfica do usuário. Caso 
o GPS não esteja ligado, o aplicativo deverá exibir a página principal da Mauá. 
 
Vamos utilizar um componente ToolBar que deverá servir de container para um Label e um 
Switch (ambos com alinhamento alLeft). Sobre oformulário, acrescente um WebBrowser 
que deve preencher o restante da área, com alClient. Adicione ainda um LocationSensor que 
pode ficar em qualquer local, uma vez que não é um componente visível. 
 
Figura 49: Interface do aplicativo. 
 
 
O botão Switch será responsável por ligar e desligar o sensor de localização. Quando o 
sensor estiver desativado, o aplicativo abrirá a página da Mauá. Para configurar isso, deve-se 
codificar o evento OnSwitch: 
 
procedure TForm1.Switch1Switch(Sender: TObject); 
begin 
 LocationSensor1.Active := Switch1.IsChecked; 
 if not Switch1.IsChecked then 
 WebBrowser1.Navigate('www.maua.br'); 
end; 
 
Para exibir o mapa gerado pelo Google Maps devemos utilizar a url de busca 
www.maps.google.com/maps? e acrescentar a esse endereço alguns parâmetros, separados 
pelo caractere &. No nosso exemplo, vamos acrescentar como parâmetros: 
 o que desejamos encontrar (q): informando as coordenadas geográficas latitude e 
longitude, separadas por uma vírgula; 
 o tipo de mapa (t): terreno, foto do satélite ou hibrido; 
 o nível de zoom (z): valor inteiro entre 1 e 21. 
 
Devemos tomar cuidado com a configuração de região definida no dispositivo móvel. Em 
alguns países, o separador decimal utilizado é o caractere ponto e em outros, como no 
Brasil, é a vírgula. Entretanto, ao enviar as coordenadas latitude e longitude para o 
Google Maps, devemos informar os valores numéricos utilizando o ponto como separador 
decimal. Para tal, devemos alterar a propriedade FormatSettings.DecimalSeparator 
antes e depois de utilizar instruções como o StrToFloat ou FloatToStr. 
Assim, considerando que o dispositivo móvel está no Campus da Mauá, em São Caetano do 
Sul, teremos o seguinte conteúdo da url que será apresentada no mapa: 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3355 
 
'www.maps.google.com/maps?q=-23.648283,-46.573378&t=h&z=15' 
 
Para garantir que o mapa seja atualizado quando o usuário se movimentar, vamos escrever o 
código-fonte no evento OnChangeLocation do LocationSensor. 
 
procedure TForm1.LocationSensor1LocationChanged(Sender: TObject; 
 const OldLocation, NewLocation: TLocationCoord2D); 
var url: string; 
begin 
 if LocationSensor1.Active then 
 begin 
 FormatSettings.DecimalSeparator := '.'; 
 url := 'www.maps.google.com/maps?q=' + 
 FloatToStr(NewLocation.Latitude) + 
 ',' + 
 FloatToStr(NewLocation.Longitude) + 
 '&t=h' + 
 '&z=15'; 
 WebBrowser1.Navigate(url); 
 FormatSettings.DecimalSeparator := ','; 
 end; 
end; 
 
Figura 50: Exibindo a localização no mapa. 
 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3366 
 
A partir desse exemplo, podemos explorar um pouco mais o uso do Google Maps. Veja como 
os parâmetros podem ser utilizados: 
O parâmetro de busca q: 
 endereço: 'q=Praça Mauá, 1 - São Caetano do Sul'; 
 CEP: 'q=09580-900'; 
 Coordenadas latitude e longitude: 'q=-23.648283,-46.573378'; 
 Neste caso, os dois valores utilizam o ponto como separador decimal e a vírgula para 
separar as coordenadas. Valores positivos representam Norte e Leste, enquanto que 
negativos são Sul e Oeste para a latitude e longitude, respectivamente. 
 estabelecimento: 'q=Instituto Mauá de Tecnologia'. 
 
O parâmetro do tipo do mapa h: 
 mapa: 't=m'; 
 satélite: 't=k'; 
 híbrido: 't=h'; 
 terreno: 't=p'. 
 
O parâmetro de zoom z deve ser um valor inteiro entre 0 e 21. 
 
Além disso, podemos traçar rotas de um ponto a outro. Para tal, não utilize o parâmetro de 
busca q, mas defina a localização (endereço, CEP, coordenadas etc.) dos parâmetros saddr 
(start address) e daddr (destination address). Podemos ainda definir o tipo de locomoção no 
parâmetro dirflg: 
 carro: 'dirflg=d'; 
 transporte público: 'dirflg=r'; 
 a pé: 'dirflg=w'; 
 bicicleta: 'dirflg=b' (em alguns locais ainda não disponível); 
 evitar rodovias: 'dirflg=h'; 
 evitar pedágios: 'dirflg=t'. 
 
Por exemplo, se quisermos almoçar no Shopping a pé, usamos a seguinte url: 
 
'www.maps.google.com/maps?saddr=instituto mauá de 
tecnologia&daddr=park shopping são caetano&dirflg=w' 
 
Veja outros parâmetros que podem enriquecer sua aplicação em: goo.gl/QEVVWv. 
 
4. Compartilhando fotos da câmera 
 
Observação: esta aplicação será executada corretamente no Emulador. Compile 
diretamente no dispositivo móvel ou, se compilar para o emulador, copie o arquivo de 
instalação apk para o dispositivo móvel para poder testar. 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3377 
 
A interface deverá conter um ToolBar com três botões, um ActionList e um Image 
(alinhamento alClient e esticando a foto com WrapMode com o valor iwStretch). 
Os botões devem estar alinhados com alLeft, alHorizCenter e alRight. Defina a identidade 
visual deles alterando a propriedade StyleLookUp para cameratoolbutton, 
searchtoolbutton e actiontoolbutton, respectivamente, de modo a obter a seguinte 
interface: 
Figura 51: Interface do aplicativo. 
 
 
Primeira Parte: Botão Câmera 
Ao invés de criar todas as ações no ActionList e depois atribuir aos objetos que as 
executarão, faremos a criação diretamente nos objetos. 
Selecione o Button1 e clique sobre a seta da propriedade Action, selecione 
então New Standard Action → Media Library → TTakePhotoFromCameraAction. 
 
Figura 52: Adicionando ação de disparo da câmera no Button1. 
 
 
Ainda com o Button1 selecionado, abra a aba Events, expanda a opção Action e acesse o 
código-fonte de onDidFinishTaking com um duplo clique. O procedimento desse método é 
executado após o usuário finalizar a captura da foto, fazendo com que a foto obtida (e 
armazenada no parâmetro Image) seja exibida no componente Image1. 
 
procedure TForm1.TakePhotoFromCameraAction1DidFinishTaking(Image: TBitmap); 
begin 
 Image1.Bitmap.Assign(Image); 
end; 
 
Segunda Parte: Botão Arquivo (Galeria) 
Selecione o Button2 e clique sobre a seta da propriedade Action, selecione 
então New Standard Action → Media Library → TTakePhotoFromLibraryAction. 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3388 
 
Figura 53: Adicionando ação abrir galeria de imagens no Button2. 
 
 
Repita o processo para digitar o código do evento onDidFinishTaking dessa ação que irá 
apresentar no Image1 a foto escolhida da galeria que está no parâmetro Image: 
 
procedure TForm1.TakePhotoFromLibraryAction1DidFinishTaking(Image:TBitmap); 
begin 
 Image1.Bitmap.Assign(Image); 
end; 
 
Terceira Parte: Botão Compartilhar 
Selecione o Button3 e clique sobre a seta da propriedade Action, selecione 
então New Standard Action → Media Library → TShowShareSheetAction. 
 
Figura 54: Adicionando ação abrir galeria de imagens no Button2. 
 
 
Para a ação ShowShareSheetAction vamos enviar a foto que está no Image1 para o 
destinatário de uma aplicação qualquer de compartilhamento, como e-mail, Facebook, 
Whatsapp etc. Preencha o código do evento onBeforeExecute do ShowShareSheetAction. 
 
procedure TForm1.ShowShareSheetAction1BeforeExecute(Sender: TObject); 
begin 
 ShowShareSheetAction1.Bitmap.Assign(Image1.Bitmap); 
end; 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
3399 
 
Figura 55: Compartilhando foto. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
AApplliiccaaççõõeess AAnnddrrooiidd ccoomm oo DDeellpphhii XXEE55 
4400 
 
Referências 
 
EMBARCADERO TECHNOLOGIES. RAD Studio: Mobile Tutorials Version XE6. 2014. Disponível 
em: <goo.gl/B0jYBC>. 05.06.2014 
 
GOMES, D. C. A., KAWAMURA, J., SCALCO,R. Delphi XE – Guia de Componentes. Apostila. 
São Caetano do Sul: EEM, 2011. 
 
GOMES, L. Sensor de localização de dispositivos móveis com Delphi XE5. Disponível em: 
<goo.gl/ockDRv>. Acesso em: 30.06.2014. 
 
PETERSON, R. Aplicativos mobile para Android e iOS com Delphi XE5. In: II JTI-MS: JORNADA 
DE TECNOLOGIAS DA INFORMAÇÃO DE MATO GROSSO DO SUL, 2., 2013, Dourados. Mini-
curso. Disponível em: <goo.gl/YmwWuK>. Acesso em: 03.06.2014.