Escrever Aplicativos iPhone Nativos Usando o Eclipse CDT

Como desenvolvedores do Windows e Linux podem ignorar o iPhone SDK e escrever aplicativos do iPhone usando ferramentas de software livre

Aprenda como usar o C Development Toolkit (CDT) do Eclipse para programar aplicativos nativos para o Apple iPhone, usando ferramentas de software livre para possibilitar o desenvolvimento do S.O. iPhone em qualquer plataforma suportada pelo Eclipse.

Antes de Iniciar

Sobre este Tutorial

Em julho de 2008, com a introdução do Apple iPhone 3G e do iPhone OS V2.0, a Apple Computer liberou versões de produção de um ambiente de desenvolvimento de aplicativos para a criação de aplicativos nativos do iPhone e do Apple iPod Touch para terceiros. Mas o ambiente de desenvolvimento de aplicativos é somente para o Apple Mac OS X, deixando os desenvolvedores que usam os sistemas operacionais Microsoft® Windows® e Linux® fora do processo com relação ao desenvolvimento de aplicativos nativos para essa excitante plataforma.

Este tutorial explora o projeto C Development Tooling (CDT) do Eclipse e como permite funcionar com projetos baseados em C e C++. Neste tutorial, você instala ferramentas de software livre para ajudar a desenvolver aplicativos nativos para a plataforma iPhone no Windows e Linux e aprender sobre o código de origem de um aplicativo básico do iPhone no Objective-C.

Objetivos

Este tutorial mostra como você pode usar o Eclipse e os plug-ins CDT para desenvolver para a plataforma iPhone, usando GNU Compiler Collection (GCC) de software livre. Você usa essas ferramentas para compilar um aplicativo de exemplo Objective-C para o iPhone.

Pré-requisitos

Este tutorial é escrito para programadores de C e C++ cujas qualificações e experiência estão em um nível principiante a intermediário. Você deveria ter uma familiaridade geral usando um shell de linha de comando UNIX® e um conhecimento de trabalho da linguagem C. As estruturas de desenvolvimento do aplicativo nativo iPhone Cocoa Touch são escritas em Objective-C e são baseadas nas estruturas Cocoa usadas no Mac OS X. Familiaridade com Objective-C e as estruturas de desenvolvimento Mac OS X Cocoa não é suposta, mas essas qualificações são úteis para fazer sentido da plataforma iPhone. Estudo adicional de desenvolvimento Cocoa é recomendado após acompanhar este tutorial de introdução.

Requisitos do Sistema

Para acompanhar este tutorial, é necessário:

  • Um computador com o Windows ou Linux com pelo menos 1,5 GB de espaço em disco livre.
  • Uma instalação do Eclipse.
  • Permissão para gravar no diretório /usr/local no sistema de arquivos(C:/cygwin/usr/local para usuários do Windows).
  • Permissão para modificar a configuração do Eclipse instalando plug-ins.

A Plataforma iPhone e iPod Touch

A plataforma iPhone e suas primas, a iPod Touch, são um telefone ativado para WiFi e um dispositivo remoto da Internet, respectivamente, como uma interface gráfica com o usuário (GUI) que é uma obra de arte, um navegador da Web integrado poderoso e diversos outros aplicativos, como e-mail, agenda, contatos, anotações, funções básicas de Geographic Information System (GIS) através de sua integração de Google Maps, assim como funções de entretenimento, como reprodução de filme e música.

A plataforma iPhone é baseada no mesmo sistema operacional Darwin e nas estruturas Objective-C Cocoa que o Mac OS X, modificada para se ajustar em um dispositivo integrado baseado em Advanced RISC Machines (ARM) com 128 MB de RAM, diversos gigabytes de armazenamento flash e uma tela sensível a diversos toques. A plataforma também possui um acelerômetro para detectar a orientação e movimentação do dispositivo e gráficos em 3-D que rivalizam com os recursos dos consoles Sony PSP e PS2.

Darwin, Objective-C e as Estruturas Cocoa Touch

Objective-C é um superconjunto da linguagem C que inclui recursos orientados a objetos para C, mas com uma sintaxe muito diferente da C++. Objective-C foi usada pela NeXT Computer no final dos anos 80 e início dos anos 90 como a linguagem de desenvolvimento de opção para seus sistemas operacionais NextStep e OpenStep. Em meados dos anos 90, a Apple adquiriu a tecnologia da NeXT Computer e assimilou grande parte do NextStep e do OpenStep no sistema operacional Mac OS, produzindo Darwin e Mac OS X da combinação. Darwin é um sistema operacional baseado em UNIX de software livre criado pela Apple como o núcleo da plataforma Mac OS X.

Como com o NextStep e o OpenStep, as ferramentas de desenvolvimento para o Mac OS X e o iPhone são baseadas em Objective-C. A Apple criou uma estrutura de desenvolvimento baseada em Objective-C para Mac OS X: Cocoa. A plataforma iPhone é baseada no mesmo núcleo do sistema operacional Darwin e na estrutura Objective-C Cocoa que a plataforma Mac OS X.Cocoa Touch é a estrutura de desenvolvimento para o iPhone.

C++ e Objective-C são extensões orientadas por objeto da linguagem C. Mas há diferenças chave entre C++ e Objective-C. Objective-C é uma linguagem e um tempo de execução de gerenciamento de tempo de vida de objeto, enquanto que C++ é somente uma linguagem e o programador gerencia o tempo de vida de objeto inteiramente. A outra principal diferença é a sintaxe das operações orientadas a objetos entre as duas. C++ estende a sintaxe de manipulação C struct , enquanto que Objective-C inventa uma nova sintaxe com colchetes com escopo definido. A Tabela 1 representa as principais diferenças entre as linguagens.

Tabela 1. Principais Diferenças Sintáticas entre C++ e Objective-C

Conceito orientado a objetosC++Objective-CExplicação
Solicitação de métodoobject_or_class.method(2, 4);[object_or_class methodWithParam1: 2 param2: 4];C++ estende a sintaxe da linguagem C para acessar elementos de struct e reutiliza a mesma para solicitações de método em classes ou objetos. Objective-C inventou uma sintaxe diferente com colchetes com escopo definido e parâmetros denominados terminados em dois pontos.
Instanciação de objeto UIView contentView = new UIView(x, y, width, height); UIView contentView = [[UIView alloc] initWithFrame: CGRectMake(x, y, width, height)]; Em C++, a palavra-chave new aloca memória para o objeto e chama um dos construtores declarados que corresponda de forma mais próxima aos parâmetros que você passa no código. Em Objective-C, você chama o método alloc da classe, que retorna um objeto não-instanciado da classe. Em seguida, você chama um método init no objeto retornado por alloc para configurar valores iniciais para a instância.
Definições de classe class MyClass { private: int myVariable; void privateMethod(); public: void setMyVariable(int param); } @interface MyClass : NSObject { int myVariable; } @private - (void)privateMethod; @public - (void)setMyVariable: (int)param; @end C++ estende a sintaxe da definição de C struct incluindo a capacidade de definir métodos em uma struct ou class. Também inclui as palavras-chave private e public (assim como a palavra-chave protected não usada neste exemplo) para fornecer o recurso orientado a objetos de encapsulação. Em Objective-C, as palavras-chave @interface e @end são usadas para definir os atributos de uma classe. Objective-C usa as palavras-chave @private, @publice @protected com significado semelhante ao das palavras-chave denominadas em C++. Classes em Objective-C precisam herdar de outra classe. Neste exemplo, a classe NSObject, enquanto que em C++, uma classe pode ser a cabeça de sua própria hierarquia de classes.
Métodos de classe e instância class MyClass { private: static int classVariable; int instanceVariable; public: static void classMethod(); void instanceMethod(int param); } @interface MyClass : NSObject { int instanceVariable; } + (void)classMethod; - (void)instanceMethod: (int)param; @end C++ usa a palavra-chave static no corpo da classe para significar que o método ou variável é um método de classe. Objective-C usa um + anexado a frente de um método de classes e um - anexado em frente de um método de instância.
Declaração de método MyClass::privateMethod() { myVariable++; } MyClass::setMyVariable(int param) { myVariable = param; } @implementation MyClass - (void)privateMethod { myVariable++; } - (void)setMyVariable: (int)param { myVariable = param; } @end C++ inclui o operador de definição de escopo :: para declarar que um método pertence a uma classe específica. Objective-C usa as palavras-chave @implementation e @end para marcar um grupo de métodos como pertencentes a uma classe específica.

Removendo Restrições de Aplicativo de seu iPhone

Decifre o plano de fundo por trás do desenvolvimento de aplicativo do iPhone e descubra como criar seus próprios aplicativos do iPhone.

Jailbreak

Quando a Apple anunciou o iPhone, a empresa minimizou a importância da falta de um ambiente de desenvolvimento de aplicativo sem restrições, citando a necessidade de proteger a rede de dados do provedor do celular contra aplicativos maliciosos em execução em telefones contaminados. Ao introduzir o iPhone software development kit (SDK) em março de 2008, um dos recursos chave era que o iPhone poderia executar somente aplicativos assinados pela Apple usando chaves exclusivas fornecidas a desenvolvedores para iPhone com quem a Apple tem um relacionamento.

Desde setembro de 2007, um grupo chamado iPhone Dev Team desenvolveu métodos para remover as restrições arquitetadas pela Apple para limitar o que poderia ser feito no iPhone. O grupo ajudou a criar as ferramentas de software livre para compilar programas para o dispositivo.

O iPhone Dev Team também criou ferramentas que removem restrições do iPhone e do iPod Touch. Essas ferramentas permitem que proprietários do iPhone usem seus dispositivos em redes além da AT&T nos Estados Unidos ou usem o iPhone em países sem uma operadora de iPhone. Esse processo é chamado de desbloqueio.

Este tutorial cobre somente "jailbreaking", que consiste em permitir que aplicativos não aprovados pela Apple sejam executados no dispositivo. Observe que o uso dessas ferramentas não é suportado pela Apple e seu uso pode anular a garantia do dispositivo se a Apple tiver evidência de modificação de software de terceiros.

Antes de Iniciar

As informações apresentadas aqui são supostamente precisas na época em que este artigo foi escrito. As etapas necessárias para fazer o jailbreak de um dispositivo podem variar com versões posteriores do iPhone OS, QuickPwn, XPwn, Pwnage e WinPwn. Leia a documentação de QuickPwn, XPwn, Pwnage e WinPwn cuidadosamente antes de iniciar.

Como ao usar qualquer outro software não familiar, use seu tempo antes de iniciar. Continue lendo para entender onde você está indo e tenha certeza de entender os possíveis resultados de usar essas ferramentas.

Ferramentas de Jailbreak: QuickPwn, XPwn, Pwnage e WinPwn

O iPhone Dev Team escreveu diversas ferramentas para fazer o jailbreak e desbloquear o iPhone e o iPod Touch, cada uma com crescente facilidade, simplicidade e sofisticação. Os detalhes de instalação e os ponteiros para a documentação on-line estão disponíveis em Recursos.

Se você possuir um iPhone, já utilizá-lo com uma conta de provedor de serviço aprovado pela Apple para seu país e apenas deseja executar aplicativos de seu próprio desenvolvimento no dispositivo, você precisa de uma solução rápida e fácil de jailbreak. De forma semelhante, se você tiver um iPod Touch, uma ferramenta simples de jailbreak é tudo que você precisa.

Efetuando Jailbreak de seu Dispositivo

QuickPwn executa a tarefa de jailbreak rapidamente. Tudo que é necessário para fazer download da versão correta do iPhone OS para seu dispositivo (somente para o iPhone OS versões 2.0 a 2.0.2 são suportadas na época em que este artigo foi escrito). Em seguida, conecte-o a seu computador com o cabo de carregamento/dados USB e coloque seu iPhone no que é chamado de modo DFU , como nas instruções do software. Em menos de 10 minutos, seu dispositivo terá jailbreak efetuado.

Se estiver usando um iPhone em um país onde atualmente não há nenhum provedor de serviços de celular aprovado pela Apple ou deseja usar um iPhone com um provedor diferente do provedor de serviços de iPhone designado para seu país, o iPhone Dev Team oferece Xpwn, Pwnage (consulte a Figura 1) ou WinPwn.

Figura 1. Pwnage é a Principal Ferramenta para Fazer o Jailbreak e Desbloqueio de iPhones

Detalhes da instalação e ponteiros para a documentação on-line estão na seção Recursos . Basicamente, Xpwn, Pwnage e WinPwn permitem criar uma versão com jailbreak efetuado do iPhone OS em seu computador. Em seguida, você usa o iTunes para fazer download do S.O. com jailbreak efetuado em seu iPhone. Isso parece mais complicado do que realmente é. As ferramentas fazem todo o trabalho difícil e usam os mesmos mecanismos automatizados que a Apple usa no iTunes para fazer upgrade do iPhone OS.

Preparando para Desenvolvimento

Após ter efetuado jailbreak de seu dispositivo e reiniciado o mesmo, você terá um dispositivo com uma linha de comando UNIX integral e diversos utilitários pré-instalados para facilitar o desenvolvimento. Mas para tocar essa linha de comando e ativar desenvolvimento, você deve instalar no dispositivo o cliente e o servidor de shell remoto seguro OpenSSH, o Linker Identity Editor e o utilitário Respring para reiniciar o painel. Esses possibilitam que você transfira seus programas para o iPhone e efetue login para executar comandos no dispositivo, assine seu código com uma chave falsa para que o iPhone execute o mesmo e reconfigure seu painel para mostrar seus novos aplicativos copiados.

A instalação de software é simplificada em iPhones com jailbreak efetuado através do uso de Cydia, um front end gerenciador de pacotes para APT. Os usuários de Linux estão provavelmente atordoados agora à medida que a frase anterior é digerida: gerenciamento de pacotes APT, aquele usado por distribuições Linux baseadas em Debian incluindo Ubuntu? Sim, exatamente, meus amigos. Sim, exatamente.

Antes de executar Cydia, certifique-se de que esteja conectado à rede de dados do celular ou WiFi — preferivelmente a segunda, já que OpenSSH é um pouco pesado. Execute Cydia, aguarde até que faça download de manifestos de pacotes a partir das origens integradas, em seguida, clique em Procurar na parte inferior da janela Cydia. Procure openssh e instale-o. Em seguida procure ldid e instale-o. Por fim, procure respring e instale-o.

Agora que você instalou OpenSSH em seu iPhone, é necessário protegê-lo. Todos os iPhones são fornecidos com duas contas de usuários: root e mobile. Ambas têm a mesma senha: alpine. Efetue login em seu dispositivo e altere a senha para essas duas contas. Torne-as diferentes uma da outra — e lembráveis. Conecte seu dispositivo à sua rede WiFi se ainda não tiver feito isso e localize seu endereço IP usando o aplicativo Configurações .

Nota: A primeira vez que você conectar ao iPhone através de OpenSSH, o dispositivo pode levar aproximadamente um minuto para responder, pois está gerando chaves exclusivas do sistema. As conexões subsequentes devem ser praticamente instantâneas.

Você está pronto para começar a criar seu próprio software para o dispositivo. A próxima seção mostra como instalar a cadeia de ferramentas que possibilita a programação do iPhone.


Instalando Ferramentas Pré-requisitas

Quando os desenvolvedores fazem referência a uma cadeia de ferramentas, eles querem dizer os compiladores, assemblers, vinculadores e outras ferramentas que funcionam juntas para construir um arquivo executável para uma plataforma específica a partir de nada, mas recursos e bibliotecas. A cadeia de ferramentas do iPhone usada pela Apple para seu iPhone SDK é realmente baseada em GCC de software livre — a mesma cadeia de ferramentas usada para desenvolvimento em Linux, Sun Solaris e Berkeley Software Distribution (BSD). Devido às suas origens de software livre, o código de origem base para o iPhone SDK está, na verdade, disponível. Membros do iPhone Dev Team produziram instruções e correções para possibilitar que desenvolvedores em outras plataformas construam e usem o mesmo. Isso é o que faremos em seguida.

Há dois requisitos antes de iniciarmos. Você já deve ter uma cadeia de ferramentas instalada para a plataforma que você está executando. Você precisa de ferramentas instaladas que podem converter o código de origem GCC em executáveis para seu sistema operacional. Dependendo de sua plataforma, é possível instalar ferramentas para Windows ou Linux.

Instalar Ferramentas Pré-requisitas no Windows: Cygwin

Cygwin é um conjunto de programas do Windows que cria um ambiente semelhante ao do UNIX para o Windows. Em vez de usar virtualização ou emulação, a equipe do Cygwin criou uma biblioteca de carregamento dinâmica do Windows que implementa uma boa parcela da interface de programação de aplicativos (API), em seguida, prosseguiu para corrigir o código de origem de muitas ferramentas UNIX populares até serem compiladas e executadas com estabilidade suficiente no Windows. Eles vêm aperfeiçoando esse ambiente há mais de 13 anos. Consulte Recursos para obter links para o site do Cygwin, onde você pode fazer download do programa de configuração do Cygwin. O programa de configuração do Cygwin é, na verdade, um download bem pequeno, pois você efetuou download dos demais programas que formam a distribuição Cygwin durante a última parte da instalação do Cygwin.

Para instalar e configurar o Cygwin:

  1. Faça download do programa de configuração do Cygwin, execute-o e clique em Avançar em todos os prompts até chegar à janela mostrada abaixo.
    Figura 2. Parte de Seleção do Diretório-raiz do Cygwin da Instalação
  2. Certifique-se de que as opções na parte inferior dessa janela correspondam àquelas na Figura 2 ou você terá problemas para trabalhar com o código de exemplo e as origens da cadeia de ferramentas de que você fará download nas próximas seções deste tutorial. Se você instalar o Cygwin em um diretório diferente daquele na Figura 2, você deve manter esse diretório em mente e fazer modificações nas etapas fornecidas nas outras seções deste tutorial para corresponderem à sua opção de instalação. Sugiro que você mantenha as coisas simples e siga o exemplo.
  3. Continue pelas janelas de instalação do Cygwin, deixando as opções padrão selecionadas, até chegar à tela de seleção espelho, mostrada abaixo.
    Figura 3. Parte da Seleção Espelho do Cygwin da Instalação
  4. Selecione um site espelho perto de você para distribuir o uso da largura da banda geograficamente. Tente usar o espelho em uma universidade de seu estado ou município, por exemplo. Se você não reconhecer nenhuma das URLs como "local", não há como dar errado se escolher cygwin.osuosl.org ou mirrors.kernels.org. Escolher URLs iniciadas por HTTP em vez de FTP pode ajudar se você estiver tendo problemas com firewalls ou proxies em sua rede.
  5. Continue com a instalação até chegar à janela de seleção de pacote, mostrada abaixo.
    Figura 4. Parte de Seleção de Pacote do Cygwin da Instalação
  6. Expanda a categoria Devel, mostrada abaixo.
    Figura 5. Expandir a Categoria Devel para Mostrar os Pacotes nessa Categoria
  7. Para os pacotes autoconf, binutils, bison, flex, gcc-c++ e make, clique em Ignorar à esquerda do pacote que deseja incluir na instalação, conforme mostrado abaixo. Clicar em Ignorar seleciona somente a caixa de opção da coluna Binário e o número da versão do pacote para mostrar onde estava "ignorar". Observe que os números de versão reais podem diferir do que é mostrado, pois os pacotes são atualizados de forma contínua.
    Figura 6. Selecione os Pacotes para Incluir na Instalação
  8. Role para baixo e expanda Rede, conforme mostrado abaixo.
    Figura 7. Expandir a Categoria Rede para Mostrar seus Pacotes
  9. Selecione os pacotes openssh e openssl, mostrados na Figura 8.
    Figura 8. Selecionar os Pacotes openssh e openssl
  10. Clique em Avançar. A configuração do Cygwin faz download dos pacotes do site espelho e instala-se no diretório especificado anteriormente. Esse processo pode levar mais de uma hora, mesmo em banda larga de 2 megabits e mais rápidas, pois esses espelhos têm alta demanda, não apenas para pacotes do Cygwin, mas para outro software livre que espelham.

Quando o Cygwin conclui download e instalação dos pacotes, você pode decidir se deseja que o Cygwin instale ícones de atalho no desktop ou no menu Iniciar e estará pronto. Você acaba de instalar a cadeia de ferramentas GCC e um ambiente completo semelhante ao UNIX que é executado de forma nativa no Windows. Agora, você pode ir diretamente para a "instalação da cadeia de ferramentas do iPhone a partir da origem."

Instalar Ferramentas Pré-requisitas no Linux

Boas notícias para os usuários do Gentoo: você muito provavelmente possui tudo o que precisa já instalado e pode seguir para a "instalação da cadeia de ferramentas do iPhone a partir da origem." Se estiver usando Debian, Ubuntu ou quaisquer distribuições baseadas nesses dois, você pode instalar o software necessário para compilar a cadeia de ferramentas do iPhone, instalando os pacotes bison, flex, build-essentials e autoconf usando o comando apt-get :

sudo apt-get install build-essential bison flex autoconf

Se estiver usando SuSE ou Red Hat Linux ou qualquer derivativo deles, como o CentOS, é necessário instalar autoconf, binutils, bison, gcc, g++, flex e make com yum.

sudo yum install bison flex autoconf binutils gcc gcc-c++ make

Se estiver usando qualquer outra distribuição Linux, consulte sua documentação para obter instruções sobre como instalar pacotes. Você deseja instalar os pacotes listados para sistemas baseados em yum. Esteja ciente de que gcc-c++ pode ser chamado de outra forma em seu sistema ou pode estar incluído com GCC. Quando os pacotes necessários são instalados, você pode seguir para a "instalação da cadeia de ferramentas do iPhone a partir da origem."


Instalando a Cadeia de Ferramentas do iPhone a partir da Origem

Fazer Download do Código de Origem da Cadeia de Ferramentas

Por que construir a cadeia de ferramentas a partir da origem em vez de fazer download de um binário? Em uma palavra: licenciamento. O código de origem contém poucas limitações de distribuição, sendo software livre. O iPhone Dev Team baseou a cadeia de ferramentas no código de origem localizado em repositórios públicos e modificou o código de forma que compilasse no Linux e no Cygwin.

Eu empacotei o código de origem necessário para compilar a cadeia de ferramentas e fornecer um link na seção Recursos . Faça download desse arquivo e copie-o para a pasta home de sua conta do usuário. Se estiver usando o Cygwin, copie-o para C:/cygwin/home/yourusername se tiver instalado o Cygwin no diretório recomendado. Extraia o pacote com sua ferramenta gzipped compatível com tar favorita e você localizará uma pasta denominada iphone-2.0-toolchain em seu diretório inicial.

Fazer Download de Firmware do iPhone da Apple

Em seguida, obtenha o firmware do iPhone e inclua o mesmo no código de origem da cadeia de ferramentas. O código da Apple necessário é o firmware do iPhone V2.0. Faz diferença a versão obtida: você quer o firmware do iPhone OS V2.0 para o iPhone de primeira geração, com o nome de arquivo iPhone1,1_2.0_5A347_Restore.ipsw. Consulte Recursos para obter qualquer artigo sobre como fazer de Pwnage ou WinPwn para obter o link a partir do qual fazer download.

O arquivo de restauração do firmware é nada mais do que um arquivo ZIP. Após ter o firmware, altere a extensão para .zip e abra-o com qualquer utilitário de extração para sua plataforma. Dentro do arquivo ZIP, você encontrará um arquivo chamado 018-3785-2.dmg. Copie esse arquivo DMG para a pasta home de sua conta do usuário, logo ao lado da pasta iphone-2.0-toolchain da anterior. (Usuários do Windows: fazemos referência à pasta home do usuário do Cygwin, não à sua pasta home de usuário do Windows.)

Montar a Imagem do Sistema Operacional

Esse arquivo DMG é uma imagem real criptografada da parte do sistema operacional no dispositivo. Você deve decriptografar esse arquivo antes de poder montar a imagem e extrair os arquivos necessários. Felizmente, o iPhone Dev Team escreveu uma ferramenta para decriptografar a imagem da partição e obteve e publicou a chave de criptografia. A próxima etapa é compilar o decriptografador de imagem e usá-lo para obter uma imagem decriptografada que pode ser montada. Abra uma sessão de terminal (no Windows, use o atalho Cygwin, e não a linha de comando do Windows), e digite o seguinte :

gcc ~/iphone-2.0-toolchain/src/vfdecrypt.c -o ~/vfdecrypt -lcrypto

Esse comando compila o código do decriptografador DMG para um arquivo executável denominado vfdecrypt em sua pasta home. Agora você pode decriptografar o arquivo DMG.

~/vfdecrypt -i ~/018-3785-2.dmg -o ~/decrypted.dmg -k \
2cfca55aabb22fde7746e6a034f738b7795458be9902726002a8341995558990f41e3755

Observe que são duas linhas separadas e não se esqueça da barra invertida (\) no final da primeira linha. É, na verdade, um único comando, mas dividimos o mesmo em dias linhas com a barra invertida para evitar ambiguidade causada pelo comprimento do comando. Você pode querer colar as duas linhas em vez de inserir manualmente a chave de decriptografia monstruosa.

Agora que você decriptografou o DMG, monte-o e extraia o conteúdo. Os usuários do Linux podem instalar os drivers HFS e montar o DMG. Tudo bem se sua distribuição possuir somente drivers HFS somente leitura, pois você deseja apenas copiar alguns arquivos. Os usuários do Windows podem usar PowerISO ou Transmac (consulte Recursos) para abrir o arquivo DMG e copiar os arquivos desejados.

Copiar as Pastas Necessárias

Agora que você montou ou abriu o DMG decriptografado, você deve copiar três pastas de lá. Suponha que decrypted.dmg refira-se ao volume montado, independentemente de se você o montou no Linux ou abriu o arquivo com Transmac ou PowerISO. As pastas são decrypted.dmg/usr/lib, decrypted.dmg/System/Library/Frameworks e decrypted.dmg/System/Library/PrivateFrameworks. Dentro da pasta iphone-2.0-toolchain estão duas pastas: iphone-fs/System/Library/ e iphone-fs/usr/. Copie a pasta lib para iphone-fs/usr/. Copie Frameworks e PrivateFrameworks para iphone-fs/System/Library/. As etapas abaixo ajudam a esclarecer quais pastas precisam ser copiadas e onde colá-las:

  1. Copie a pasta lib para seu desktop temporariamente, conforme mostrado na Figura 9. (Você irá movê-la em breve para onde deve estar.)
    Figura 9. Copiar a Pasta lib para seu Desktop
  2. Copie as pastas Frameworks e PrivateFrameworks para seu desktop temporariamente, conforme mostrado abaixo.
  3. Copie a pasta lib para seu desktop temporariamente, conforme mostrado na Figura 9. (Você irá movê-la em breve para onde deve estar.)
    Figura 10. Copiar as Pastas Frameworks e PrivateFrameworks
  4. Mova a pasta lib de seu desktop para a pasta iphone-fs/usr.
  5. Mova Frameworks e PrivateFrameworks juntas para a pasta iphone-fs//System/Library, conforme mostrado abaixo.
  6. Copie a pasta lib para seu desktop temporariamente, conforme mostrado na Figura 9. (Você irá movê-la em breve para onde deve estar.)
    Figura 11. A Pasta lib Fica na Pasta lib e as Pastas Frameworks e PrivateFrameworks em /System/Library

Compilar a Cadeia de Ferramentas

Após ter copiado as pastas para seus destinos, você pode desmontar o DMG ou fechar Transmac ou PowerISO. Agora, abra um terminal e digite os seguintes comandos:

cd ~/iphone-2.0-toolchain
./make-toolchain

Esses comandos finalmente iniciam o processo de compilação da cadeia de ferramentas do iPhone e sua instalação em /usr/local em seu sistema. O processo leva aproximadamente duas horas em um Core 2 Duo MacBook de 2,0 GHz executando o Microsoft Windows XP em VMware com 640 MB de RAM alocados para a máquina virtual (VM). Após aguardar alguns minutos, você verá muita coisa rolar muito rapidamente. Não se preocupe: isso significa que está funcionando!A única vez que você deve se preocupar é se parar e retornar à linha de comando do shell após exibir diversas linhas de erro, como as abaixo.

Figura 12. Linhas de Erro de Exemplo Durante o Processo make

Se o processo make parar, mas você não vir nenhuma linha de erro como as da Figura 12, você concluiu com êxito o processo de compilação. Agora que você construiu a cadeia de ferramentas, está pronto para iniciar a criação se seu próprio software para o iPhone. Em seguida, você deve instalar o Eclipse CDT e pode explorar como permite que você programe C e C++ no Eclipse.


Desenvolvimento de C e C++ com o Eclipse CDT

Instalar o Eclipse CDT e outros Plug-ins

Para trabalhar com Objective-C no Eclipse, é necessário instalar duas coisas: o Eclipse CDT (para gerenciar makefiles e seus arquivos de projeto) e um plug-in de editor do Eclipse (para fornecer realce da sintaxe de Objective-C). O plug-in Color Editor oferece realce da sintaxe para mais de 140 linguagens.

Se ainda não tiver o Eclipse ou se não quiser integrar todos esses plug-ins em sua instalação do Eclipse, verifique o projeto EasyEclipse (consulte Recursos) e faça download do EasyEclipse para a distribuição C e C++. EasyEclipse inclui Eclipse, Eclipse CDT, Subclipse e plug-ins CVS para gerenciar suas revisões de origem, assim como diversos plug-ins para realce da sintaxe e manipulação de diferentes linguagens pelo editor padrão, incluindo Objective-C. Encontre tudo isso em um único download simples para Windows, Linux e Mac OS X.

Se você já tiver o Eclipse instalado e não tiver nenhum problema para incluir plug-in manualmente, você pode incluir ambos em sua cópia do Eclipse facilmente. Para instalar o Color Editor, faça download do plug-in e solte o JAR em seu diretório plugins do Eclipse. Para instalar o Eclipse CDT, vá para a página de download do Eclipse CDT e localize a URL correta para sua versão do Eclipse. No Eclipse, vá para Ajuda > Atualização de Software > Localizar e Instalar... > Procurar Novos Recursos para Instalar > Novo Site Remoto... e insira a URL correta do CDT para sua versão do Eclipse. Continue com a instalação e reinicie o Eclipse (consulte Recursos para o CDT e o Color Editor).

Criar um Projeto Eclipse CDT

Após instalar o Eclipse CDT e o Color Editor, instalando EasyEclipse ou incluindo manualmente os plug-ins, você pode iniciar a programar em C ou C++.

Inicie criando um projeto simples para o Eclipse CDT:

  1. Execute o Eclipse. No ambiente de trabalho, escolha Arquivo > Novo > Projeto para ativar a janela Novo Projeto .
  2. Escolha Geral > Projeto e, em seguida, clique em Avançar, conforme mostrado abaixo.
    Figura 13. A Janela Novo Projeto
  3. Denomine o projeto HelloWorld.
  4. Se estiver usando o Windows, altere o local padrão para C:/cygwin/home/yourusername/HelloWorld, em seguida, clique em Concluir.

    O novo projeto aparece em seu Project Explorer no ambiente de trabalho. Clique em Sim se o Eclipse solicitar que você altere para a Perspectiva C/C++.

  5. Crie dois arquivos o projeto: Makefile e HelloWorld.c.
  6. Copie o código da Listagem 1 para o Makefile.
    Listagem 1. Conteúdo do Makefile
    CC=gcc
    CXX=g++
    LD=$(CC)
    
    all:    HelloWorld
    
    HelloWorld:    HelloWorld.o
        $(LD) $(LDFLAGS) -o $@ $^
    
    %.o:    %.c
        $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
    
    clean:
        rm *.o HelloWorld
  7. Copie o código da Listagem 2 para o HelloWorld.c.
    Listagem 2. Conteúdo do HelloWorld.c
    #include <stdio.h>
    
    int main(void) {
      printf("Hello, world!\n");
      return 0;
    }

Executar o Projeto

Agora,você pode executar esse projeto. Abra um terminal e vá para o diretório onde seu projeto foi criado. Lá, digite o comando make verifique se há erros no make. Se tiver criado os arquivos Makefile e HelloWorld.c corretamente, não deve haver nenhum erro e a saída produzida o console deve ter somente duas linhas.

gcc -c   HelloWorld.c -o HelloWorld.o
gcc  -o HelloWorld HelloWorld.o

Digitar make na linha de comando faz com que um programa chamado make interprete o makefile, que efetivamente indica a make que deve compilar HelloWorld.c em um arquivo de objeto chamado HelloWorld.o, vincular HelloWorld.o implicitamente às bibliotecas C padrão e produzir um arquivo executável chamado HelloWorld. Esse é o significado dos dois comandos produzidos como saída do console pelo make.

Se você tiver programado em C no UNIX antes, isso, provavelmente, não é uma novidade interessante. No entanto, é bom verificar se o código C simples e o makefile estão funcionando corretamente executando o programa compilado e vinculado com o seguinte comando:

./HelloWorld

Isso deve produzir a saída "Hello, world!" no console. Agora, modifique o makefile e produza um arquivo executável executado no iPhone usando sua nova cadeia de ferramentas.

Criar um Arquivo Executável para o iPhone

Para criar tal arquivo executável, é necessário sobrescrever as duas primeiras linhas do makefile com o seguinte código:

CC=/usr/local/bin/arm-apple-darwin9-gcc
CXX=/usr/local/bin/arm-apple-darwin9-g++

Esse comando indica a make para usar sua nova cadeia de ferramentas do iPhone, em vez de a cadeia de ferramentas de seu sistema usada anteriormente. Digite make clean na linha de comando e o programa make executa a regra clean na parte inferior, que exclui o arquivo executável e o arquivo de objeto produzido anteriormente pela versão anterior do makefile.

Agora, você pode digitar make e a nova cadeia de ferramentas é chamada, em vez de a cadeia de ferramentas do sistema. Isso produz um arquivo de objeto HelloWorld.o e o arquivo executável HelloWorld para o iPhone. Copie-o para seu dispositivo para ver se sua cadeia de ferramentas realmente funciona. Conecte seu dispositivo à sua rede WiFi, descubra seu endereço IP no aplicativo Configurações e envie o arquivo executável HelloWorld para ele com um comando semelhante ao seguinte (substitua IPHONE_IP pelo endereço IP para seu dispositivo).

scp HelloWorld root@IPHONE_IP:~/

Executar o Programa

Agora, efetue login através de ssh para executar o programa. Substitua IPHONE_IP novamente pelo endereço IP de seu dispositivo.

ssh root@IPHONE_IP

Quando você tive efetuado login, você está no prompt do usuário root no iPhone.

./HelloWorld

E aposto que você está desapontando pela saída "Killed" no console. O que ocorreu é que o loader de executável do iPhone espera que todos os executáveis estejam assinados. O iPhone Dev Team conseguiu remover praticamente todas as restrições do OS V2.0, mas não quiseram mexer muito com o loader de executável. Nem tudo está perdido: você pode usar o comando ldid do utilitário Linker Identity Editor instalado com o Cydia anteriormente. O comando ldid produz uma assinatura de executável falsa para enganar o loader de executável.

ldid -S HelloWorld
./HelloWorld

Desta vez, funciona e a galera grita em aprovação. Você executou código com êxito em seu dispositivo que você mesmo escreveu e compilou apenas minutos atrás. Você chega à única conclusão lógica que um programador florescente do iPhone pode chegar neste momento: vamos criar uma GUI para ele!


Compilando e Construindo um Pacote Configuração de Aplicativo Nativo Cocoa Touch iPhone

Supondo que suas experiências anteriores funcionaram, é aqui que a coisa esquenta. Você irá criar um aplicativo GUI simples que possa ser ativado tocando seu ícone na tela sensível ao toque do iPhone.

Modificar o makefile de seu Projeto

Você inicia criando o aplicativo GUI, modificando o makefile para seu projeto e escrevendo algum código Objective-C. Para manter as coisas simples, há código do programa de amostra na pasta iphone-2.0-toolchain em examples/GUI/HelloWorldiPhone. Pegue o makefile e todos os outros arquivos dessa pasta e sobrescreva seus arquivos do projeto Eclipse com ele. Exclua HelloWorld.c, que você substituiu por HelloWorld.m, em Objective-C.

Abra o novo makefile no Eclipse, mostrado na Listagem 3 e examine-o.

Listagem 3. O Novo Arquivo make
CC=/usr/local/bin/arm-apple-darwin9-gcc
CXX=/usr/local/bin/arm-apple-darwin9-g++
LD=$(CC)

CFLAGS=-I/usr/local/lib/gcc/arm-apple-darwin9/4.2.1/include \
    -isysroot /usr/local/iphone-sysroot

LDFLAGS=-framework CoreFoundation -framework Foundation -framework UIKit \
    -lobjc -bind_at_load -isysroot /usr/local/iphone-sysroot

all:    HelloWorld.app

HelloWorld.app:    HelloWorld Info.plist
    mkdir -p HelloWorld.app
    cp Info.plist HelloWorld Default.png icon.png HelloWorld.app/

HelloWorld:    HelloWorld.o HelloWorldApp.o
    $(LD) $(LDFLAGS) -o $@ $^

%.o:    %.m
    $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

clean:
    rm -rf *.o HelloWorld HelloWorld.app

Essa versão do makefile inclui CFLAGS e LDFLAGS, que indicam ao compilador e ao vinculador onde localizar seus arquivos de inclusão e de biblioteca. Observe os parâmetros -framework do vinculador. Eles indicam ao vinculador que deve usar as estruturas obtidas do firmware do iPhone ao preparar sua cadeia de ferramentas do iPhone.

A regra de compilação CC também foi alterada. Você não está mais compilando arquivos .c para arquivos .o; em vez disso, agora, você se preocupa com arquivos .m. Como você provavelmente deduziu quando eu disse que HelloWorld.m substitui HelloWorld.c, .m (que significa módulo) é o arquivo de origem para programas Objective-C.

Há uma regra extra para algo chamado HelloWorld.app. Verificando os comando abaixo da regra, parece ser uma pasta na qual você empilha o executável e alguns outros arquivos, como o Info.plist. A Listagem 4 mostra esse arquivo.

Listagem 4. Info.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
 "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>CFBundleDevelopmentRegion</key>
    <string>en</string>
    <key>CFBundleExecutable</key>
    <string>HelloWorld</string>
    <key>CFBundleIdentifier</key>
    <string>com.pjtrix.helloworld</string>
    <key>CFBundleInfoDictionaryVersion</key>
    <string>0.1</string>
    <key>CFBundleName</key>
    <string>HelloWorld</string>
    <key>CFBundlePackageType</key>
    <string>APPL</string>
    <key>CFBundleShortVersionString</key>
    <string>1.0.0</string>
    <key>CFBundleSignature</key>
    <string>????</string>
    <key>CFBundleVersion</key>
    <string>1.0</string>
</dict>
</plist>

O arquivo Info.plist é usado pela UI do painel do iPhone para descobrir qual é o nome do executável e como chamar o ícone na tela sensível ao toque. O Info.plist é o que transformas seu HelloWorld.app de apenas uma pasta com alguma coisa dentro dela em um pacote configurável de aplicativo do iPhone real. Observe que Info.plist possui um I maiúsculo em seu nome: o painel do iPhone é exigente e espera que os arquivos do pacote configurável sejam denominados de forma precisa.

O pacote configurável também contém dois arquivos gráficos: Default.png e icon.png. O painel do iPhone usa icon.png como o ícone para seu programa no painel. Default.png é usado para exibir um gráfico simulado na tela enquanto o usuário aguarda até seu executável carregar e desenhar sua UI.

Nota: O nome do arquivo icon.png deve ser somente em minúsculas ou não será exibido. Da mesma forma, Default.png deve ter um D maiúsculo ou não será exibido na inicialização do aplicativo.

Agora, prossiga para a parte realmente importante do aplicativo: o código Objective-C que faz com que tudo aconteça.

O Código Objective-C

Inicie com HelloWorld.m, que a Listagem 5 mostra.

Listagem 5. HelloWorld.m
//
//  HelloWorldApp.h
//  HelloWorld
//
//  Criado por PJ Cabrera em 18/08/2008.
//  Copyright de PJ Cabrera 2008. Todos os direitos reservados.
//

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import "HelloWorldApp.h"

int main(int argc, char *argv[]) {
    // Esse conjunto de liberação automática é gerenciado pelo dispatcher de eventos da 
    // UI. Ele libera automaticamente quaisquer objetos alocados que estiverem fora do 
    // escopo. A implementação do iPhone de Objective-C 2.0 ainda não possui coleta de  
    // lixo, mas os conjuntos de liberação automática e a liberação apropriada de  
    // objetos alocados ainda é uma boa prática.
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    // É onde a execução da UI é iniciada. Isso instancia a subclasse UIApplication
    // e a subclasse UIApplicationDelegate especificadas como parâmetros de cadeia. 
    // O nome de uma subclasse UIApplication pode ser passado como UIApplication e
    // UIApplicationDelegate.
    UIApplicationMain(argc, argv, @"HelloWorldApp", @"HelloWorldApp");

    // Force a liberação do conjunto de liberação automática e de todos os objetos ainda 
    // alocados.
    [pool release];
    return 0;
}

Na verdade, não parece muito diferente de C. Foundation e UIKit são as duas estruturas Objective-C que serão mais usadas na plataforma Cocoa Touch. Foundation é onde cadeias, listas e hierarquias bases orientadas a objetos são definidas em Cocoa e Cocoa Touch. UIKit define muitos elementos da interface com o usuário em um aplicativo do iPhone.

Objective-C sendo um superconjunto de C, a inicialização do aplicativo é definida muito da mesma forma que em C: tudo começa na função main . A primeira linha do código real dentro da função main é a primeira parte de Objective-C nessa parte do código. Lá, você está alocando e inicializando uma instância de uma classe Objective-C , NSAutoreleasePool, usada para gerenciar a memória. No Mac OS X e Objective-C V2, é bem semelhante à coleta de lixo, mas não está integralmente implementado no ambiente Objective-C do iPhone nesta versão do iPhone OS.

A segunda linha do código real é onde a estrutura da UI inicia a execução. UIApplicationMain instancia as classes denominadas nos dois parâmetros de cadeia e chama métodos específicos nessas duas instâncias de classe que colocam o aplicativo em execução. A última parte do código é chamada quando a interface com o usuário é encerrada. Libera o conjunto de liberação automática e retorna ao ambiente de chamada.

Agora, dê uma olhada em HelloWorldApp.m. É para onde UIApplicationMain mover a ação. Carregue o arquivo a seguir no Eclipse.

Listagem 6. HelloWorldApp.m
//
//  HelloWorldApp.m
//  HelloWorld
//
//  Criado por PJ Cabrera em 18/08/2008.
//  Copyright de PJ Cabrera 2008. Todos os direitos reservados.
//

#import "HelloWorldApp.h"

@implementation HelloWorldApp

- (void)applicationDidFinishLaunching:(UIApplication *)application {
    // Crie uma janela de "tela inteira" para conter a UI.
    window = [[UIWindow alloc] initWithContentRect:
        [UIHardware fullScreenApplicationContentRect] ];

    // Crie uma visualização para conter o conteúdo da janela.
    contentView = [[UIView alloc] initWithFrame: CGRectMake(0.0f, 0.0f, 320.0f, 480.0f)];

    // Crie uma barra de navegação para a parte superior da visualização, com dois botões.
    // Os botões não fazem nada neste exemplo.
    nav = [[UINavigationBar alloc] initWithFrame: CGRectMake(0.0f, 0.0f, 320.0f, 48.0f)];
    [nav pushNavigationItem:[[UINavigationItem alloc] initWithTitle:@"Hello World"]];
    [nav showButtonsWithLeftTitle: @"Left" rightTitle: @"Right"];
    [nav setBarStyle: 0];
    [contentView addSubview: nav];

    // Crie uma visualização de texto, esse é um editor de texto básico, com teclado 
    // incorporado.
    text = [[UITextView alloc] initWithFrame: CGRectMake(0.0f, 48.0f, 320.0f, 480.0f)];
    [text setText: [[NSString alloc]
        initWithString: @"Hello World\nCocoa Touch Application"]];
    [contentView addSubview: text];

    // UIWindow pode conter somente uma visualização, contentView. contentView pode 
    // conter muitos controladores de suspensão, que controlam as diferentes  
    // visualizações em seu aplicativo.
    window.contentView = contentView;

    // Estas três instruções efetivamente mostram a janela.
    [window orderFront: self];
    [window makeKey: self];
    [window _setHidden: NO];
}

- (void)dealloc {
    // Libere os elementos da UI, já que foram alocados
    [text release];
    [nav release];
    [contentView release];
    [window release];

    // E não se esqueça de chamar a classe-pai dealloc
    [super dealloc];
}

@end

Quando UIApplicationMain instancia a classe HelloWorldApp , a execução do aplicativo continua com o método chamado applicationDidFinishLaunching. É onde você cria os elementos iniciais da interface com o usuário que iniciam o aplicativo do ponto de vista do usuário. Primeiro, a função aloca uma instância da janela e inicializa a mesma com o tamanho de tela, chamando a classe UIHardware do método fullScreenApplicationContentRect.

Em seguida, aloca e inicializa uma instância UIView , que contém todos os outros elementos da tela. Há uma barra de navegação com dois botões chamados Left e Right que neste exemplo são apenas para exibição. Há também uma grande instância UITextView com o texto "Hello, World" e "Cocoa Touch Application" em duas linhas separadas. Por fim, configure essa visualização como a visualização principal para sua janela e configure a janela para receber entrada e ficar visível.

Se você executar make e tudo ocorrer sem problemas, make terá criado uma pasta HelloWorld.app e copiado a mesma para seu arquivo Info.plist, as imagens icon.png e Default.png e seu arquivo executável HelloWorld. Copie essa pasta para seu dispositivo. Como antes, substitua pelo endereço IP de seu iPhone IPHONE_IP nos comandos abaixo.

scp -r HelloWorld.app root@IPHONE_IP:/Applications/
ssh root@IPHONE_IP

Ao efetuar login no dispositivo, assine o executável para que possa ser executado.

ldid -S /Applications/HelloWorld.app/HelloWorld

Tornar o Aplicativo Acessível

Para tornar seu aplicativo acessível a partir do painel do iPhone, copie todo o pacote configurável do aplicativo para uma pasta chamada Applications na raiz do sistema de arquivos do iPhone. Mas para que apareça no painel sem precisar reiniciar o dispositivo, em seguida, execute o aplicativo Respring instalado no início do tutorial e efetue "respring" do painel.

Após efetuar respring do painel, seu aplicativo HelloWorld aparece entre os outros ícones. Toque-o para ativá-lo e veja: uma barra de navegação na parte superior com dois botões denominados Left e Right e uma grande visualização de texto com as frases, "Hello World" e "Cocoa Touch Application" em duas linhas separadas. E a grande surpresa: toque na área de texto e aparece um teclado pop-up na parte inferior da tela para que você digite. O teclado vem "gratuitamente" quando você cria uma área de texto. Não foi necessário escrever código para ativá-lo.


Resumo

Usar o Eclipse para programar aplicativos para o iPhone não está isento de problemas. Objective-C não é suportado por ferramentas de refatoração, não é fácil configurar depuração remota no momento (apesar de GDB suportar depuração de Objective-C) e plug-ins de terceiros, como o Color Editor, precisam ser instalados para obter-se realce da sintaxe de código Objective-C. Eu poderia ter usado mais tempo configurando o Eclipse CDT para permitir compilação no Eclipse em vez de usar make a partir da linha de comando. Mas isso teria se transformado em um tutorial do Eclipse CDT em vez de um tutorial do Cocoa Touch.

Com o tempo, espero reunir um grupo de desenvolvedores para que me ajudem a estender o suporte de Objective-C para o Eclipse CDT. Se quiser aprender mais sobre o desenvolvimento em Cocoa Touch sem o iPhone SDK, usando o Eclipse no Windows ou Linux, pode entrar em contato comigo por meu e-mail e eu posso direcioná-lo a informações adicionais. Também pode entrar em contato comigo se emperrar em qualquer ponto deste tutorial, como com problemas para fazer com que a cadeia de ferramentas construa ou fazer com que os exemplos sejam executados.

Espero que este tutorial ajude-o a iniciar. Programar para o iPhone pode ser bem divertido.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Linux
ArticleID=403760
ArticleTitle=Escrever Aplicativos iPhone Nativos Usando o Eclipse CDT
publish-date=05162014