Aproveite ao máximo seu iPad na hora de ler

 

Sei que para algumas pessoas alguns procedimentos deste “guia” podem parecer meio óbvios. Mas escrevi com base nas dúvidas que eu observo por aí. Portanto, boa leitura!

iBooks. Seu grande aliado!

É certo que não existe apenas um aplicativo para exibir e catalogar e-livros na AppStore. Se fizermos uma busca, retornaremos inúmeros resultados.

Dentre eles: o kindle, leitor da Amazon, Google Books, da Google, e etc.

A razão pela qual eu escolhi o iBooks como meu leitor principal foi a conveniência, afinal de contas ele foi desenvolvido pela Apple, pensado e projetado para os iGadgets, é free, possui integração com a loja de livros da AppStore, é compatível com os formatos de livros digitais mais usados, tem dicionário embutido (apenas para língua inglesa), interface bonita e simples, sem muitas firulas, e usabilidade impecável.

As principais funcionalidades estão apenas a um toque.

Entendendo a interface principal

Como eu mencionei acima, a interface do iBooks é bastante usual, autoexplicativa. Vamos ao básico:

1. Nome da Estante – Título da sua “estante de livros”;
2. iBookStore – Loja de e-books oficial da AppStore. Nela você poderá comprar e baixar seus livros conforme desejar. O processo de compra é idêntico ao de aplicativos. Apenas com uma ressalva, é possível fazer o download de uma prévia do e-book antes de realizar a compra, um “sample”. Ideal para saber se realmente é aquilo que você procura;
3. Coleções – Como o próprio nome sugere, aqui você pode conferir suas coleções, bem como adicionar novas. O iBooks é instalado com duas coleções padrões: Livros e PDFs. No decorrer do post entenderemos melhor está função;
4. Modo de visualização “Estante de livros” – Ativa o modo de visualização “Estante de livros”, idêntico a imagem acima;
5. Modo de visualização “Lista” – Ativa o modo de visualização em forma de lista. O diferencial deste modo visualização é que quando ativo, ele dá acesso a alguns filtros de listagens, muito importante para quem possuí muitos títulos armazenados. Os filtros são: Títulos, onde ele organiza por ordem alfabética com base nos nomes dos livros, autores, organiza com base nos autores, e categorias, onde ele cataloga com base no estilo do livro. Exemplo: aventura, ficção, manuais e etc.;
6. Editar – Habilita as funções de mover, ordenar e apagar seus livros;
7. Buscar – Um simples campo de busca onde você pode buscar pelo nome do autor, título, editora, categoria e etc;
8. Estante – Local onde seus livros ficam dispostos.

Funcionalidades Básicas

Agora vamos conferir as principais funções do aplicativo e aprender como utilizá-las.

Dicionário
Com certeza um dos principais recursos desse maravilhoso aplicativo. Vale lembrar que por enquanto ele funciona apenas com a língua Inglesa. Quem sabe nas próximas versões a Apple inclua suporte ao Português…

Usar o dicionário do iBooks é muito simples. Basta tocar e manter o dedo no termo em que você deseja pesquisar por alguns segundos, no menu que aparecerá, basta selecionar a opção “dicionário”.

Veja o exemplo:

Como você pode ver, ao selecionar “dicionário”, abre-se uma janelinha suspensa com a definição da palavra em questão. Mão na roda, hein…

Destacar texto e adicionar notas

Quando estamos estudando, seja para exames, seminários ou coisa do tipo, ou simplesmente queremos destacar determinada parte do texto, é comum que façamos marcações para saber que aquele trecho é relevante para nós, bem como o hábito de escrever notas para especificar algo que você observou naquela passagem. E é essa a função desses recursos.
O primeiro, como o próprio nome sugere, destaca uma parte do texto selecionada por você, enquanto o segundo adiciona notas personalizadas que ficam armazenadas no canto direito da sua tela.

• O procedimento para destacar o trecho de um texto é muito simples. Primeiramente toque e mantenha seu dedo por alguns segundos na palavra a qual você deseja começar a marcação. Note que nas extremidades da palavra que você escolheu, surgirão dois “selecionadores”, toque e arraste até o ponto de sua preferência. Por fim, no menu suspenso, selecione a opção destacar.

Confira logo abaixo:

Perceba que após destacado, basta que se dê dois toques em qualquer uma das partes destacadas para que se possa selecionar ou copiar aquele trecho. Para remover a marcação é necessário tocar uma única vez em qualquer parte marcada e selecionar a opção “Remover destaque”.

• O processo de adicionar notas é quase idêntico ao de destacar o texto. Toque e aguarde até que os “selecionadores” apareçam. Especifique a área a qual você deseja associar uma nota, e por fim, no menu suspenso, selecione a opção “Nota”.

Exemplo:

Note que após a inserção de uma nota, a mesma ficará sendo exibida na margem direita do aplicativo, e o trecho que você selecionou também ficará destacado. Caso você deseje excluir a nota, basta selecioná-la e apagar todo o seu conteúdo.

Obs: Após a exclusão de uma nota, o trecho selecionado continuará destacado. Para remover, basta seguir os procedimentos do item anterior.

Sépia e marcadores

Por padrão, o iBooks vem configurado para exibir as páginas de seus livros com fundo branco e letras pretas. Mais uma vez, aqui vale o gosto do usuário.

Eu, particularmente, tenho uma melhor leitura com as páginas em tom de sépia. Além de achar mais divertido (rsrsrsr), minha visão não cansa tão rapidamente. Se você não sabe o que é sépia, entenda a diferença a seguir:

Para ativar esse modo de visualização, basta selecionar o ícone no canto superior direito da tela referente à fonte: “AA”, procurar a opção “sépia” e mover o botão para o modo ativado. Vale lembrar que esta função só será exibida quando algum livro estiver sendo lido.

OBS: Caso o arquivo em questão seja em formato PDF, esta opção não estará disponível.

O marcador do iBooks é mais um recurso indispensável em sua leitura. Pode até parecer brincadeira, mas muita gente não sabe qual a sua função. Ou melhor, muita gente não sabe se quer que ele exista!

Para os desavisados de plantão, segue a dica:
O marcador serve simplesmente para marcar o progresso da sua leitura. Outra função bem legal do marcador do iBooks, é que se você, além do iPad, lê seus livros em outros dispositivos como o iPod touch ou iPhone, ao sincroniza-los com o iTunes, o marcador também será atualizado. Assim você sempre irá continuar exatamente de onde parou independente do dispositivo usado para a leitura.

Marcar uma página é muito simples. Na página que deseja salvar seu progresso, toque no último botão do canto superior direito. Após tocá-lo repare que ele ficará vermelho, indicando que aquela página foi marcada.

Agora toda vez que você abrir aquele livro, ele automaticamente vai exibir a última página que você marcou. Simples, hein…

Xing Ling com os dias contados?

O incrível avanço tecnológico das versões chinesas do iPhone que possuem dual-chip e recepção de TV estão com os dias contados. Segundo a edição de hoje do jornal Folha de S. Paulo, o Ministério Público quer dificultar a vida do mercado paralelo e encontrar uma maneira de bloquear ligações de aparelhos celulares falsificados.

Aquele seu cunhado chato não poderá mais tirar vantagem do celular chinês dele
Segundo a ANATEL, cerca de 20% das linhas ativas hoje no país usam aparelhos sem a certificação, que é obrigatória, chegando a 40% só entre os clientes pré-pagos. Isso representa uma perda anual de R$ 1 bilhão para os fabricantes dos produtos originais, o dobro do que era em 2008.
Por causa disso, o Ministério Público quer abrir uma ação civil que obrigue as teles a bloquear estes aparelhos clandestinos, impossibilitando qualquer chamada através dele. O problema é como fazer isso.

Crédito da imagem: Folhapress
A ANATEL e as operadoras podem até mesmo serem consideradas como rés no processo, por não fiscalizarem as vendas clandestinas. A comercialização e a prestação de serviços a aparelhos não-certificados é proibida no país.
Crédito da imagem: Folhapress
Uma das soluções em estudo seria a distribuição de uma senha para cada cliente, que cadastraria seu aparelho e o associaria a um chip. Dispositivos com IMEI não certificado seriam bloqueados e impossibilitados de funcionar. Mas este procedimento ainda precisa ser melhor definido antes de aplicado, pois muitos celulares falsos já são capazes de utilizar IMEI autêntico.

Apple oferece recursos para facilitar a adoção do iPad em empresas

Prevendo que muitos dos primeiros compradores do iPad considerarão a possibilidade de usá-lo para fins profissionais, a Apple incluiu uma série de recursos empresariais em seu site, para facilitar o uso do seu novo produto em empresas. A documentação digital disponível inclui desde cenários de distribuição dele entre funcionários até uma visão geral dos seus recursos de segurança e proteção de dados.

É importante ressaltar aqui que o iPad oferece as mesmas facilidades de uso e configuração de recursos corporativos existentes em iPhones, integrada aos seus principais aplicativos nativos de comunicações e internet. Se a sua empresa possui um servidor baseado no Microsoft Exchange 2003 ou 2007, o aparelho pode obter a partir dele emails, contatos e compromissos assim que são oferecidos para você.
A Apple também adaptou diversas ferramentas para facilitar a configuração de lotes de iPads em ambientes corporativos com alta segurança, suportando os mais avançados (e seguros) padrões de rede e o recursos Remote Wipe, que possibilita a destruição remota de dados de um dispositivo em caso de perda ou roubo. Como novidade para a tablet, porém, estão os diversos aplicativos capazes de tirar proveito da sua interface touchscreen de alta resolução, como a suíte de produtividade iWork, por exemplo.

Para ler mais sobre os recursos do iPad para empresas, basta visitar a página empresarial do produto no site da Apple.

Primeiros passos para se tornar um desenvolvedor de aplicativos para iPhone e iPad

Você sonha em se tornar um desenvolvedor de aplicativos para iOS, mas não sabe por onde começar? Então veja aqui os primeiros passos básicos para começar a criar seus próprios programas e, quem sabe, ficar famoso com isso. E o melhor: qualquer um pode se tornar um grande desenvolvedor para o iPhone.

Introdução

Ninguém duvida que a App Store revolucionou a telefonia mundial, pois trouxe para o mundo dos celulares a dinâmica e variedade de instalação de aplicativos que sempre existiu nos computadores, aumentando exponencialmente as capacidades do aparelho. Já haviam maneiras de instalar aplicativos menos elaborados em smartphones antes, via download em sites ou envio por SMS, mas a facilidade de ter o que se quer com apenas um clique (ou toque) acabou sendo copiada por diversos fabricantes e até mesmo reutilizada pela própria Apple, na sua versão para Mac.

Se do lado do consumidor a loja foi um sucesso, do lado de quem faz aplicativos foi aberto um campo imenso, pois possibilitou que qualquer um (como eu e você) pudesse criar e vender aplicativos para o mundo inteiro, coisa que antigamente só era viável a grandes empresas multinacionais. A Apple não só disponibilizou toda a estrutura de servidores para armazenar e distribuir os apps (com uma loja centralizada), mas também criou um kit de desenvolvimento (SDK) que qualquer um pode baixar e criar aplicativos. Tudo o que você precisa é de equipamento compatível e muito, muito estudo.

1º Passo – Comprar um Mac

Muita gente esbarra nesse primeiro passo, pois para desenvolver para o iOS (sistema operativo do iPhone, iPad, iPod touch e AppleTV) é obrigatório possuir um computador com Mac OS X. Há quem faça a gambiarra de tentar instalar o sistema em PCs Intel (os chamados hackintoshes), mas o melhor mesmo é investir em um bom Mac, principalmente agora que eles baixaram de preço no Brasil. Além de ser a ferramenta perfeita, você verá que ele mudará sua experiência com computadores para o resto de sua vida.

O Mac mais barato hoje no nosso país é o Mac mini (link) e custa R$1.999. Se você é estudante ou trabalha na rede de ensino, pode usar a área educacional da Apple Store Online e pagar ainda menos: R$1.849 (link). Ele vem só com a CPU central, ideal se você já tiver monitor, teclado e mouse do seu PC anterior.

Mas se você estiver querendo investir em algo um pouco mais consistente, que o ajude também em outros aspectos de sua vida (e não só no desenvolvimento de apps), o melhor conselho é o de investir em um MacBook (Air ou Pro) ou até mesmo em um iMac, que na semana passada ganhou um descontão de R$1.000. Lembrando que na área educacional os preços são ainda menores.

2º Passo – Inscrever-se no programa gratuito da Apple

Enquanto você decide se compra um Mac ou uma bicicleta, você já pode começar a baixar o material necessário para iniciar o desenvolvimento, se inscrevendo gratuitamente como Apple Developer. Esse passo não custa nada e você tem acesso ao último SDK, exemplo de códigos, vídeos de introdução e um vasto material em PDF para aprender os primeiros passos de programação. É material suficiente para dias e dias de aprendizado, sem gastar nenhum tostão. Absolutamente tudo é em inglês, o que torna obrigatório o conhecimento básico da língua.

Além da versão gratuita, há o Apple Developers Program, que é pago (US$99 ou 74€ por ano) e permite alguns benefícios a mais, como instalar e rodar os códigos no seu aparelho (com a versão grátis você só pode testá-los no simulador do Mac), tem acesso à versões beta do iOS e também tem direito a publicar seu aplicativo na App Store. Mas isso você pode fazer depois que tiver uma boa base da teoria.

3º Passo – Estudar, estudar, estudar

As ferramentas que a Apple proporciona são uma verdadeira mão na roda, facilitando muito o desenvolvimento de aplicativos. Mas não bastam para começar a criar programas para o iPhone. É preciso muito estudo da linguagem básica de programação, chamada Objective-C, que não é algo que se aprenda em duas semanas. Por isso, é preciso muito estudo e dedicação.

Além do material em PDF disponibilizado pela Apple, há também alguns volumes convertidos em formato iBook, que podem ser baixados direto na App Store para serem lidos no iPhone, iPad ou iPod touch.

Se você não se contentar com o material gratuito (que é extenso) e preferir livros comerciais dedicados a isso, com uma linguagem mais abordável, é possível comprar no Brasil obras importadas (veja a lista de algumas sugestões aqui). Infelizmente não há obras de destaque em português para aprender programação para iPhone.

4º Passo – Criar seu primeiro aplicativo

Nesse ponto, você já tem todas as condições de começar a desenvolver seu primeiro aplicativo. Mesmo que você ainda não tenha um registro pago da Apple, poderá criar e testar apps no simulador do iPhone (ou iPad) no Mac.

A primeira coisa é saber o que você quer fazer. É normal os primeiros resultados serem apps básicas e com função duvidosa, mas que são fundamentais para a evolução do aprendizado. Mas não faça como alguns devs, que se empolgam com o primeiro aplicativo e o publicam na App Store… Depois de ter experiência suficiente, tente pensar em algo útil que realmente vá servir para os usuários. De preferência, que ainda não exista na loja.

Depois que você já pegou a prática e até mesmo já desenvolveu um ou mais aplicativos funcionais, aí sim poderá partir para o passo final.

5º Passo – Inscrever-se como desenvolvedor da Apple

Você agora já tem tudo para começar ganhar fama (e quem sabe, dinheiro) com suas criações. É o momento de se inscrever oficialmente como um desenvolvedor de iOS e pagar a taxa necessária, que poderá ser recuperada facilmente se seu aplicativo fizer sucesso.

Há três tipos de contas: a Individual (só você tem acesso à conta) e a Company (você pode ter uma equipe que também terá acesso à conta), ambas custando US99; ou então a Enterprise (permite que se crie aplicativos internos para empresas, sem passar pela App Store) que custa US$299.

A conta paga também dá acesso aos fóruns técnicos de desenvolvedores, onde são debatidas questões e problemas relativos ao iOS. Em época de versões beta, há também uma área confidencial com várias novidades sobre as futuros sistemas.

—————————————–

Esses são os passos básicos para todos que quiserem começar a investir na programação para iPhones e iPads. As possibilidades são enormes e a cada ano o mercado cresce cada vez mais. Se você gosta disso, não deixe para amanhã o que você pode começar hoje.

       

fonte: http://blogdoiphone.com

OBJECTIVE-C

Olá pessoal. Percebendo a necessidade de algumas pessoas em entender alguns conceitos do Objective-C, estou disponibilizando este tutorial feito por Alberto Martins que encontrei na net. Divirtam-se…


Antes de começar este tutorial gostaria de responder a uma pegunta do Arthur Lopes:
O asterisco no Objective-C tem uma função especial. Ele define a variável como um ponteiro. Os ponteiros são concebidos para armazenar endereços de memória. Com um ponteiro você pode indiretamente manipular os dados armazenados em outras variáveis. Ou seja você cria aquela variável com a referência para outro objeto. Enquanto sem asterisco você cria variáveis por valor.

Ex:
NSArray foo;
Você não deve dizer que foo é um NSArray. Ainda. Ele está apenas pronto para apontar para um (e nesse momento está apontando para NULL “nulo”), até você fazer isto:
foo = new NSArray(…)
Agora foo está apontando para um objeto NSArray.
Você pode ter ponteiros para tipos básicos:
int i = 5; // i é um tipo integer básico
int* x; // x é um PONTEIRO para um integer
x = &i; // x agora aponta para o mesmo espaço de memória que “i” está.
Agora nós podemos referenciar o ponteiro “x” e usar ele para mudar o valor de “i”.
*x = 7; // atribui o valor da variável onde o ponteiro está apontando, para 7
Espero que ajude. Qualquer dúvida procure por “Tipo valor, Tipo referência” no google que vai ter bastante material.
Vamos ao tuto..

Objective-C

Uma iniciação aos conceitos e à linguagem por Alberto Martins – algol@astro.iagusp.br

Introdução

Este breve tutorial foi criado para suprir a falta de informação sobre a linguagem Objective-C no Brasil, e com isso incentivar sua popularização. Para aqueles que já programam em C, a adaptação ao paradigma de orientação à objetos por meio da linguagem Objective-C ocorre de forma simples e natural, visto que sintaticamente apenas poucas construções são adicionadas. Observamos que no momento este não é um tutorial completo, ou seja, conhecer um pouco de C será não apenas de grande valia, como praticamente necessário para construir programas mais complexos. Devemos salientar também que por enquanto não iremos utilizar o framework “Foundation”, nem qualquer outro, nos mantendo nos rudimentos da linguagem.A linguagem Objective-C foi criada por Brad Cox e sua empresa, a StepStone Corporation, no início da década de 80. Em 88 ela foi licenciada pela NeXT, tornando-se a linguagem de desenvolvimento do NeXTstep. O suporte do GNU/gcc foi acrescentado em 1992. Em 1994 as empresas NeXT Computer e Sun Microsystems criaram uma especificação do NeXTstep conhecida como OpenStep. A implementação da Free Software Foundation da especificação OpenStep é denominada GNUStep. Atualmente Objective-C é utilizada como a principal linguagem de programação do MacOS X, que é baseado no NeXTstep. A versão da Apple do ambiente NeXTStep/GNUStep com adições é denominada Cocoa.

Características

Objective-C é apenas um conjunto de adições à linguagem C. Ela dá ao C suporte à construções orientadas a objetos como as da Smalltalk. Objective-C suporta polimorfismo, posing, categorias, e é uma linguagem dinâmica, com typing e binding dinâmicos. Com Objective-C você pode adicionar classes e categorias em tempo de execução de forma fácil. E tudo isso com uma sintaxe de mensagem simples e elegante: olhe os títulos destas subseções e você já saberá como conversar com os objetos! Objective-C realiza chamadas de mensagem dinâmicas rapidamente, entre 1,5 e 2,0 vezes o tempo de uma chamada de função em C.

Programação Orientada à Objetos

O conceito de orientação à objetos é na verdade algo muito simples. Diariamente utilizamos objetos para realizar tarefas, e programar OO não é nada alem disso.Programadores mais antigos estão acostumados a pensar a programação separando dados e fuções que seriam aplicadas neles. A própria forma de pensar era diferente; para alguns problemas era óbvia a necessidade de uma integração maior entre os dados e as funções, e isto foi o aparecimento do objeto. Tomando um exemplo simples: supomos que você possua uma televisão. A não ser que você seja um milhonário ou um professor pardal, essa televisão deve ter saído de uma linha de montagem, sendo assim igual a muitos outros aparelhos do mesmo modelo. Entretanto essa é a sua televisão, e ela possui um número de identificação (ou número serial) único. No exemplo acima e agora traduzindo para o conceito de OO, sua televisão é uma instância da classe televisão. E cada vez que uma nova televisão é produzido, uma nova instância da classe televisão é criada. Existem também certas coisas que você pode fazer com a sua televisão, como ligar e desligar, modificar o volume e configurações de cor, ligar o PIP, etc. As funções realizadas com a televisão, em OO, denominam-se métodos. Em alguns casos os métodos são aplicados na instância da classe, em outros eles são aplicados na classe em si. Por exemplo, ligar a televisão seria um método de instância e descobrir quantos televisores foram produzidos por um determinado fabricante seria um método de classe. Quando vamos comprar um televisor em alguma loja, costumamos encontrá-los agrupados junto com tocadores de DVD, por exemplo. Bem, isso não se dá por acaso: televisores, assim como tocadores de DVD são eletrônicos, e com isso possuem características e funções em comum. Podemos então pensar nestes dois aparelhos como sendo instâncias de uma classe denominada eletrônicos. Entretanto não queremos instâncias da classe eletrônicos, e sim das classes televisão e toca-DVD, logo dizemos que as classes televisão e toca-DVD são subclasses (ou classes filhas) da superclasse (ou classe pai) eletrônicos. Esse é um conceito muito importante em orientação à objetos, e é denominado herança: quando criamos uma subclasse ela herda as características e métodos de sua superclasse. Nesse caso podemos dizer que nunca iremos criar uma instância da classe eletrônicos, logo esta é denominada uma classe abstrata, ou seja, uma classe que serve apenas para ser superclasse de outras classes.

Ambiente de programação

Para programar em Objective-C, tal como em qualquer outra linguagem moderna, você precisa de um editor e um compilador. Ambos estão disponíveis gratuitamente em muitos dos sistemas operacionais atuais.No MacOS X, você deve instalar os “Developer Tools” gratuitos da Apple, caso eles não estejam presentes no seu sistema. Essas ferramentas incluem dentre muitas outras coisas o compilador gcc e um ambiente de programação extremamente eficiente, denominado Xcode. No Linux você já deve ter o gcc instalado, bem como muitos editores de texto (vi, pico, emacs). Você tambem pode utilizar algum ambiente de programação, como o KDevelop ou ferramentas GNUStep. No Windows você pode instalar o compilador Objective-C que acompanha o sistema MinGW (http://www.mingw.org). Para escrever os códigos, qualquer editor de texto puro, como o Notepad, ou algum ambiente de programação devem servir. Nos três sistemas, compilar um programa utilizando a linha de comando resume-se ao gcc (para projetos maiores costuma-se utilizar ferramentas como make, automake, etc), cujo formato geral de chamada é:

gcc arquivos.m -o nome_do_programa -l objc

Os arquivos de código da linguagem Objective-C possuem sufixo “.m”, enquanto que os cabeçários possuem, como em C, sufixo “.h”. Por algum motivo alguem na FSF não parece gostar muito de uma diretriz de pré-processamento (mais sobre isso depois) do Objetive-C denominada “#import”, que serve para substituir “#include” de forma a não ser necessário escrever “#ifndef #define #endif” para não incluir o mesmo arquivo várias vezes, e com isso as versões do gcc utilizadas em computadores com Linux e Windows dão “Warnings” na hora de compilar. Para acabar com esse problema, utilize a chamada do gcc com “-Wno-import”. Computadores com o gcc fornecido pela Apple não sofrem desse problema. Para compilar programas utilizando o Xcode da Apple você deve criar um novo projeto do tipo “Cocoa Application” e sobrescrever o arquivo “main.m” que será criado automaticamente.

Meu primeiro programa: classes, objetos e métodos

Nesta seção vamos implementar um programa básico, já utilizando conceitos de programação orientada à objetos.Os programas em Objective-C possuem quatro partes bem definidas . A primeira define diretrizes para o pré-processador, a segunda define as classes e métodos, a terceira a implementa os métodos e a quarta é o programa em si. Mais tarde mostraremos como cada parte pode ficar armazenada em um arquivo separado, facilitando a organização do programa em si. Para facilitar, podemos iniciar lendo o programa a seguir que define nossa primeira classe, o Gato. Esse dócil animal mia, logo vamos implementar uma classe “Gato” que possui um método chamado “miau” que serve apenas para escrever “Miaau!” na tela. Veja o código: meuGato.m

//
// Programa Gato
// 
// por Alberto GOK Martins
// para o tutorial de ObjC
//

// aqui comecam as diretrizes do pre-processador
#import 
#import 

// aqui comeca a definicao das interfaces
@interface Gato: Object

-(void) miau;

@end

// aqui comecam as implementacoes dos metodos
@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

@end

// aqui comeca o programa
int main( int argc, const char *argv[] )
{
        Gato *meuGato;

        meuGato = [Gato alloc];
        meuGato = [meuGato init];

        [meuGato miau];

        [meuGato free];

        return 0;
}

Todas as linhas que iniciam por “//” são linhas de comentários. Estas são ignoradas, logo é permitido escrever qualquer coisa após as duas barras. Comentários são utilizados para documentar um programa, facilitando sua compreensão. Outra forma de inserir comentários em programas Objective-C é utilizar os caracteres “/*” no início do comentário e “*/” no final; desta forma pode-se criar blocos de comentário com muitas linhas, sem que seja necessário escrever “//” a cada linha nova. As linhas iniciadas por “#” são diretrizes de pré-processamento. No programa acima utilizamos “#import <…>”, que diz para o compilador localizar, processar e importar informações dos arquivos “stdio.h” e “objc/Object.h”, ambos arquivos do sistema. Estes arquivos contém informações sobre a rotina “printf” e a classe “Object”, que foram utilizadas no nosso programa. A segunda parte do arquivo consiste na definição das Classes e de suas interfaces. Quando nós definimos uma nova classe é necessário dizer ao compilador algumas coisas. A primeira delas é falar de onde a classe vem, ou seja quem é a sua superclasse. Utilizamos para isso a seção “@interface”, cujo formato geral é:

@interface NovaClasse: SuperClasse
{
        Declaração_de_variáveis;
}

Declaração_de_métodos;

@end

No nosso programa definimos a classe “Gato”, que por enquanto não possui variáveis e apenas um método, o “miau”. Esse é um método da instância da classe “Gato” pois sua declaração é iniciada com o símbolo “-”. Poderíamos também criar um método da própria classe “Gato” utilizando o símbolo “+” para, por exemplo, contar o número de gatos que foram criados no programa. Após o sinal “-” temos a declaração entre parênteses do que o método irá retornar; no caso, “void”, indica que nada será retornado. Finalmente temos o nome do método. Mais adiante forneceremos o formato geral de declaração de métodos. A terceira parte do arquivo é a implementação dos métodos da classe. Ela define os métodos, ou seja contém seus códigos, declarados na parte “@interface”. O formato é:

@interface NovaClasse 

Definição_de_métodos;

@end

A definição de um método nada mais é do que sua declaração sem o caractere “;” acompanhada por seu código, que é colocado entre chaves “{” e “}”. No nosso programa, o método “miau” tem o código definido por uma instrução da biblioteca “stdio.h” chamada “printf”, que serve para mostrar caracteres na tela. A quarta e última parte do arquivo, é o programa em si. Esta parte contem a rotina denominada “main” que indica precisamente onde o programa deve iniciar sua execução. Ela inicia com a palavra “int”, especificando que “main” deve retornar um valor inteiro ao sistema quando terminar sua execução. As palavras que aparecem entre parêntesis “()” servem para lidar com argumentos passados pela linha de comando. A primeira linha da rotina “main” define uma variável chamada “meuGato”, dizendo que “meuGato” é um objeto que guardará valores da classe “Gato”. O asterísco diz que “meuGato” é um ponteiro para um “Gato”. Na segunda linha alocamos espaço na memória para o “meuGato”, e na terceira inicializamos as variáveis que podem estar presentes dentro do “meuGato”. Observe que na segunda linha passamos uma mensagem para a classe “Gato”, enquanto que na terceira a mensagem vai para a instância “meuGato”. Os métodos “alloc” e “init” não foram escritos por você, entretanto podemos utilizá-los pois foram definidos para a classe “Object”, que é a superclasse de “Gato”. Na quarta linha passamos uma mensagem para o objeto “meuGato”, dizendo para ele miar, ou seja, executar o método “miau” que implementamos. Na quinta linha passamos uma mensagem para “meuGato” dizendo que ele não será mais necessário, e que podemos liberar a memória que foi reservada à ele. Na sexta linha especificamos o valor que o programa deve retornar ao sistema; no caso 0, indicando que tudo ocorreu bem. Vamos finalmente compilar e executar o nosso programa. Para gerar o executável deve-se utilizar um compilador, no caso o gcc, e como visto anteriormente sua chamada (desta vez já com os nomes dos arquivos corretos) é:

gcc meuGato.m -o meuGato -l objc

Executando o arquivo “meuGato” deve-se obter a seguinte saída:

Miaau!

Um gato mais real… Vejamos agora um programa um gato um pouco mais elaborado. Todos devemos concordar que os gatos possuem certas características, como cor do pêlo, tamanho, peso, etc. Logo está faltando algo ao nosso gato. No programa a seguir implementamos o peso, bem como funções para defini-lo e obtê-lo; fica para você a tarefa de implementar as outras características.

//
// Programa Gato com caracteristica
// 
// por Alberto GOK Martins
// para o tutorial de ObjC
//

// aqui comecam as diretrizes do pre-processador
#import 
#import 

// aqui comeca a definicao das interfaces
@interface Gato: Object
{
        double peso;
}

-(void) miau;
-(void) setPeso: (double) p;
-(double) getPeso;

@end

// aqui comecam as implementacoes dos metodos
@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

@end

// aqui comeca o programa
int main( int argc, const char *argv[] )
{
        Gato *meuGato;
        Gato *meuGato2;

        meuGato = [[Gato alloc] init];
        meuGato2 = [[Gato alloc] init];

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];
        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);

        [meuGato free];
        [meuGato2 free];

        return 0;
}

A primeira adição no programa acima em relação ao original são as declarações dos métodos “setPeso” e “getPeso”. O primeiro recebe um valor real do tipo double, e o segundo retorna um valor tipo double. Estamos prontos para enunciar um formato geral de declaração de métodos:

tipo_de_método(tipo_do_retorno_do_método) nome_do_método: (tipo_do_argumento) argumento;

exemplo de método de classe:

        +(int) quantosGatos;

exemplo de método de instância:

        -(void) setPeso: (double) p;

Na parte de implementação temos as implementações de “setPeso” e “getPeso”. Na rotina “main” podemos notar que estamos criando dois gatos diferentes. O primeiro pesa 4.2kg, enquanto que o segundo 4.9kg. Devemos observar que, de modo distinto do programa original, estamos alocando memória e inicializando “meuGato” ao mesmo tempo. Essa é uma construção muito utilizada, junto com a alternativa seguinte:

Gato *meuGato = [[Gato alloc] init];

Podemos observar, ainda dentro da rotina “main”, como passar argumentos para o objeto “meuGato”, com o método setPeso. Ou também como obter o valor de uma característica do “meuGato”, com o método “getPeso” e imprimi-lo na tela com a função “printf”. A saída agora deve ser:

Miaau!
Miaau!
meuGato pesa: 4.200000 kg
meuGato2 pesa: 4.900000 kg

Mais sobre classes, objetos, métodos

Na seção anterior vimos como passar um argumento para um método. Entretanto muitas vezes é desejável poder passar mais do que um argumento por vez, por exemplo para definir a posição (x,y) de um ponto no R². Felizmente existe um tipo de construção que nos permite fazê-lo:

-(tipo) nome: (tipo) variável nome: (tipo) variável;

exemplo, um método para definir as posições de um ponto no R2:

-(void) setX: (double) x andY: (double) y;

passando a mensagem:

[Objeto setX: 1.511 andY: 2.332];

Geralmente é interessante ter métodos para definir cada argumento separadamente, ainda que existam os métodos para definir múltiplos argumentos de uma só vez. Um método também pode retornar um objeto. Por exemplo, poderíamos implementar um método de instância na classe “Gato” que definisse uma reprodução sexuada. Para isso temos que ter duas instâncias da classe “Gato” allocadas e inicializadas; uma para receber a mensagem e outra para ser o objeto a ser recebido como argumento da mensagem. Devemos ter também um objeto do tipo “Gato”, que armazenará o gato filho. Acompanhe a definição do método “reproduzir”:

-(Gato *) reproduzir: (Gato *) Gato2
{
        // funcao para criar um gato filho com a media dos pesos dos pais
        // antes de algum protesto, nao estamos tentando ser biologicamente corretos!

        Gato *Gatinho=[[Gato alloc] init];
        double pesoGatinho;

        pesoGatinho = (peso+[Gato2 getPeso])/2;

        [Gatinho setPeso: pesoGatinho];

        return Gatinho;
}


int main( int argc, const char *argv[] )
{
        Gato *meuGato = [[Gato alloc] init];
        Gato *meuGato2 = [[Gato alloc] init];
        Gato *meuGatoFilho;

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];

        meuGatoFilho = [meuGato reproduzir: meuGato2];
        [meuGatoFilho miau];

        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);
        printf("meuGatoFilho pesa: %lf kg\n",[meuGatoFilho getPeso]);

        [meuGato free];
        [meuGato2 free];
        [meuGatoFilho free];

        return 0;
}

Em Objective-C você pode se referir ao próprio objeto que está recebendo a mensagem, usando para isso a palavra “self”. Isso tem muitas utilidades, por exemplo para executar um método que precise executar outros métodos. Um exemplo não muito bom seria criar um método “comer” para o nosso gato que utilizasse o método “setPeso” (como [self setPeso: 5]) para engordá-lo; nesse caso poderíamos alterar o valor de “peso” sem recorrer ao “self”, porém caso tivéssemos algum método que realizasse muitas tarefas isso seria de grande utilidade. Agora uma dica de organização: tipicamente os programadores dividem suas classes em arquivos separados, nomeados “classe.h” e “classe.m”; o primeiro contém a seção “@interface” e o segundo “@implementation”. O arquivo de interface diz ao compilador como a sua classe é, enquanto que o arquivo de implementação contém o código verdadeiro da classe. Para realizar ligar os diversos arquivos devemos compilar o programa de uma forma especial, bem como nos utilizar da diretriz de pré-processamento “#import”. Observe a nova implementação do programa do gato: Gato.h

//
// Classe Gato - interface
// 
// por Alberto GOK Martins
// para o tutorial de ObjC
//

#import 

@interface Gato: Object
{
        double peso;
}

-(void) miau;
-(void) setPeso: (double) p;
-(double) getPeso;
-(Gato *) reproduzir: (Gato *) Gato2;

@end

Gato.m

//
// Classe Gato - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import 
#import "Gato.h"

@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

-(Gato *) reproduzir: (Gato *) Gato2
{
        // funcao para criar um gato filho com a media dos pesos dos pais
        // antes de algum protesto, nao estamos tentando ser biologicamente corretos!

        Gato *Gatinho=[[Gato alloc] init];
        double pesoGatinho;

        pesoGatinho = (peso+[Gato2 getPeso])/2;

        [Gatinho setPeso: pesoGatinho];

        return Gatinho;
}

@end

main.m

//
// Programa Gato com caracteristica
// em multiplos arquivos
//
// por Alberto GOK Martins
// para o tutorial de ObjC
//

#import 
#import "Gato.h"

int main( int argc, const char *argv[] )
{
        Gato *meuGato = [[Gato alloc] init];
        Gato *meuGato2 = [[Gato alloc] init];
        Gato *meuGatoFilho;

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];

        meuGatoFilho = [meuGato reproduzir: meuGato2];
        [meuGatoFilho miau];

        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);
        printf("meuGatoFilho pesa: %lf kg\n",[meuGatoFilho getPeso]);

        [meuGato free];
        [meuGato2 free];
        [meuGatoFilho free];

        return 0;
}

Preste especial atenção em como a diretiva “#import” é utilizada. O arquivo “Gato.h” precisa de informações sobre a classe “Object” que foi definida no arquivo “objc/Object.h”, e por isso devemos importá-lo em “Gato.h”. Já o arquivo “Gato.m” deve importar o arquivo de interface de sua classe, o “Gato.h”, bem como “stdio.h”, pois utiliza a função “printf”. Finalmente, o programa principal deve importar o arquivo “stdio.h” pela função “printf” e o arquivo “Gato.h” por instanciar objetos da classe “Gato”. Isso pode parecer um pouco confuso, mas na verdade o conceito é bastante simples: deve-se importar tudo o que for utilizar. Para compilar programas com multiplos arquivos no gcc, use a seguinte linha de comando:

gcc arquivo1.m arquivo2.m main.m -o nome_do_programa -l objc

no caso do nosso programa, use:

gcc Gato.m main.m -o gato -l objc

execute o programa e veja o resultado; ele deve ser similar ao apresentado abaixo:

Miaau!
Miaau!
Miaau!
meuGato pesa: 4.200000 kg
meuGato2 pesa: 4.900000 kg
meuGatoFilho pesa: 4.550000 kg

Herança

Nesta seção falaremos sobre um dos conceitos mais importantes da programação orientada a objetos: a herança.Uma classe pode ter a si mesma como superclasse, e essa classe, que não possui superclasse é denominada classe raiz (ou root). A classe raiz pode ser programada por você mesmo, ou então como é mais comum, ser a classe Object, descrita em “objc/Object.h” ou a classe NSObject, descrita em “Foundation/NSObject.h”. A classe que foi criada neste tutorial é uma subclasse de Object, e com isso ela herda certos métodos, como free e outros que foram definidos para a classe Object. No entanto suponha que agora seja necessário criar um classe para cachorros. Bem, poderíamos criar uma subclasse de Object denominada Cachorro e implementar funções como setPeso e getPeso idênticas às da classe Gato. Uma solução melhor, seria criar uma subclasse de Object denominada Animal, e as classes Cachorro e Gato seriam subclasses da classe Animal, que por sua vez seria uma classe abstrata, visto que nunca iremos criar uma instância de Animal. No exemplo abaixo fizemos justamente isso. Animal.h

//
// Classe Abstrata Animal - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import 

@interface Animal : Object
{
        double peso;
}

-(void) setPeso: (double) p;
-(double) getPeso;

@end

Animal.m

//
// Classe Abstrata Animal - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

@implementation Animal

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

@end

Gato.h

//
// Classe Gato - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

// aqui comeca a definicao das interfaces
@interface Gato: Animal

-(void) miau;

@end

Gato.m

//
// Classe Gato - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Gato.h"
#import 

// aqui comecam as implementacoes dos metodos
@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

@end

Cachorro.h

//
// Classe Cachorro - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

// aqui comeca a definicao das interfaces
@interface Cachorro: Animal

-(void) auau;

@end

Cachorro.m

//
// Classe Cachorro - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Cachorro.h"
#import 

// aqui comecam as implementacoes dos metodos
@implementation Cachorro

-(void) auau
{
        printf("AuAu!\n");
}

@end

main.m

//
// Programa de Animais com heranca
//
// por Alberto GOK Martins
// para o tutorial de ObjC
//

#import 
#import "Gato.h"
#import "Cachorro.h"

// aqui comeca o programa
int main( int argc, const char *argv[] )
{
        Gato *meuGato = [[Gato alloc] init];
        Gato *meuGato2 = [[Gato alloc] init];
        Cachorro *meuCachorro = [[Cachorro alloc] init];
        Cachorro *meuCachorro2 = [[Cachorro alloc] init];

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];

        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);

        [meuCachorro setPeso: 10.2];
        [meuCachorro2 setPeso: 13.3];
        [meuCachorro auau];
        [meuCachorro2 auau];

        printf("meuCachorro pesa: %lf kg\n",[meuCachorro getPeso]);
        printf("meuCachorro2 pesa: %lf kg\n",[meuCachorro2 getPeso]);

        [meuCachorro free];
        [meuCachorro2 free];
        [meuGato free];
        [meuGato2 free];

        return 0;
}

Observe que no exemplo acima o método “reproduzir” nao existe mais. Optamos por não escrevê-lo, pois embora essa seja uma atividade comum para todos os animais a reprodução de animais diferentes deve gerar objetos de classes diferentes, e não um animal genérico da classe animal. Para contornar o problema você poderia escrever dois métodos, um para cada classe, denominados “reproduzir”, que embora partilhassem o mesmo nome seriam um pouco diferentes; afinal você não espera que um casal de cachorros gerem filhos gatos. Implementar um método comum exigirá um pouco mais de conhecimento, e isso será realizado na próxima seção, denominada Polimorfismo, Typing dinâmico e Binding dinâmico. Suponha agora que você queira que o método getPeso para um gato retorne o peso em gramas e não em quilos. Bem, você pode modificar a implementação original de getPeso na clase Animal, porém isso modificará também o retorno do getPeso para cachorros. Para solucionar este problema pode-se utilizar um conceito denominado overriding. Overriding é simplesmente sobrescrever um método. Quando você cria um método com o mesmo nome de um outro método que foi herdado pela classe, vale o método da classe e não o da superclasse. Logo, você poderia criar um método dentro da classe Gato com o mesmo nome (no caso, getPeso) e com isso apenas o método da classe Gato seria afetado, permitindo que a classe Cachorro continuasse retornando o peso em kilogramas. Experimente, realizando overriding de getPeso da classe Gato (não esqueça de modificar o printf da rotina main para escrever “g” ao invés de “kg”). Dentro de classes podemos também instanciar objetos. Por exemplo, suponhamos que todos os animais (logo todas as subclasses da classe Animal – novamente, não estamos tentando ser biologicamente corretos!) tenham olhos. Podemos então, definir uma classe denominada Olho, e instanciá-la dentro da classe Animal. Observe a interface e implementação da classe Olho, bem como os novos arquivos da classe Animal. Olho.h

//
// Classe Olho - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import 

@interface Olho : Object
{
        int estado_da_pupila;
}

-(void) setEstado_Da_Pupila: (int) pupil;
-(void) printEstado_Da_Pupila;

@end

Olho.m

//
// Classe Olho - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Olho.h"

@implementation Olho

-(void) setEstado_Da_Pupila: (int) pupil
{
        if(pupil==0) estado_da_pupila=0;
        if(pupil==1) estado_da_pupila=1;
        if(pupil==2) estado_da_pupila=2;
}

-(void) printEstado_Da_Pupila
{
        if(estado_da_pupila==0)
        {
                printf("A pupila está contraída\n");
        }
        if(estado_da_pupila==1)
        {
                printf("A pupila está normal\n");
        }
        if(estado_da_pupila==2)
        {
                printf("A pupila está dilatada\n");
        }
}

@end

Animal.h

//
// Classe Abstrata Animal - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import 
#import "Olho.h"

@interface Animal : Object
{
        double peso;
        Olho *AOlho;
}

-(void) setPeso: (double) p;
-(double) getPeso;
-(void) printEstado_Da_Pupila;
-(void) setEstado_Da_Pupila: (int) edp;

@end

Animal.m

//
// Classe Abstrata Animal - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

@implementation Animal

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

-(void) printEstado_Da_Pupila
{
        // funcao para imprimir o estado da pupila de um animal

        if(AOlho)
               [AOlho printEstado_Da_Pupila];
        else
                printf("Não foi definido um estado da pupila deste animal.\n");
}

-(void) setEstado_Da_Pupila: (int) edp
{
        [AOlho free];
        AOlho = [[Olho alloc] init];
        [AOlho setEstado_Da_Pupila: edp];
}

@end

O código que deve ser utilizado para testar o funcionamento do Olho em main.m é:

[meuGato setEstado_Da_Pupila: 1];
[meuGato printEstado_Da_Pupila];

Obtivemos agora um enorme problema. Como é que vamos liberar a memória alocada para o Olho do Animal? Como não podemos acessar diretamente o objeto AOlho não podemos liberar a memória sem criar um método pertencente à classe Animal específico para isso; ou então, como saída mais inteligente, realizar um overriding do método free. Caso não liberemos a memória teremos um problema que se denomina vazamento de memória, ou memory leakage. Bem, para realizar o overriding de free precisamos saber como liberar a memória alocada pelo próprio objeto, no entanto como o método free é agora diferente do original ele não mais saberá como liberar a memória alocada para o objeto. A saída para isso é a instrução super que se refere a classe pai do recebedor da mensagem. Super chamará não o método da classe atual, mas aquele que foi herdado. Desta forma podemos sempre nos referir ao método antigo de todos os métodos que foram implementados através de overriding. Logo a implementação do método free para a classe Animal deve ser:

-(id) free
{
        [AOlho free];
        return [super free];
}

Deixaremos para nos preocupar com a palavra id na próxima seção

Polimorfismo, Typing dinâmico e Binding dinâmico

Polimorfismo é um conceito muito simples. Ele nada mais é do que a habilidade que uma linguagem orientada à objetos tem de definir métodos com o mesmo nome para classes diferentes. Cada definição de classe guarda o código necessário para seus métodos.Typing dinâmico é a característica que a linguagem tem de poder postergar a determinação da classe de um objeto até o tempo de execução do programa, enquanto que Biding dinâmico é poder postergar a determinação do método que será invocado em um objeto até o tempo de execução. Para realizar o typing e o binding dinâmicos utiliza-se o tipo id. Este é um tipo de objeto genérico, que pode ser utilizado para guardar objetos pertencentes a qualquer classe. Na seção anterior utilizamos o tipo id para realizar o overriding do método free. Vejamos agora, como implementar o método reproduzir na classe Animal, e permitir que a classe Gato e Cachorro se reproduzam, sem que seja necessário criar dois métodos distintos:

-(id) reproduzir: (id) Animal2
{
        // funcao para criar um animal filho com a media dos pesos dos pais
        // antes de algum protesto, nao estamos tentando ser biologicamente corretos!
        // existe um teste para verificar se os animais sao da mesma classe.

        id Filho=[[[self class] alloc] init];

        if ([self class] == [Animal2 class])
        {
                printf("O filho nasceu sadio!\n");
                [Filho setPeso: (peso+[Animal2 getPeso])/2];
        }
  else
        {
                printf("O filho nasceu morto, pois os pais são de classes diferentes!\n");
                [Filho setPeso: 0];
        }
        return Filho;

}

Na implementação da função acima utilizamos o tipo id, pois não sabemos qual será a subclasse de Animal que será passada nem a classe que irá retornar. Utilizamos também a palavra self que serve para se referir ao próprio objeto, logo dizer [self class] é uma forma de pedir para o objeto retornar a própria classe; no método reproduzir precisamos criar um filho da mesma classe dos pais, logo usamos [self class] como a classe do filho.

Últimas palavras

Esse tutorial deve ser aprimorado, com o passar do tempo e com sua ajuda. Por favor, não deixe de enviar um email dizendo o que achou, se conseguiu aprender alguma coisa ou se não conseguiu aprendeu nada.Por enquanto é isso. Após essas seções estarem melhor talhadas, pretendo incluir outros tópicos, como C-básico, posing, categorias e a utilização básica do framework Foundation. Entretanto, enquanto esses aprimoramentos não vem, e caso você queira se aprofundar na linguagem eu sugiro os links e referências presentes na seção Referências e links.

Referências e links

Apple Objective-C Manual
GNU Objective-C Manual
comp.lang.Objective-C FAQ
Programming in Objective-C, Stephen Kochan. Sams Publishing, 2004.

The C Programming Language, Brian W. Kernighan e Dennis M. Ritche. Prentice Hall, Inc., 1988.

GNUstep

Página por Alberto G. O. K. Martins – algol@astro.iag.usp.br
Design based on the Dekorte’s Objective-C webpage. CSS additions by Alberto G. O. K. Martins.
Qualquer contribuição, alteração, comentário ou sugestão, favor enviar para o email algol@astro.iag.usp.br.

Publicado em OBJECTIVE-C

Como funciona a nova tela do iPhone 4

Durante a apresentação do iPhone 4, na WWDC 2010 (Conferência anual da Apple), realizada em 7/6, Steve Jobs detalhou que o novo aparelho fará uso do que a Apple chama de “Retina display” (algo como Tela retina).

Mas o que exatamente é uma tela Retina e como ela, junto com outras tecnologias de tela, beneficiam o novo iPhone, mais magro e pronto para HD (alta definição)? Para explicar de forma simples, a nova tela do telefone é um LCD (tela de cristal líquido) que ostenta uma densidade de pixel superalta ao espremer a resolução de 960x640 pixels em 3,5 polegadas – uma densidade de 326 pixels por polegada (ppi). A tela Retina possui quatro vezes o número de pixels dos iPhones anteriores; seu tamanho não mudou, resultando no dobro de densidade de pixels. Em comparação ao modelo 3GS, que possui uma tela de 163ppi com uma resolução de 480 por 320 pixels, é fácil imaginar como essa nova tela vai brilhar.

_{Imagem close-up da tela do iPhone 4, que possui uma resolução superalta}

Enquanto falava sobre a nova tela, Steve Jobs detalhou que após um certo ponto o olho humano falha em distinguir pixels individuais. De acordo com o CEO da Apple, esse “número mágico”, quando não existe mais pixelização visível, está próximo de 300 ppi. Dessa maneira, com a tela do iPhone 4 vindo com 326 ppi, sua imagem supostamente sempre vai ter um visual suave e uniforme.

_{Em comparação, o mesmo ícone na tela do iPhone 3GS apresenta pixelização}

As fotos deste artigo matéria (acima), feitas pela editora sênior da PC World americana, Melissa Perenson, mostram um ícone de uma tela do iPhone 4 em comparação ao mesmo ícone no 3GS. A diferença, como você pode ver, é bem evidente.
A companhia ainda afirma que a tela do iPhone 4 terá uma proporção de contraste (contrast ratio) quatro vezes maior do que os modelos anteriores. Além do uso de mais pixels compactos, a tela, que é uma backlit LED, também vai adotar a tecnologia IPS (In-Plane Switching), presente no iPad, para melhorar os ângulos de visão e a exibição de cores.
A Apple não é a primeira a colocar uma tela de resolução superalta em um smartphone. O Nexus One, do Google, por exemplo, possui uma tela OLED (Organic light-emitting diode) com uma resolução de 800 x 480 pixels.




fonte: http://macworldbrasil.uol.com.br

Android ultrapassa Apple

Segundo um estudo publicado pela NPD, os smartphones Android ultrapassaram pela primeira vez o iPhone, por 7% nos Estados Unidos e, ao continuar assim, podem vir a ultrapassar a RIM, líder do segmento.

Observando a imagem, podemos ver que o primeiro trimestre de 2010 foi muito positivo para a Google e o seu Android. Temos a RIM que continua a cair, mas não tão acentuadamente como no último trimestre de 2009. Temos a Apple que estagnou em relação ao último trimestre de 2009. Temos ainda as quedas do Windows Mobile e da Palm, recentemente adquirida pela HP. 

Neste momento temos no pódio:

• RIM -  36%
• Android – 28%
• iPhone OS – 21%

O grande vencedor é sem dúvida, o Android, pois o fato de saírem novos smartphones com esta plataforma todos os meses, ajuda imenso a sua propagação.

Existem algumas conclusões a retirar deste estudo:

Por um lado, o fato da Apple estar ao que tudo indica, a preparar uma nova geração de iPhones para Junho, pode ser a razão para a Apple ter estagnado. Além disso, nem podemos comparar a quantidade de smartphones com Android com os iPhones, por isso é mais que normal que o Android continue a subir.

Em relação à RIM, o novo Sistema Operacional que a fabricante apresentou pode vir dar um novo alento, impedindo assim a subida vertiginosa do Android.

Quanto ao Windows Mobile e o Palm WebOS, vamos esperar pelo Windows Phone 7 e veremos também o que a HP faz do WebOS, pois estão também a perder terreno.

Liberado o Spirit, jailbreak do iPad e do OS 3.1.3 em iPhones e iPods touch

A ferramenta era esperada para sexta-feira, mas só foi liberada na noite de ontem. Desenvolvida pelo hacker @comex, com apoio de vários grupos, o Spirit faz o jailbreak fácil e rápido não apenas em iPads, mas também em iPhones e iPods touch com o OS 3.1.3. Mas apesar disso, ele não realiza o desbloqueio da operadora.

A ferramenta funciona do mesmo jeito que o blackra1n, bastando apenas um clique do mouse para realizar todo o serviço. Em menos de um minuto, ele instala no aparelho o Cydia. Porém, várias recomendações devem ser seguidas antes de se iniciar o processo.

É sempre bom destacar que o jailbreak não é considerado ilegal pela lei brasileira, quando feito no próprio aparelho. Ele também não é sinônimo de pirataria de aplicativos. Para mais informações, leia aqui.

Para começar, quem tem iPhonne 3G ou 3GS bloqueado com a operadora NÃO DEVE FAZÊ-LO, pois ele não desbloqueia a nova baseband.

Nos aparelhos com novo iBoot ele faz um jailbreak untethered, ou seja, ele é permanente, não precisando refazê-lo sempre que reiniciar o sistema. Se é o seu caso e você já tenha jailbreak, terá que restaurar o aparelho pelo iTunes para o OS 3.1.3 e só então realizar o processo. Lembrando que isso é somente para quem pode ativar com o chip da operadora. Funciona com qualquer versão do iTunes a partir do 9.0.

No iPad, é possível instalar o Cydia, mas nem tudo funciona ainda. Aplicativos que usam o MobileSubstrate (como SBSettings e WinterBoard) bagunçam todo o sistema do tablet. O ProSwitcher (que permite o multitasking) também não funciona.

O Cydia ainda está mal adaptado para a tela do tablet (Saurik sempre foi meio lento nas atualizações), enquanto que seu concorrente, o Rock, já ganhou versão nova.

Eu já testei aqui no iPhone com OS 3.1.3 e tudo funcionou perfeitamente. Basta instalar o 3.1.3 direto no iTunes e rodar o programa.

Se você quiser tentar, há versões para Windows e Mac OS X diretamente no site.

A razão para os hackers terem demorado tanto para liberarem a ferramenta é que o exploit explorado pelo Spirit é muito fácil de ser reparado pela Apple. Tão fácil que já se espera o lançamento de uma atualização do OS (3.1.4) que anule o jailbreak ainda esta semana. E aí, o próximo só em junho/julho, depois do lançamento do iPhone 4.

Por isso, sugere-se que quem esteja já com o jailbreak no 3.1.2 com o boot antigo que permaneçam nele, pois a 3.1.3 não traz nenhuma novidade. O Spirit é voltado principalmente para quem tem iPad e para quem possui um dispositivo novo e queira fazer o destravamento untethered.

fonte : http://www.blogdoiphone.com

Opera Mini 5 chega ao iPhone

E num anúncio de última hora, os utilizadores do iPhone, poderão dispor de uma nova alternativa para navegação na internet, à versão mobile do Safari. A Apple aprovou a inclusão do Opera Mini 5 na App Store. Os proprietários do smartphone da Apple poderão tirar partido de um verdadeiro peso pluma na navegação móvel.

Esta notícia surge num ambiente de alguma surpresa. Isto porque todos sabermos as políticas rígidas de aprovação de aplicações para iPhone, nomeadamente de não ver geralmente com bons olhos, aplicações que de alguma forma repliquem funcionalidades já disponíveis no iPhone OS.

Não seria a primeira vez que a Apple alegava este princípio para recusar aplicações. Do nosso ponto de vista a aprovação do Opera Mini só traz vantagem e em especial algo que até agora não existia no panorama atual de browsers no iPhone, escolha. Podemos confirmar que já está disponível em Portugal, por isso que espera? Descarregue e instale, é gratuito e ficará surpreendido pela leveza deste pequeno grande browser.
Depois de o testarmos por alguns momentos, obtivemos algumas impressões interessantes. Fica prometida uma análise em breve ao desempenho do mais rápido browser até hoje desenhado.


fonte http://pplware.sapo.pt