Você está na página 1de 33

Aprendendo Cocoa

com Objective-C
Paris Buttfield-Addison
Jonathon Manning

Novatec
Authorized Portuguese translation of the English edition of titled Learning Cocoa with Objective-C 3E ISBN
9781449318499 © 2012 Paris Buttfield-Addison, Jonathon Manning. This translation is published and sold by
permission of O'Reilly Media, Inc., the owner of all rights to publish and sell the same.
Tradução em português autorizada da edição em inglês da obra Learning Cocoa with Objective-C 3E ISBN
9781449318499 © 2012 Paris Buttfield-Addison, Jonathon Manning. Esta tradução é publicada e vendida com a
permissão da O'Reilly Media, Inc., detentora de todos os direitos para publicação e venda desta obra.
© Novatec Editora Ltda. [2013].
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo
parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora.
Editor: Rubens Prates
Tradução: Lúcia Ayako Kinoshita
Revisão técnica: Edgard Damiani
Revisão gramatical: Lívia Freitag
Editoração eletrônica: Carolina Kuwabata
ISBN: 978-85-7522-342-0
Histórico de impressões:
Abril/2013 Primeira edição
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
Fax: +55 11 2950-8869
Email: novatec@novatec.com.br
Site: www.novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec

Dados Internacionais de Catalogação na Publicação (CIP)


(Câmara Brasileira do Livro, SP, Brasil)

Manning, Jonathon
Aprendendo Cocoa com Objective-C / Jonathon
Manning e Paris Buttfield-Addison ; [tradução
Lúcia Ayako Kinoshita]. -- São Paulo : Novatec
Editora, 2013.

Título original: Learning Cocoa with


Objective-C.
ISBN 978-85-7522-342-0

1. Cocoa 2. Interface de programas aplicativos


(Software) 3. Mac OS (Computador) 4. Objective-C
(Linguagem de programação para computadores)
5. Softwares aplicativos - Desenvolvimento
I. Buttfield-Addison, Paris. II. Título.

13-03184 CDD-005.26

Índices para catálogo sistemático:

1. Cocoa com Objective-C : Ferramentas para


aplicativos : Software : Desenvolvimento :
Processamento de dados 005.26
MP20130405
Sumário

Prefácio.................................................................................................................13

Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa..........................................20


Programas para desenvolvedores de Mac e de iOS..................................... 21
Inscrevendo-se em um programa para desenvolvedores.........................22
Fazendo download do Xcode a partir do Apple Developer....................22
Conhecendo o Xcode...............................................................................23
Interface do Xcode..............................................................................27
Desenvolvendo um aplicativo simples em Objective-C...............................35
Fazendo o design da interface..............................................................35
Conectando o código..........................................................................37
Usando o iOS Simulator...........................................................................39

Capítulo 2 ■ Programação orientada a objetos com Objective-C...............................41


Programação orientada a objetos.............................................................. 41
Objetos..............................................................................................42
Herança.............................................................................................43
Interfaces e implementações................................................................43
Métodos............................................................................................ 44
Mensagens........................................................................................ 46
Propriedades.......................................................................................47
Protocolos..........................................................................................50
Extensões de classe............................................................................. 51
Gerenciamento de memória.....................................................................53
Contagem de referências.....................................................................54
Contagem automática de referências (Automatic reference counting).....54
Grafos de objetos em Objective-C........................................................55

5
6 Aprendendo Cocoa com Objective-C
Ciclo de vida do NSObject.......................................................................56
Alocação e inicialização......................................................................56
Retain e Release..................................................................................57
Finalização e liberação de memória.....................................................57

Capítulo 3 ■ Foundation..........................................................................................58
Objetos mutáveis e imutáveis...................................................................58
Strings.....................................................................................................59
Criando strings.................................................................................. 60
Trabalhando com strings..................................................................... 61
Comparando strings...........................................................................64
Fazendo buscas em strings..................................................................64
Arrays.....................................................................................................65
Enumeração rápida............................................................................ 68
Arrays mutáveis..................................................................................69
Dicionários..............................................................................................70
NSValue e NSNumber..............................................................................72
Dados......................................................................................................73
Carregando dados de arquivos e de URLs............................................73
Serialização e desserialização...............................................................75
Padrões de projeto no Cocoa....................................................................78
Modelo-visão-controlador...................................................................78
Delegação...........................................................................................80

Capítulo 4 ■ Aplicativos no OS X e no iOS..................................................................82


O que é um aplicativo?.............................................................................82
Aplicativos, frameworks, utilitários e outros.........................................84
Quais são os componentes de um app?................................................84
Usando NSBundle para encontrar recursos em aplicativos................... 86
Ciclo de vida do aplicativo....................................................................... 88
Aplicativos OS X................................................................................ 88
Aplicativos iOS.................................................................................. 90
A sandbox do aplicativo...........................................................................94
Restrições aos aplicativos.....................................................................95
Sumário 7
Capítulo 5 ■ Interfaces gráficas de usuário...............................................................99
Interfaces no OS X e no iOS......................................................................99
MVC e design de aplicação.....................................................................100
Arquivos nib...........................................................................................101
Estrutura de um arquivo nib............................................................. 102
Outlets e ações..................................................................................106
Como os arquivos nib são carregados................................................ 107
Construindo uma interface..................................................................... 108
Diretrizes e restrições........................................................................ 109
Gerando um app com nibs e restrições..................................................... 111
Core Animation......................................................................................113
Camadas...........................................................................................114
Animações........................................................................................114

Capítulo 6 ■ Blocos e filas de operações.................................................................117


Blocos....................................................................................................117
Sintaxe de bloco................................................................................119
Ciclo de vida dos blocos.................................................................... 120
Métodos que recebem blocos como parâmetro................................... 122
Blocos e gerenciamento de memória.................................................. 123
Modificando variáveis locais de dentro dos blocos usando __block..... 124
Concorrência e filas de operações........................................................... 124
Filas de operações e NSOperation..................................................... 126
Executando tarefas em filas de operações........................................... 126
Reunindo tudo...................................................................................... 128

Capítulo 7 ■ Desenhando imagens gráficas em visões............................................132


Como funciona o desenho de imagens gráficas....................................... 132
Grade de pixels...................................................................................... 134
Displays Retina................................................................................. 135
Pixels e pontos de tela....................................................................... 136
Desenhando em visões........................................................................... 137
Retângulos de moldura..................................................................... 137
Retângulos de limites........................................................................ 138
8 Aprendendo Cocoa com Objective-C
Criando uma visão customizada............................................................. 139
Criando o projeto............................................................................. 139
Preenchendo com uma cor sólida...................................................... 140
Trabalhando com caminhos (paths)................................................... 142
Criando caminhos customizados....................................................... 143
Múltiplos subcaminhos..................................................................... 145
Sombras............................................................................................147
Gradientes.........................................................................................151
Transformações................................................................................. 155

Capítulo 8 ■ Áudio e vídeo....................................................................................157


AV Foundation....................................................................................... 158
Reproduzindo vídeos usando AVPlayer................................................... 158
AVPlayerLayer................................................................................... 159
Reunindo tudo.................................................................................160
Reproduzindo áudio com AVAudioPlayer................................................ 164
Trabalhando com a biblioteca de fotos.................................................... 165
Capturando fotos e vídeos da câmera................................................166
Criando um aplicativo para fotos....................................................... 169
Biblioteca de fotos..............................................................................171

Capítulo 9 ■ Objetos de modelo e armazenamento de dados..................................173


Codificação chave-valor...........................................................................174
Key-Value observing............................................................................... 176
Registrando-se para receber notificações sobre alteração..................... 177
Notificando observadores a respeito de mudanças.............................. 178
Notificações com NSNotification............................................................ 179
Preferências............................................................................................ 180
Registrando as preferências padrão.....................................................181
Acessando as preferências.................................................................. 182
Definindo as preferências.................................................................. 183
Trabalhando com o sistema de arquivos.................................................. 184
Usando NSFileManager.................................................................... 186
Locais para armazenamento de arquivos............................................ 189
Sumário 9
Trabalhando com a sandbox................................................................... 190
Habilitando a sandbox...................................................................... 190
Painéis para abrir e salvar...................................................................191
Marcadores com escopo de segurança.................................................191

Capítulo 10 ■ Bindings do Cocoa............................................................................194


Conectando visões a modelos................................................................. 195
Um app simples com bindings................................................................ 196
Conectando-se a controladores............................................................... 198
Controladores de array e de objetos........................................................200
Um app mais complexo com binding...................................................... 201

Capítulo 11 ■ Visões de tabela e visões de coleção.................................................208


Fontes de dados e delegados...................................................................208
Visões de tabela.....................................................................................209
UITableView no iOS...............................................................................209
Seções e linhas.................................................................................. 210
Controladores de visão de tabela........................................................ 211
Células de visão de tabela................................................................. 212
Implementando uma visão de tabela................................................. 216
NSTableView no OS X............................................................................ 219
Ordenando uma visão de tabela........................................................ 223
NSTableView com bindings............................................................... 224
Visões de coleção................................................................................... 225
UICollectionView no iOS.................................................................. 225

Capítulo 12 ■ Aplicativos com base em documentos...............................................229


Classes NSDocument e UIDocument.....................................................230
Objetos de documento no MVC.............................................................230
Tipos de documentos..............................................................................231
O papel dos documentos........................................................................ 232
Aplicativos baseados em documentos no OS X........................................ 232
Salvamento automático e versões....................................................... 233
Representando documentos com NSDocument.................................. 234
Salvando dados simples..................................................................... 235
10 Aprendendo Cocoa com Objective-C
Salvando dados mais complexos........................................................ 237
Aplicativos baseados em documentos no iOS...........................................241
Representando documentos com UIDocument.................................. 242

Capítulo 13 ■ Redes..............................................................................................249
Conexões............................................................................................... 249
NSURL............................................................................................250
NSURLRequest.................................................................................251
NSURLConnection........................................................................... 252
NSURLResponse e NSHTTPURLResponse....................................... 252
Criando um aplicativo em rede............................................................... 253
Descobrindo serviços na vizinhança.......................................................254
Buscando bibliotecas compartilhadas do iTunes................................. 255

Capítulo 14 ■ Trabalhando no mundo real.............................................................257


Trabalhando com localização.................................................................258
Hardware para localização................................................................258
Framework Core Location.................................................................260
Trabalhando com o Core Location..................................................... 261
Geocodificação......................................................................................265
Localização e privacidade.......................................................................268
Movimentação do dispositivo.................................................................269
Trabalhando com o Core Motion.......................................................270
Imprimindo documentos....................................................................... 275
Imprimindo no OS X........................................................................ 275
Imprimindo no iOS.......................................................................... 276

Capítulo 15 ■ Event Kit..........................................................................................279


Compreendendo os eventos....................................................................279
Acessando o depósito de eventos.......................................................280
Acessando calendários...................................................................... 281
Acessando eventos............................................................................ 281
Trabalhando com eventos.......................................................................282
Criando um aplicativo de eventos...........................................................284
Privacidade do usuário...........................................................................290
Sumário 11
Capítulo 16 ■ O Instruments e o depurador............................................................291
Introduzindo o Instruments...................................................................292
A interface do Instruments................................................................294
Observando dados............................................................................295
Adicionando instrumentos da biblioteca............................................296
Corrigindo problemas com o Instruments..............................................297
Ciclos de retenção e vazamentos.............................................................303
Usando o depurador..............................................................................306
Definindo breakpoints......................................................................307
Inspecionado conteúdo de memória.................................................. 310
Trabalhando com o console do depurador.......................................... 311

Capítulo 17 ■ Compartilhamento e notificações.....................................................312


Compartilhamento.................................................................................312
Compartilhamento no iOS................................................................ 315
Compartilhamento no OS X...............................................................317
Notificações............................................................................................318
Notificações por push........................................................................318
Enviando notificações por push......................................................... 320
Preparando-se para receber notificações por push................................321
Recebendo notificações por push....................................................... 323
Notificações locais............................................................................ 325

Capítulo 18 ■ Apps não padrão..............................................................................327


Ferramentas de linha de comando.......................................................... 327
Painéis de preferência............................................................................. 329
Como funcionam os painéis de preferências....................................... 329
Domínio de preferências...................................................................330
Criando um exemplo de painel de preferências...................................331
Itens da barra de status.......................................................................... 333
Criando um app de barra de status................................................... 335

Capítulo 19 ■ Trabalhando com textos...................................................................337


Internacionalização e localização............................................................ 337
Arquivos de strings...........................................................................338
12 Aprendendo Cocoa com Objective-C
Criando um exemplo de aplicativo localizado....................................338
Formatando dados com NSFormatter.....................................................340
Formatando datas com NSDateFormatter.......................................... 341
Identificando dados com NSDataDetector...............................................343
Testando um detector de dados...............................................................344

Capítulo 20 ■ iCloud..............................................................................................347
O que o iCloud armazena...................................................................... 347
Preparando-se para usar o iCloud...........................................................349
Verificando se o iCloud funciona.............................................................351
Armazenando configurações....................................................................351
Armazenamento no iCloud.................................................................... 357
Aprendendo Cocoa
com Objective-C
Paris Buttfield-Addison
Jonathon Manning

Novatec
Authorized Portuguese translation of the English edition of titled Learning Cocoa with Objective-C 3E ISBN
9781449318499 © 2012 Paris Buttfield-Addison, Jonathon Manning. This translation is published and sold by
permission of O'Reilly Media, Inc., the owner of all rights to publish and sell the same.
Tradução em português autorizada da edição em inglês da obra Learning Cocoa with Objective-C 3E ISBN
9781449318499 © 2012 Paris Buttfield-Addison, Jonathon Manning. Esta tradução é publicada e vendida com a
permissão da O'Reilly Media, Inc., detentora de todos os direitos para publicação e venda desta obra.
© Novatec Editora Ltda. [2013].
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo
parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora.
Editor: Rubens Prates
Tradução: Lúcia Ayako Kinoshita
Revisão técnica: Edgard Damiani
Revisão gramatical: Lívia Freitag
Editoração eletrônica: Carolina Kuwabata
ISBN: 978-85-7522-342-0
Histórico de impressões:
Abril/2013 Primeira edição
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
Fax: +55 11 2950-8869
Email: novatec@novatec.com.br
Site: www.novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec

Dados Internacionais de Catalogação na Publicação (CIP)


(Câmara Brasileira do Livro, SP, Brasil)

Manning, Jonathon
Aprendendo Cocoa com Objective-C / Jonathon
Manning e Paris Buttfield-Addison ; [tradução
Lúcia Ayako Kinoshita]. -- São Paulo : Novatec
Editora, 2013.

Título original: Learning Cocoa with


Objective-C.
ISBN 978-85-7522-342-0

1. Cocoa 2. Interface de programas aplicativos


(Software) 3. Mac OS (Computador) 4. Objective-C
(Linguagem de programação para computadores)
5. Softwares aplicativos - Desenvolvimento
I. Buttfield-Addison, Paris. II. Título.

13-03184 CDD-005.26

Índices para catálogo sistemático:

1. Cocoa com Objective-C : Ferramentas para


aplicativos : Software : Desenvolvimento :
Processamento de dados 005.26
MP20130405
capítulo 1

Ferramentas de desenvolvimento do Cocoa

Desenvolver aplicativos usando Cocoa e Cocoa Touch envolve o uso de um con-


junto de ferramentas desenvolvido pela Apple. Neste capítulo, você aprenderá
sobre essas ferramentas, onde obtê-las, como usá-las, como elas funcionam em
conjunto e do que elas são capazes.
Tais ferramentas de desenvolvimento têm uma longa história. Originalmente
um conjunto de ferramentas para aplicativos standalone para o NeXTSTEP
OS, elas foram adotadas pela Apple para serem usadas como as ferramentas
oficiais do OS X. Posteriormente, a Apple combinou-as em um único aplicativo,
conhecido como Xcode, embora alguns dos aplicativos (como o Instruments
e o iOS Simulator) permaneçam separados em consequência de seus papéis
relativamente periféricos no processo de desenvolvimento.
Além dos aplicativos para desenvolvimento, a Apple oferece a possibilidade
de inscrição em seus Developer Programs (anteriormente o Apple Developer
Connection), que oferecem recursos e suporte aos desenvolvedores. Os progra-
mas permitem acesso a fóruns online para desenvolvedores e suporte técnico
especializado para pessoas interessadas em conversar com os engenheiros res-
ponsáveis pelos frameworks.
Atualmente, com a introdução das lojas de aplicativos seletos da Apple para
o OS X e o iOS, tais programas para desenvolvedores tornaram-se o modo
oficial como os desenvolvedores fornecem suas credenciais quando submetem
aplicativos à Mac App Store ou à iTunes App Store – que, em essência, são suas
passagens para vender apps por meio da Apple. Neste capítulo, você aprenderá
a se inscrever nesses programas, assim como a usar o Xcode, a ferramenta de
desenvolvimento utilizada para gerar apps para OS X e para iOS.

20
Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 21

Programas para desenvolvedores de Mac e de iOS


A Apple possui dois programas para desenvolvedores, um para cada uma das
duas plataformas para as quais você pode escrever apps: o iOS e o OS X.
Você deverá efetuar uma inscrição paga para se tornar membro do programa
para desenvolvedor de iOS se quiser executar código em seus dispositivos iOS,
uma vez que fazer a inscrição é a única forma de obter os certificados de assi-
natura de código necessários. (Na época em que este livro foi escrito, a inscrição
nos programas para desenvolvedores custava 99 dólares/ano, por programa.)
Não é necessário ser membro do programa para desenvolvedores de Mac, caso
você não tenha a intenção de submeter apps na Mac App Store (pode ser que
você prefira, por exemplo, vender seus apps por conta própria). No entanto, o
programa para desenvolvedores de Mac inclui recursos úteis, como acesso com
antecedência à próxima versão do sistema operacional. Portanto, vale a pena se
você estiver pensando seriamente em criar apps. Fazer download do Xcode é
gratuito, mesmo que você não seja membro dos programas para desenvolvedores.
Ambos os programas oferecem, entre uma série de outros recursos menores:
• Acesso aos Apple Developer Forums, frequentados por engenheiros da
Apple e concebidos de modo a permitir que você faça perguntas aos seus
colegas desenvolvedores e às pessoas que escreveram o sistema operacional.
• Acesso às versões beta do sistema operacional antes de serem liberadas
para o público, o que permite que você teste seus aplicativos na próxima
versão do OS X e do iOS, além de fazer as alterações necessárias com
antecedência. Você também receberá versões beta das ferramentas de
desenvolvimento.
• Um certificado de assinatura digital (um para OS X e outro para iOS)
usado para identificá-lo nas App Stores. Sem isso, você não poderá sub-
meter os apps à venda, o que torna esses programas obrigatórios para
todos que queiram liberar softwares, seja gratuitamente ou para venda
por intermédio da App Store.
Como desenvolvedor, você poderá se inscrever em um ou em ambos os progra-
mas para desenvolvedores. Eles não dependem um do outro.
Por fim, não é preciso inscrever-se em um programa para desenvolvedor para
visualizar a documentação ou para fazer download da versão atual das ferra-
mentas para desenvolvedores, de modo que você pode brincar de escrever apps
sem a necessidade de abrir a carteira.
22 Aprendendo Cocoa com Objective-C
Inscrevendo-se em um programa para desenvolvedores
Para se inscrever em um dos programas para desenvolvedores, você precisará,
inicialmente, de um Apple ID. É provável que você já tenha, pois a maioria dos
serviços on-line da Apple exige que você tenha um para identificá-lo. Se você
já usou o iCloud, a loja iTunes (para músicas ou para apps), o MobileMe ou o
serviço de suporte e de reparos da Apple, então você já tem um ID. Pode ser que
você tenha até mais de um (um dos autores deste livro tem quatro). Se ainda não
possuir um ID, você criará um como parte do processo de inscrição. Quando se
inscrever em um programa, ele será associado ao seu Apple ID.
Para começar, acesse o site da Apple para escolher o programa ao qual você
quer se associar:
• Para o programa para Mac, acesse http://developer.apple.com/programs/mac/
• Para o programa para iOS, acesse http://developer.apple.com/programs/ios/
Basta ir clicando nos passos para se inscrever.
Você pode optar por se inscrever como pessoa física ou jurídica. Se você se
inscrever como pessoa física, seus apps serão vendidos sob seu nome. Se você
se inscrever como pessoa jurídica, seus apps serão vendidos sob a razão social
de sua empresa. Escolha com cuidado, pois é muito difícil convencer a Apple a
mudar o tipo do seu programa.
Inscrevendo-se como pessoa física, somente seu cartão de crédito será necessário.
Já como pessoa jurídica, será necessário o seu cartão de crédito, bem como uma
documentação que prove que você tem autoridade para associar sua empresa
aos termos e condições da Apple.
Geralmente, a Apple leva 24 horas para ativar uma conta para pessoa física e
um pouco mais de tempo para pessoa jurídica. Após receber a confirmação da
Apple, você receberá um e-mail com um link para ativar sua conta; feito isso,
você será um desenvolvedor totalmente capacitado!

Fazendo download do Xcode a partir do Apple Developer


Para desenvolver apps para qualquer uma das plataformas, você usará o Xcode,
o ambiente de desenvolvimento integrado da Apple. O Xcode combina um
editor de código-fonte, um depurador, um compilador, um criador de perfis
(profiler), simuladores de iPhone e de iPad, e muito mais, em um único pacote.
Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 23
É o ambiente no qual você passará a maior parte de seu tempo quando estiver
desenvolvendo aplicações.
Há duas maneiras de fazer download do Xcode. Se estiver executando o OS X
Lion (10.7 ou mais recente), você poderá obter o XCode a partir da Mac App
Store. Basta abrir o aplicativo App Store e procurar por “Xcode” e ele aparecerá.
O download é gratuito, embora seja bastante pesado (a versão corrente na época
em que este livro foi feito tinha certa de 1,7 GB).
Se estiver executando o OS X Snow Leopard (10.6), ou simplesmente não quiser
usar a App Store, você pode fazer o download do Xcode a partir do site da Apple.
Fazer isso exige a inscrição em um dos programas para desenvolvedores. Acesse
http://developer.apple.com/xcode/ e faça login em sua conta de desenvolvedor para
baixar o aplicativo. Se estiver executando o Lion e quiser fazer o download
diretamente, acesse https://developer.apple.com/downloads/ e procure por “Xcode”
– você encontrará o link para download nos resultados da busca.
Após ter feito o download do Xcode, instalá-lo é simples. A Mac App Store
fornece um instalador sobre o qual você poderá dar um clique duplo. Se fizer
o download diretamente, você obterá uma imagem de disco que deverá ser
aberta, a qual contém o mesmo instalador. Siga os comandos para instalação.

Conhecendo o Xcode
O Xcode está organizado em torno de uma única janela. Cada um de seus
projetos terá uma janela que se adapta para mostrar aquilo em que você está
trabalhando.
Para começar a explorar o Xcode, será necessário, inicialmente, criar um projeto
seguindo os passos a seguir:
1. Inicie o Xcode. Encontre o Xcode abrindo o Spotlight (teclando ⌘-Barra de
espaço) e digitando Xcode. Você também pode encontrá-lo abrindo o Finder,
acessando seu disco rígido e abrindo o diretório Applications. Se algum
projeto tiver sido aberto anteriormente, o Xcode o abrirá para você. Caso
contrário, a tela Welcome to Xcode aparecerá (Figura 1.1).
24 Aprendendo Cocoa com Objective-C

Figura 1.1 – Janela Welcome to Xcode.


2. Crie um novo projeto. Clique em “Create a new Xcode project” ou vá para
File→New→Project.
Você será solicitado a escolher o tipo de aplicativo a ser criado. O seletor de
template está dividido em duas áreas. Do lado esquerdo, você encontrará
um conjunto de categorias em que os aplicativos podem estar. Você pode
optar por criar um template para projeto iOS ou Mac, o que definirá um
diretório de projeto, colocando você na direção correta para começar.
Como no momento só estamos testando o Xcode, o tipo de projeto não
importa, portanto, escolha Application, abaixo do título OS X, e selecione
Cocoa Application. Isso criará um aplicativo Mac vazio.
3. Insira informações sobre o projeto. Dependendo do tipo de template de projeto
selecionado, você será solicitado a fornecer diferentes informações sobre
como o novo projeto deverá ser configurado.
Você terá de fornecer as seguintes informações, no mínimo, independente da
plataforma ou template que tenha escolhido:

Nome do aplicativo (product name)


Esse é o nome do projeto e será visível ao usuário. Você poderá mudar essa
informação posteriormente.
Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 25
Identificador de sua empresa (company identifier)
Essa informação é usada para gerar um bundle ID (identificador de pacote),
uma string que parece com um nome de domínio invertido. (Por exemplo, se
a O’Reilly criasse um aplicativo chamado MyUsefulApplication, o bundle ID
seria com.oreilly.MyUsefulApplication.)

Os bundle IDs são os identificadores únicos de um aplicativo e são usados


para identificar o app no sistema e na App Store. Como cada bundle ID deve
ser único, o mesmo ID não pode ser usado por mais de um aplicativo nas iOS
ou Mac App Stores. Por isso que o formato é baseado nos nomes de domínio.
Se você for o dono do site usefulsoftware.com, todos os seus bundle IDs seriam
iniciados com com.usefulsoftware, e você não usaria acidentalmente um bundle
ID que outra pessoa estivesse usando ou quisesse usar porque ninguém mais
possui o mesmo nome de domínio.

Prefixo de classe (class prefix)


Prefixos de classe são códigos que contém duas ou três letras inseridas na frente
de suas classes, evitando que os nomes de suas classes interfiram nas classes
existentes. Isso significa que uma classe chamada String com prefixo de classe
igual a LC (de "Learning Cocoa") seria a classe LCString. As classes da Apple, por
exemplo, normalmente usam NS como prefixo de classe – sua classe String é a
NSString. A Apple também usa outros prefixos.

Uso do Automatic Reference Counting


Controla se seu aplicativo usará o método antigo de gerenciamento manual de
memória empregado anteriormente ao iOS 5.0 e ao OS X Lion (10.7.). É melhor
deixar sempre essa opção ativada, pois ela evita um bocado de dores de cabeça.

Este livro presume que seus projetos usarão o Automatic Reference Counting,
portanto, certifique-se de que a caixa de seleção esteja marcada em todos os
projetos que forem criados para este livro!

Inclusão de testes de unidade (unit tests)


Testes de unidade são blocos separados de código executados em tempo de
compilação para testar a funcionalidade de seu código. Eles permitem que você
teste partes de seu código-fonte isoladamente, o que permitirá a você encontrar
bugs mais facilmente. Testes de unidade são extremamente úteis quando você
26 Aprendendo Cocoa com Objective-C
estiver fazendo algo mais complexo do que apps pequenos. Não cobriremos testes
de unidade neste livro, mas há um vídeo da O’Reilly da série Breakdown (http://
shop.oreilly.com/product/0636920016465.do) que serve como um excelente recurso.

Embora seja muito recomendado, adicionar testes de unidade ao seu código é


opcional. Por esse motivo, este livro não supõe que você os tenha acrescentado
aos seus projetos.

Se estiver escrevendo um aplicativo para a Mac App Store, você também será
solicitado a fornecer a categoria para a App Store (se é um jogo, um app educa-
tivo, um app para redes sociais e assim por diante).
Dependendo do template, você também será solicitado a fornecer outras infor-
mações (por exemplo, a extensão dos arquivos de documentos, se estiver criando
um aplicativo que lide com documentos, como um app para Mac).
Siga os passos a seguir para criar um novo projeto para um aplicativo iOS
chamado HelloCocoa, que o ajudará a conhecer melhor o ambiente do Xcode.
1. Crie um novo aplicativo Cocoa Touch para iOS. Crie seu projeto novo selecionando
File→New→Project ou pressionando ⌘-Shift-N. Selecione Application a partir da
lista iOS, selecione Single-View Application e depois clique em Next. Isso criará
um app com somente uma tela (Figura 1.2).

Figura 1.2 – Selecionando Single-View Application para iOS.


2. Dê um nome ao aplicativo. Digite HelloCocoa na seção Product Name.
Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 27
3. Faça o aplicativo ser executado no iPhone. Selecione iPhone da lista suspensa Devices.

Aplicativos iOS podem ser executados no iPad, no iPhone ou em ambos.


Aplicativos que executam em ambos são chamados aplicativos “universais”,
os quais executam o mesmo binário, mas possuem diferentes interfaces de
usuário. Para esse exercício, basta selecionar iPhone.

4. Defina o identificador de sua empresa. Insira o nome de domínio de seu site na


forma invertida. Desse modo, nosso nome de domínio, oreilly.com, seria
inserido como com.oreilly.
Se você não tem um nome de domínio, insira um nome qualquer, desde
que se pareça com um nome de domínio invertido. Algo como com.mycompany
servirá.

Se você planeja liberar seu app na App Store ou em algum outro lugar, é
muito importante usar um identificador de empresa que esteja de acordo com
o nome de domínio que você tem. A App Store faz essa exigência, e o fato
de o sistema operacional usar o bundle ID, gerado a partir do identificador
da empresa, significa que usar um nome de domínio do qual você é o dono
elimina a possibilidade de criar acidentalmente um bundle ID que entre em
conflito com o ID de outra pessoa.

5. Clique em Next para criar o projeto. Deixe o restante das configurações conforme
mostrado na figura 1.3.
6. Selecione o local em que o projeto será salvo; você será solicitado a especificá-lo.
Selecione um local que seja adequado a você.
Após ter feito isso, o Xcode abrirá o projeto e você poderá, então, começar
a usar toda a interface do Xcode (Figura 1.4).

Interface do Xcode
Conforme mencionado, o Xcode mostra todo seu projeto em uma janela, a qual
está dividida em várias seções. Você pode abrir e fechar cada seção à vontade,
dependendo do que quer visualizar.
Vamos dar uma olhada em cada uma dessas seções e analisar o que elas fazem.
28 Aprendendo Cocoa com Objective-C

Figura 1.3 – Criando o projeto.

Figura 1.4 – Interface do Xcode.

Editor
O editor do Xcode (Figura 1.5) é o local em que você passará a maior parte do
tempo. Toda a edição do código-fonte, o design da interface e a configuração
do projeto acontecem nessa seção do aplicativo, a qual mudará, dependendo
do arquivo que você tiver aberto no momento.
Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 29

Figura 1.5 – Editor do Xcode.


Se você estiver editando código-fonte, o editor será um editor de textos, com
preenchimento automático de código, destaque a elementos da sintaxe e todos
os recursos usuais que os desenvolvedores esperam de um ambiente de desen-
volvimento integrado. Se estiver modificando uma interface de usuário, o editor
será um editor visual, permitindo que você arraste nele os componentes de sua
interface. Outros tipos de arquivos também possuem seus próprios editores
especializados.
O editor também pode ser dividido em editor principal (main editor) e editor as-
sistente (assistant editor). O assistente mostra arquivos relacionados ao arquivo
aberto no momento no editor principal. Ele continuará a mostrar arquivos
relacionados com o que estiver aberto, mesmo que você abra diferentes arquivos.
Por exemplo, se você abrir um arquivo de interface e depois abrir o assistente, este,
por padrão, mostrará o código relacionado à interface que você está editando.
Se você abrir outro arquivo de interface, o assistente mostrará o código-fonte
para os arquivos que acabaram de ser abertos.
Você também poderá pular diretamente de um arquivo no editor para sua
contraparte – por exemplo, de um arquivo de interface para o arquivo de im-
plementação correspondente. Para isso, pressione Control-⌘-Seta para Cima para
abrir a contraparte do arquivo corrente no editor corrente. Você também pode
pressionar Control-⌘-Option-Seta para Cima para abrir a contraparte do arquivo
corrente em um painel assistente.
30 Aprendendo Cocoa com Objective-C
Barra de ferramentas
A barra de ferramentas do Xcode (Figura 1.6) funciona como um controlador
de missão para toda a interface. É a única parte do Xcode que não muda sig-
nificativamente à medida que você desenvolve seus aplicativos, e serve como o
local no qual você pode controlar o que seu código está fazendo.

Figura 1.6 – Barra de ferramentas do Xcode.


Da esquerda para a direita, a barra de ferramentas apresenta os seguintes itens:

Botão Run
Ao clicar nesse botão, o Xcode compila e executa o aplicativo. Dependendo do
tipo de aplicativo que você estiver executando e da configuração selecionada no
momento, esse botão produzirá diferentes efeitos:
• Se você estiver criando um aplicativo Mac, o novo app aparecerá no Dock
e será executado em sua máquina.
• Se estiver criando um aplicativo iOS, o novo app será iniciado no iOS
Simulator ou em um dispositivo iOS que estiver conectado, como um
iPhone ou um iPad. Se clicar e segurar esse botão, você poderá mudá-lo
de Run para outra ação, como Test, Profile ou Analyze. A ação Test per-
mitirá que quaisquer testes de unidade que tenham sido definidos sejam
executados; a ação Profile permitirá que o aplicativo Instruments (veja
Capítulo 16) seja executado; a ação Analyze fará uma verificação em seu
código e apontará problemas e bugs em potencial.
Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 31
Botão Stop
Clicar nesse botão interromperá qualquer tarefa que o Xcode esteja executando
no momento – se estiver compilando seu aplicativo, essa ação será interrompi-
da; se seu aplicativo estiver executando no depurador nesse momento, ele será
interrompido.

Seletor de esquema
Esquemas (schemes) é o nome dado pelo Xcode para as configurações de cons-
trução (build) de seu aplicativo – ou seja, o que está sendo construído e como.
Seu projeto pode conter vários alvos (targets), que são os produtos finais a serem
criados pelo seu aplicativo. Os alvos podem compartilhar recursos, como código-
-fonte, som e imagens, permitindo que você administre mais facilmente uma
tarefa, como, por exemplo, gerar uma versão iOS de um aplicativo Mac. Não é
necessário criar dois projetos; basta ter um projeto com dois alvos que possam
compartilhar o máximo de código-fonte, conforme desejado.
Para selecionar um alvo, clique no lado esquerdo do seletor de esquemas.
Você também pode escolher o local em que seu aplicativo será executado. Se
estiver gerando um aplicativo Mac, normalmente você vai querer executar seu
aplicativo no Mac que estiver utilizando. Se estiver gerando um aplicativo iOS,
porém, você terá a opção de executar o aplicativo em um simulador de iPhone ou
em um simulador de iPad. (Na verdade, eles são o mesmo aplicativo, mas mudam
de formato, dependendo do aplicativo que é executado nele.) Você também pode
optar por executar o aplicativo em um dispositivo iOS que esteja conectado, se
ele tiver sido instalado corretamente para desenvolvimento.

Botão de breakpoints
O botão de breakpoint controla se os breakpoints estão habilitados ou não.
Breakpoints são pontos que você pode definir em seu código, e que instruem o
depurador a fazer uma pausa no app enquanto ele estiver executando, permitindo
que você inspecione o estado do programa.
Se o botão de breakpoints estiver ativado, o depurador será interrompido em
qualquer breakpoint que for alcançado. Caso contrário, os breakpoints serão
ignorados.

Apresentação de status
A janela de status mostra o que o Xcode está fazendo no momento – gerando
seu aplicativo, fazendo download de documentação, instalando um aplicativo
em um dispositivo iOS e assim por diante.
32 Aprendendo Cocoa com Objective-C
Se houver mais de uma tarefa em progresso no momento, um pequeno botão
aparecerá do lado esquerdo, o qual permitirá que as tarefas sejam ciclicamente
apresentadas, quando clicado.

Seletor de editor
O seletor de editor determina como o editor será apresentado. Você pode optar
por mostrar somente um único editor, o editor com o assistente ou o editor de
versões, que permite comparar diferentes versões de um arquivo, caso você esteja
usando um sistema de controle de versões.

Seletor de visão
O seletor de visão (view) controla se as visões do navegador, do depurador e
de detalhes aparecem na tela. Se estiver com necessidade de espaço na tela, ou
simplesmente quiser que ela esteja menos congestionada, você pode acionar ou
dispensar rapidamente as partes da tela clicando em cada um dos elementos.

Navegador
Do lado esquerdo da janela do Xcode está o navegador (navigator), que apresenta
informações sobre seu projeto (Figura 1.7).

Figure 1.7 – Painel navegador.


Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 33
O navegador está dividido em sete abas:
• O navegador de projeto (project navigator) fornece uma lista de todos os ar-
quivos que compõem seu projeto. É o navegador mais comumente usado,
pois determina o que é mostrado no editor. O que estiver selecionado no
navegador de projeto estará aberto no editor.
• O navegador de símbolos (symbols navigator) lista todas as classes e funções
existentes em seu projeto. Se estiver à procura de um resumo rápido de
uma classe, ou quiser pular diretamente para um método dessa classe, o
navegador de símbolos será uma ferramenta muito útil.
• O navegador de buscas (search navigator) permite executar buscas pelo seu
projeto, caso você esteja procurando por um texto específico. (O atalho é
⌘-Shift-F.)
• O navegador de problemas (issue navigator) lista todos os problemas que o Xco-
de tenha percebido em seu código. Eles incluem avisos, erros de compilação
e problemas que o analisador integrado de código tenha identificado.
• O navegador de depuração (debug navigator) é ativado quando você estiver
depurando um programa. Ele permite que você examine o estado de
várias threads que compõem seu programa.
• O navegador de breakpoint (breakpoint navigator) lista todos os breakpoints
definidos por você que devem ser usados durante a depuração.
• O navegador de log (log navigator) lista todas as atividades executadas pelo
Xcode, relacionadas com seu projeto (como compilar, depurar e analisar).
Como os logs não são apagados, você pode retroceder e visualizar relató-
rios de compilações anteriores a qualquer momento.

Utilidades
O painel de utilidades (utilities pane, Figura 1.8) mostra informações adicionais
relacionadas com o que você está fazendo no editor. Se estiver editando uma
interface, por exemplo, o painel de utilidades permitirá configurar o elemento
da interface de usuário que estiver selecionado no momento.
O painel de utilidades está dividido em duas seções: o inspetor (inspector), que
mostra detalhes extras e configurações relacionados com o item selecionado
no momento, e a biblioteca (library), que é um conjunto de itens que podem
ser adicionados ao seu projeto. O inspetor e a biblioteca são mais intensamente
utilizados quando você estiver construindo interfaces de usuário. No entanto,
34 Aprendendo Cocoa com Objective-C
a biblioteca também contém vários itens úteis, como templates de arquivos e
porções de código que você pode arrastar e soltar.

Figura 1.8 – Painel de utilidades.

Área de depuração
A área de depuração (debug area, Figura 1.9) mostra informações fornecidas pelo
depurador quando o programa está sendo executado. Sempre que quiser ver
o que o aplicativo está informando quando estiver em execução, você poderá
visualizar essa informação na área de depuração.

Figura 1.9 – Área de depuração.


Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 35
A área está dividida em duas seções. A seção à esquerda mostra os valores das
variáveis locais quando uma pausa é feita no aplicativo; a seção à direita mostra
o log atual do depurador, que inclui qualquer registro proveniente do aplicativo
sendo depurado.

Desenvolvendo um aplicativo simples em Objective-C


Vamos direto ao trabalho com o Xcode. Começaremos criando um aplicativo
iOS simples e depois faremos sua conexão com o código. Se estiver mais inte-
ressado em desenvolvimento para Mac, não se preocupe – as mesmas técnicas
poderão ser aplicadas.
Esse aplicativo de exemplo mostrará um único botão o qual, quando aciona-
do, apresentará um alerta, alterando o rótulo do botão para “Test!”. Faremos a
implementação com base no aplicativo que criamos na seção “Conhecendo o
Xcode” (página 23), portanto, certifique-se de ter aberto esse projeto.
Em geral, fazer o design da interface antes, e depois acrescentar o código-fonte
é uma boa prática. Isso significa que seu código-fonte será escrito com uma
compreensão de como ele estará mapeado àquilo que o usuário vê.
Sendo assim, começaremos pelo design da interface do aplicativo.

Fazendo o design da interface


Quando estiver criando a interface de um aplicativo para iOS, você terá duas
opções. Você poderá fazer o design das telas de seu aplicativo em um storybo-
ard, o qual mostrará como todas as telas se relacionam, ou você poderá fazer o
design de cada tela separadamente. Este livro descreverá, posteriormente, mais
detalhes dos storyboards. Por enquanto, esse primeiro aplicativo terá somente
uma tela, de modo que isso não importa muito, de qualquer forma.
Comece abrindo o arquivo de interface e adicionando um botão:
1. Abra o storyboard principal. Como projetos recém-criados usam storyboards
por padrão, a interface de seu app será armazenada no arquivo MainS-
toryboard.storyboard.
Abra-o selecionando-o no navegador do projeto. O editor será alterado
para mostrar a tela única e vazia do aplicativo.
36 Aprendendo Cocoa com Objective-C
2. Arraste um botão. Adicionaremos um único botão à tela. Todos os controles
da interface de usuário são mantidos na biblioteca de objetos (object library)
que está na parte inferior do painel Details do lado direito da tela.
Para encontrar o botão, você pode fazer rolagens pela lista até encontrar
o Round Rect Button, ou pode digitar button no campo de buscas na parte
inferior da biblioteca.
Depois de tê-lo localizado, arraste-o para a tela.
3. Configure o botão. Qualquer item que você acrescentar a uma interface poder
ser configurado. Por enquanto, mudaremos somente seu rótulo.
Selecione o novo botão clicando nele e selecione o inspetor de atributos
(Attributes inspector), que corresponde à terceira aba à esquerda na parte
superior do painel Utilities. Você também pode acessá-lo pressionando
⌘-Option-4.
Modifique o campo Title do botão para Hello!

Você também pode modificar o título dando um clique duplo no botão na


interface.

Nossa interface simples agora está completa (Figura 1.10). Só falta conectá-la
ao código.

Figura 1.10 – Interface completa.


Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 37
Conectando o código
Aplicativos não são apenas interfaces – como desenvolvedor, você também deve
escrever o código-fonte. Para trabalhar com a interface que você projetou, será
necessário criar conexões entre seu código-fonte e sua interface.
Há dois tipos de conexões que podem ser feitas:
• Outlets são variáveis que se referem a objetos na interface. Ao usar outlets,
você pode instruir um botão a mudar sua cor, seu tamanho, ou a se
ocultar. Existem também coleções de outlets, que permitem criar um array
de outlets e selecionar quais objetos estão contidos em uma coleção no
Interface Builder.
• Ações (actions) são métodos em seu código-fonte, executados em resposta
a uma interação do usuário com um objeto. Essas interações incluem o
usuário tocar um dedo em um objeto, arrastar com um dedo, e assim por
diante.
Para fazer o aplicativo se comportar da maneira que descrevemos anteriormente
– acionar o botão mostrará um rótulo e alterará o texto do botão – será neces-
sário usar tanto um outlet quanto uma ação. A ação será executada quando o
botão for acionado e ela usará a conexão do outlet com o botão para modificar
seu rótulo.
Para criar ações e outlets, você deverá ter tanto o editor da interface quanto
o código-fonte correspondente abertos. Em seguida, segure a tecla Control e
arraste, partindo de um objeto no editor da interface em direção ao seu código
(ou para outro objeto no editor de interface, se quiser criar uma conexão entre
dois objetos de sua interface).

A palavra interface tem duplo significado na programação em Cocoa. Ela


se refere tanto à GUI que você projeta quanto aos métodos e propriedades
expostos publicamente, disponibilizados pelas classes em Objective-C. Para
mais informações sobre esse segundo significado, consulte “Interfaces e
implementações” (página 43).

Criaremos agora as conexões necessárias:


1. Abra o assistente. Para isso, selecione a segunda aba no seletor de editor na
barra de ferramentas. O assistente deve mostrar o código correspondente
à interface ViewController.h. Se isso não ocorrer, clique no pequeno ícone
38 Aprendendo Cocoa com Objective-C
em forma de smoking (que representa o assistente) e navegue para
Automatic→ViewController.h.
2. Crie o outlet do botão. Segure a tecla Control e arraste do botão para o espaço
entre as linhas @interface e @end no código-fonte. Uma janela pop-up apa-
recerá. Deixe tudo como está, mas mude o campo Name para helloButton.
Clique em Connect. Uma nova linha de código aparecerá: o Xcode criou a
conexão para você, que aparecerá em seu código-fonte na forma de uma
propriedade de sua classe.
3. Crie a ação do botão. Segure a tecla Control e, novamente, arraste do botão
para o espaço entre as linhas @interface e @end no código. Uma janela pop-
-up aparecerá novamente.
Dessa vez, mude o campo Connection de Outlet para Action. Mude o campo
Name para showAlert. Clique em Connect. Uma segunda linha de código
aparecerá: o Xcode criou a conexão, que é um método dentro da classe
ViewController.

4. Abra ViewController.m selecionando-o no navegador do projeto. Você pode querer fe-


char o assistente selecionando a aba mais à esquerda no seletor de editor
na barra de ferramentas.
5. Role para baixo até o método showAlert: Você o encontrará na parte inferior do
arquivo.
6. Insira o novo código. Selecione o método todo e apague-o. Substitua-o pelo
código a seguir:
- (IBAction)showAlert:(id)sender {
UIAlertView* alert = [[UIAlertView alloc] initWithTitle:@"Hello!"
message:@"Hello, world!"
delegate:nil
cancelButtonTitle:@"Close"
otherButtonTitles:nil];
[alert show];

[helloButton setTitle:@"I was clicked!" forState:UIControlStateNormal];


}

Esse código cria uma UIAlertView, que mostra uma mensagem ao usuário em
uma janela pop-up. Ele a prepara configurando seu título para "Hello" e o texto
dentro da janela para “Hello, world!” O alerta é, então, apresentado ao usuário.
Por último, o botão tem seu texto alterado para “I was clicked!”
Capítulo 1 ■ Ferramentas de desenvolvimento do Cocoa 39
O aplicativo está pronto para ser executado. Clique no botão Run no canto su-
perior esquerdo. O aplicativo será iniciado no simulador de iPhone.

Caso você, por acaso, tenha um iPhone ou um iPad conectado ao seu


computador, o Xcode, por padrão, irá tentar iniciar o aplicativo no dispositivo,
em vez de iniciá-lo no simulador. Para o Xcode utilizar o simulador, vá ao menu
Scheme no canto superior esquerdo da janela e altere o esquema atualmente
selecionado para o simulador.

Quando o app acabar de ser carregado no simulador, toque no botão. Um alerta


aparecerá; quando você fechá-lo, também perceberá que o texto do botão será
alterado.

Usando o iOS Simulator


O iOS Simulator (Figura 1.11) permite que você teste aplicativos iOS sem a
necessidade de ficar lidando com dispositivos. É uma ferramenta útil, mas
tenha em mente que o simulador e um dispositivo de verdade se comportam
de maneiras bem distintas.

Figura 1.11 – O iOS Simulator.


40 Aprendendo Cocoa com Objective-C
Para começar, o simulador é muito mais rápido do que um dispositivo de ver-
dade, e tem muito mais memória. Isso ocorre porque o simulador faz uso dos
recursos de seu computador. Se você estiver gerando um aplicativo que faz uso
intenso de processamento, ele terá uma execução muito mais suave no simulador.
O iOS Simulator é capaz de simular quatro diferentes tipos de dispositivo:
dispositivos com display Retina do tamanho do iPhone (o que inclui todos os
iPhones e iPod touches vendidos em 2012 e posteriormente); dispositivos sem
display Retina do tamanho do iPhone (todos os iPhones e iPod touches até o
lançamento do iPhone 4, em 2010); e o iPad e iPad mini (começando pelo iPad
de terceira geração, lançado em 2012).
Para mudar o dispositivo, abra o menu Hardware, selecione Device e escolha o
dispositivo que você deseja simular.
Você também pode simular eventos de hardware, como o botão home (tela
inicial) sendo pressionado ou o iPhone sendo bloqueado. Para simular o acio-
namento do botão home, clique no botão virtual na parte de baixo da tela e
selecione Hardware→Home ou pressione ⌘-Shift-H. Para bloquear o dispositivo,
pressione ⌘-L ou selecione Hardware→Lock.

Se não houver espaço na tela, o simulador não mostrará os botões de hardware


virtuais. Portanto, se quiser simular o botão home sendo pressionado, será
necessário usar o atalho de teclado ⌘-Shift-H.

Há diversos recursos adicionais no simulador, os quais examinaremos com


mais detalhes à medida que se tornarem relevantes às várias partes do iOS que
serão discutidas.