[lead2]

De que se trata o artigo:

Neste artigo veremos os principais pontos para iniciar o desenvolvimento na plataforma iOS. Para isso, usaremos um projeto simples como modelo para explicar a estrutura da linguagem Objective-C e começar a desenvolver aplicações para iPad/iPhone.

[/lead2]
Guia do artigo: Objective-C Tutorial

O que é a Objective-C?

A linguagem Objective-C é usada para o desenvolvimento de aplicações para a plataforma iOS, que compreende iPhone, iPad e iPod Touch.

Além de exemplificar a linguagem Objective-C, apresentamos alguns recursos da IDE Xcode e do Interface Builder. Itens indispensáveis no desenvolvimento para a plataforma iOS.

Muitas pessoas procuram saber qual a linguagem que devem usar para desenvolver aplicativos para a plataforma iOS. Quando descobrem que devem usar Objective-C surge de imediato uma questão: Objective-C é igual a C? Com a negativa, outra pergunta segue: Objective-C é igual a o que? Pois é, aí reside o grande problema de se aprender Objective-C, ela não é lá muito parecida com muita coisa, mas também não é totalmente alienígena.

Neste artigo, a ideia não é se estender às origens do Objective-C (ObjC para os íntimos), mas sim fazer uma breve descrição de sua história para em seguida iniciarmos seu estudo. ObjC é uma linguagem Orientada a Objetos que tem como pais o C e o SmallTalk. Nos anos 90, Steve Jobs foi demitido da Apple e fez alguns investimentos. Entre eles, adquiriu parte de uma nova empresa, a NeXT. Esta empresa desenvolveu uma linguagem para trabalhar com workstations gráficas, no caso a Objective-C.

Uma das condições para a volta de Jobs para a Apple foi que a NeXT fosse comprada, e isto foi feito. Como Jobs assumiu a frente dos negócios da Apple, ele decidiu reformular vários produtos. E um deles foi o próprio sistema operacional, que estava bastante defasado. Para esta árdua tarefa, a linguagem escolhida para dar suporte ao novo sistema operacional foi Objective-C. Assim nasceu o Mac OS X.

Nas primeiras versões, o Mac OS X era um sistema híbrido, usava funcionalidades do sistema antigo (Mac OS 9) junto com os novos recursos. Como Objective-C se mostrou uma linguagem poderosa, quando foi lançado o primeiro iPhone, decidiu-se adotar ObjC como linguagem nativa do dispositivo.

Preparando a IDE

A primeira grande dificuldade em usar ObjC é se acostumar com o IDE, que no caso é o Xcode. Aliás, vale dizer, que por meios legais, não é possível programar para iOS sem usar um Mac com processador Intel. Mesmo que você tente usar um PC convencional (desses que rodam Windows), ainda assim você terá que simular o Mac OS X de alguma forma. Usar o Xcode será meio esquisito no começo, mas logo nos acostumamos. O Xcode vem gratuitamente com o sistema operacional. Se em um primeiro momento você não encontrá-lo, use o Finder e vá no diretório Macintosh HD/Developers/Applications. Pode acontecer do Xcode não estar instalado e neste caso você deve recorrer ao DVD de instalação do Mac OS X para isso. Depois da instalação basta acessar o diretório mencionado que o encontrará.

Instalando o SDK

Outro passo importante é instalar o SDK de desenvolvimento para iOS. Para fazer o download gratuito deste SDK, acesse: http://developer.apple.com/programs/ios/.

Iniciando a codificação

Para explicar ObjC desenvolveremos um código bem simples, pois a maneira mais fácil de expor uma linguagem é apresenta-la na prática. Para isso, vamos montar um projeto que será uma calculadora. Uma calculadora básica, com quatro operações, e nada sofisticada visualmente, pois a ideia é fornecer subsídios para aprender a programar. Para iniciar, execute o Xcode. Ao abri-lo, teremos uma tela semelhante à Figura 1.

Tela de abertura
do Xcode
Figura 1. Tela de abertura do Xcode.

Para criar um projeto novo, devemos selecionar Create a new Xcode project. Feito isso, selecionamos o modelo de projeto, que no nosso caso será View-based Application e depois nomeá-lo como Calc. Se você criou corretamente o projeto, terá uma tela igual à Figura 2.

Tela inicial do
projeto
Figura 2. Tela inicial do projeto.

Se você já utilizou o Visual Studio ou Eclipse, não sentirá tanta dificuldade em se acostumar com o Xcode. Repare que do lado esquerdo temos a estrutura do projeto. Esta estrutura é montada de acordo com o modelo que você escolhe no instante de criação do projeto. No nosso caso escolhemos View-Based Application. Em outra ocasião falaremos dos demais modelos que podem ser criados.

Você deve estar se perguntando, por que escolhemos este modelo? Como falamos, vamos desenvolver uma calculadora básica. Esta calculadora terá apenas uma view, portanto escolhemos o tipo mais adequado para as nossas necessidades iniciais.

O fato de iniciarmos com um modelo de projeto não significa que somos obrigados a manter o esquema proposto. Você tem total de liberdade de modificar o modelo na medida em que suas necessidades forem surgindo. Por exemplo, o fato de utilizarmos apenas uma view não significa que você não pode acrescentar outras views no projeto. O modelo pode ser moldado de acordo com as suas necessidades, isto é, você não precisa (e nem deve) ficar preso a um esquema proposto.

Criando Classes

Como falamos, ObjC é uma linguagem Orientada a Objetos, portanto nada mais natural que criar classes para escrever nossos objetos. No caso do nosso projeto, vamos criar uma classe que fará essencialmente cálculos.

O objetivo é montar uma classe que seja capaz de fazer as quatro operações da nossa calculadora. Para criar qualquer elemento novo ao projeto, precisamos dar um clique com o botão direito em cima do nome do projeto, que fica na primeira linha do lado esquerdo, e escolher Add. Como somos programadores organizados, vamos criar primeiro uma pasta para colocar a nova classe. Por isso, depois de selecionar a opção Add, escolha a opção Groups. Em seguida basta dar um nome – no nosso caso vamos chamar esta pasta de Calculator.

Com a pasta criada vamos criar a classe propriamente dita. Assim como a linguagem C, ObjC também trabalha com dois arquivos, um header e o fonte. Em C usa-se extensões .h e .c e em ObjC .h e .m. Conceitualmente essas extensões se equivalem. No arquivo .h colocamos as declarações dos métodos que vamos implementar no .m. Como podemos verificar, a linguagem não é tão esquisita assim.

Para criar esta classe, damos um clique com o botão direito em cima da pasta que acabamos de criar e selecionamos Add / Files. Ao fazermos isso, nos será perguntado qual tipo de arquivo pretendemos adicionar ao projeto. Escolha Objective-C Class. Depois disso basta dar um nome para esta classe, que no nosso caso será Calculator. Sim, podemos ter o nome da classe igual ao nome da pasta.

A pasta no Xcode tem a finalidade de organizar o código e não é usada no momento de compilação do código, por isso podemos ter o mesmo nome tanto para a classe como para a pasta. Outro ponto importante, no momento em que estiver nomeando a classe, deixe selecionado o checkbox Also create “Calculator.h”, que vai criar o .h automaticamente para você, conforme a Figura 3.

Tela New File
Figura 3. Tela New File.

Pronto, criamos uma classe no nosso projeto, agora vamos implementá-la. Como dissemos anteriormente, a ideia é disponibilizar à nossa calculadora as quatro operações básicas: soma, subtração, divisão e multiplicação. Para isso criaremos métodos para nos ajudar nesta tarefa:

  • setAccumulator – método que terá como finalidade armazenar o primeiro número de uma operação;
  • clear – método que como o próprio nome diz, irá limpar (zerar) o número da operação;
  • accumulator – método que retornará o conteúdo do primeiro número da operação;
  • add – método para executar a operação de soma;
  • subtract – método para executar a operação de subtração;
  • multiply – método para executar a operação de multiplicação;
  • division – método para executar a operação de divisão.

ObjC herdou um pouco da linguagem C, por isso primeiro temos que declarar os métodos e variáveis que vamos trabalhar no arquivo .h. Dito isto, vamos digitar o código da Listagem 1.

Listagem 1. Código do arquivo Calculator.h.

  #import <Foundation/Foundation.h>
   
  @interface Calculator : NSObject {
      double accumulator;
  }
  - (void)setAccumulator:(double)value;
  - (void)clear;
  - (double)accumulator;
  - (void)add:(double)value;
  - (void)subtract:(double)value;
  - (void)multiply:(double)value;
  - (void)division:(double)value;
   
  @end 

Na primeira linha temos a importação do código da Foundation. #import equivale ao #include do C. No momento da compilação o código da Foundation será incorporado ao nosso código. Foundation é uma classe usada para controlar classes do tipo NSObject. No momento que criamos esta classe, nós escolhemos o modelo Objective-C Class. Por isso, quando criamos a classe Calculator, esta linha já foi automaticamente incluída no nosso código. Como estamos codificando o Calculator.h é natural encontrarmos a declaração @interface Calculator : NSObject. Nesta linha estamos declarando que a classe Calculator é derivada do tipo NSObject. Em seguida criamos uma variável do tipo double chamada accumulator, que será usada para nos ajudar nas operações. Esta variável conterá o valor do primeiro operando das nossas contas.

Depois declaramos os métodos que esta classe utilizará. Vamos entender suas assinaturas. Na declaração de setAccumulator, por exemplo, temos um método que não retornará nenhuma informação, por isso iniciamos com – (void). Por outro lado, vamos precisar enviar um valor para ser armazenado na variável accumulator, e por esta razão informamos : (double) value. Isso quer dizer que setAccumulator não retornará valor, mas deverá receber um valor do tipo double chamado value. O método clear não retornará valor e não vai receber nenhum valor como parâmetro. Já o método accumulator retornará um valor do tipo double e não receberá nenhum valor.

Resumindo este código, os arquivos .h (chamados de header) têm suas variáveis e métodos declarados dentro da instrução @interface. Observe que a última linha @end finaliza o @interface.

Agora que já declaramos as variáveis e os métodos da classe, vamos de fato codificá-la. O seu código é apresentado na Listagem 2.

Listagem 2. Código do arquivo Calculator.m.

  #import "Calculator.h"
   
  @implementation Calculator
  - (void)setAccumulator:(double)value {
      accumulator = value;
  }
   
  - (void)clear {
      accumulator = 0;
  }
   
  - (double)accumulator {
      return accumulator;
  }
   
  - (void)add:(double)value {
      accumulator += value;
  }
   
  - (void)subtract:(double)value {
      accumulator -= value;
  }
   
  - (void)multiply:(double)value {
      accumulator *= value;
  }
   
  - (void)divide:(double)value {
      accumulator /= value;
  }
   
  @end 

Neste código vamos encontrar na primeira linha #import "Calculator.h". Com esta instrução estamos trazendo para dentro da implementação as declarações feitas em Calculator.h. Com a instrução @implementation Calculator, se inicia a codificação desta classe e com @end se finaliza. Tudo que estiver contido entre estas instruções faz parte da implementação de Calculator.m. Quem tem algum conhecimento da linguagem C não terá dificuldades para compreender o código escrito, para aqueles que não são tão familiarizados, destacamos algumas explicações:

  • Em setAccumulator, recebemos um double que chamamos de value e atribuímos o valor desta variável para a variável accumulator, que foi declarada também como double no Calculator.h;
  • Em clear, estamos zerando o conteúdo da variável accumulator;
  • Em accumulator, estamos disponibilizando o conteúdo da variável accumulator;
  • Em add, subtract, multiply e division estamos executando as suas operações correspondentes.

Depois de codificar a classe Calculator, você pode compilar o projeto para se certificar que todo o código está correto. Para isso basta pressionar COMANDO +B. Se você ainda não está familiarizado com o teclado do Mac, o botão COMANDO é aquele que tem a maçã impressa. Se tudo estiver perfeito podemos ir em frente. Se encontrar algum problema, conserte para não ficar complicado arrumar mais a frente.

Implementando o código da interface com o usuário

Desenvolvida a classe Calculator, vamos agora codificar a camada de visão do projeto, responsável pela interação da aplicação com o usuário. Antes de iniciar esta codificação precisamos entender como funcionará a calculadora. Existirão na tela botões para os números (0 a 9), botões para as quatro operações e um botão para o igual (que exibirá o resultado da operação), além de um visor que mostrará o número digitado e o resultado. A ideia não é fazer uma super calculadora, mas sim mostrar uma implementação simples e de fácil compreensão, por isso trabalharemos apenas com números inteiros.

Observem que citamos vários botões e um display. Todos eles serão elementos de interface com o usuário. Veremos que é muito importante ter em mente quais serão estes elementos para poder preparar a ligação dos mesmos com as funcionalidades da aplicação (neste caso, as operações matemáticas).

Para saber qual o local correto para implementar a interface do usuário, precisamos esclarecer a estrutura do projeto. Todo projeto iOS tem esta estrutura básica:

  • Classes – pasta que contém as classes criadas pelo wizard do Xcode;
  • Other Sources – pasta que contém o fonte que inicia o projeto;
  • Resources – Como o nome diz, é a pasta que armazena os recursos do projeto, tais como imagens, views, fontes, etc.
  • Framework – Pasta que contém os frameworks usados no projeto. Se desejarmos incluir algum framework, este é o local adequado. Os frameworks encontrados nesta pasta nesse momento foram incluídos pelo wizard do Xcode;
  • Products – É a pasta que contém o executável da aplicação. Mas não se engane, para colocar este executável no seu dispositivo (iPhone, iPad ou iPod) você precisará de um provision, e isso será tema de um próximo artigo.

Nesse momento, vamos observar o conteúdo da pasta Other Source:

  • Calc_Prefix.pch – arquivo que contém os “#imports” que farão parte de todos os fontes do projeto;
  • main.m – Aqui os aficionados pela Linguagem C vão gostar. Sim, é através de um arquivo main que se inicia a execução de um aplicativo na plataforma iOS.

A partir do código do main.m é delegado para o arquivo CalcAppDelegate (que foi gerado automaticamente pelo wizard) o controle da execução da aplicação, e será neste código que encontraremos a inclusão da view CalcViewController. Falaremos mais sobre todas essas delegações em outras oportunidades, mas se você tiver paciência em dar uma olhada nos códigos contidos nos arquivos main.m e CalcAppDelegate, poderá aprender sobre todas essas delegações.

Todo o código que estamos vendo em main, CalcAppDelegate e CalcViewController, foram gerados automaticamente pelo wizard do Xcode. Cada wizard executa um script diferente para cada modelo que selecionamos no momento da criação do projeto, e como escolhemos View-Based Application, nos foi criado um projeto pronto para ser implementado usando a classe CalcViewController. Por esta razão vamos codificar nossa interface nesta classe. Dito isto, atualize o código de CalcViewController para o código exibido na Listagem 3.

Listagem 3. Código do arquivo CalcViewController.h.

  #import <UIKit/UIKit.h>
  #import "Calculator.h"
   
  @interface CalcViewController : UIViewController {
      Calculator *basicCalculator;
      IBOutlet UILabel *lblDisplay;
      double operator01, result;
      NSString *strDisplay, *operation;
      BOOL enablePoint, afterEqual, showNumberValid, enableCount;
  }
  @property (nonatomic, retain) Calculator *basicCalculator;
  @property (nonatomic, retain) UILabel *lblDisplay;
  @property (nonatomic, retain) NSString *strDisplay, *operation;
   
  - (IBAction)showClear;
  - (IBAction)showDivide;
  - (IBAction)show9;
  - (IBAction)show8;
  - (IBAction)show7;
  - (IBAction)showMultiply;
  - (IBAction)show6;
  - (IBAction)show5;
  - (IBAction)show4;
  - (IBAction)showSubtract;
  - (IBAction)show3;
  - (IBAction)show2;
  - (IBAction)show1;
  - (IBAction)showAdd;
  - (IBAction)show0;
  - (IBAction)showEqual;
  - (void)showNumber:(NSString *)number;
  @end 

Na primeira linha desse código incluímos a classe UIKit. Esta é a classe mais comum no desenvolvimento para plataforma iOS. Ela disponibiliza todos os recursos necessários para a aplicação interagir com o usuário.

Na segunda linha temos a inclusão da nossa classe Calculator. Vamos precisar dela para poder realizar nossas contas. Ao contrário do arquivo Calculator.h que derivava de NSObject, este arquivo deriva de UIViewController. Isto vai permitir ter maior controle sobre a view. Aliás, por se tratar de uma view, ela só pode ser derivada desta classe.

Depois disso criamos uma variável basicCalculator do tipo Calculator. Fazemos isso para poder usar todos os métodos desta classe em nosso código através da variável.

Na linha seguinte temos uma das principais características de desenvolvimento da plataforma iOS. Vamos usar o tipo IBOutlet. Toda vez que você encontrar uma declaração com as iniciais IB quer dizer que esta variável terá uma ligação com algum elemento gráfico criado no Interface Builder (IB). Na linha em questão estamos informando que a variável lblDisplay é do tipo UILabel e que esta terá uma ligação com um elemento criado no Interface Builder. Esta variável será usada para exibir os números digitados e o resultado das contas.

Depois criamos duas variáveis do mesmo tipo double: uma para guardar um dos operadores e outra para armazenar o resultado de uma operação, no caso operator01 e result.

Em seguida criamos mais duas variáveis do tipo NSString, que usaremos como controle: strDisplay e operator. Na strDisplay teremos uma cópia do conteúdo da lblDisplay. É interessante fazer isso para facilitar a manipulação de conteúdo, visto que é muito mais rápido e produtivo manipular variáveis do tipo NSString do que variáveis do tipo UILabel.

O último conjunto de variáveis criadas nesta classe foram as booleanas. Estas variáveis servirão para ajudar a controlar o fluxo de execução das ações executadas pelo usuário.

Depois das declarações nós definimos as propriedades de algumas destas variáveis. Fazemos isso para poder controlar melhor o conteúdo destas variáveis de uma forma mais transparente e eficiente. Mais adiante apresentaremos mais detalhes quando estivermos explicando o código de implementação desta classe.

Após definirmos as propriedades, declaramos as ações que esta classe vai executar. Observe que cada uma destas ações tem como início – (IBAction). Lembre-se quando falamos que toda declaração que se inicia com IB indica que existe uma ligação desta ação com algum elemento criado no Interface Builder. Como podemos observar, criamos uma ação para cada situação possível que o usuário pode efetuar usando a calculadora. Por exemplo, quando o usuário pressionar o botão do número zero, internamente executará o método show0, quando pressionar o botão de igual, executará o método showEqual, e por ai em diante. Compreendido este código, vamos implementar CalcViewController.m de acordo com a Listagem 4.

Listagem 4. Código de CalcViewController.m.

  #import "CalcViewController.h"
   
  @implementation CalcViewController
   
  @synthesize basicCalculator, lblDisplay, strDisplay, operation;
   
  - (void)viewDidLoad {
      [super viewDidLoad];     
      self.strDisplay = [[NSString alloc] init];
      operation = [[NSString alloc] init];
      afterEqual = FALSE;
      showNumberValid = TRUE;
      enablePoint = TRUE;
      enableCount = FALSE;
      lblDisplay.text = @"0";
  }
   
  - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
      return YES;
  }
   
  - (IBAction)showClear {
      self.strDisplay = @"";
      lblDisplay.text = self.strDisplay;
      lblDisplay.text =@"0";
      operation = @"";
  }
   
  - (IBAction)showDivide {
      if (!afterEqual) {
       [self showEqual];
       enableCount = TRUE;
      }
      operation = @"4";
      operator01 = [self.strDisplay doubleValue];
      self.strDisplay = @"";
  }
   
  - (IBAction)show9 {
      [self showNumber:@"9"];
  }
   
  - (IBAction)show8 {
      [self showNumber:@"8"];
  }
   
  - (IBAction)show7 {
      [self showNumber:@"7"];
  }
   
  - (IBAction)showMultiply {
      if (!afterEqual) {
       [self showEqual];
       enableCount = TRUE;
      } 
      operation = @"3";
      operator01 = [self.strDisplay doubleValue];
      self.strDisplay = @"";
      enableCount = FALSE;
  }
   
  - (IBAction)show6 {
      [self showNumber:@"6"];
  }
   
  - (IBAction)show5 {
      [self showNumber:@"5"];
  }
   
  - (IBAction)show4 {
      [self showNumber:@"4"];
  }
   
  - (IBAction)showSubtract {
      if (!afterEqual) {
       [self showEqual];
       enableCount = TRUE;
      }
      operation = @"2";
      operator01 = [self.strDisplay doubleValue];
      self.strDisplay = @"";
      enableCount = FALSE;
  }
   
  - (IBAction)show3 {
      [self showNumber:@"3"];
  }
   
  - (IBAction)show2 {
      [self showNumber:@"2"];  
  }
   
  - (IBAction)show1 {
      [self showNumber:@"1"];
  }
   
  - (IBAction)showAdd {
      if (!afterEqual) {
       [self showEqual];
       enableCount = TRUE;
      }
      operation = @"1";
      operator01 = [self.strDisplay doubleValue];
      self.strDisplay = @"";
      enableCount = FALSE;
  }
   
  - (IBAction)show0 {
      [self showNumber:@"0"];
  }
   
  - (IBAction)showEqual {
      if (operation != @"") {
       switch ([operation intValue]) {
           case 1:
                basicCalculator = [[Calculator alloc] init];
                [basicCalculator setAccumulator:operator01];
                [basicCalculator add:[self.strDisplay doubleValue]];
                result = [basicCalculator accumulator];
                [self showClear];
                self.strDisplay = [self.strDisplay stringByAppendingFormat:@"%g",result];
                lblDisplay.text = self.strDisplay;
                operator01 = 0;
                result = 0;
                [basicCalculator release];
                afterEqual = TRUE;
                break;
           case 2:
                basicCalculator = [[Calculator alloc] init];
                [basicCalculator setAccumulator:operator01];
                [basicCalculator subtract:[self.strDisplay doubleValue]];
                result = [basicCalculator accumulator];
                [self showClear];
                self.strDisplay = [self.strDisplay stringByAppendingFormat:@"%g",result];
                lblDisplay.text = self.strDisplay;
                operator01 = 0;
                result = 0;
                [basicCalculator release];
                afterEqual = TRUE;
                break;
           case 3:
                basicCalculator = [[Calculator alloc] init];
                [basicCalculator setAccumulator:operator01];
                [basicCalculator multiply:[self.strDisplay doubleValue]];
                result = [basicCalculator accumulator];
                [self showClear];
                self.strDisplay = [self.strDisplay stringByAppendingFormat:@"%g",result];
                lblDisplay.text = self.strDisplay;
                operator01 = 0;
                result = 0;
                [basicCalculator release];
                afterEqual = TRUE;
                break;
           case 4:
                basicCalculator = [[Calculator alloc] init];
                [basicCalculator setAccumulator:operator01];
                [basicCalculator division:[self.strDisplay doubleValue]];
                result = [basicCalculator accumulator];
                [self showClear];
                self.strDisplay = [self.strDisplay stringByAppendingFormat:@"%g",result];
                lblDisplay.text = self.strDisplay;
                operator01 = 0;
                result = 0;
                [basicCalculator release];
                afterEqual = TRUE;
                break;
           default:
                break;
       }    
      }
  }
   
  - (void)showNumber:(NSString *)number {
      if (afterEqual && operation == @"") {
       afterEqual = FALSE;
       [self showClear];
      } if (afterEqual) {
       afterEqual = FALSE;
      }
      if ([self.strDisplay doubleValue] == 0 && [number doubleValue] == 0)  {
       showNumberValid = FALSE;
      }
      if (showNumberValid) {
       self.strDisplay = [self.strDisplay stringByAppendingFormat:@"%@",number];
       lblDisplay.text = self.strDisplay;
      } else if (number == @"." && [self.strDisplay doubleValue] == 0) {
       self.strDisplay = [self.strDisplay stringByAppendingFormat:@"0."];
       lblDisplay.text = self.strDisplay;
      } else if (!enablePoint && [number doubleValue] == 0) {
       self.strDisplay = [self.strDisplay stringByAppendingFormat:@"0"];
       lblDisplay.text = self.strDisplay;
      } else {
       lblDisplay.text = @"0";
      }
  }
   
  - (void)didReceiveMemoryWarning {
      [super didReceiveMemoryWarning];
  }
   
  - (void)viewDidUnload {
      lblDisplay = nil;
  }
   
  - (void)dealloc {
      [super dealloc];
  }
   
  @end 

Este código é um pouco mais extenso, sendo assim, vamos comentar sobre mais alguns pontos importantes para completar as explicações. O primeiro deles é o método viewDidLoad. Você deve ter percebido que este método não foi declarado em CalcViewController.h e mesmo assim está sendo usado em CalcViewController.m.

Para explicar isso, recorremos ao uso do SDK. Quando incluímos o UIKit no nosso código, trazemos várias declarações de métodos que são considerados importantes para o bom desempenho da aplicação. Por isso não precisamos declarar viewDidLoad, isto já foi feito quando incluímos a biblioteca do SDK.

No decorrer de seus estudos sobre iOS você verá vários métodos que não precisam ser declarados, como os métodos que usam o acelerômetro, por exemplo. Mais um ponto a ser tratado sobre viewDidLoad é que este é o primeiro método a ser chamado pela aplicação quando esta classe é executada. Ou seja, se você precisa executar um determinado código antes de qualquer outro, este é o local adequado para isso. Observe que todo código contido neste método está apenas inicializando as variáveis que serão usadas na aplicação.

Anteriormente falamos sobre propriedades de algumas variáveis que criamos, agora vamos observar a variável strDisplay, neste código implementado, para entender o porquê criamos propriedades nela no CalcViewController.h. Observe que todas as vezes que usamos esta variável usamos também o prefixo “self”. Ele indica que estamos querendo usar uma variável pertencente a esta classe, e só podemos usar este prefixo porque criamos uma propriedade para esta variável.

Uma grande vantagem de usar o self é garantir que podemos usar esta variável em qualquer ponto da classe, sem correr o risco de deixarmos a variável fora de escopo.

Outro ponto importante que vale a pena comentar é a forma que chamamos um método de dentro da própria classe. Observe o método show1. Nele temos o seguinte código: [self showNumber:@"1"]. showNumber é o nome do método que queremos executar, e @”1” é o parâmetro que queremos passar para ele. Agora vamos por partes. Os colchetes indicam que o que está contido neles é para ser executado como um bloco, chamados também de contêineres. O self, como já foi explanado, mostra onde está o que queremos executar. Neste caso estamos executando um método contido na própria classe. showNumber é o nome do método que queremos chamar e para passar parâmetros precisamos usar o símbolo “:”. Toda vez que você deseja indicar um tipo string deve colocar o símbolo “@” na frente do conteúdo desejado, que por sua vez deve estar entre aspas.

No exemplo citado, estamos passando um parâmetro do tipo string que contém o número 1. Esta talvez seja a mudança mais chata de se acostumar no início. Outra curiosidade em nosso código está na linha self.strDisplay = [self.strDisplay stringByAppendingFormat:@”%g”, result]. Nesta linha estamos concatenando o conteúdo de self.strDisplay com o resultado da operação. O problema inicial é que a variável que contém o resultado é do tipo double, por isso precisamos fazer uma conversão. Para isso, usamos um formato muito conhecido pela linguagem C, o “%g”. Mais uma vez usamos o símbolo “@” na frente para indicar que estamos concatenando um tipo string.

Interface Builder

Terminamos toda a codificação, agora precisamos criar uma interface para o usuário poder interagir e assim executar nosso código. Na pasta Resources vamos encontrar o arquivo CalcViewController.xib. Na plataforma, arquivos de extensão Nib e Xib indicam que são arquivos feitos para serem editados pelo Interface Builder, sendo os responsáveis pela interação entre o usuário e a aplicação. Extensões Nib são usadas em arquivos gráficos para aplicações desktops, e extensões Xib em arquivos gráficos para aplicações iOS. Isto quer dizer que se desejamos criar a interface que usará o código que implementamos em CalcViewController.h e .m, precisamos trabalhar com o seu arquivo correspondente na extensão .xib. Localizado o arquivo CalcViewController.xib, dê dois cliques.

O IB é uma ferramenta muito intuitiva. Ao iniciá-lo veremos uma view, que reproduz a tela de um iPhone, uma janela chamada Library, que contém os elementos gráficos que podem ser colocados na view, uma janela chamada View Attributes, que contém os atributos de cada componente, e a janela CalcViewController.xib, que contém os elementos deste arquivo – Figura 4.

Interface Builder
Figura 4. Interface Builder.

Você deve montar sua view conforme o que está demonstrado na Figura 4. Os botões da calculadora são formados por componentes UIButton, que pode ser encontrado na janela Library. Para adicioná-lo basta arrastar este componente até a view e soltar. Fazemos isso para cada botão, e para colocar os números alteramos o atributo Title através da janela View Attributes. Para fazer o display da calculadora, utilizamos o componente UILabel, também encontrado na janela Library. Assim como feito com os botões, arraste este componente até a view e solte.

O código da calculadora está pronto e agora montamos o visual da nossa aplicação. O que falta é associar (ligar) os elementos que codificamos com os elementos gráficos. Por exemplo, como a aplicação vai identificar o componente UILabel que acabamos de colocar na nossa view com a variável lblDisplay, declarada no arquivo CalcViewController.h? Lembre-se que esta variável declarada no arquivo .h tinha um prefixo IBOutlet, por isso podemos associá-la com este componente visual.

Para isso, dê um clique com o botão direito em cima do elemento File’s Owner que está dentro da janela CalcViewController.xib. Aparecerá uma janela popup aonde encontraremos a variável lblDisplay. Esta variável aparece exatamente porque a declaramos como IBOutlet no CalcViewController.h. Assim, dê um clique no círculo que se encontra do lado direito do nome dessa variável e arraste até o componente UILabel contido na janela view (Figura 5).

Ligando lblDisplay
com um elemento gráfico
Figura 5. Ligando lblDisplay com um elemento gráfico.

Ao fazermos esta ação estamos ligando uma variável declarada com um elemento gráfico da view. Agora precisamos relacionar as ações do usuário com as ações declaradas no CalcViewController.h.

Para cada botão teremos uma determinada ação relacionada, portanto dê um clique com o botão direito em cima de um botão já posicionado na view. Vai aparecer uma janela popup com uma relação de eventos possíveis para este componente. No círculo associado à opção Touch Down dê um clique e arraste até o File’s Owner da janela CalcViewController.xib, como indica a Figura 6.

Associando evento
com ação
Figura 6. Associando evento com ação.

Outra janela popup vai aparecer para File’s Owner com a relação das ações declaradas no arquivo CalcViewController.h (as IBActions). Neste momento, escolha a ação correspondente para o botão, por exemplo, se for a ação do botão 9, relacione com a ação show9. Observe a Figura 7.

Janela popup em
File’s Owner com lista de ações
Figura 7. Janela popup em File’s Owner com lista de ações.

Terminada todas as ações para todos os botões vamos sair do Interface Builder, salvando o arquivo CalcViewController.xib. Agora compile o projeto clicando COMANDO+B. Se não aparecer qualquer problema podemos executar o projeto. Deste modo, clique OPTION+COMANDO+ENTER. Se tudo correr bem, teremos uma pequena calculadora disponível, conforme a Figura 8.

Calculadora
rodando no simulador
Figura 8. Calculadora rodando no simulador.

Conclusão

Com isso terminamos a nossa calculadora básica. Neste projeto, não foi nosso foco a qualidade visual da calculadora, mas quando você for desenvolver um projeto que terá distribuição comercial, a interface gráfica é de grande importância para a aceitação do projeto perante seus usuários. Como você deve ter percebido, fizemos muitas relações com a linguagem C, que sem dúvida é a linguagem mais próxima de ObjC, mas não se engane, também existem muitas diferenças.

Esperamos que a partir deste artigo você possa começar a desenvolver suas primeiras aplicações para iPad e iPhone. Este é um mundo muito novo, com muito mercado a ser explorado, aproveite. Até a próxima!

Confira também