Desenvolvimento em iOS

3.ª Edição Atualizada A disseminação de dispositivos como o iPhone, o iPad ou o iPod Touch veio revolucionar o dia a dia de todos nós. Também o surgimento da App Store, associada a estes aparelhos, contribuiu grandemente para esta mudança significativa, ou não fosse a loja online da Apple, onde qualquer programador pode colocar as suas aplicações (gratuitas ou pagas), tornando-as disponíveis a todos os utilizadores a nível mundial.

Apesar do acesso generalizado que a App Store veio incutir, esta garante que, antes das aplicações serem disponibilizadas ao público em geral, são submetidas a um cuidadoso processo de verificação e validação, o qual é alvo de detalhe na parte final deste livro.

3.ª Edição Atualizada

Esta obra, atualizada para o iOS7, apresenta, assim, o desenvolvimento de aplicações para iOS (iPhone, iPad e iPod Touch) desde os primeiros passos até um nível mais avançado, abordando temas tão importantes como:

Nuno Fonseca, Catarina Reis, Catarina Silva, Luis Marcelino, Vitor Carreira

• Som, fotografia e vídeo • Persistência (incluindo Core Data e iCloud) • Redes sociais (Twitter e Facebook) • Sensores de movimento • Serviços de rede • Conceitos avançados • Submissão à App Store

3.ª Ed. At.

• Ambiente de desenvolvimento Xcode • Introdução à linguagem Objective-C • Utilização de componentes gráficos • Model-View-Controller • Mapas e localização • Desenho e animação • Gestos e toques multitouch

A título de exemplo, os autores construíram ao longo do livro uma aplicação completa que se intitula “O Meu Diário”. Esta obra é, portanto, uma ferramenta essencial para todos aqueles que desejam desenvolver aplicações (apps) para os dispositivos móveis da Apple.

Nuno Fonseca – Licenciado em Eng.ª Eletrotécnica e de Computadores (IST/UTL), com mestrado e doutoramento em Eng.ª Informática (FCTUC e FEUP, respetivamente). Dedica-se a Computer Audio e a Multimédia. É autor do livro “Introdução à Engenharia de Som” da FCA e responsável pela criação de diversas apps disponíveis na App Store (“Family Finger Race”, “Jane Austen – Fan Kit”, etc.).

Catarina Reis – Licenciada em Eng.ª Informática (FCTUC) e com doutoramento em Eng.ª Multimédia (UPC – Barcelona, Espanha). Dedica-se ao desenvolvimento de software para plataformas móveis e metodologias ágeis.

Catarina Silva – Licenciada em Eng.ª Eletrotécnica, com mestrado e doutoramento em Eng.ª Informática (FCTUC).

Dedica-se aos sistemas inteligentes e ao desenvolvimento de software para dispositivos móveis.

Luis Marcelino – Licenciado em Eng.ª Eletrotécnica e de Computadores (IST/UTL) com doutoramento em Sistemas de Informação (University of Salford, Reino Unido). Foi docente na Universidade do Algarve e na Universidade Nova de Lisboa e participou no desenvolvimento de apps como “AZnimal” ou “Playnify”. Dedica-se à interação pessoa-máquina e aos dispositivos móveis.

Vitor Carreira – Licenciado em Eng.ª Informática (FCTUC). Dedica-se aos sistemas de larga escala e às arquiteturas de software. É responsável pela programação de diversas aplicações disponíveis na App Store.

N. Fonseca C. Reis C. Silva L. Marcelino V. Carreira

Código fonte dos programas apresentados na obra disponíveis em www.fca.pt, até o livro se esgotar ou ser publicada nova edição atualizada ou com alterações.

ISBN 978-972-722-786-0

www.fca.pt

Os autores são todos docentes no DEI/ESTG do Instituto Politécnico de Leiria.

• Atualizado para iOS 7 • Dos conceitos base aos avançados • Desenvolvimento de uma aplicação completa

Distribuição

Lidel – edições técnicas, lda

SEDE: R. D. Estefânia, 183, R/C Dto., 1049-057 LISBOA Internet: 21 354 14 18 – livraria@lidel.pt / Revenda: 21 351 14 43 – revenda@lidel.pt Formação/Marketing: 21 351 14 48 – formacao@lidel.pt / marketing@lidel.pt Ensino Línguas/Exportação: 21 351 14 42 – depinternacional@lidel.pt Fax: 21 352 26 84 LIVRARIA: Av. Praia da Vitória, 14A – 1000-247 LISBOA Tel.: 21 354 14 18 – e-mail: livraria@lidel.pt

Copyright © dezembro 2013 (3.ª Edição Atualizada); julho 2012 (1.ª Edição) FCA – Editora de Informática, Lda. ISBN: 978-972-722-786-0 Capa: Emília Calçada Impressão e acabamento: Cafilesa – Soluções Gráficas, Lda. – Venda do Pinheiro Depósito Legal N.º 368287/13 Livro segundo o Novo Acordo Ortográfico

Todos os nossos livros passam por um rigoroso controlo de qualidade, no entanto, aconselhamos a consulta periódica do nosso site (www.fca.pt) para fazer o download de eventuais correções.

Os nomes comerciais referenciados neste livro têm patente registada.

Marcas Registadas de FCA – Editora de Informática, Lda. –

®

®

®

Reservados todos os direitos. Esta publicação não pode ser reproduzida, nem transmitida, no todo ou em parte, por qualquer processo eletrónico, mecânico, fotocópia, digitalização, gravação, sistema de armazenamento e disponibilização de informação, sítio Web, blogue ou outros, sem prévia autorização escrita da Editora, exceto o permitido pelo CDADC, em termos de cópia privada pela AGECOP – Associação para a Gestão da Cópia Privada, através do pagamento das respetivas taxas.

ÍNDICE GERAL PREÂMBULO ...................................................................................................... XI 1. INTRODUÇÃO .................................................................................................. 1

1.1 Contexto histórico ................................................................................................................ 1 1.2 “O Meu Diário” – A minha primeira aplicação iOS ....................................................... 2 1.2.1 Um novo projeto ......................................................................................................... 3 1.2.2 A interface gráfica ...................................................................................................... 6 1.2.3 Outlets e actions ........................................................................................................... 9 2. OBJECTIVE-C ................................................................................................ 15

2.1 Introdução ao Objective-C ................................................................................................ 15 2.1.1 Principais caraterísticas ........................................................................................... 15 2.1.2 O primeiro programa de linha de comandos ....................................................... 16 2.1.3 Tipo de dados booleano .......................................................................................... 19 2.2 Classes e objetos ................................................................................................................. 19 2.2.1 Declaração da interface............................................................................................ 22 2.2.2 Implementação da classe ......................................................................................... 27 2.2.3 Invocação de métodos ............................................................................................. 29 2.3 Propriedades ....................................................................................................................... 30 2.4 Herança ................................................................................................................................ 35 2.4.1 Polimorfismo ............................................................................................................. 37 2.4.2 Redefinição de métodos .......................................................................................... 39 2.5 Alocação e iniciação ........................................................................................................... 39 2.5.1 Nil, self e id................................................................................................................ 40 2.5.2 Initializer ..................................................................................................................... 41 2.5.3 Método new ................................................................................................................ 45 2.5.4 Construtores de conveniência ................................................................................ 45 2.6 Exceções ............................................................................................................................... 47 3. CONCEITOS AVANÇADOS .................................................................................. 51

3.1 Gestão de memória ............................................................................................................ 51 3.1.1 Ciclo de vida de um objeto ..................................................................................... 52 3.1.2 Automatic Reference Counting (ARC) ...................................................................... 54 3.2 Propriedades revisitadas ................................................................................................... 64 3.2.1 Diretiva @synthesize ................................................................................................ 64 3.2.2 Atributos .................................................................................................................... 65 © FCA – Editora de Informática

VI

DESENVOLVIMENTO EM iOS

3.2.3 Atomicidade .............................................................................................................. 66 Protocolos ............................................................................................................................ 67 Delegates ............................................................................................................................... 71 Seletores ............................................................................................................................... 72 Categorias ............................................................................................................................ 74 3.6.1 Extensões ................................................................................................................... 76 3.7 Membros de classe ............................................................................................................. 77 3.8 Documentação .................................................................................................................... 78

3.3 3.4 3.5 3.6

4. FRAMEWORK FOUNDATION................................................................................ 81

4.1 Framework Cocoa Touch .................................................................................................... 81 4.2 Classe NSObject ................................................................................................................. 81 4.2.1 Introspeção ................................................................................................................ 82 4.2.2 Descrição .................................................................................................................... 83 4.2.3 Comparação de objetos............................................................................................ 83 4.3 Classe NSString ................................................................................................................. 84 4.4 Classe NSMutableString .................................................................................................. 86 4.5 Classe NSNumber ................................................................................................................. 87 4.6 Coleções ............................................................................................................................... 89 4.6.1 Classes NSArray e NSMutableArray ..................................................................... 89 4.6.2 Classes NSDictionary e NSMutableDictionary ................................................ 92 4.6.3 Fast enumerations ....................................................................................................... 95 4.7 Método -copy e tipos mutáveis ......................................................................................... 96 4.8 Outras classes ...................................................................................................................... 96 5. INTERAÇÃO COM O UTILIZADOR ......................................................................... 99

5.1 Ciclo de vida ....................................................................................................................... 99 5.1.1 Anatomia de uma aplicação iOS .......................................................................... 100 5.1.2 Views ......................................................................................................................... 106 5.1.3 Controlos ................................................................................................................. 108 5.1.4 View controller .......................................................................................................... 108 5.2 “O Meu Diário” – Modelo e view controllers ................................................................. 109 5.2.1 Modelo ..................................................................................................................... 110 5.2.2 View controllers......................................................................................................... 120 5.3 User experience ................................................................................................................... 132 5.3.1 A plataforma iOS .................................................................................................... 132 5.3.2 Princípios da Human Interface (HI)....................................................................... 135 6. CONTROLADORES .......................................................................................... 141

6.1 Navegação entre ecrãs ..................................................................................................... 141 6.1.1 Navigation controller ................................................................................................ 141 © FCA – Editora de Informática

ÍNDICE GERAL

VII

6.1.2 Tab Bar Controller .................................................................................................... 143 6.1.3 Modal Controller ................................................................................................ 144 6.1.4 Segue ......................................................................................................................... 145 6.2 “O Meu Diário” – Navegação simples .......................................................................... 146 6.3 Table view controllers ......................................................................................................... 154 6.4 “O Meu Diário” – Table view controller .......................................................................... 161 6.4.1 Filtrar as entradas do diário .................................................................................. 172 7. MAPAS E LOCALIZAÇÃO .................................................................................. 177

7.1 Contexto ............................................................................................................................. 177 7.2 Localização ........................................................................................................................ 178 7.2.1 Adicionar a framework Core Location .................................................................. 178 7.2.2 Core Location Manager ............................................................................................. 180 7.2.3 Location Manager Delegate .................................................................................. 182 7.2.4 Classe CLLocation ................................................................................................. 183 7.2.5 Utilização da framework Core Location ............................................................... 184 7.3 Mapas – Framework MapKit ............................................................................................ 192 8. MOVIMENTO ................................................................................................ 203

8.1 Rotação da interface ........................................................................................................ 203 8.2 Sensores de movimento ................................................................................................. 212 8.3 Deteção de shakes ............................................................................................................. 218 9. PERSISTÊNCIA ............................................................................................. 221

9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8

Introdução ......................................................................................................................... 221 Sandbox ............................................................................................................................... 222 NSUserdefaults .............................................................................................................. 222 Property Lists .............................................................................................................. 226 Archiving ............................................................................................................................ 228 SQLITE ................................................................................................................................. 237 ICLOUD .................................................................................................................................. 238 Preservação e restauro de estado ................................................................................... 244

10. SOM E IMAGEM .......................................................................................... 249

10.1 Som................................................................................................................................ 249 10.1.1 Gravação de som............................................................................................. 249 10.1.2 Reprodução de som ........................................................................................ 252 10.1.3 Eventos sonoros/música de fundo ............................................................... 253 10.2 Câmara ......................................................................................................................... 256 10.2.1 Captação de imagem ...................................................................................... 257 © FCA – Editora de Informática

VIII

DESENVOLVIMENTO EM iOS

10.2.2 Persistência dos conteúdos multimédia ...................................................... 260 10.2.3 Reprodução de vídeo ..................................................................................... 261 10.2.4 Mostrar foto ..................................................................................................... 262 10.3 Retoques finais ............................................................................................................ 266 11. DESENHO ................................................................................................. 267

11.1 Estratégias de desenho ............................................................................................... 267 11.2 UIKit.............................................................................................................................. 270 11.2.1 “O Meu Diário” – Painel de Itens .............................................................. 271 11.2.2 Ciclo de desenho ............................................................................................. 274 11.2.3 Coordenadas e transformações .................................................................... 276 11.2.4 Estado gráfico .................................................................................................. 277 11.2.5 Contexto gráfico .............................................................................................. 278 11.2.6 Desenho com UIKit ........................................................................................ 279 11.3 Core Graphics .............................................................................................................. 281 11.3.1 Sistema de coordenadas por omissão .......................................................... 282 11.3.2 Desenho com Core Graphics......................................................................... 282 11.3.3 Vista customizada para “O Meu Diário” .................................................... 284 11.4 Core Image ................................................................................................................... 292 11.4.1 Manipulação de imagens ............................................................................... 293 11.4.2 Face detection..................................................................................................... 295 12. GESTOS.................................................................................................... 299

12.1 Tipos de gestos ............................................................................................................ 299 12.2 Reconhecimento de gestos......................................................................................... 300 12.2.1 Reconhecimento de gestos com o Interface Builder .................................. 301 12.2.2 Reconhecimento de gestos através de código ............................................ 302 12.2.3 Painel de fotografias ....................................................................................... 303 12.3 Toques .......................................................................................................................... 306 13. ANIMAÇÃO ................................................................................................ 309

13.1 Conceitos fundamentais ............................................................................................ 309 13.2 Animação de vistas UIKit .......................................................................................... 311 13.3 Layers (Camadas) ........................................................................................................ 312 13.3.1 Transformações ............................................................................................... 315 13.4 Animações implícitas ................................................................................................. 316 13.5 Animações explícitas .................................................................................................. 321 13.5.1 Animação simples .......................................................................................... 323 13.5.2 Animação com pontos múltiplos ................................................................. 324 13.5.3 Grupo de animações....................................................................................... 325 13.6 Projeção em perspetiva .............................................................................................. 326 © FCA – Editora de Informática

ÍNDICE GERAL

IX

13.7 Animação em “O Meu Diário” ................................................................................. 327 13.8 Sprite Kit ...................................................................................................................... 333 13.8.1 Apresentação do conteúdo ............................................................................ 334 13.8.2 Texturas e Sprites ............................................................................................ 334 13.8.3 Ações na cena .................................................................................................. 335 13.8.4 Simulação física e ligações entre corpos ...................................................... 335 14. EXECUÇÃO CONCORRENTE ............................................................................. 337

14.1 Introdução à programação concorrente .................................................................. 337 14.2 Blocos ............................................................................................................................ 337 14.2.1 Declaração ........................................................................................................ 337 14.2.2 Invocação ......................................................................................................... 339 14.2.3 Importação de variáveis ................................................................................ 340 14.3 Grand Central Dispatcher (GCD) ................................................................................ 341 14.3.1 Dispatch queues ................................................................................................. 342 14.3.2 Execução de tarefas ........................................................................................ 345 14.3.3 Execução única de um bloco ......................................................................... 346 14.4 Operation queues ........................................................................................................... 347 14.4.1 Classe NSOperation ....................................................................................... 347 14.4.2 Execução das operações ................................................................................. 348 14.4.3 GCD vs. NSOperation .................................................................................... 349 14.5 Sincronização ............................................................................................................... 350 14.6 Multitasking .................................................................................................................. 351 14.7 O Meu Diário ............................................................................................................... 352 14.7.1 Singleton ............................................................................................................ 353 14.7.2 Persistência em background ............................................................................ 353 14.7.3 AVAudioPlayer............................................................................................... 354 15. SERVIÇOS DE REDE ..................................................................................... 357

15.1 Rede e comunicação ................................................................................................... 357 15.2 Sistema de carregamento de URL ............................................................................ 359 15.2.1 Carregamento de URL ................................................................................... 360 15.2.2 Cache .................................................................................................................. 361 15.2.3 Autenticação e credenciais ............................................................................ 361 15.2.4 Exemplo de carregamento de URL .............................................................. 362 15.3 WebKit .......................................................................................................................... 365 15.3.1 Utilização do WebKit ..................................................................................... 366 15.3.2 Exemplo............................................................................................................ 367 15.4 Análise e extração de dados ...................................................................................... 367 15.4.1 Exemplo NSJSONSerialization ................................................................. 369 15.4.2 Exemplo NSXMLParser ................................................................................... 371 © FCA – Editora de Informática

X

DESENVOLVIMENTO EM iOS

15.5 Social Framework .......................................................................................................... 374 15.5.1 SLRequest ........................................................................................................ 375 15.5.2 Autenticação .................................................................................................... 375 15.5.3 SLCOMPOSEVIEWCONTROLLER ......................................................................... 376 15.5.4 Twitter em “O Meu Diário” .......................................................................... 378 16. CORE DATA ............................................................................................... 385

16.1 16.2 16.3 16.4

Introdução .................................................................................................................... 385 Modelo de dados e objetos geridos .......................................................................... 389 Adicionar Core Data a um projeto existente .......................................................... 392 Adicionar Core Data à aplicação “O Meu Diário” ................................................ 395

17. RETOQUES FINAIS E APP STORE ..................................................................... 411

17.1 Retoques finais ............................................................................................................ 411 17.1.1 Aspeto gráfico ................................................................................................. 411 17.1.2 Interação com o utilizador............................................................................. 412 17.1.3 Otimização ....................................................................................................... 413 17.1.4 Testes ................................................................................................................ 413 17.2 Ícones ............................................................................................................................ 414 17.3 Launch image ................................................................................................................. 416 17.4 App Store ..................................................................................................................... 417 17.4.1 Submissão à App Store .................................................................................. 418 17.4.2 Submissão do Bundle ...................................................................................... 420 17.4.3 Processo de review ........................................................................................... 422 17.5 Marketing ..................................................................................................................... 422 17.5.1 Formas de divulgação .................................................................................... 423 17.5.2 Público-alvo ..................................................................................................... 423 ANEXO A - FRAMEWORKS ................................................................................... 425 ÍNDICE REMISSIVO ........................................................................................... 427

© FCA – Editora de Informática

PREÂMBULO Este livro resultou da conjugação de cinco vontades com o propósito de proporcionar ao público que lê em língua portuguesa o conhecimento e a capacidade de desenvolver aplicações para alguns dos dispositivos móveis mais apetecíveis dos dias de hoje, os dispositivos que correm o sistema operativo iOS da Apple: iPhone, iPad e iPod Touch.

Tendo os autores backgrounds diferentes, desde a programação às bases de dados, passando pela multimédia ou pela inteligência artificial, um dos grandes “trunfos” do livro passa pelas diferentes perspetivas com que pode ser lido. Quer o contexto seja começar a desenvolver apps do zero ou afinar alguns aspetos da apresentação, da interação, da persistência, da multimédia, ou mesmo compreender a forma de submissão de aplicações na App Store, os leitores poderão encontrar informação proveitosa ao longo do livro.

Foi realizado um esforço para apresentar os termos em português, sem deixar de manter a coerência do desenvolvimento num ambiente anglo-saxónico, permitindo assim atingir mais leitores, melhorar a compreensão e assegurar uma melhor ligação à documentação oficial disponibilizada pela Apple.

O nosso objetivo foi tornar a leitura leve, independente e clara para que o livro tanto pudesse ser lido de seguida, como pesquisado seletivamente de acordo com a necessidade do momento. Ao longo do livro é desenvolvida uma aplicação, denominada “O Meu Diário”, que permite usar uma abordagem extremamente prática à aquisição de competências específicas no desenvolvimento de aplicações.

Gostaríamos de agradecer a todas as pessoas e entidades que, direta ou indiretamente, contribuíram para a elaboração deste livro. Em especial à FCA pela aposta no primeiro livro desta área em português, à ESTG–IPLeiria pelas condições proporcionadas e à Apple pela tecnologia que disponibiliza constantemente.

Só nos resta desejar “Boas apps!”. Esperamos que apreciem realmente e que através deste livro se tornem appillionaires!

Os autores © FCA – Editora de Informática

XIV

TÍTULO DO LIVRO

© FCA – Editora de Informática

PERSISTÊNCIA

Neste capítulo vamos abordar as formas essenciais de armazenamento de informação por parte das aplicações tanto no decorrer de uma aplicação como entre chamadas consecutivas do utilizador. Começamos por analisar a forma mais simples de persistência, usando o NSUserDefaults e de seguida são analisadas outras formas como Property Lists, Archiving e SQLite. Serão ainda abordados os mecanismos de preservação e restauro do estado das aplicações e o iCloud, deixando o Core Data para um capítulo específico.

9.1

INTRODUÇÃO

Os exemplos apresentados ao longo deste livro até ao momento ainda não consideram o que acontece ou deve acontecer quando o utilizador acede à aplicação pela segunda, terceira e outras vezes subsequentes. Os utilizadores esperam, previsivelmente, que o estado da aplicação se mantenha desde a última vez que a usaram. No exemplo que nos tem acompanhado neste livro, faria pouco sentido que cada vez que um utilizador acedesse à aplicação “O Meu Diário” tivesse de reintroduzir as entradas anteriores. Assim, na esmagadora maioria das aplicações, é necessária persistência, isto é, que o estado da aplicação seja salvaguardado entre chamadas à aplicação. Até nos jogos, informação sobre o jogador, o nível ou a pontuação deve ser guardada e estar disponível na próxima chamada.

Neste capítulo vamos abordar algumas formas de persistência: NSUserDefaults; Property Lists; Archiving; SQLite; iCloud. © FCA – Editora de Informática

222

9.2

DESENVOLVIMENTO EM iOS

SANDBOX

Em iOS cada aplicação tem uma área isolada do File System designada por sandbox (caixa de areia), ficando desta forma isolada das restantes aplicações.

Assim, cada aplicação tem uma diretoria Documents e só pode escrever/ler aí por questões de segurança e de privacidade, ou seja, quando uma aplicação é removida basta limpar a sua diretoria.

Abrindo uma janela do Finder pode aceder-se ao local onde se encontra o simulador: “Home” → “Library” → “Application Support” → “iPhone Simulator”. Aí encontra-se, para cada versão do simulador instalada, uma pasta com cada uma das aplicações. Analisando o exemplo da Figura 9.1, focando na versão mais recente do iOS, a 7.0, na diretoria Applications existe uma diretoria para cada aplicação, com um identificador único e, dentro da pasta de cada aplicação, a estrutura: Documents, Library, Media, tmp. A diretoria Documents é usada para guardar os ficheiros do utilizador na maioria das formas de persistência. O que fica na diretoria Documents é salvaguardado (sincronizado) com o iTunes e com o iCloud. Uma exceção a esta regra são os NSUserDefaults, que ficam armazenados na diretoria Library, como veremos já de seguida. Já a diretoria tmp é usada para ficheiros temporários.

FIGURA 9.1 – Estrutura de diretorias no iPhoneSimulator

9.3

NSUSERDEFAULTS NSUserDefaults é uma classe que permite que uma aplicação facilmente

defina e aceda ao que normalmente se designa como as suas próprias ... © FCA – Editora de Informática

...

PERSISTÊNCIA

237

initWithObjects:[NSMutableArray array], [NSMutableArray array], nil]; (…) }

No caso do NewItemViewController.h, ShowItemViewController.h e MapViewController.h, temos apenas de alterar a definição da propriedade do repositório de @property (strong) Repository *repository; para: @property (strong)id<PRepository> repository;

Desta forma podemos testar a nossa aplicação “O Meu Diário” e verificar que entre chamadas as nossas entradas se mantêm, dando à aplicação a dimensão persistência, que é incontornável na maioria das aplicações.

9.6

SQLITE

O SQLite (http://www.sqlite.org/) é a forma de o iOS usar bases de dados embebidas. Trata-se de uma forma bastante simples e eficiente de armazenar e pesquisar quantidades grandes de dados. Sendo uma base de dados, também permite fazer pesquisas e agregações de uma forma mais rápida do que usando objetos.

Trata-se de biblioteca em C, que implementa um motor transacional de bases de dados, aberto, autocontido (normalmente é um ficheiro), sem servidor e com um nível mínimo de configuração. Uma potencial vantagem da utilização de SQLite é que as estruturas dos dados (e os dados propriamente ditos) podem ser transportados para plataformas e tecnologias diferentes.

Para se usar uma base de dados SQLite começa por se abrir a base de dados com a função sqlite3_open(), que no caso da base de dados não existir cria uma na localização especificada: int sqlite3_open(const char *filename, sqlite3 **db);

Como o SQLite se encontra desenvolvido em C, de forma a ser mais portável, os parâmetros são parâmetros C e não Objective-C, como por exemplo a string que passa a localização do ficheiro da base de dados não é uma NSString, mas sim uma string C. Para contornar esta situação, existem métodos para conversão entre estes tipos, por exemplo para converter uma NSString para string C: char *stringC = [stringObjC UTF8String]; © FCA – Editora de Informática

238

DESENVOLVIMENTO EM iOS

Para aceder à base de dados para pesquisas e alterações usa-se o comando: int sqlite3_exec(sqlite3 *db, const char * sql, int (*callback)…

em que a string C com a designação sql tem o comando SQL standard que se pretende executar na base de dados que é passada no primeiro parâmetro. A base de dados aceita os comandos normais de outros Sistemas de Gestão de Bases de Dados (SGBD), como criação e eliminação de tabelas, criação de índices e inserções de registos e pesquisas.

Fica implícito nesta descrição que, para usar o SQLite como forma de persistência, será necessário ter alguns conhecimentos sobre criação, manipulação e pesquisas em bases de dados usando SQL, o que pode ser limitativo em algumas circunstâncias.

Quando se pretende fechar a base de dados, SQLite deve-se usar o comando de forma a garantir a consistência da base de dados uma vez terminada a aplicação: int sqlite3_close(sqlite *db);

9.7

ICLOUD

Com o iOS 5 surgiu um novo serviço denominado iCloud, que permite a atualização simultânea de informação em todos os dispositivos de um utilizador.

A ideia subjacente a este serviço é proporcionar uma forma de persistência generalizada e transparente para o utilizador, ou seja, ao usar uma aplicação em qualquer dispositivo, o utilizador terá acesso a todo o conteúdo que usou/ /salvaguardou nas vezes anteriores que correu a aplicação, qualquer que tenha sido o dispositivo em que o tenha feito, mesmo um Mac com OS X. Neste momento já existe um conjunto de aplicações ditas ready for iCloud, nomeadamente “iTunes”, “PhotoStream”, “Documents in the Cloud”, “Calendar”, “Mail”, “Contacts”, etc.

Do ponto de vista do programador, a API está disponível para todas as aplicações e consiste simplesmente na generalização dos mecanismos de persistência que temos vindo a falar neste capítulo. Cada aplicação tem uma sandbox na iCloud para onde se pode fazer upload de ficheiros e dados de forma automática, havendo a gestão automática das atualizações, ou seja, a resolução automática de conflitos de versões e a notificação de todas as mudanças, mesmo que a aplicação em causa não esteja a correr em nenhum dispositivo. © FCA – Editora de Informática

PERSISTÊNCIA

239

Tecnicamente a iCloud funciona pela partição dos documentos (divisão em chunks), sendo enviados por partes de e para a iCloud. Desta forma, apenas os chunks novos, ou os alterados, terão de ser enviados/recebidos. Acresce ainda que, para efeitos de otimização de desempenho, sempre que possível a comunicação pode ser peer-to-peer em vez de via iCloud. Por exemplo, quando existem dois dispositivos na mesma rede Wi-Fi, em que um dispositivo tenta aceder a dados que outros já em atualizados, a ligação é feita diretamente via rede Wi-Fi. Estes sistemas funcionam na base da existência de metadados, ou seja, a informação sobre os dados (nome, tamanho, data da criação, data da última alteração, etc.), que é sempre atualizada da iCloud, sendo os ficheiros atualizados na base da necessidade de acesso e de acordo com o método mais expedito.

A iCloud inclui gratuitamente 5GB de armazenamento cloud para Mail, Document Storage e Backup. A compra de música, aplicações, livros e Photo Stream não contam para o limite de armazenamento. Uma outra vantagem é que quando compra livros ou aplicações, estes serão descarregados para a sua iCloud, podendo ser acedidos a partir de qualquer dispositivo, estando neste momento definido um limite de 10 dispositivos por utilizador.

Existem duas formas de adotar o armazenamento iCloud numa aplicação: 1) iCloud document storage – armazenamento de documentos do utilizador e de dados de aplicações.

2) iCloud key-value data storage – armazenamento e partilha de dados de configurações (preferências) com pequeno volume.

O acesso à iCloud é controlado com definições específicas de iCloud, denominadas de entitlements, que são configuradas através do Xcode para dar um nível de segurança que assegura que apenas as aplicações autorizadas têm acesso aos dados que criam. Para configurar a iCloud, tendo o projeto selecionado, aparecem na zona de edição um conjunto de informações gerais organizadas em separadores. No separador Capabilities, a primeira informação relaciona-se com iCloud, como se pode ver na Figura 9.3.

FIGURA 9.3 – Definição de iCloud para um projeto © FCA – Editora de Informática

240

DESENVOLVIMENTO EM iOS

Para se inserir estas funcionalidades numa aplicação tem de providenciar um Apple ID que esteja identificado como desenvolvedor da Apple, como é indicado na Figura 9.4.

FIGURA 9.4 – Pedido de Apple ID do programa developer

Uma vez inserido o Apple ID com as caraterísticas corretas, é então possível ativar os entitlements (direitos), como se pode ver na Figura 9.5.

FIGURA 9.5 – Habilitação de entitlements para uso de iCloud

A partir deste momento já temos os entitlements ativados como se pode observar na Figura 9.6.

FIGURA 9.6 – Entitlements configurados no Xcode

Ao habilitar os entitlements, o Xcode configura automaticamente ambas as formas de armazenamento de documentos e de valores: document storage (com.apple.developer.ubiquity-container-identifiers) e key-value storage (com.apple.developer.ubiquity-kvstore-identifier), como se pode verificar na Figura 9.6.

Vamos então adaptar a aplicação “O Meu Diário” para a utilização de iCloud, nomeadamente usando o key-value storage para salvaguardar e partilhar

a informação da última seleção do botão Guardar Coordenadas, que foi salvaguardada no início deste capítulo usando NSUserDefaults.

© FCA – Editora de Informática

PERSISTÊNCIA

241

Assim temos, como já tinha ocorrido com o NSUserDefaults, duas etapas ambas a codificar no NewItemViewController.m: 1) No método saveItemChanges: – salvaguardar a nossa preferência sempre que o utilizador a altera.

2) No método viewDidLoad – repor a preferência sempre que o utilizador acede a um novo Item.

Assim, começamos pelo método saveItemChanges: - (IBAction) saveItemChanges:(id)sender { (…)

NSUserDefaults *defaults = [NSUserDefaultsstandardUserDefaults]; [defaults setBool:_locationSwitch.isOn forKey:@"GPS"]; [defaults synchronize]; //ICLOUD

NSUbiquitousKeyValueStore *store = [NSUbiquitousKeyValueStore defaultStore]; if (store) { //COMPATÍVEL COM PRÉ-IOS 5 [store setBool:_locationSwitch.isOn forKey:@"GPS"]; } (…) }

De forma análoga ao realizado para o NSUserDefaults, estamos a obter um handler, desta vez para o armazenamento na iCloud e a definir um par nome-valor (que substitui um que já exista com o mesmo nome). No método viewDidLoad: - (void)viewDidLoad { [superviewDidLoad]; if (item == nil) { NSUserDefaults *defaults = [NSUserDefaults © FCA – Editora de Informática

242

DESENVOLVIMENTO EM iOS standardUserDefaults]; [_locationSwitch setOn:[defaults boolForKey:@"GPS"]]; //ICLOUD

NSUbiquitousKeyValueStore *store = [NSUbiquitousKeyValueStore defaultStore]; if (store) { [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(storeChanged:) name:NSUbiquitousKeyValueStoreDidChangeExternally Notification object:store]; [store synchronize]; } (…) }

Aqui a implementação é ligeiramente diferente entre o NSUserDefaults e o NSUbiquitousKeyValueStore. Neste caso registamos um observer para sermos avisados sempre que há uma mudança no armazenamento iCloud. Assim, caso seja detetada uma alteração, é chamado o método storeChanged: - (void)storeChanged:(NSNotification*)notification { NSDictionary *userInfo = [notification userInfo]; NSNumber *reason = [userInfo objectForKey:NSUbiquitousKeyValueStoreChangeReasonKey]; if (reason) { NSInteger reasonValue = [reason integerValue]; NSLog(@"storeChanged with reason %d", reasonValue); if ((reasonValue==NSUbiquitousKeyValueStoreServerChange )||(reasonValue== © FCA – Editora de Informática

PERSISTÊNCIA

243

NSUbiquitousKeyValueStoreInitialSyncChange)) { NSArray *keys = [userInfo objectForKey: NSUbiquitousKeyValueStoreChangedKeysKey]; NSUbiquitousKeyValueStore *store = [NSUbiquitousKeyValueStore defaultStore]; NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults]; NSString *key = [keys objectAtIndex:0]; BOOL bValue =[store boolForKey:key]; [userDefaults setBool:bValue forKey:key]; [userDefaults synchronize]; NSLog(@"storeChanged updated value for %@",key); }//IF REASONVALUE }//IF (REASON) }

Este método deteta qual o motivo da alteração remota e pode agir em conformidade. Neste caso temos apenas uma chave booleana armazenada e estamos a atualizá-la no NSUserDefaults local. Este procedimento é o recomendado, uma vez que o armazenamento key-value na iCloud não deve substituir o NSUserDefaults, deve sim ser usado como forma complementar para a partilha de preferências entre instâncias da aplicação a correrem dispositivos diferentes.

Caso o conjunto de preferências guardado fosse mais alargado, poder-se-ia usar o seguinte código no interior do ciclo: for (NSString *key in keys) { id value = [store objectForKey:key]; [userDefaults setObject:value forKey:key]; } Espaço na iCloud para key-value storage O armazenamento key-value storage tem como principal objetivo ser usado em pequenos volumes de dados, normalmente preferências das aplicações, ou outros dados que não sejam alterados com muita frequência. Cada aplicação tem um máximo de 1024 chaves e 1 © FCA – Editora de Informática

244

DESENVOLVIMENTO EM iOS

MB de armazenamento total de key-value storage. Caso este limite seja excedido, é recebida a notificação NSUbiquitousKeyValueStoreQuotaViolationChange pelo método observer.

9.8

PRESERVAÇÃO E RESTAURO DE ESTADO

Como foi referido ao longo deste capítulo, quando um utilizador volta para uma aplicação, independentemente da forma e motivo que o levaram a abandoná-la anteriormente, a aplicação deve sempre apresentar-se ao utilizador no último ponto da sua interação, de forma que o utilizador possa prosseguir com a tarefa que havia interrompido. Até esta fase deste capítulo, os meios que apresentámos para este efeito prendem-se de uma forma geral com a preservação dos dados, essencial para atingir aquele objetivo. No entanto, além do estado dos dados é também crucial a preservação do restante estado da aplicação. Vamos nesta secção apresentar o suporte para preservação e restauro disponibilizado pela UIKit. O sistema de preservação de estado da UIKit fornece uma infraestrutura simples e relativamente flexível para preservar e restaurar o estado de controladores e vistas de uma aplicação. Esta infraestrutura determina o processo de restauração e preservação nos momentos adequados, com algumas indicações que o programador deve fornecer, normalmente muito dependentes da aplicação. Na realidade, o programador estará mais preparado para definir para a sua aplicação quais os objetos a preservar e qual o mapeamento do conteúdo preservado quando a aplicação volta a ser usada. É então possível escolher que partes da interface do utilizador devem ser preservadas, sendo possível a reutilização de código que já introduza preservação.

Existem 3 pontos fulcrais onde se deve incluir preservação do estado de uma aplicação: 1)

No app delegate, que gere o estado ao mais alto nível;

2) Nos view controllers, que gerem o estado da interface com o utilizador; 3) Nas custom views, caso existam.

Desta forma, para tirar partido das potencialidades de preservação e restauro do estado, uma aplicação deve fornecer ao UIKit uma lista de objetos, sendo a forma explícita de preservação e restauro relativamente transparente para o programador.

© FCA – Editora de Informática