Desenvolvimento de um aplicativo de rede social para iPhone baseado em IBM Lotus Connections 2.5

O IBM® developerWorks® lançou recentemente seu primeiro aplicativo nativo para iPhone na Apple Application Store, uma ótima ferramenta para os usuários explorarem e descobrirem o conteúdo e a comunidade do developerWorks, conectarem-se com outros profissionais de TI e especialistas no assunto e buscarem oportunidades de compartilhar experiência.

Ami Dewar, developerWorks Advanced design team lead, IBM

Ami DewarAmi Dewar é chefe da equipe Advanced design da developerWorks. Advanced design é uma equipe híbrida de designers, desenvolvedores e arquitetos que trabalham para manter o developerWorks na linha de frente. Ami, anteriormente trabalhando como designer gráfico chefe, é designer da IBM há seis anos, criando mais de 1200 gráficos de recursos e 8000 ilustrações técnicas. Saiba mais sobre o perfil de Ami em My developerWorks.



Nicholas Poore, Advisory Software Engineer, IBM China

Conselheiro em engenharia de software do IBM developerWorks, Nick Poore é o arquiteto-executivo da comunidade do My developerWorks e trabalha em designação para a equipe de entrega de produtos Lotus Connections 3.0. Nick juntou seu entusiasmo pelo iPhone da Apple ao conhecimento de Lotus Connection para desenvolver um dos primeiros aplicativos nativos da IBM para iPhone.



05/Nov/2010 (Primeira publicação 05/Nov/2010)

Introdução

O developerWorks reconheceu que os dispositivos remotos são agora a forma preferencial de comunicação e organização de conteúdo, e o iPhone da Apple especificamente ganhou popularidade no mundo todo.  Além disso, o IBM Lotus® Connections 2.5, que são os produtos subjacentes da comunidade do developerWorks, oferece agora a experiência ideal para o usuário que emula alguns dos aplicativos remotos de rede social mais populares.  

O aplicativo para iPhone do developerWorks destaca muitos dos recursos de rede social mais populares do Lotus Connections:

  • Uma visualização de atualizações públicas, que permite que os usuários vejam toda a atividade que está acontecendo na comunidade, procura por identificação, palavra-chave ou nome de usuário para encontrar conteúdo e usuários do My developerWorks
  • A capacidade de manter em dia o “My updates”, postar atualizações de status para perfis ou adicionar um comentário ao perfil de um colega

Todos esses recursos eram obtidos com o uso das APIs públicas do Lotus Connections 2.5.

Como uma introdução ao uso das APIs do Lotus Connections 2.5, nós guiaremos você pelas etapas de criação de um aplicativo simples para iPhone que exibe as entradas mais recentes do blog do My developerWorks. Esse processo exigiu que compreendêssemos como acessar API de blogs, fazer o download de dados do feed, analisar os dados e exibir os dados corretamente no iPhone.


Navegação pelas APIs do Lotus Connections 2.5  

O Lotus Connections oferece um grande conjunto de interfaces de programação de aplicativos (APIs) públicas que têm muitos usos para desenvolvimento. A primeira etapa no entendimento de como usar as APIs para qualquer uma das suas necessidades de desenvolvimento, seja para um aplicativo de iPhone ou outro uso, é compreender como navegar pela documentação da API.

Os aplicativos do Lotus Connections (Activities, Blogs, Bookmarks, Communities, Files, Profiles e Wikis) e a página inicial do Lotus Connections fornecem APIs que podem ser integradas a outros aplicativos, como o aplicativo para iPhone. Usando as APIs, é possível acessar e usar de forma programática os mesmos dados exibidos no conjunto da comunidade do Lotus Connections, como toda a atividade da comunidade no My developerWorks. As APIs do Lotus Connections são baseadas em Atom Syndication Format, que permite comunicação em duas vias (leitura/gravação). Para usar as APIs só é preciso que sua linguagem de programação seja capaz de enviar e receber XML em vez de HTTP.

As APIs do Lotus Connections estão documentadas no Centro de Informações do Lotus Connections. No aplicativo para iPhone, nosso foco era obter as atualizações contínuas do usuário para nossa comunidade, então encontramos uma documentação chamada “Getting a feed of all our public updates". Essa documentação nos apontou as APIs de atualizações. As APIs para atualizações nos permitiram obter a atividade (pública) mais recente gerada pelos usuários no My developerWorks. Mencionamos as mesmas APIs de atualizações para o exemplo do blog. Para encontrar essas APIs vá até Developing - Lotus Connections APIs - Updates API - Getting updates feeds - Getting a feed of all public updates.

Agora é importante entender como usar o feed para obter o feed necessário para o seu aplicativo.

A tabela 1 descreve o recurso para obter o conteúdo da API. Um recurso é uma URL dentro da API que permite acessar os dados. Esse recurso nos dá a URL raiz para acessar todas as atualizações públicas dentro do Lotus Connections.

Tabela 1. Detalhes de solicitação de API Atom
RecursoDescrição
/atom/stories/publicObtém um feed de todas as atualizações públicas

Essa URL recupera todas as atualizações públicas. Neste exemplo, estamos interessados em apenas um único aplicativo, o Blogs, como o feed que precisamos que retorne.

A tabela 2 descreve os parâmetros, como identificar um aplicativo, o Blogs, que podem ser usados para permitir que o aplicativo recupere o conteúdo filtrado desejado.

Tabela 2. Parâmetros para filtrar o feed do Lotus Connections
ParâmetroDescrição
beforeRetorna somente os itens que foram modificados pela última vez antes da data especificada para esse parâmetro. Formata a data usando a sintaxe: 2008-02-07T21:07:56Z.
containerID exclusivo de um dos seguintes itens:

  • Uma atividade no aplicativo Activities
  • Um blog em um aplicativo Blogs
  • Uma coleção de marcadores de uma pessoa no aplicativo Bookmarks
  • Uma comunidade no aplicativo Communities
  • Um arquivo no aplicativo Files
  • Um perfil de uma pessoa no aplicativo Profiles
  • Um wiki no aplicativo Wikis

Use este parâmetro com o parâmetro de origem. No parâmetro de origem, especifique o aplicativo no qual esse ID exclusivo do item é válido. Este parâmetro é ignorado se um nome de aplicativo válido não for especificado no parâmetro de origem.

emailEndereço de e-mail de uma pessoa. Use este parâmetro para limitar o feed de atualizações para conter somente atualizações geradas por uma pessoa específica. Não use este parâmetro se o Lotus Connections estiver configurado para ocultar endereços de e-mail; neste caso, use o ID do usuário.
lang Use este parâmetro para solicitar material em um idioma diferente que o especificado na solicitação de HTTP. Para especificar o idioma, use um dos seguintes formatos:

  • Formato Java™ (por exemplo, en_IE, es_GT)
  • Formato Dojo (por exemplo, en-ie, es-gt)
pageNúmero da página. Especifica a página a ser retornada. O padrão é 1.
psTamanho da página. Especifica o número de entradas a serem retornadas por página. O número máximo permitido é 100.
sinceRetorna somente os itens que foram modificados pela última vez depois da data especificada por esse parâmetro. Formata a data usando a sintaxe: 2008-02-07T21:07:56Z.
sourceEspecifica um único recurso a partir do qual você deseja que o feed de atualizações seja retornado. As opções são:

  • Activities
  • Blogs
  • Bookmarks
  • Communities
  • Files
  • Profiles
  • Wikis
useridO ID exclusivo de uma pessoa. Use este parâmetro para limitar o feed de atualizações para conter somente atualizações geradas por uma pessoa específica. O valor deste parâmetro tem precedência quando tanto este parâmetro quanto o parâmetro de e-mail são especificados.

Também estamos interessados nas 30 atualizações mais recentes do blog, em confronto com a configuração padrão de 20 entradas. Fazemos essa designação usando o parâmetro de tamanho de página (ps).

O feed para visualização das 30 atualizações mais recentes do blog se parece com o seguinte:

https://www.ibm.com/developerworks/mydeveloperworks/news/atom/stories/public?source=blogs&ps=30

Alguns dos parâmetros usados com mais frequência são language, sincee userid. É importante observar que o parâmetro de retorno do tipo de idioma não traduz o conteúdo de contribuição do usuário. No entanto, ele traduz os rótulos padrão ou UI associadas a esse conteúdo. Os parâmetros before esince permitem aplicar registros de data e hora e limitar os dados recuperados para somente as atualizações ocorridas antes ou depois de uma data específica. O userid permite limitar as atualizações para aquelas geradas por um usuário específico.

Mesmo mostrando somente um único feed para o mesmo aplicativo, o aplicativo para iPhone do My developerWorks aproveita as APIs do Lotus Connection para exibir todo o conteúdo de contribuição do usuário, filtrado por aplicativo, resultados de procura, dados de perfil e outros.


Obter dados para o aplicativo e analisá-los usando as APIs do Lotus Connections

Agora que entendemos como acessar os dados do Lotus Connections usando as APIs, a próxima etapa é começar a compor o aplicativo para iPhone. Usamos o gerador de modelos Apple xCode para criar um projeto para iPhone de aplicativo baseado em visualização chamado SampleApplication (consulte a figura 1).

Figura 1. Janela do novo projeto do xCode
Janela do novo projeto do xCode

Quando o projeto é iniciado, vários arquivos são criados automaticamente, incluindo os arquivos SampleApplicationViewController.h e SampleApplicationViewController.m. Visualizando o arquivo SampleapplicationViewController.m, é possível ver o método viewDidLoad. Este método é chamado quando a visualização é carregada no aplicativo. Adicionar a solicitação de conexão ao feed das APIs do Lotus Connections no método viewDidLoad inicia a solicitação para a API quando a visualização é carregada e o usuário inicia o aplicativo. Para começar a usar a API, é preciso primeiro definir um NSURLRequest, que é onde se adiciona a URL do feed ATOM obtido na primeira seção.

Depois que tivermos um objeto NSURLRequest, criamos uma NSURLConnection e passamos para ela o NSURLRequest, dando a ela o delegado. Uma NSURLConnection é uma interface simples usada para comunicação entre o seu aplicativo para iPhone e o Lotus Connections através das APIs Atom. Criar uma conexão usando NSURLConnection é um modo mais direto. Ela requer que o aplicativo forneça um objeto delegado no qual esse delegado implementa os seguintes métodos:

  • connection:didReceiveResponse:
  • connection:didReceiveData:
  • connection:didFailWithError:
  • connectionDidFinishLoading:

Damos a ela um delegado porque a NSURLConnection carrega a solicitação de modo assíncrono e precisa saber o que fazer com o NSData retornado da NSURLConnection.

Antes de prosseguir, vamos definir um objeto delegado de acordo com o guia de desenvolvedor da Apple. Um objeto delegado ou delegação é um padrão simples e potente no qual um objeto em um programa atua em nome de, ou em coordenação com, outro objeto. O objeto que está sendo delegado mantém uma referência ao outro objeto, o delegado, e, no momento apropriado, envia uma mensagem para ele. A mensagem informa o delegado de um evento que o objeto que está sendo delegado vai tratar ou acabou de tratar. Nesse caso, quando os dados são retornados da NSURLConnection, ela chama o objeto delegado e o informa de que os dados estão prontos para serem analisados e podem ser exibidos para o usuário.

A listagem 1 mostra o código usado para inicializar uma conexão com NSURLRequest no mesmo aplicativo. Se a conexão for bem-sucedida ela configura networkActivityIndicatorVisible como YES. Essa configuração exibe um indicador visual na UI do iPhone de que há atividade de rede em andamento.

Listagem 1.Criar uma NSURLRequest
//Blogs Atom feed API
  NSURL *url = [[[NSURL alloc]
    initWithString:@"https://www.ibm.com/developerworks/mydeveloperworks/news/
atom/stories/public?source=blogs&ps=30"]
	 autorelease];

  NSURLRequest* request = [[NSURLRequest alloc]
	   initWithURL:url];



  NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:request 
delegate:self];		
  if (connection) {
	//conection is good turn on the network indicator spinner
	[UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
  } else {
	 //error	
}

A próxima etapa é definir o método que é chamado quando a conexão responde. Nesse método, obtemos o Content-Lenght do cabeçalho do objeto de resposta. Usamos esse valor para definir o tamanho do objeto NSMutableData, que é onde armazenamos todos os dados retornados da solicitação. Consulte a listagem 2.

Listagem 2. Processar a resposta da NSURLConnection
////////////////////////////////////////////////////////////////////////////////////
- (void)connection:(NSURLConnection*)connection didReceiveResponse:
(NSHTTPURLResponse*)response {
	//response saved so that status Codes can be checked later
    _response = [response retain];
    NSDictionary* headers = [response allHeaderFields];
    int contentLength = [[headers objectForKey:@"Content-Length"] intValue];
    
    //append the responseData used in connectionDidFinishLoading:
    _responseData = [[NSMutableData alloc] initWithCapacity:contentLength];}

Conforme os dados são recebidos através da conexão, incluímos todos os dados no objeto responseData. É possível que esse método seja chamado mais de uma vez, isso porque ele inclui os dados em vez de configurar os dados. Consulte a listagem 3.

Listagem 3. Obter todos os dados de resposta
////////////////////////////////////////////////////////////////////////////////////
- (void)connection:(NSURLConnection*)connection didReceiveData:(NSData*)data {
	[_responseData appendData:data];
	}

Depois que a conexão tiver acabado de carregar, o método do objeto delegado, connectionDidFinishLoading, é chamado. Agora você tem todos os dados retornados da solicitação e envia esses dados para o analisador para que você possa obter os títulos de entrada do blog no feed de atualizações.

Como nesse ponto você parou de receber dados do servidor, sua solicitação está completa e você pode desligar o indicador de atividade de rede, como a listagem 4 demonstra.

Listagem 4. Criar o analisador e passar para ele os dados para análise
////////////////////////////////////////////////////////////////////////////////////
- (void)connectionDidFinishLoading:(NSURLConnection *)connection {

	[UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
		
		
		AtomParser *parser = [[AtomParser alloc] initWithData:_responseData];
		[parser parse];
				
		_items = parser.items;
		[_tableView reloadData];
}

Finalmente, você cria uma classe que analisa o feed Atom. Primeiro, crie uma classe Objective-C no seu projeto do XCode. Chamamos nosso analisador de feed Atom de AtomParser.m e AtomParser.h. Então, altere-o para que o AtomParser.h seja uma subclasse de NSXMLParser e que também implemente o protocolo NSXMLParserDelegate. Essa etapa é feita no AtomParser.h e se parece com o seguinte:

@interface AtomParser : NSXMLParser <NSXMLParserDelegate>

Agora que criou a classe AtomParser, é preciso criar o método de análise que é chamado na listagem 5, que mostra o que está contido no método de análise no AtomParser.m.

Listagem 5. Invocar o NSXMLParser
- (BOOL)parse {
	_items = [[NSMutableArray alloc] init];
	
	self.delegate = self;
	
	BOOL result = [super parse];
	
	
	return result;
}

Agora, é preciso inicializar a array dos itens, que é onde se armazena todas as informações que serão passadas para SampleApplicationViewController.m para serem exibidas em tableView. Configure o delegado como self, o que significa que você tem de definir os métodos NSXMLParserDelegate:

  • elements: parser:didStartElement:namespaceURI:qualifiedName:attributes:
  • parser:foundCharacters:
  • parser:didEndElement:namespaceURI:qualifiedNames:

Depois disso, chame a superclasse herdada da classe AtomParser para executar a análise dos dados retornados da API do Lotus Connections. Conforme os dados são analisados, os métodos delegados são chamados e é nesta etapa que você decide quais dados ignorar e quais dados colocar na array de itens. Para o mesmo aplicativo, você está interessado somente nos elementos de título em uma identificação <entry>. Mostraremos mais adiante como exibir essas informações em UITableView.

Quando a análise do método NSXMLParser começar a ser executada, ela chama primeiro a implementação delegada do método: parser:didStartElement:namespaceURI:qualifiedName:attributes:. Esse método olha os nomes de elemento e procura um elemento <title>. Quando encontra um, ele define BOOL _foundTitle como YES, para que ele saiba armazenar o conteúdo da cadeia de caractere no elemento <title>. Usamos o elemento <title> neste exemplo porque tableView exibe todos os títulos das últimas 30 entradas do blog a partir dos dados da API que você recuperou. A listagem 6 mostra que elementName é igual a title;bif, então ele define foundEntry BOOL apropriadamente. Ele também verifica o elementName em relação à cadeia de caractere “entry” para verificar se todas as identificações no feed Atom que são chamadas de “title” são filhas das identificações <entry>. Neste caso, você deseja somente os elementos <title> que são filhos de elementos <entry>. Se você olhar todo o feed Atom retornado pela API, é possível ver que há um elemento <title> que define o título do feed Atom. Esse elemento <title> não é filho de um elemento <entry>, portanto, iremos ignorá-lo.

Listagem 6. Verificar o elementNames
////////////////////////////////////////////////////////////////////////////////////
- (void)         parser: (NSXMLParser*) parser
    didStartElement: (NSString*) elementName
        namespaceURI: (NSString*) namespaceURI
    qualifiedName: (NSString*) qName
        attributes: (NSDictionary*)attributeDict {
        if ([elementName isEqualToString:@"entry"]) {
            _foundEntry = YES;
        }
        if ([elementName isEqualToString:@"title"]) {
            _foundTitle = YES;
            _title = [[NSMutableString alloc] init];
        }
	
}

O próximo método chamado no processo de análise é parser:foundCharacters:, que fornece todo ou parte do conteúdo da cadeia de caractere no elemento atual. Como não há garantia de que ele chame todo o conteúdo da cadeia de caractere na primeira vez, o objeto NSMutableString _title inclui a cadeia de caractere atual até que o último método seja chamado:

parser:didEndElement:namespaceURI:qualifiedNames:

Listagem 7. Salvar o valor de texto do elemento de título
////////////////////////////////////////////////////////////////////////////////////
- (void)         parser: (NSXMLParser*) parser
        foundCharacters: (NSString*) string {
        	if (_foundTitle '&& _foundEntry) {
        			[_title appendString:string];
        	}
}

O último método chamado como delegado de NSXMLParserDelegate é parser:didEndElement:namespaceURI: qualifiedName: Esse método verifica se o elementName é igual ao “title” e se _foundEntry BOOL está configurado como YES. Se elementName for igual a “title” e _foundEntry for verdadeiro, então você analisou a identificação completa de título para salvar o valor de sequência do conteúdo do elemento <title> na array de itens. Essa etapa significa que encontramos a extremidade de um elemento <title> que é filho de um elemento <entry>. Se isso for verdadeiro, então ele salva o valor de sequência do conteúdo do elemento <title> na array de itens. Você inclui os valores de sequência em _title na listagem 7. Depois que a cadeia de caractere do título é adicionada à array de itens, você libera o objeto de cadeia de caractere de título, para que o próximo título não seja incluído no título anterior. Se elementName for igual a “entry”, então você quer configurar foundEntry como NO. Em outras palavras, se o analisador encontrar um elemento com o nome “title”, ele saberá que não se trata de um filho de um elemento <entry>, e todos os outros nomes de elemento neste exemplo são ignorados.

Listagem 8. Salvar o valor de texto do elemento de título
////////////////////////////////////////////////////////////////////////////////////
- (void)         parser: (NSXMLParser*) parser
    didEndElement: (NSString*) elementName
      namespaceURI: (NSString*) namespaceURI
    qualifiedName: (NSString*) qName {
      if ([elementName isEqualToString:@"title"] && _foundEntry) {
            _foundTitle = NO;
            [_items addObject:_title];
            [_title release];
      }
      if ([elementName isEqualToString:@"entry"]) {
            _foundEntry = NO;	
      }
}

Exibição dos dados no iPhone

Finalmente, você deseja preparar os dados para serem exibidos no iPhone do modo como planejou que o usuário os visualizasse.

Quando a análise estiver completa, você terá uma array de itens NSString pronta para ser exibida na tabela. Para fazer o tableview, carregue os dados da tabela na array de itens chamada [_tableView reloadData], mostrada na listagem 4. Esse código chama a implementação do método delegado tableview de tableView:cellForRowAtIndexPath: Como SampleApplicationViewController.m é o delegado de tableView, você chama o método definido nessa classe. É possível ver o delegado tableView e a origem de dados definidos abaixo no método viewDidLoad. Esse código é inserido logo abaixo dos códigos NSURLRequest e NSURLConnection.

Listagem 9. Implementar viewDidLoad
// Implement viewDidLoad to do additional setup after 
loading the view, typically from a nib.

- (void)viewDidLoad {

    [super viewDidLoad];


_tableView = [[[UITableView alloc] initWithFrame:self.view.bounds] autorelease];

    [self.view addSubview:_tableView];


_tableView.delegate = self;

_tableView.dataSource = self;


//Blogs Atom feed API

NSURL *url = [[[NSURL alloc] 

initWithString:@"https://www.ibm.com/developerworks/mydeveloperworks/news/atom/
stories/public?source=blogs&ps=30"]

  autorelease];


NSURLRequest* request = [[NSURLRequest alloc] 

initWithURL:url];

Quando o UITableView está carregando, ele chama tableView:cellForRowAtIndexPath: quantas vezes as células da tabela estiverem visualizáveis na tela. Por exemplo, se a tela tem 100 pixels de altura e cada célula da tabela tiver 10 pixels de altura, ele chama o método 10 vezes. O método retorna uma instância de classe TableViewCell. Essa instância é um layout dos dados exibidos na tabela. Conforme o usuário rolar a tabela, ela chama tableView:cellForRowAtIndexPath: toda vez que uma célula da tabela aparecer na tela. Toda vez que UiTableView chamar o método, ele passa um indexPath, que é o valor do UITableViewCell que ele quer que retorne. No mesmo aplicativo, você passa de volta um UITableViewCell com a entrada de título do blog configurada no textLabel de UITableViewCell.

Listagem 10. Criar UITableViewCells
// Customize the appearance of table view cells.
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:
(NSIndexPath *)
indexPath {
    static NSString *CellIdentifier = @"Cell";
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
reuseIdentifier:CellIdentifier] autorelease];
 		    NSString* title = [[NSString alloc] initWithString:[_items
objectAtIndex:indexPath.row]];
            cell.textLabel.font = [UIFont systemFontOfSize:12];
            cell.textLabel.text = title;
                     				 				
    }
    // Configure the cell...
    return cell;
  }

Finalmente, o UiTableView precisa saber quantas linhas exibir na tabela. É preciso exibir somente o número de linhas da tabela que estão na array de itens. Como a chamada da API solicitou 30 entradas, o tamanho da array de itens será 30. Só para se certificar, a classe de origem de dados de visualização da tabela implementa tableView: numberOfRowsInSection:. Esse método retorna o tamanho de tableView com base no tamanho da array de itens, que, neste caso, é 30.

Listagem 11. Obter o número de linhas e seções no UITableView
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
	return 1;
}
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)
section {
	return [_items count];
	}

O mesmo aplicativo não inclui uma visualização detalhada acessada quando o usuário seleciona um UITableViewCell como o aplicativo do My developerWorks faz. No entanto, essa tarefa pode ser feita implementando tableView:didSelectRowAtIndexPath:. Nesse método, você inicializa outro UIViewController e faz o aplicativo navegar nessa visualização, mostrando uma visualização mais detalhada do UITableViewCell.

Parabéns! Depois de completar essas etapas, seu aplicativo de amostra para iPhone exibindo as 30 entradas mais recentes do blog a partir do Lotus Connections se parece com a exibição mostrada na figura 2.

Figura 2. Windows Picture e Fax Viewer
Windows Picture e Fax Viewer

Ajuste de desempenho do seu aplicativo

Ao usar as APIs Atom do Lotus Connections, pode-se considerar muitas vezes implementar um cache local para otimizar o desempenho do seu aplicativo para iPhone, dependendo daquilo que seu aplicativo exibe. Você deve pensar sobre o seguinte:

  • Se seu aplicativo está acessando dados que não são atualizados com frequência, como um perfil de usuário, você deve implementar armazenamento em cache.
  • Se estiver obtendo dados que são atualizados com frequência, como os dados no aplicativo de amostra Blogs, o armazenamento em cache não é ideal porque ele não exibe os dados mais atualizados do usuário.

O armazenamento em cache pode ser implementado em vários níveis diferentes. É possível armazenar em cache os resultado no NSMutableData retornado da solicitação de conexão. Essa abordagem evita que o aplicativo faça o download do feed toda vez que ele é carregado. O aplicativo ainda é solicitado a analisar os dados em cache antes de exibi-los.

Ou é possível armazenar em cache os dados analisados que estão na array de itens. Essa implementação elimina a necessidade de fazer o download do feed e analisá-lo antes de exibi-lo.

Para armazenar em cache a array de itens, os objetos armazenados na array precisam estar em conformidade com NSCoding. No mesmo aplicativo, a array de itens armazena o título como objetos NSString. Portanto, ela pode ser armazenada em cache no disco do aplicativo.

Listagem 12. Configurar e obter itens NSArray em cache
////////////////////////////////////////////////////////////////////////////////////
+(void)cacheItems:(NSArray*)items {
	NSString *kFile = @"cachedArrayFile";
	NSString *kArray = @"Array";
		
	NSMutableData *theData;
	NSKeyedArchiver *encoder;
	
	theData = [NSMutableData data];
	encoder = [[NSKeyedArchiver alloc]
initForWritingWithMutableData:theData];
	[encoder encodeObject:items forKey:kArray];
	[encoder finishEncoding];
	
	NSArray *paths = NSSearchPathForDirectoriesInDomains
(NSDocumentDirectory, NSUserDomainMask, YES);
	NSString *documentsDirectory = [paths objectAtIndex:0];
	NSString *path = [documentsDirectory
stringByAppendingPathComponent:kFile];

	[theData writeToFile:path atomically:YES];
	[encoder release];
}


////////////////////////////////////////////////////////////////////////////////////
+(NSMutableArray *)getCachedItems {
	NSString *kFile = @"cachedArrayFile";
	NSString *kArray = @"Array";
	NSMutableArray *tempArray = [NSMutableArray array];
	NSArray *paths = NSSearchPathForDirectoriesInDomains
(NSDocumentDirectory, NSUserDomainMask, YES);
	NSString *documentsDirectory = [paths objectAtIndex:0];
	NSString *path = [documentsDirectory
stringByAppendingPathComponent:kFile];

	NSFileManager *fileManager = [NSFileManager defaultManager];
	if([fileManager fileExistsAtPath:path]) {
		//open it and read it
		NSMutableData *decodeData;
		NSKeyedUnarchiver *decoder;
		
		decodeData = [NSData dataWithContentsOfFile:path];
		decoder = [[NSKeyedUnarchiver alloc]
		
initForReadingWithData:decodeData];
		tempArray = [decoder decodeObjectForKey:kArray];
		[decoder finishDecoding];
		[decoder release];
	}
	return tempArray;
}

Conclusão

Usar as APIs do Lotus Connections 2.5 para criar aplicativos para o iPhone é algo bem direto. Desde que você tenha um entendimento básico de como navegar pelas APIs do Lotus Connections e for capaz de seguir algumas etapas simples para obter os dados dos feeds Atom do Lotus Connections, analise os dados e depois exiba-os no seu aplicativo, você está se saindo bem. Para saber tudo o que as APIs do Lotus Connections 2.5 são capazes de fazer, verifique o aplicativo para iPhone do My developerWorks disponível agora na Apple aApp Store.


Download

DescriçãoNomeTamanho
Código de amostraSampleApplication.zip39.5KB

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=Lotus
ArticleID=577091
ArticleTitle=Desenvolvimento de um aplicativo de rede social para iPhone baseado em IBM Lotus Connections 2.5
publish-date=11052010