Curso de programação para IPHONE – Parte 8

Olá galera. Apesar de estar muito ocupado na empresa, estou de volta com algum aprendizado sobre o XCODE. Daremos uma vistoriada geral nesta fantástica aplicação que tem tudo que precisamos para fazermos aplicações para o iPhone. Boa aula.

Introdução ao XCODE

Programar para Apple começa com o XCODE, é um ambiente integrado de desenvolvimento ( mais conhecido por IDE), que pode ser chamado a partir do diretório do desenvolvedor.

Para escrever programas para iPhone, você deve ter baixado o iPhone SDK, como discutido nos capítulos anteriores. Depois de feito isso, escolha Arquivo> Novo projeto irá abrir um wizard para ajudar a criar seu projeto.

Você vai ser imediatamente solicitado a selecionar um modelo para o seu novo projeto. O modelo que você escolher vai preencher o seu projeto com o framework padrão, arquivos padrões, objetos padrões, e sempre o mesmo código padrão. Como você vai ver, vai ser uma grande ajuda para iniciar o seu próprio código. Para o seu primeiro programa, quero começar com o mais simples modelo que podemos encontrar: Window-Based Application.
Depois de selecionar um modelo, você precisará também do nome do seu projeto e escolher onde salvá-lo, depois que você tiver feito isso, você está pronto para iniciar a codificação. Antes de chegarmos lá, porém, vamos dar uma olhada mais de perto na forma de trabalho do ambiente XCODE.

A Anatomia do XCODE

Quando acionado, o XCODE exibe apenas uma janela.  Onde aparece o nosso primeiro projeto, helloworld.

Como você pode ver, a janela principal do Xcode compreende três partes.

Na esquerda tem uma barra lateral que contém uma listagem de todos os arquivos que estão sendo usados no seu projeto, organizados por tipo. Sempre que você precisar adicionar frameworks, imagens, bases de dados, ou outros arquivos para seus projetos, você vai fazê-lo aqui. O painel esquerdo contém também alguns outros elementos úteis, em especial um item de Errors and Warnings (Erros e avisos) que você pode clicar em abrir para ver rapidamente os problemas na sua compilação.

O topo-direito contém um painel com uma lista de arquivos desagrupados usado pelo seu projeto. Quando você clica em um desses, o seu conteúdo será exibido no painel inferior direito. Como você pode ver, mesmo o mais simples programa irá incluir mais de uma meia-dúzia de arquivos.

O que é cada um deles.

Neste capítulo iremos focar exclusivamente nos cabeçalhos e arquivos de código fonte. No próximo capítulo iremos expandir o nosso trabalho para incluir também o arquivo do Interface Builder “.xib”.

Compilando e Executando no XCODE

Para compilar no Xcode, escolha Build > Build and Run a partir dos menus. Seu programa irá compilar e fazer o link. Em seguida, ele será instalado no iPhone Simulator, e do iPhone Simulator irá iniciar. Se você tentar isso, utilizando o projeto que acaba de criar usando o modelo Window-Based Application, você verá todo o processo, resultando em uma janela vazia branca sobre tela exibindo dentro do seu iPhone Simulator. Note que os programas só existem no seu Simulator (ou no iPhone), que não pode ser executado diretamente em seu Macintosh. Se quiser mais tarde re-executar um programa que você já tenha compilado, você pode fazê-lo em uma das três maneiras. Você pode simplesmente clicar no botão do programa, que deve agora aparecer no seu Simulator. Ou, você pode escolher Run > Run a partir de dentro Xcode. Finalmente, você pode escolher Build and Go no Xcode, que só compila se for necessário, em seguida, executa seu programa. E é isso. Com uma compreensão rudimentar do Xcode agora em mãos, você está pronto desenvolver seu primeiro programa.

Criando um primeiro projeto no XCODE: Olá, Mundo!

Como já observado, você deve iniciar qualquer projeto, executando File > New Project, escolher um modelo, e nomear o seu projeto. Para a nossa primeira amostra de projeto, foram selecionados o modelo Window-Based Application, e o nome alomundo. Antes de você começar a escrever o novo código, você precisa de uma compreensão básica do que já está lá, por isso vamos analisar o conteúdo dos três mais importantes arquivos que o nosso modelo Window-Based, que são: main.m, alomundoAppDelegate.h, e o alomundoAppDelegate.m.

Entendendo o  main.m

O primeiro arquivo criado pelo XCODE é main.m, que contém a sua função principal:

int UIApplicationMain (

int argc,
char *argv[],
NSString *principalClassName,
NSString *delegateClassName
);

A criação desta rotina principal é automática, e você geralmente não deve perder  tempo com ele. No entanto, vale a pena entender como ele funciona. Ele Começa com uma diretiva #import, que é o equivalente do Objective-C ao #include do C#. Mais especificamente, você incluiu o UIKit framework, que é o mais importante framework no Objective-C.

O próximo a ser criado é o NSAutoreleasePool. Você deve se lembrar dele, pois foi mencionado em nossa discussão de gestão de memória no capítulo anterior. É o que dá suporte ao método autorelease da classe NSObject. Observe também que você libera o pool  depois que você executar o seu pedido principal da rotina, seguindo a regra de que, se você atribuir a memória para um objeto, você também deve liberá-lo.

A linha com o UIApplicationMain é o que cria a sua aplicação e executa o seu ciclo de evento. Os argumentos da função se parecem com isto:

int UIApplicationMain (int argc,

char *argv[],
NSString *principalClassName,
NSString *delegateClassName
);

Tal como acontece com o resto do arquivo main.m, você nunca deve ter de alterar esta código, mas devemos, no entanto, falar brevemente sobre os dois últimos argumentos embora eles geralmente serem definidos por padrão como nil (nulos) .

O principalClassName define a classe principal  da aplicação, por padrão é o UIApplication. Esta categoria tem uma série de ações e controle de eventos para o seu programa, tema que vamos voltar a falar em outros capítulos. O objeto UIApplication é criado como parte desta rotina inicial, mas note que nenhuma link com o objeto é provido. Se precisar acessá-lo (e você irá), você pode utilizar um método da classe UIApplication para fazê-lo:

[UIApplication sharedApplication];

Isso retornará o objeto da aplicação. Isto será normalmente enviado como parte de uma mensagem aninhada UIApplication para um método, como você verá em futuros capítulos.

Por enquanto, a aplicação faz duas coisas a se notar: ela chama o arquivo .xib padrão e ele interage com seu Application Delegate. O delegateClassName define a aplicação do objeto delegado. Como já se observou ali, este é o objeto que responde a algumas mensagens da aplicação, tal como foi definido pelo protocolo da classe UIApplicationDelegate. Entre outras coisas, a aplicação deve responder e delegar o ciclo de vida das mensagens, mais especificamente o applicationDidFinishLaunching: que controla o seu programa em termos de conteúdo, como iremos falar mais tarde. Nos moldes do Xcode, seus arquivos de classes delegates sempre terão o nome do projeto + appdelegate. Seu programa irá encontrá-los, graças a propriedade delegate que é construído no Interface Builder. Você pode mudar os argumentos enviados para UIApplicationMain e você pode adicionar ao arquivo main.m outros comandos, mas geralmente não vai querer. O padrão deve funcionar bem para todos os programas. Então, vamos sair do main.m e nos voltar para o arquivo onde qualquer programação realmente começa:  O application delegate.

Entendendo o application delegate

Como você já viu, o application delegate é responsável por responder a muitas das mensagens das aplicações. Você pode referenciar ao capítulo anterior, para uma lista de algumas das mais importantes ou ir guia de referência da Apple e fuçar UIApplicationDelegate para uma listagem completa. Mais especificamente, um application delegate deve fazer o seguinte:

• No momento do lançamento, é preciso criar um objeto Window e exibi-lo para o usuário.
• É preciso inicializar seus dados.
• É preciso responder ao pedido de “quit”.
• É preciso lidar com advertências de baixa memória.

Entre estes itens, é o primeiro que é de extrema importância para você agora. Seus arquivos de application delegate, alomundoAppDelegate.h e alomundoAppDelegate.m, sabem desta forma que o seu programa começou ..

O Arquivo Header

Agora, você está realmente usando classes, que é o tipo de codificação que compõe a grande maioria dos códigos Objective-C. vamos mostrar o conteúdo de seu primeiro arquivo de cabeçalho de classe, alomundoAppDelegate.h.

@interface helloworldxcAppDelegate : NSObject <UIApplicationDelegate> {    (1)
UIWindow *window;    (2)
}
@property (nonatomic, retain) IBOutlet UIWindow *window;     (3)

Novamente, não há nada para mudar daqui, mas queremos analisar o conteúdo, tanto para reiterar algumas das lições que aprendemos no capítulo anterior como para lhe dar uma boa base para um trabalho que vai fazer no futuro.  Primeiro, você verá uma linha interface (1) que herda suas delegações do NSObject e inclui uma promessa de seguir o protocolo UIApplicationDelegate.  Em seguida, você tem a declaração de uma variável de instância do objeto UIWindow (2).  Finalmente, você declara essa variável window como uma propriedade (3). Você notará que esta declaração,  inclui alguns dos atributos que nós já mencionamos anteriormente, que são nonatomic,  retain. Esta linha inclui também uma declaração IBOutlet, que diz que o objeto  foi realmente criado no Interface Builder. Iremos examinar este conceito de forma mais aprofundada no próximo capítulo, mas, por enquanto, você só precisa saber que você tem um objeto window já preparado para seu uso.  Embora você não possa modificar este arquivo header neste exemplo, você vai no futuro,  e você geralmente irá repetir os padrões que você vê aqui: criando mais  variáveis de instancia, incluindo IBOutlets, e definirá mais propriedades. Você também pode declarar cabeçalho de métodos neste arquivo, algo que este exemplo de cabeçalho não contém.

O Arquivo source code (Código fonte)

Vamos agora para o arquivo onde exibe código-fonte do application delegate, que é o alomundoAppDelegate.m, e é aqui que você vai  colocar o seu novo código.

#import “alomundoAppDelegate.h”                                                            (1)
@implementation alomundoAppDelegate                                                  (2)
@synthesize window;                                                                                   (3)
– (void)applicationDidFinishLaunching:(UIApplication *)application {     (4)
[window makeKeyAndVisible];                                                                  (5)
}
– (void)dealloc {
[window release];
[super dealloc];
}
@end

O Código começa com a inclusão do arquivo de cabeçalho da classe (1) e um @implementation (2). Sua propriedade window (3), também recebe uma declaração @synthesize (vide capitulo 5). Mas é o conteúdo do método applicationDidFinishingLaunching (4) que  realmente interessa a você. Como você pode relembrar, essa é uma das mensagens de ciclo de vida do iPhone OS  que falamos nos capítulos anteriores. Sempre que uma aplicação do iPhone é totalmente  carregado na memória, vai enviar uma mensagem applicationDidFinishingLaunching: para  aplicação delegada, na execução desse método. Você vai notar há já existe um código para exibir a janela que será criada (5).

Para este projeto básico, você adicionará o seu novo código para que essa mesma rotina faça o objeto dizer “Olá, Mundo!”

Escrevendo o código

Fui otimista ao dizer como é fácil escrever códigos utilizando o SDK do iPhone em capítulos anteriores. Contudo, o programa  “Olá, Mundo!” pode não ser tão fácil como um comando “print” em uma única declaração, mas é bastante simples, considerando que você está  lidando com um complexo ambiente de interface gráfica com janelas.  Como prometido, você escreverá tudo dentro do método applicationDidFinishingLaunching, como mostraremos:

(void)applicationDidFinishLaunching:(UIApplication *)application {
[window setBackgroundColor:[UIColor redColor]];                              (1)
CGRect textFieldFrame = CGRectMake(50, 50, 150,40); (2)
UILabel *label = [[UILabel alloc] initWithFrame:textFieldFrame]; |
label.textColor = [UIColor whiteColor]; |
label.backgroundColor = [UIColor redColor]; (3)
label.shadowColor = [UIColor blackColor]; |
label.font = [UIFont systemFontOfSize:24]; |
label.text = @”Hello, World!”; |
[window addSubview:label];
[window makeKeyAndVisible];
[label release];
}

Imaginando que este é o seu primeiro olhar num código real de Objective-C, vamos examinar tudo com certa profundidade.

Sobre a janela

O código começa enviando uma mensagem para o objeto window, dizendo para ele para definir o seu background para azul (1). Se você recordar da nossa discussão do arquivo header, dissemos que o Interface Builder foi quem criou a janela. O IBOutlet que foi definido no cabeçalho é o que permite fazer este tipo de manipulação.  Note que esta linha também faz uso de uma mensagem aninhada, o que havíamos prometido que aconteceria com uma certa freqüência. Aqui, você faz uma chamada para o objeto UIColor e solicita que  para ele envie a cor vermelha. Você, então,  passa isso para a sua janela.  Neste curso, vamos atingir um grande número de classes do UIKit sem explicar com muita  profundidade. Isso porque os objetos mais simples têm todas as interfaces padrões, a único complexidade  é, em particular as mensagens que eles aceitam. Se você se sentir como se fosse precisar de mais informações sobre uma classe, você deve olhar no guia de referência da Apple, disponível online em  developer.apple.com (ou no Xcode).

Sobre Frames

Você irá agora definir onde o seu texto será colocado. Você inicia o processo usando CGRectMake para definir um retângulo (2). Trabalharemos com Canvas da tela, o SDK utiliza um  grade com a origem (0,0) fixado na parte superior esquerda. Seu retângulo iniciará, portanto, 50 pixels à direita e 50 para baixo (50,50) a partir da origem. O resto dessa linha de código define o retângulo em 150 pixels de largura e 40 de altura, que é espaço suficiente para o seu texto.  Você vai usar este retângulo como um “Frame”, que é um dos métodos que você pode usar para definir uma visão da localização.

Sobre Labels

O label é uma simples classe que lhe permite escrever texto na tela. Como você poderia esperar, o seu label começa com a própria criação de um objeto label (3).  Note que ele segue o padrão de metodologia de criação de objetos aninhados que nós introduzimos nos capítulos anteriores. Primeiro você usa um objeto de classe para alocar o objeto, e então usamos um método de instância para inicializá-lo.  Depois de enviar uma série de mensagens para seu objeto, desta vez utilizando o ponto ( Oferecemos isso como uma variação da forma como você define o  janela da cor de fundo. Se preferir, você pode  utilizar o ponto window.backgroundColor lá, também. As duas maneiras de acessar propriedades são  totalmente equivalentes.  O mais importante dessas mensagens define o  texto do label. Você também pode definir um tamanho de fonte e algumas cores.  Você ainda pode dar ao texto uma atraente sombra preta, para demonstrar como é fácil fazer coisas legais  usando os objetos do iPhoneSO.  Cada objeto que você usar a partir de um Framework vai ter diversas propriedades, métodos e notificações  que você poderá tirar vantagem. O melhor lugar para procurar é  no guia de referências de classes.

Executando o Alô Mundo!

Para compilar e executar no Xcode, escolha Build > Build and Run a partir dos menus. Lembro que várias formas de se criar no XCODE e eu mostrei apenas como fazer no código, sem a utulização do Interface Buider para que você veja a quantidade de código que é inserido, sem o uso desta ferramenta. No próximo capítulo voce verá esta mesma aplicação sendo criada facilmente pelo IB sem digitar uma linha de código e veremos também outra aplicação mais complexa. Abraços.