DESENVOLVIMENTO DE APP PARA IOS...

DESENVOLVIMENTO DE APP PARA IOS !1

Índice

Aviso Legal………………………………………………………………………………3

Meus Canais……………………………………………………………………………..4

Introdução ………………………………………………………………………………5

Como utilizar este livro …………………………………………………………………7

Desenvolvimento Híbrido e Nativo para iOS……….…………………………………..8

A IDE .…………………………………………………………………………………..9

Linguagem e projeto …………………………………………………………………..13

Básico de Swift..………………………………………………………………………..18

View Controllers ………………………………………………………………………21

Segues …………………………………………………………………………………24

Camera e Fotos ………………………………………………………………………..27

Localização ……………………………………………………………………………29

Mapas …………………………………………………………………………………33

Considerações finais …………………………………………………………………..36


Aviso Legal

A produção deste livro exigiu muito trabalho e tempo de dedicação exclusiva de minha parte. Também investi muito tempo e dinheiro para adquirir este conhecimento, que agora busco formatar de forma que outras pessoas possam atingir o mesmo de forma mais rápida e prática.

Este é o sentido do trabalho: Você emprega sua energia e seus recursos para produzir algo que facilitará a vida de outras pessoas. Em troca, você será remunerado de forma que pode utilizar este pagamento como meio de troca para usufruir das facilidades produzidas pelo trabalho de ainda mais pessoas.

Você aprenderá a desenvolver aplicativos para iOS mais rápido se tiver a ajuda e acompanhamento de pessoas que já passaram por esse processo antes, evitando perder tempo com caminhos que não funcionam e focando naquilo que já foi testado e aprovado.

Atualmente este livro está sendo distribuído de forma inteiramente gratuita, mas peço que não altere ou extraia partes deste material para que seja distribuído de outras formas.

O download deve ser feito de nosso canal oficial (www.congressodemobile.com.br/livro-ios/).

Caso goste do livro, recomende que seus amigos façam o download através de nosso website!


http://www.congressodemobile.com.br/livro-ios/

Meus Canais

Possuo alguns canais na internet onde publico dicas de desenvolvimento Mobile , vídeo-aulas e outros conteúdos para ajuda-lo nesta jornada. Acompanhe todos para receber as novidades e ficar sabendo sobre os programas.

Blog

http://congressodemobile.com.br/blog

Canal do Youtube

https://www.youtube.com/channel/UC2KkjDLb0U9ULyhup-rQIzg

Pagina do Facebook

https://www.facebook.com/CongressodeMobile

Snapchat

https://www.snapchat.com/add/filipetb


http://congressodemobile.com.br/blog

https://www.youtube.com/channel/UC2KkjDLb0U9ULyhup-rQIzg

https://www.facebook.com/CongressodeMobile

https://www.snapchat.com/add/filipetb

Introdução

Quando o meu interesse pelo desenvolvimento mobile começou eu ainda estava na faculdade, entre 2010 e 2012, se ouvia falar do “boom” que foi o aplicativo Angry Birds da Rovio Entertainment e de outros apps de empresas bilionárias como a Zynga, também foram anos que tive conhecimento de aplicativos, hoje bilionários, como Instagram e WhatsApp.

Através do conhecimento de notícias de diversos cases de sucesso, alguns até muito simples, eu fiquei curioso e estimulado a conhecer mais sobre o desenvolvimento de aplicativos, principalmente para iOS, pois pesquisas apontavam que apesar da maioria dos usuários se concentrarem nas plataformas Android, os usuários do iOS tendem a gastar mais dinheiro com aplicativos do que os dos demais, eram diversos os cases de empresas que a maior parte do seu faturamento vinha dos aplicativos para iOS.

Conforme eu aprendia mais desenvolvimento de aplicativos para iOS, mais eu ficava interessado no mundo mobile, mais cases de startups de sucesso apareciam, mais oportunidades batiam na minha porta, contratações para desenvolvimento de aplicativos iOS, propostas de sociedade para desenvolver ideias e mais. Chegando assim a compreender os verdadeiros benefícios e possibilidades que esse conhecimento proporciona.

Nem tudo foram flores em minha jornada para aprender a desenvolver aplicativos mobile. A carência de materiais bem formatados e completos publicados no Brasil é grande até hoje. Mesmo na internet, quando comecei, não se encontrava conteúdos em português, sendo que mesmo hoje ainda se encontram poucos, além de que são extremamente raros os conteúdos estarem atualizados, ainda mais agora com novas versões do Swift, linguagem hoje utilizada para desenvolver aplicativos iOS, e com o fim do Parse, backend as a service mais utilizado do mundo.


Esse cenário jamais vai mudar sem a profissionalização do ensino de desenvolvimento mobile no país. É por isso que hoje eu empreendo neste mercado, produzindo conteúdo e oferecendo cursos completos para o mercado mobile.

É com muito orgulho que publico este material como forma de deixar a minha contribuição para os brasileiros futuros profissionais, empreendedores e professores do mercado mobile.

Investir no aprendizado de desenvolvimento de aplicativos para iOS vale muito a pena. Em 2015 a apple anunciou que alcançou a marca dos 100 Bilhões de downloads de aplicativos na sua loja, a App Store. Segundo pesquisas realizadas em 2015 pela companhia de análise App Annie, os aplicativos disponíveis na App Store geram 75% mais receita do que os disponíveis na Play Store.

Ainda estamos vivenciando o “Boom” da era mobile, são inúmeras as oportunidades nesse mercado, a carência por profissionais qualificados só aumenta, o mesmo pode se dizer quanto ao surgimento de startups de sucesso.

Segundo matéria publicada na revista Pequenas Empresas & Grandes Negócios em fevereiro de 2016, 1 Bilhão de dólares é a previsão de investimento em publicidade para mobile no Brasil em 2016. O valor pode ultrapassar 2,5 bilhões de dólares até 2018, além de 40% foi o aumento no número global de instalações de aplicativos desenvolvidos por brasileiros entre dezembro de 2014 e dezembro de 2015. O ritmo foi superior ao de mercados com tradição em apps, como EUA, Alemanha e Inglaterra. O mercado está cada vez melhor e mais aquecido.

Este livro foi escrito de forma que uma pessoa que não sabe absolutamente nada sobre desenvolvimento mobile possa entender como é que ele funciona. Você poderá aprender rapidamente o que demoraria um bom tempo “pulando de galho em galho” por diferentes websites em inglês na internet ou através dos poucos livros disponíveis, na sua maioria desatualizados, no mercado.

Espero que você faça bom proveito e que em breve possa me enviar o seu relato, contando sobre o seu avanço no desenvolvimento de aplicativos para iOS!

Um grande abraço, Filipe Torres


Como utilizar este livro

Você pode utilizar este livro de duas formas. A primeira é ir com calma, absorvendo profundamente cada um dos tópicos abordados, buscando entender todas as possíveis dúvidas. Dessa forma, é importante que você aplique o conhecimento na medida que for aprendendo. Familiarize-se com o ambiente de programação, com o IDE Xcode e com a linguagem Swift praticando no seu próprio computador. Em seguida aprenda os conceitos do desenvolvimento iOS e seus componentes, é sempre importante você por em prática cada passo aprendido, dessa maneira você fixará melhor o conteúdo, sanará eventuais dúvidas e estará melhor preparado para desenvolver seu aplicativo.

A segunda maneira seria prosseguir mesmo que ainda não tenha dominado por completo um assunto. Isto em um primeiro momento, pode parecer estranho, mas o fato é que o nosso conhecimento não é construído de forma linear. A familiarização com uma nova linguagem de programação se da com o tempo e com o contato que temos com ela, então na medida que avançamos o conteúdo a prática com a linguagem vai aumentando. Se você ler o livro inteiro mesmo sem absorver 100% do conteúdo, ao começar de novo e voltar nas partes anteriores, você terá uma visão diferente do conteúdo, compreendendo coisas que antes não havia compreendido e também tendo novas percepções.

Você também pode utilizar este livro como um guia, caso esteja desenvolvendo um aplicativo, ou apenas estudando, e queira realizar consultas. Os capítulos do livro possuem materiais de consulta e que podem ser muito úteis quando você precisar relembrar de algum procedimento necessário para solucionar a parte do seu aplicativo que você estiver desenvolvendo.

Lembre-se que para aprender a desenvolver bons aplicativos, todo conteúdo novo é válido. Não tenha pressa, leia com calma e fique à vontade para utilizar outros materiais e outras fontes como complemento.


Desenvolvimento Híbrido e Nativo para iOS

Existem basicamente duas formas de desenvolver aplicativos para iOS, através de desenvolvimento Nativo e Híbrido.

Desenvolvimento nativo, que será o tipo de desenvolvimento abordado neste livro, significa dizer que o aplicativo foi desenvolvido no próprio ambiente da apple, utilizando seu IDE (Xcode) e suas linguagens (Objective-C ou Swift). Ao se desenvolver um aplicativo nativamente temos acesso a APIs nativas do próprio sistema operacional, dessa forma desenvolvemos um aplicativo específico para aquela plataforma, ganhando em performance e customizações. Desenvolver um aplicativo nativamente também tem outras vantagens, até mesmo em relação ao mercado mobile, mas não é o meu objetivo com este livro aprofundar nesse assunto.

Quanto ao desenvolvimento híbrido, temos um ambiente de desenvolvimento diferente do disponibilizado pela empresa responsável pela plataforma, no nosso caso a Apple. Geralmente a linguagem usada nesse tipo de desenvolvimento é o JavaScript, que por sua vez acaba se assemelhando bastante com o desenvolvimento web. Existem vários ambientes e frameworks, como ionic, para se desenvolver híbrido. Desenvolvimento cuja vantagem é que desenvolvemos o aplicativo somente uma vez, em uma linguagem, e exportamos para várias plataformas, economizando tempo de desenvolvimento. A suas principais desvantagens são a queda de performance e customização, uma vez que exportado para a plataforma desejada, seu aplicativo vai rodar dentro do core do browser da plataforma, como se fosse um aplicativo web. Além de que o projetos híbridos tendem a valer menos do que nativos.

Bom, não é meu objetivo comparar os dois tipos de desenvolvimentos e sim mencionar as duas possibilidades. Neste livro, abordaremos o desenvolvimento nativo, utilizando o Xcode 7 como IDE, programando na linguagem de programação mais atual da Apple no momento que escrevo este livro, o Swift 2.2.


A IDE

A IDE da apple se chama Xcode, no momento em que escrevo este livro a sua ultima versão é a 7, e ele é o ambiente de desenvolvimento da apple que nos permite desenvolver aplicativos para iOS. O Xcode é basicamente a única ferramenta necessária, nele você encontra um excelente Editor, Debugger, gerenciador de código fonte, simulador, SDKs e mais. Existe também o Instruments que você pode adicionar ao Xcode para fazer algumas coisas extras como gerenciar a performance, por exemplo, mas não vem ao caso.

O Xcode é gratuito e você pode baixa-lo na App Store para Mac, então você precisa de um Mac ou de uma máquina virtual com o Mac OS para desenvolver aplicativos para iOS.

Ao abrir o Xcode a primeira tela que nos deparemos é esta a seguir:

Explicando rapidamente essa tela, temos:


1. Aqui você acessa o playground. O Playground é basicamente uma ferramenta que te permite desenvolver uma parte ou outra do aplicativo para iOS ou mesmo brincar com o Xcode sem precisar dar “biuld” e simular no iOS Simulator. É uma ótima ferramenta para fins de testes de código e até mesmo para aprender a linguagem Swift. Se você é completamente iniciante no desenvolvimento iOS sugiro que brinque um pouco com o playground.

2. Aqui criamos um projeto Xcode do zero, é aqui que começamos quando vamos desenvolver um novo aplicativo.

3. Nessa opção você pode checar se tem alguma projeto já existente em um repositório remoto, o Xcode se integra bem com ferramentas de versionamento de software como git, por exemplo, para trabalhar com times de desenvolvimento.

4. Essa parte mostras os projetos já existentes, caso você queira continuar algum de onde parou.

Ao apertar na opção 2, criar um novo projeto Xcode, a seguinte tela aparece:


Observe que no menu lateral temos a possibilidade de desenvolver aplicativos para iOS, watchOS, tvOS, OS X e outros. Então devemos ir no item iOS e selecionar o sub-item Application.

Então aparecerão as opções para escolhermos o tipo de projeto que queremos, a menos que você vá desenvolver um game, é comum sempre começarmos com o Single View Application, pois é o tipo de projeto com menos coisas e a partir dele podemos criar todos os outros, então adequamos de acordo com nossas necessidades.

Na próxima tela você deve digitar o nome do aplicativo que você está desenvolvendo, em Organization Name é o que vai aparecer no Copyright (quem desenvolveu), você pode por o que quiser nesse campo, entretanto, no Bundle Identifier deve ser um identificador único, uma boa maneira de você fazer isso é colocar em notação DNS reversa, por exemplo, br.com.congressodemobile.filipetorres. Note que coloquei o domínio do meu site ao contrário e por fim adicionei o meu nome. Em seguida devemos escolher a linguagem Swift e escolher se devemos criar o nosso aplicativo para iPhone e iPad ou para somente um dos dois. Pressione Next e selecione a pasta onde você quer salvar o projeto.

Feito isso o ambiente de programação do Xcode é enfim aberto.


Não quero estender muito a explicação sobre o Xcode em si, se não o livro vai ficar muito extenso e meu objetivo é simplificar ao máximo.

Então para finalizar este capítulo, vamos explicar a imagem de maneira bem resumida:

1. Configurações básicas do projeto.

2. Navegador, serve para navegarmos pelo nosso projeto, é onde podemos ver os arquivos do nosso projeto, pesquisar por eles, ver erros e avisos do compilador e breakpoints.

3. Inspetor, nos permite analisar e editar componentes selecionados na janela principal, geralmente do arquivo Main.storyboard.

4. Tela onde ficarão componentes disponíveis para arrastarmos para tela principal no Main.storyboard e utilizarmos no nosso projeto, componentes como botões, campos de texto, etc.


Linguagem e projeto

A linguagem atualmente utilizada para se desenvolver aplicativos para iOS é a Swift, que está na versão 2.2, ainda é possível utilizar Objective-C, antiga linguagem utilizada pela Apple, porém o suporte para a mesma foi descontinuado.

A linguagem Swift é orientada a objetos, ou seja, possui classes, métodos, herança e outros conceitos de linguagem orientada a objetos. Mas fique tranquilo, se você nunca programou alguma linguagem com orientação a objetos isso não te impede de aprender a linguagem, com a prática você vai aprendendo os conceitos.

O Xcode é projetado para você desenvolver seu projeto no padrão MVC (Model, View e Controller), porém, apesar de recomendado, não necessariamente você precisa seguir esse padrão de projeto, então, para não complicar muito, em outra oportunidade lhe ensinarei desenvolvimentos de projetos em Swift no padrão MVC.

Vamos então continuar com o raciocínio inicial do livro e simplificar as coisas. Vou, antes de estudarmos a linguagem, mostrar como funciona um projeto iOS no Xcode.

No menu lateral esquerdo, no navegador, você deve encontrar o arquivo Main.storyboard, é nele que construimos as telas do nosso aplicativo, em outras palavras, toda a parte visual fica ali, e ela é construída simplesmente arrastando os componentes do item 4 da imagem anterior, do capítulo passado, para a tela desejada com o próprio mouse.

Assim que criamos um projeto temos o arquivo ViewController.swift. Se abrirmos ele veremos que tem uma classe de nome ViewController (mesmo nome do arquivo) e essa classe herda a classe UIViewController, isso quer dizer que podemos utilizar as funções e propriedades da classe herdada, esta no caso é responsável por gerenciar os eventos que ocorrem na tela.


Como você pode ver na imagem o arquivo já vem com duas funções dentro da classe ViewController, essas funções são da classe UIViewController e estão sendo sobrescritas, por isso o “override”. Isso significa dizer que estamos sobrescrevendo, ou seja, “escrevendo por cima” do método original na UIViewController, então quando esse método for chamado, vai ser executado o código que sobrescrevemos.

Como meu objetivo não é ensinar conceitos de programação orientada a objetos e sim fazer com que você tenha compreensão básica do desenvolvimento de aplicativos para iOS, vamos dar continuidade.

Esta classe, ViewController, já vem linkada com a view(tela) inicial presente no Main.storyboard, então podemos capturar e gerenciar os eventos que ocorrem nessa view dentro dessa classe. A função viewDidLoad, por exemplo, é disparada quando a view acabou de ser carregada, então podemos colocar códigos nessa função para serem executados nesse evento.

Bom, vamos então criar o nosso “Hello World”.

Primeiro vamos montar nossa UI, que será apenas a tela inicial com um botão e uma label (rótulo). Então devemos apenas encontrar os componentes e arrastar para a tela. Segue a imagem com os passos para construir nossa UI:


Escolhemos um botão e arrastamos para o lugar da tela de nossa preferencia, em seguida fizemos o mesmo procedimento com a label.

Ao selecionar componentes na nossa view, no caso o botão ou a label, podemos mexer nas propriedades dele no inspetor, tais como título, fonte, tamanho, cor, etc.

Depois de ajustados os elementos na tela, devemos “linkar” esses elementos ao nosso código. Para isso devemos clicar no botão “Show Assistant Editor” localizado no canto superior direito como demonstrado na figura abaixo.

Uma vez clicado no botão, o Xcode abre na janela principal dois arquivos ao mesmo tempo, nesse caso o Main.storyboard e o ViewController.swift. Para selecionar o arquivo que deve ser aberto na parte esquerda basta clicar no arquivo desejado no navegador, já o arquivo da parte direito você deve clicar no arquivo desejado no navegador segurando a tecla option.

O próximo passo é realizar a “linkagem” de fato, fazemos isso segurando a tecla control, clicando no botão na tela do Main.storyboard e arrastando para o código, dentro da nossa classe, no ViewController.swift. Ao fazermos isso, temos a imagem a seguir:


Na imagem acima temos uma janelinha que apareceu para configurarmos o tipo de “linkagem” que queremos. Como na imagem acima estamos linkando o botão e o nosso interesse é capturar o evento quando o mesmo for pressionado, devemos mudar para Action no item Connection. Devemos ainda definir o nome da nosso método, no caso eu defini como touchHello. Observe também que mudei o Type para UIButton, isso é opcional, apesar de recomendado, uma vez que estamos lidando com um botão.

Devemos fazer o mesmo procedimento de “linkagem” com a label, porém, com a label o item Connection vai ser Outlet. Isso porque queremos manipular as propriedades da nossa label, como por exemplo seu texto. A opção Action é somente para eventos, que no nosso projeto é usado para o evento de clique do botão.

Uma vez linkado os componentes, podemos voltar para a visualização normal, clicando em Standard Editor, botão do lado do Assistant Editor, e selecionando o arquivo ViewController.swift no navegador.

Agora de fato vamos codificar o nosso “Hello World”. Para exibir no console podemos usar a função print() e para exibir na label que colocamos na tela devemos acessar o nosso outlet que criamos ao “linka-la”. Isso é feito da seguinte forma: self.nomeDoOutletQueDefinimos.text. Segue a imagem final:


Excelente, construímos nosso “Hello World”, basta agora executar, clicando no botão play, no canto superior esquerdo.

PS: Ao executar, o Xcode vai fazer a biuld do seu projeto em seguida simular seu aplicativo no simulador, por padrão ele abre o iPhone 6s Plus, mas se seu computador não tem muita memória eu recomendo que troque para o iPhone 5s. Essa opção está localizada também na parte superior esquerda, porém mais próximo do centro.

A imagem acima representa o aplicativo Hello World sendo rodado no simulador após termos clicado no botão Say Hello!, observe que o texto da label foi alterado para Hello World.

PS: A posição do botão e da label foi alterado para o topo da tela para que a imagem capturada do simulador ficasse menor.


Básico de swift

Neste capítulo eu quero lhe apresentar a sintaxe da linguagem Swift com o objetivo que você adquirira a base e com o tempo ir se familiarizando.

A sintaxe do Swift, de maneira geral, é bem simples. Para lhe apresentar a sintaxe eu vou utilizar um projeto do playground, também sugiro que o utilize e pratique bastante.

Variáveis e Constantes Existem duas formas de se declarar variáveis e constantes, a explícita e a implícita.

Ates de demonstrar cada uma preciso dizer que variáveis são seguidas por var quando declaradas, já constantes por let.

Declaração explícita é onde definimos explicitamente o tipo de dado que a variável ou constantes é na declaração, por exemplo: var altura : Float. Nesse exemplo declaramos explicitamente a variável altura como do tipo Float.

Declaração implícita se faz ausente o uso do tipo de dado na declaração da variassem ou constante, por exemplo: let minutosEmUmaHora = 60. Nesse exemplo estamos declarando implicitamente uma constante do tipo Int, pois ao atribuirmos o valor 60, automaticamente o compilador considera minutosEmUmaHora uma constante do tipo inteiro.

Segue a imagem de testes realizados no Playground do Xcode:


Arrays Se você já programou em qualquer outra linguagem deve estar mais que familiarizado que essa estrutura de dados. Array nos permite armazenar uma coleção de dados do mesmo tipo em uma variável. No Swift, existem 3 formas de se declarar um Array, sendo duas delas explícitas e uma implícita. Segue a image exemplo:

A linguagem nos dispões também de várias operações que podemos realizar com Arrays, como por exemplo .append(), insert(), removeLast(), que serve para adicionar um elemento ao final do array, inserir um elemento na posição desejada e remover o ultimo elemento do array, respectivamente. Existem várias outras operações, você pode dar uma olhada na documentação da apple, pelo próprio Xcode, para mais detalhes.

Dicionários e Tuplas Um dicionário armazena uma coleção não ordenada de valores. Cada valor no dicionário está associado a uma chave. Em outras palavras, um dicionário armazena um número de pares chave/valor.

Como os Arrays, as chaves e os valores armazenados em um dicionário precisam ser do mesmo tipo. Isto significa que se você pergunta a um dicionário por um valor de uma chave em particular, você sabe que tipo o dicionário irá retornar. Salvo quando o tipo de dado é AnyObject, mas não vem ao caso mencionar.

Já as Tuplas, apesar de serem similares a Arrays e Dicicionários, a principal diferença é que os valores armazenados em uma tupla não precisam ser do mesmo tipo. Segue a imagem exemplo simulada no playground:


Concatenação e Interpolação Muitas vezes se faz necessário mostrar valores em forma de String, seja no console ou na própria tela. Para isso, podemos usar de concatenação ou interpolação.

Para concatenarmos valores a uma String, basta usarmos o operador +, por exemplo: var livro = "Desvendando " + tupla.1 teria como resultado “Desvendando iOS”.

É recomendado que usemos interpolação na maior parte das vezes, pois podemos interpolar várias vezes e diferentes tipos de dados na mesma String. Fazemos isso através do operador \(), por exemplo: var escrevendo = "Desvendando \(tupla.1) em \(dict[“dia"]!) de \(mes)” teria como resultado “Desvendando iOS em 2 de Junho”.

if, for, foreach e while A estrutura de decisão if se assemelha a outras linguagens como C e Java, com a diferença que não precisa de parênteses para a condição, sendo assim, algo como: if altura > 1.8 { } é aceito normalmente pelo compilador.

Já a estrutura de repetição for era igual ao C(for(int i = 0; i< 10, i++)), porém com atualizações da linguagem, a estrutura se encontra deprecada na versão 2.2 e será removida na versão 3 do Swift. Um for em Swift agora deve ser feito da seguinte maneira: for i in 0…9 { }.

A linguagem Swift acaba que dando suporte ao foreach, estrutura de repetição encontrara em linguagens como PHP, por padrão. O foreach fica do mesmo jeito do for normal: for direcao in direcoes { }.

O while ainda é o mesmo do C e Java, com a mesma diferença do if, não necessário por parênteses: while altura < 1.9 { altura += 0.1 }.

Classes e Structs No Swift temos estruturas do tipo class e struct, elas funcionam como qualquer classe de linguagens orientadas a objetos. Basicamente a principal diferença entre as duas estruturas é que structs são passadas por valor enquanto classes são passadas por referência. Isso quer dizer que se eu atribuir uma instancia de classe a uma segunda classe, a mesma é passada por referencia, então todas as alterações que eu fizer na segunda classe também ocorrerão na primeira, enquanto com structs não, as alterações afetariam somente a segunda.


View Controllers

Logo no inicio desse livro criamos um projeto básico que já iniciava com uma View

Controller e aprendemos que para cada view(tela) existe um arquivo .swift com uma

classe que a controla / gerencia.

Na maioria dos casos são utilizados 2 tipos de ViewController’s, a própria View

Controller que é gerenciada por uma classe do tipo UIViewController (a que

utilizamos no nosso primeiro projeto) e a Table View Controller que é gerenciada

por uma classe do tipo UITableViewController.

Table Views são encontradas em praticamente todos os aplicativos disponíveis hoje e

são uma parte integrante e bem importante na experiência do usuário na plataforma

iOS. Table Views fazem apenas uma coisa e fazem muito bem, mostrar uma lista

ordenada de itens.

Table Views são componentes bem complexos e requer muito conteúdo para explica-

los. Para não deixar o livro muito extenso, não abordarei sobre Table View’s aqui.

Então caso queira saber mais como trabalhar com Table Views eu sugiro que se

inscreva no meu canal do youtube (http://bit.ly/ytbookios), pois postarei aulas em

video no canal sobre esse componente e mais.

Em um projeto de aplicativo muito provavelmente precisamos trabalhar com várias

telas, ou seja, teremos mais de uma View Controller e o usuário deve navegar entre elas.

Existem 3 maneiras de combinar View Controllers, fazemos isso através de Tab Bar

View Controller, Split View Controller e Navigation View Controller.

Quando um conteúdo precisa ser distribuído em várias telas, Navigation Controller é

geralmente a opção escolhida. O que faz o Navigation Controller ser especial é que ele

cria e gerencia uma hierarquia de View Controllers, muitas vezes referida como uma

pilha de navegação. O Navigation Controller gerencia várias subviews, incluindo uma


http://bit.ly/ytbookios

barra de navegação no topo que lhe permite voltar para a tela anterior ou ir para uma

próxima tela.

A imagem abaixo representa a Main.storyboard com Navigation Controller:

Segue o projeto em execução:

Note que podemos navegar entre duas ou mais telas, no exemplo, ao clicarmos no botão

Hello, vamos para a tela seguinte e automaticamente aparece o botão Voltar para a tela

anterior.

Tab Bar Controllers também gerenciam um array de View Controllers, a grande

diferença é que uma view(tela) em uma Tab bar Controller não necessariamente precisa

ter uma relação com outra, como tem no Navigation. Tab Bar Controllers são ótimos

para tarefas diferentes, que não tem relação entre si, no mesmo aplicativo.


O aplicativo relógio do iOS é um exemplo de uso de Tab Bar Controller, acessamos as

diferentes telas do aplicativo clicando nos ícones na barra de navegação na parte

inferior do aplicativo. Outros exemplos de aplicativos famosos que utilizam Tab Bar

Controller são o Instagram, Facebook e o Whatsapp.

Criarei video aulas no meu canal do youtube sobre os 3 componentes responsáveis por

combinar View Controllers(TabBar, Navigation e Split), então se inscreva agora no meu

canal do youtube: http://bit.ly/ytbookios.



Segues

Segues (pronuncia-se “Sé-gu-eis”) são responsáveis pelas transições entre View

Controllers. Como vimos no capítulo passado, podemos combinar várias Views através

de alguns componentes, mas quem realiza de fato a transição entre elas, são as Segues

(elas representam as setas que partem de uma tela para outra no Main.storyboard).

Tipos de Segues:

Show Segue, são chamadas em Navigation Controllers, também usamos quando

queremos apenas fazer uma transição de uma view para outra, sem combina-las.

Show Detail Segue, são usadas em Split Views, quando você tem algo na master e

quer mostrar mais informações no detail, é essa a segue usada, daí o nome dela. Esse

tipo de Segue também funciona no Navigation Controller.

Modal Segue, basicamente joga uma tela, que ocupa todo o campo visual, em cima da

atual.

Popover Segue, parecido com o Modal Segue, com a diferença que a tela que é

jogada em cima não ocupa todo o campo visual, somente uma parte da tela e você pode

clicar fora dela para fecha-la.

As Segues mais usadas são geralmente Show e Show Detail, já a Modal não é tão

comum, uma vez que essa transição não é adequada em muitos casos. Popover tem um

visual melhor em iPad’s e iPhone’s Plus, uma vez que são aparelhos de telas maiores,

mas com um pouco de configuração você consegue o mesmo efeito em aparelhos

menores.

Para fazer uma uma Segue é bem fácil, na sua storyboard basta segurar a tecla control,

clicar no botão ou componente que você deseja que realize a transição e arrastar para a

tela para qual ele deve realizar a transição.

Na imagem a baixo temos uma Split View Controller, onde a View da calculadora é a

Master e o gráfico a Detail. Estamos criando uma Segue do botão da calculadora para a

tela do gráfico.


Após esse procedimento, vai aparecer uma janela para escolhermos o tipo de Segue que

desejamos, nessa caso, como se trata de uma Split View, iremos escolher a Show Detail.

Feito isso, a Segue deve aparecer na tela. O próximo passo é clicar na Segue, ir no

inspector e definir um Identifier para ela. Identifier é um nome único que você deve

da para sua Segue de modo que você possa acessa-la via código.

Ta, mas onde usaremos esses Identifiers no nosso código? É isso que falaremos a seguir,

abordando alguns métodos e eventos que os utilizam:

func performSegueWithIdentifier(identifier: String, sender: AnyObject?)

Nesse método, realizamos a transição via código, passando o Identifier da Segue no

parâmetro identifier e você pode passar qualquer objeto como o sender, que é o objeto/

componente que está causando a transição.

func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?)

Esse evento é disparado automaticamente, na própria View Controller da tela que está

causando a transição, quando uma transição vai ocorrer. Ele serve para prepararmos a


próxima tela, para qual será realizado a transição, enviando informações que sejam

necessárias.

func shouldPerformSegueWithIdentifier(identifier: String?, sender:

AnyObject?) -> Bool

Esse evento também é disparado automaticamente na própria View Controller que está

causando a transição. Assim como o prepareForSegue, você deve implementa-lo na

classe para utiliza-lo. Nesse método você pode fazer com que a transição não ocorra

dependendo de uma condição, para isso basta retornar false.


Câmera e Fotos

Tanto a câmera quanto a biblioteca de fotos são acessadas através da classe chamada

UIImagePickerController, que nada mais é do que uma UIViewController. É bem

simples de usar, você precisa apenas configurar e mostra-la na tela de forma modal.

Vamos então aos passos para uso:

1. Crie uma instancia e defina um delegate (não é possível fazer nada sem definir

um delegate, que pode ser a própria View Controller).

2. Configure ( Definir se vai ser a câmera ou a biblioteca de fotos que será mostrada,

se permite edição, tipo de mídia (foto ou vídeo), etc).

3. Mostre na tela, isso é feito através do método presentViewController().

4. Responder aos métodos do delegate que são disparados quando o usuário faz

alguma ação específica.

Definimos o que de fato vai aparecer na UIImagePickerController na etapa de

configuração onde definimos o Source Type do objeto instanciado.

Source Types podem ser:

UIImagePickerControllerSourceType.SavedPhotosAlbum - Rolo da Câmera

UIImagePickerControllerSourceType.PhotoLibrary - Biblioteca de Fotos

UIImagePickerControllerSourceType.Camera - Câmera

A Apple recomenda que perguntemos, no nosso código, à plataforma se o Source Type

que temos interesse em utilizar está disponível, pois pode não ter disponibilidade em

algumas plataformas. Fazemos isso através do método estático, da classe

UIImagePickerController, .isSourceTypeAvailable(sourceType) -> Bool.

Também é recomendado checar as mídias disponíveis (foto e/ou vídeo), fazemos isso

através do método estático .availableMediaTypesForSourceType(sourceType) ->

[String]? da classe UIImagePickerController. Isso nos permite distiguir uma câmera que

pode gravar vídeo de uma que que pode somente tirar fotos, por exemplo. Isso é


importante pois além de algumas plataformas não darem suporte o próprio usuário

pode negar permissão.

Na imagem acima, capturamos o evento de tap do botão (da mesma forma que fizemos

no inicio desse livro no projeto inicial “Hello World”) com o método importImages.

Dentro desse método instanciamos uma UIImagePickerController, atribuímos seu

delegate a nossa própria ViewController (Para isso, nossa view deve implementar as

classes UIImagePickerControllerDelegate e UINavigationControllerDelegate), em

seguida verificamos a disponibilidade do Source Type que desejamos utilizar (Biblioteca

de fotos, nesse caso), se disponível, definimos o Source Type e por fim mostramos a tela

de seleção de fotos da biblioteca.

Os outros dois métodos são métodos do delegate, o primeiro é disparado quando o

usuário terminou de escolher a imagem e nesse caso capturamos a imagem escolhida e

atribuímos à imagem da imageView da nossa classe, já o segundo é disparado caso ele

cancele a seleção de imagens.


Localização

Localizações no iOS são definidas através do Core Location. Vamos então aborda-lo a

seguir.

Core Location é um framework para gerenciar a localização do dispositivo e sua

direção. Não há user interface no Core Location e o objeto que que o representa é o

CLLocation e tem propriedades como coordenadas, altitude, velocidade, direção, etc.

Importante, para trabalharmos com localização precisamos importar o framework,

então fazemos import CoreLocation no arquivo onde vamos usa-lo.

O CLLocation pode utilizar do GPS, Wifi e sinal de torres de celular para determinar

sua localização e a precisão das propriedades desse objeto podem e devem ser definidas,

uma vez que quanto maior a precisão, maior o consumo da bateria do seu

celular ou tablet, então você deve escolher a precisão de acordo com o objetivo do seu

aplicativo com objetivo de economizar ao máximo a bateria do aparelho onde ele vai

rodar.

Para escolher a precisão do CLLocation existem algumas constantes/chaves pré-

definidas, são elas:

kCLLocationAccuracyBestForNavigation - Para aplicativos de navegação, situações em

que você precisa saber a exato momento de dobrar o carro em uma rua, por exemplo.

Ao habilitar esse modo o celular deve estar carregando, bastante bateria será usada.

kCLLocationAccuracyBest - Segundo a Apple, utiliza do mais alto nível de precisão

para determinar a localização, faz uso do GPS.

kCLLocationAccuracyNearestTenMeters - Precisão em torno de 10 metros, deve

provavelmente fazer um mix do uso do GPS e do Wifi.

kCLLocationAccuracyHundredMeters - Precisão de 100 metros, deve utilizar em sua

maior parte o Wifi.

kCLLocationAccuracyKilometer - Precisão em torno de 1 quilômetro, deve utilizar de

sinal de torres de celular para saber a localização.


kCLLocationAccuracyThreeKilometers - Precisão em torno de 3 quilômetros, deve

utilizar de sinal de torres de celular para saber a localização e a precisão que menos

gasta bateria do dispositivo.

Para capturarmos um CLLocation com nossa localização fazemos através do

CLLocationManager, que é nos enviado através de eventos do delegate dele.

Fazemos isso em 4 passos:

1. Checar se o hardware que estamos usando da suporte ao tipo de atualização de

localização que precisamos.

2. Criar uma instancia de CLLocationManager e definir seu delegate.

3. Configurar de acordo com o tipo de atualização de localização que queremos.

4. Começar o monitoramento do CLLocationManager para alterações de localização.

Antes de começarmos a capturar a localização do dispositivo precisamos pedir

permissão ao usuário e podemos fazer isso duas maneiras:

Através do método requestWhenInUseAuthorization() para requisitar a autorização do

usuário para captura da localização somente quando o aplicativo estiver ativo.

Através do método requestAlwaysAuthorization() para requisitar a autorização do

usuário para captura da localização sempre, mesmo quando o aplicativo não estiver

ativo.

Nosso Status quanto a autorização pode ser obtido através do método

authorizationStatus() e pode retornar valores como Authorized (autorizado), Denid

(negado), Restricted (restrito, incapaz) e NotDetermined (ainda não definido).

Para isso funcionar, você precisa adicionar duas entradas na Info.plist, são elas:

NSLocationWhenInUseUsageDescription e NSLocationAlwaysUsageDescription.

Basta você clicar com o botão direito em algum espaço vazio da Info.plist e apertar em

Add Row (adicionar linha) para inserir uma entrada.

Você também deve definir a propriedade desiredAccuracy : CLLocationAccuracy,

responsável pela precisão dos dados de localização que serão retornados, com uma das


constantes de precisão do CLLocation que abordamos anteriormente e a propriedade

distanceFilter : CLLocationDistance, responsável pela distancia em metros em que a

localização atual deve exceder, da ultima localização capturada, para receber uma nova

atualização.

Sempre trabalhe com a configuração mínima necessária para que seu aplicativo

funcione bem.

Para começar e parar o monitoramento da localização utilizamos os dois métodos a

seguir:

startUpdatingLocation() - Para inicia o monitoramento de atualizações na localização.

stopUpdatingLocation() - Para parar o monitoramento de atualizações na localização.

PS: Certifique-se de parar as atualizações quando seu aplicativo não for consumir as

mudanças de localização.

Por fim, o nosso método do delegate que captura os eventos de atualização de

localização é:

func locationManager(CLLocationManager, didUpdateLocations: [CLLocation])

Note que o didUpdateLocations é um Array de localizações e isso acontece porque

mesmo com o seu dispositivo (celular ou tablet) em repouso ou tela bloqueada, o GPS

pode continuar gravando a sua localização. Você não quer que o celular “acorde” e use

ainda mais sua bateria toda vez que precisar gravar uma localização, você quer ele em

repouso, mas que continue gravando por onde você andou. Em uma aplicativo de

corrida ou de ciclismo por exemplo, queremos que o aplicativo monitore o percurso que

o usuário fez, mas o celular não deve estar ativo com tela desbloqueada e aberto no

aplicativo durante todo o percurso.

Também existe a possibilidade de você monitorar somente mudanças de localização

bem significativas, através dos métodos:

startMonitoringSignificantLocationChanges()

stopMonitoringSignificantLocationChanges()

Essa “mudança significativa” não é bem definida, mas pense em mudanças de

localização realizadas a nível de veículos e não caminhadas. São bem econômicas em


termos de bateria, mas não se esqueça de parar as atualizações quando seu aplicativo

não for consumir as mudanças de localização.

Existem ainda uma terceira forma de monitorar mudanças de localização que é por

regiões, através dos métodos:

startMonitoringForRegion(CLRegion)

stopMonitoringForRegion(CLRegion)

Nesse caso o método do delegate que captura os eventos de atualização muda, seguem:

func locationManager(CLLocationManager, didEnterRegion: CLRegion)

func locationManager(CLLocationManager, didExitRegion: CLRegion)

No iOS 9 foi criada a possibilidade de você requisitar a sua localização atual apenas

uma vez ao invés de ficar monitorando atualizações e isso é feito através do método:

requestLocation()

Nesse caso você só precisa definir o desiredAccuracy, chamar o método e capturar a

localização no método do delegate (o mesmo método do startUpdatingLocation e do

startMonitoringSignificantLocationChanges).

Nota: Essa ultima forma só funciona no iOS 9.0 e posteriores. Você pode identificar se

seu aplicativo está rodando no iOS 9 ou posterior da seguinte forma:

if #available(iOS 9.0, * ) {}


Mapas

É possível trabalhar com mapas no iOS e isso é feito através do MapKit.

MapKit é um framework que fica com com a parte de interface do usuário (UI) e

basicamente o que ele faz é mostrar um mapa. A classe responsável por gerenciar e

mostrar o mapa é a MKMapView (Arraste o componente pra storyboard e em seguida

“linke” com o ViewController através de um IBOutlet, como já fizemos anteriormente

com a label do projeto “Hello World”)

Importante, para trabalharmos com mapas precisamos importar o framework, então

fazemos import MapKit no arquivo onde vamos usa-lo.

Nesses mapas há os chamados Annotations, são pontos no mapas que guardam

informações como coordenadas, um título e um sub-título. Annotations são mostrados

usando a classe MKAnnotationView. No exemplo abaixo temos um Annotation sendo

mostrado e representado por um pino, isso é possível através da sub-classe

MKPinAnnotaionView.

Annotations podem ter callouts. Por padrão callouts mostram somente o título e o sub-

título, porém também podem ter os chamados Accessory Views. Os callouts aparecem

quando o AnnotationView é pressionado.


Na imagem acima temos um Callout com um accessory view na esquerda representado

por uma UIImageView e um na direita representado por UIButton.

Adicionamos e removemos um Annotation no mapa através dos métodos:

addAnnotation(MKAnnotation) - Adiciona um Annotation

addAnnotations([MKAnnotation]) - Adiciona um Array de Annotation

removeAnnottation(MKAnnotation) - Remove um Annotation

removeAnnottations([MKAnnotation]) - Remove um Array de Annotation

Capturamos os Annotations existentes através da propriedade annotations :

[MKAnnotation] da instancia do nosso mapa (outlet do tipo MKMapView que

“linkamos” anteriormente).

Quando tocamos em um Annotation um evento é disparado para um método especifico

do delegate do MKMapView:

func MapView(MKMapView, didSelectAnnotationView: MKAnnotationView)

Isso pode ser bem útil para configurarmos o nosso Callout, fazendo um download da

imagem necessária a ser mostrada, por exemplo.

A seguir, alguma propriedades do MKMapView que podem ser úteis durante a

configuração do seu mapa:

mapType : MKMapType - Pode ser .Standart, .Satellite e . Hybrid

showsUserLocation : Bool - Mostar ou não a localidade do usuário no mapa.


userLocationVisible : Bool - Se a localização atual do usuário está visível no mapa

userLocation : MKUserLocation - Objeto Annotation que representa a localização

atual do usuário.

zoomEnabled : Bool - Se o usuário pode dar zoom no mapa.

scrollEnabled : Bool - Se o usuário pode rolar o mapa.

region : MKCoordinateRegion - A área atualmente mostrada no mapa.

Há muito ainda do que se pode fazer com mapas, várias outras propriedades, métodos e

eventos do delegate. Para não deixar o livro muito extenso para essa primeira versão,

abordarei mais sobre mapas no meu canal do youtube. Então caso queira saber mais

como trabalhar com o framework MapKit eu sugiro que se inscreva no meu canal do

youtube (http://bit.ly/ytbookios), pois postarei aulas em video no canal sobre esse

framework e mais.



Considerações Finais

Chegamos ao fim do nosso estudo de desenvolvimento de aplicativos para iOS,

analisando os principais assuntos de desenvolvimento para iniciantes. Obviamente não

abordamos aqui tudo o que existe, pois precisaríamos de um livro de mais de 200

páginas. O meu objetivo foi dar uma geral em assuntos básicos e importantes, capaz de

dar a você uma base para que você possa compreender mais sobre desenvolvimento

iOS.

Se você aprender todos os pontos abordados no livro e tiver um pouco mais de estudo

extra, certamente poderá desenvolver aplicativos profissionais.

Talvez você tenha chegado até aqui sem ter absorvido todos os pontos. Não tem

problema, na verdade, isso é o esperado. Você deve estudar com calma, sem ansiedade,

colocando em prática cada ponto abordado. Se você apenas leu todas estas explicações,

ao precisar trabalhar com algum desses pontos, com certeza lembrará que já estudou

isso e então poderá revisar para então aprender de forma profunda.

A minha sugestão é que você estude com calma, porém com um certa frequência, por

exemplo, estudar algum assunto de desenvolvimento iOS uma vez por dia. Busque

conteúdos complementares em livros, websites, videos e também se inscreva no meu

canal do youtube (http://bit.ly/ytbookios), pois lá postarei aulas sempre atualizadas e

em videos sobre desenvolvimento iOS.

Muito obrigado pela sua leitura e espero que você realmente esteja disposto a dar o

próximo passo em seu aprendizado.

Nos vemos em breve!

Filipe Torres

CongressodeMobile.com.br



DESENVOLVIMENTO DE APP PARA IOS...

Documents

Transcript of DESENVOLVIMENTO DE APP PARA IOS...