Conteúdo


Desenvolvendo aplicativos nativos para dispositivos remotos com IBM Worklight

Comments

Introdução

Se você tem experiência no desenvolvimento de aplicativos remotos, sabe que há muitas escolhas. De ferramentas e linguagens de desenvolvimento a plataformas de tempo de execução, há muitas escolhas importantes a serem feitas. Mas há uma escolha em particular que é tema de discussão mais que as outras. É a escolha de arquitetura e empacotamento de aplicativo.

Uma das primeiras decisões a fazer, ao começar um projeto de aplicativo remoto, é sobre o tipo de aplicativo que será criado.

Figura 1. Escolhas de arquitetura de aplicativo remoto

Desenvolvedores de aplicativo remoto podem escolher entre aplicativos remotos da web, aplicativos híbridos ou aplicativos nativos, como mostra a Figura 1. Existe muito debate sobre a resposta “certa”, mas na realidade não existe resposta errada. Alguns projetos podem favorecer a onipresença e portabilidade de um aplicativo remoto da web, enquanto outros favorecem a otimização e a exploração do dispositivo que as abordagens híbrida ou nativa proporcionam. Cada uma dessas abordagens possui vantagens e desvantagens, e qualquer uma pode ser a escolha certa para um dado projeto de aplicativo.

A decisão sobre qual arquitetura de aplicativo utilizar no projeto é importante, pois afeta diretamente a experiência do usuário. No entanto, é criticamente importante poder fazer essa escolha. Em outras palavras, as ferramentas e tecnologias usadas para desenvolver, executar e gerenciar aplicativos remotos não deve fazer essa escolha para o desenvolvedor.

Essa é exatamente a posição adotada pela plataforma de aplicativo remoto IBM Worklight em termos de arquitetura de aplicativo. A plataforma oferece suporte a todos os tipos de aplicativos mostrados na Figura 1 e permite que o desenvolvedor escolha qual abordagem é ideal para o projeto. Independente da sua escolha, o Worklight proporciona a você serviços de tempo de execução, integração, segurança e capacidade de gerenciamento para seus aplicativos remotos.

Neste artigo, tratamos especificamente do uso do Worklight para desenvolver, entregar e gerenciar aplicativos nativos. Na maior parte do tempo, explicaremos o processo para criar, desenvolver, implementar e gerenciar um aplicativo remoto nativo no Worklight. Mas antes disso, precisamos discutir algo importante: por que escolher o Worklight para criá-los quando já há várias ferramentas por aí para criar aplicativos nativos, muitas delas fornecidas diretamente pelos fornecedores das plataformas?

Para responder a essa pergunta, precisamos considera alguns fatores:

  • Plataforma holística: Ao decidir o que é necessário para o desenvolvimento de aplicativos remotos na empresa, alguns requisitos são óbvios. Em particular, sabemos que é necessário um conjunto de ferramentas de desenvolvimento para isso. Mas é fácil esquecer que também é preciso desenvolver, distribuir e gerenciar os aplicativos implementados. Em outras palavras, não é necessário apenas uma ferramenta de desenvolvimento, mas sim uma plataforma completa. O Worklight é uma plataforma de aplicativos remota, corporativa, de ponta a ponta, que permite desenvolver, desenvolver, implementar, executar e gerenciar aplicativos remotos.
  • Plataforma comum: Em organizações que possuem vários projetos de aplicativo remoto para vários locais diferentes, o desenvolver acaba adotando vários, se não todos, dos estilos de arquitetura remota. Você pode ter uma abordagem de gerenciamento de ferramenta e ciclo de vida para cada um dos estilos de arquitetura diferente, ou pode ter uma única plataforma e conjunto de ferramentas com suporte para cada um desses estilos diferentes. A segunda escolha é a melhor, até mesmo para sua sanidade. O Worklight oferece uma única plataforma e conjunto de ferramentas para todos os estilos de arquitetura de aplicativo remoto que discutimos neste artigo.
  • Serviços em comum: Novamente, considerando a probabilidade de você adotará vários estilos de arquitetura na organização, seria bom (e conveniente e inteligente) pode usar uma única abordagem de segurança e integração para todos os diferentes tipos de aplicativos. Com o Worklight, é possível desenvolver um conjunto único de serviços de integração, serviços de segurança e serviços de aplicativo remoto (por exemplo, serviços de notificações push) para utilizar em vários aplicativos remotos diferentes na empresa. Além disso, mesmo aplicativos de tipos de arquitetura diferentes podem compartilhar esses serviços em comum.

Usando APIs do Worklight para aplicativos iOS nativos

Nas próximas seções, explicaremos o processo de desenvolver um aplicativo nativo do iOS usando o Worklight. O aplicativo de amostra utiliza as APIs nativas integradas do Worklight para demonstrar a chamada de procedimentos remotos, a análise de dados remotos e a integração com os controles nativos de interface com o usuário do iOS. O objetivo é demonstrar claramente como é possível criar um aplicativo nativo sem esforço, aproveitando os vários recursos e benefícios que a plataforma Worklight oferece.

O aplicativo em si usa as APIs nativas do Worklight para ler o feed RSS de um website público (neste exemplo, cnn.com).

Figura 2. Aplicativo Worklight de amostra

Este cenário de aplicativo é propositadamente simples, para que você possa observar como o Worklight lida com as interações nativas no lado do cliente e a chamada de adaptadores remotos no lado do servidor. O Worklight oferece vários recursos nos lados de cliente e de servidor criados para melhorar a experiência de desenvolvimento e a capacidade de gerenciamento de aplicativos remotos.

Visão geral de como criar o aplicativo de amostra:

  1. Crie uma API nativa do Worklight
  2. Crie e configure um aplicativo nativo do iOS
  3. Chame um procedimento do Worklight
  4. Manipule a resposta do procedimento

Este artigo inclui o seguinte material para download:

  • WLNativeRssReader.zip - Projeto de API nativa do Worklight
  • RssFeedReader_v1.zip – Projeto Xcode nativo limpo para o trabalho
  • RssFeedReader_v2.zip – Projeto Xcode nativo concluído
  • Worklight native API Snippets.doc - segmentos de código

Criando uma API nativa do Worklight

O Worklight permite que aplicativos nativos do iOS comuniquem-se com um Servidor Worklight por meio da biblioteca de APIs nativas do Worklight. Para atender a um aplicativo iOS nativo, o servidor Worklight precisa saber da sua existência, e para isso você cria uma pasta de API nativa no projeto do Worklight. Essa pasta contém uma biblioteca de API nativa e um arquivo de configuração para serem copiados para o projeto nativo e o arquivo application-descriptor.xml a ser implementado no Servidor Worklight. Esse arquivo contém metadados que descrevem o aplicativo para o Servidor Worklight, o que permite que o servidor comece a atender solicitações do aplicativo e a gerenciá-lo.

Para desenvolver o projeto de API nativa do Worklight:

  1. Abra o Worklight Studio e crie um projeto do Worklight (Figura 3).
    Figura 3. Criando um projeto do Worklight
  2. Dê ao projeto o nome de WLNativeRssReader. Selecione a opção Native API e clique em Next (Figura 4).
    Figura 4. Tipos de aplicativo no assistente de projeto do Worklight
  3. Insira o nome do aplicativo WLNativeRssReader. Selecione iOS no campo Environment. Clique em Finish (Figura 5).
    Figura 5. O painel de assistente de aplicativo de API nativa
  4. Clique em Yes para abrir a perspectiva associada (Figura 6).
    Figura 6. Solicitação de alteração de perspectiva no Worklight Studio
  5. Agora você está pronto para implementar o aplicativo no Servidor Worklight. Isso significa que o servidor estará ciente da existência do aplicativo e poderá atender a solicitações. Para isso, clique com o botão direito na pasta do aplicativo WLNativeRssReader e selecione Run As > Deploy Native API.
    Figura 7. Implementando o projeto de API nativa
  6. Expanda a pasta WLNativeRssReader e clique duas vezes no arquivo worklight.plist (Figura 8).
    Figura 8. Localizando o arquivo de propriedades no projeto nativo
    Figura 9. Propriedades do arquivo worklight.plist
  7. Edite o arquivo worklight.plist, que contém a configuração do servidor. Nesse arquivo:
    • protocol: O protocolo de comunicação do servidor Worklight, que é HTTP ou HTTPS.
    • host: O nome do host do servidor Worklight.
    • port: A porta do servidor Worklight.
    • wlServerContext: O caminho de raiz de contexto do aplicativo no servidor Worklight.
    • application id: O ID do aplicativo, definido no arquivo application-descriptor.xml.
    • application version: A versão do aplicativo.
    • environment: O ambiente de destino do aplicativo nativo (Android ou iOS).

Antes de continuar, vamos ver os componentes do projeto. Eles incluem (Figura 10):

  • WorklightAPI: Essa pasta é uma biblioteca de APIs do Worklight, que você deve copiar para o projeto nativo do iOS.
  • application-descriptor.xml: Arquivo usado para definir metadados do aplicativo e para definir as configurações de segurança a serem seguidas pelo servidor Worklight.
  • Worklight.plist: Arquivo que contém configurações de conectividade a serem usadas por um aplicativo nativo do iOS. É necessário copiar esse arquivo para o projeto nativo do iOS.
  • server\conf: Assim como em qualquer projeto do Worklight, você modifica os arquivos na pasta server\conf para criar a configuração do servidor.
Figura 10. Estrutura do projeto de API nativa do Worklight

Criando um adaptador HTTP

Adaptadores são executados no servidor e conectam-se a aplicativos remotos.

Os adaptadores são a parte dos aplicativos no lado do servidor, sendo implementados no Worklight e atendidos por ele. Os adaptadores conectam-se a aplicativos corporativos (também chamados de sistemas de backend), fornecem dados aos aplicativos remotos e realizam nos dados a lógica necessária no lado do servidor.

Os vários benefícios proporcionados pelos adaptadores do Worklight incluem:

  • Desenvolvimento rápido: Adaptadores são desenvolvidos em JavaScript e XSL. Os desenvolvedores utilizam JavaScript flexível e eficiente no lado do servidor para produzir código sucinto e legível para integrar com os aplicativos de backend e processar dados. Os desenvolvedores também podem usar XSL para transformar dados de backend hierárquicos em JSON.
  • Recursos de somente leitura e transacionais: Os adaptadores do Worklight oferecem suporte para modos de somente leitura e transacionais para acesso a sistemas de backend.
  • Segurança: Os adaptadores do Worklight usam recursos flexíveis de autenticação para criar conexões com sistemas de backend. Adaptadores oferecem controle sobre a identidade do usuário com o qual a conexão é feita. Pode ser um usuário do sistema ou um usuário em cujo nome a transação é feita.
  • Transparência: Os dados recuperados de aplicativos de backend são expostos de maneira uniforme, de modo que os desenvolvedores de aplicativo possam acessar os dados uniformemente, independente da origem, formato ou protocolo.
  1. No Worklight Studio, clique com o botão direito no projeto do Worklight e clique em New > Worklight Adapter (Figura 11).
    Figura 11. Criando um adaptador do Worklight
  2. Selecione o adaptador HTTP Adapter. Em Adapter name, insira RSSReader. Clique em Finish (Figura 12). O Worklight gera agora os arquivos apropriados de JavaScript, XML e XSL que formam o componente do adaptador no lado do servidor.
    Figura 12. O assistente de criação de adaptador
  3. Para os fins deste artigo, use os arquivos de adaptador HTTP padrão gerados pelo Worklight (Figura 13).
    Figura 13. Arquivos de adaptador do Worklight

    Vamos examinar a estrutura básica de um adaptador:

    • RSSReader.xml: Define as propriedades e procedimentos do adaptador.
    • RSSReader-imp.js: Usa JavaScript para criar procedimentos.
    • filtered.xsl: Usa XSL para filtrar os registros e campos recebidos (opcional).
  4. A Listagem 1 mostra o arquivo RSSReader.xml que foi gerado pelo Worklight.
    Lista 1. RSSReader.xml
    <displayName>RSSReader</displayName>
    	<description>RSSReader</description>
    	<connectivity>
    		<connectionPolicy xsi:type="http:HTTPConnectionPolicyType">
    			<protocol>http</protocol>
    			<domain>rss.cnn.com</domain>
    			<port>80</port>	
    			<!-- Following properties used by adapter's key manager for 
    			choosing specific certificate from key store  
    			<sslCertificateAlias></sslCertificateAlias> 
    			<sslCertificatePassword></sslCertificatePassword>
    			-->		
    		</connectionPolicy>
    		<loadConstraints maxConcurrentConnectionsPerNode="2" />
    	</connectivity>
    
    	<procedure name="getStories"/>
    <procedure name="getStoriesFiltered"/>

    Nesse arquivo:

    • protocol: O protocolo de comunicação com o terminal (http ou https).
    • domain: O nome do host ou nome de domínio do terminal.
    • port: A porta do terminal.
    • procedure: Declara um procedimento que é exposto ao adaptador.
  5. Em seguida, você deve implementar o adaptador no servidor Worklight. Ao fazer isso, o adaptador (e os serviços de backend subsequentes) poderá ser acessado pelos aplicativos que apontam para o mesmo servidor Worklight (Figura 14).
    Figura 14. Implementando o novo adaptador
  6. Abra seu navegador da web e acesse http://localhost:10080/WLNativeRssReader/console.
    Figura 15. Visualizando o aplicativo no Worklight Console

Criando e configurando um aplicativo nativo do iOS

É possível criar um projeto Xcode ou usar um que já existe (para este exercício, use o projeto Xcode incluído com este artigo). Agora você irá integrar o projeto do Worklight com um aplicativo nativo do iOS.

A integração consiste nas seguintes etapas:

  1. Vincule o projeto a algumas bibliotecas nativas do Worklight.
  2. Importe a API do Worklight e os arquivos worklight.plist para o projeto nativo.
  3. Adicione código de procedimento do Worklight.
  4. Solidifique a conexão entre código nativo e do Worklight.
  5. Execute o aplicativo concluído no simulador de iPhone.

Agora, vamos continuar:

  1. Abra o projeto anexado RssFeedReader no XCode, clicando duas vezes no arquivo RssFeedReader.xcodeproj.
    Figura 16. Projeto de iOS nativo no XCode
  2. Copie a pasta WorklightAPI e o arquivo worklight.plist do projeto no Worklight Studio para o diretório raiz do projeto nativo. É possível arrastar e soltar os arquivos do Worklight Studio para o ambiente do Xcode. Isso inclui os arquivos de biblioteca do Worklight necessários no projeto Xcode nativo.
    Figura 17. Arquivos a incluir no projeto nativo
  3. Marque a opção Copy items into destination group’s folder (se necessário) e clique no botão Finish (Figura 18).
    Figura 18. Adicionando arquivos ao projeto XCode
  4. Ao concluir, o explorador de projeto deve estar como na Figura 19.
    Figura 19. Projeto do XCode após copiar os arquivos necessários
  5. Vincule as bibliotecas a seguir ao aplicativo nativo do iOS. Isso garante que as bibliotecas nativas necessárias estão incluídas no projeto (Figura 20):
    • CFNetwork
    • SystemConfiguration
    • MobileCoreServices
    • CoreData
    • Security
    • libz.dylib
    • sqlcipher.framework (se não já estiver incluído)
    Figura 20. Vinculando bibliotecas ao projeto
  6. Clique no sinal de + e digite o nome da biblioteca na lista acima que você deseja adicionar na caixa de pesquisa (Figura 21).
    Figura 21. Lista de bibliotecas disponíveis para o projeto XCode
  7. Após adicionar todas as bibliotecas necessárias, a estrutura do projeto deve estar como na Figura 22.
    Figura 22. Projeto XCode após vincular as bibliotecas necessárias

Criar e testar chamada do adaptador

  1. Crie uma nova classe; para isso, selecione File > New > File (Figura 23).
    Figura 23. Criando uma classe no XCode
  2. Selecione Objective-C class e clique em Next (Figura 24).
    Figura 24. O assistente de novo arquivo no XCode
  3. Dê à classe o nome de MyInvokeListener e clique em Next.
    Figura 25. Dando nome à nova classe
  4. Selecione a pasta em que deseja salvar o arquivo (dentro da pasta do projeto) e clique em Create (Figura 26).
    Figura 26. Salvando a nova classe
  5. Agora você irá escrever código. Abra o arquivo MyInvokeListener.h e adicione o código mostrado na Listagem 2. O propósito dessas modificações é configurar initWithController de modo que contenha uma referência a MainView após ser chamado durante a inicialização de MyInvokeListener.
    Lista 2. MyInvokeListener.h
    #import <Foundation/Foundation.h>
    
    #import "WLClient.h"
    #import "WLDelegate.h"
    #import "MasterViewController.h"
    
    @interface MyInvokeListener : NSObject <WLDelegate> {
    @private
        MasterViewController *vc;
    }
    
    - (id)initWithController: (MasterViewController *) mainView;
  6. Abra o arquivo MyInvokeListener.m e adicione o código mostrado na Listagem 3.
    Lista 3. MyInvokeListener.m
    #import "MyInvokeListener.h"
    
    @implementation MyInvokeListener
    
    - (id)initWithController: (MasterViewController *) mainView{
        if ( self = [super init] ){
            vc = mainView;        
        }
        return self;
    }
    
       @end
  7. Adicione os dois métodos na Listagem 4:
    • onSuccess: será chamado quando o procedimento concluir com sucesso.
    • onFailure: será chamado quando o procedimento fracassar.
    Lista 4. Os métodos onSuccess e onFailure para chamada do adaptador
    //onSuccess callback - called when the adapter Invocation finsih successfully.
    -(void)onSuccess:(WLResponse *)response {
    
    }
    
    
    //onFailure callback - called when the adapter Invocation failed.
    -(void)onFailure:(WLFailResponse *)response{
    
    }
  8. Implemente onFailure primeiro. Se ocorrer uma falha, você deve exibir uma mensagem ao usuário e interromper UiActivityInidcator (Listagem 5).
    Lista 5. Implementação do método onFailure
    //onFailure callback - called when the adapter Invocation failed.
    -(void)onFailure:(WLFailResponse *)response{
        NSLog(@"\nProcedure Invocation Failure: %@", response);
        NSString *resultText = @"Invocation failure. ";    
        if ([response responseText] != nil){
            resultText = [resultText stringByAppendingString:[response responseText]];
        }
        NSLog(@"\nProcedure Invocation Failure: %@", resultText);
        //Display a message to the user.
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"No network connection"
    
    message:@"Please check your network connection and make sure the adapter been deployed."
    
    delegate:nil
    
    cancelButtonTitle:@"OK"
    
    otherButtonTitles:nil];
    
        [alert show];
    [vc.spinner stopAnimating];
    }
  9. Em seguida, implemente o método onSuccess. Mediante o sucesso na execução, você deve obter o objeto JSON da resposta e extrair os itens em um array, para poder iterar pelos itens, adicionando cada um a tableView (a Listagem 6 mostra a resposta do procedimento).
    Lista 6. Resultado da chamada do procedimento 'getStoriesFiltered' pelo Servidor Worklight
    "Items": [
          {
             "description": "Russian President Vladmir Putin says everyone will be 
    welcomed at next year's Winter Olympics, regardless of their \"nationality, race 
    or sexual orientation.\"",
             "guid": "http:\/\/edition.cnn.com\/2013\/10\/28\/world\/europe\/
    russia-putin-olympics-gay\/index.html",
             "link": "http:\/\/edition.cnn.com\/2013\/10\/28\/world\/europe\/
    russia-putin-olympics-gay\/index.html?
    eref=edition",
             "pubDate": "Tue, 29 Oct 2013 03:16:43 EDT",
             "title": "Putin: Gays, lesbians come to Sochi"
          },
          {
             "description": "An Israeli air strike hit two concealed rocket launchers in 
    the Gaza Strip Monday, 
    the military announced.",
             "guid": "http:\/\/edition.cnn.com\/2013\/10\/28\/world\/meast\/
    israel-gaza-airstrike\/index.html",
             "link": "http:\/\/edition.cnn.com\/2013\/10\/28\/world\/meast\/
    israel-gaza-airstrike\/index.html?
    eref=edition",
             "pubDate": "Mon, 28 Oct 2013 11:53:11 EDT",
             "title": "Israel launches Gaza air strike"
          },
  10. Adicione o código na Listagem 7, que realiza a iteração e análise:
    Lista 7. Manipulando resultados de chamada do adaptador no retorno de chamada de onSuccess
    //onSuccess callback - called when the adapter Invocation finsih successfully.
    -(void)onSuccess:(WLResponse *)response {
        NSLog(@"\nProcedure Invocation Success: -------------------------");
        //Retrive the JSON response.
        NSDictionary *responseDict = [response getResponseJson];
        //Get all the items within the JSON response to array.
        NSArray *itemsArray = [responseDict objectForKey:@"Items"];
        //For each item in the array create a new cell in the tableView.
        for (int i=0; i<[itemsArray count]; i++){
            NSDictionary *itemDict = [itemsArray objectAtIndex:i];
            NSLog(@"Title :: %@" , [itemDict objectForKey:@"title"]);        
            [vc addNewObject:itemDict atIndex:i];
        }
        
        //Stop the UIActivityIndicator spinning.
        [vc.spinner stopAnimating];
    }
  11. Desenvolva e execute o aplicativo para garantir que não há erros. O aplicativo deve estar como mostra a Figura 27.
    Figura 27. Aplicativo de amostra no simulador de iPhone
  12. Abra o arquivo MasterViewConroller.m e adicione o código necessário para chamar o adaptador do Worklight. Primeiro você define myInvocationData com o nome do adaptador e o procedimento que deseja chamar. Em seguida, você define o invokeListener que irá atender chamadas do procedimento e disparar os métodos onSuccess ou onFailure implementados no MyInvokeListener.
  13. Primeiro, adicione as importações mostradas na Listagem 8.
    Lista 8. Adicionando importações para as novas classes
    //Add reference to the Worklight API
    #import "MyInvokeListener.h"
    #import "WLProcedureInvocationData.h"
  14. No arquivo MasterViewConroller.m, localize o método invokeWorklightProcedure e adicione o código mostrado na Listagem 9.
    Lista 9. O método invokeWorklightProcedure
    //invoke the worklight procedure to get rss feeds.
    - (void)invokeWorklightProcedure
    {
        NSLog(@"%@", @" in invokeWorklightProcedure() ...");    
        WLProcedureInvocationData *myInvocationData = [[WLProcedureInvocationData 
    alloc] initWithAdapterName:@"RSSReader" procedureName:@"getStoriesFiltered"];
        MyInvokeListener *invokeListener = [[MyInvokeListener alloc] initWithController: self];
        [[WLClient sharedInstance] invokeProcedure:myInvocationData withDelegate:invokeListener];
    }
  15. Agora, adicione código que irá chamar inovkeWorklightProcedure quando o aplicativo for iniciado. Procure pelo método viewDidLoad.
    Lista 10. Código para chamar o adaptador do Worklight na inicialização do aplicativo
    - (void)viewDidLoad
    {
        NSLog(@"%@", @"viewDidLoad - MasterViewController");
        //self.tbViewObjects = [[NSMutableArray alloc] init];
        [super viewDidLoad];
        
        //Add refresh button to the navigationBar.
        UIBarButtonItem *refreshButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:
    UIBarButtonSystemItemRefresh target:self action:@selector(refreshRssFeed:)];
        self.navigationItem.rightBarButtonItem = refreshButton;
        
        //Create a UIActivityIndicator
        [self initUIActivityInticator];
        
        //Set the tableView bacground image.
        UIImageView *bg = [[UIImageView alloc] initWithImage:[UIImage imageNamed:
    @"page_background.jpg"]];
        [self.tableView setBackgroundView:bg];
        
        //Set padding of 5px to the cells.
        UIEdgeInsets inset = UIEdgeInsetsMake(5, 0, 0, 0);
        self.tableView.contentInset = inset;    
        
        //Call worklight procedure.
        [self invokeWorklightProcedure];
        [spinner startAnimating];
    }
    - (void)viewDidLoad
    {
        NSLog(@"%@", @"viewDidLoad - MasterViewController");
        //self.tbViewObjects = [[NSMutableArray alloc] init];
        [super viewDidLoad];
        
        //Add refresh button to the navigationBar.
        UIBarButtonItem *refreshButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:
    UIBarButtonSystemItemRefresh target:self action:@selector(refreshRssFeed:)];
        self.navigationItem.rightBarButtonItem = refreshButton;
        
        //Create a UIActivityIndicator
        [self initUIActivityInticator];
        
        //Set the tableView bacground image.
        UIImageView *bg = [[UIImageView alloc] initWithImage:[UIImage imageNamed:
    @"page_background.jpg"]];
        [self.tableView setBackgroundView:bg];
        
        //Set padding of 5px to the cells.
        UIEdgeInsets inset = UIEdgeInsetsMake(5, 0, 0, 0);
        self.tableView.contentInset = inset;    
        
        //Call worklight procedure.
        [self invokeWorklightProcedure];
        [spinner startAnimating];
    }

    Navegue até o final do método e adicione as linhas na Listagem 11 imediatamente após o procedimento //call worklight.

    Lista 11. Chamando o procedimento do adaptador
    //Call worklight procedure.
    [self invokeWorklightProcedure];
    [spinner startAnimating];
  16. Essas duas linhas chamam o procedimento do Worklight quando o aplicativo é iniciado (viewDidLoad) e, quando onSuccess é executado, adiciona os itens à visualização de tabela. Se ocorrer um evento onFailure, um alerta será exibido para o usuário.
  17. Desenvolva e execute o aplicativo em um simulador de iPhone (Figura 28).
    Figura 28. Aplicativo sendo executado em um simulador de iPhone
    Figura 29. Janela de console do Xcode
  18. Na Figura 29, você percebe que há um erro de conexão com o servidor. Há quatro explicações possíveis para esse erro:
    • Você se esqueceu de implementar o aplicativo.
    • Você implementou o aplicativo, mas não implementou o adaptador.
    • Você implementou o aplicativo e o adaptador corretamente e consegue vê-los no console do Worklight (http://localhost:10080/WLNativeRssReader/console/), mas o endereço de host em worklight.plist não corresponde ao endereço IP da máquina.
    • O wlServerContext dentro do arquivo worklight.plist não corresponde ao contexto do servidor. Neste caso, wlServerContext deve ser /WLNativeRssReader e não /.
  19. Abra o navegador da web e acesse http://localhost:10080/WLNativeRssReader/console/ para verificar se você consegue ver o aplicativo e o adaptador implementados.
    Figura 30. Visualizando o aplicativo e o adaptador no Worklight Console
  20. Em seguida, abra um terminal de linha de comando e digite ifconfig (para Mac OS).
    Figura 31. Determine o endereço IP do ambiente local
  21. Abra o arquivo worklight.plist e verifique se o endereço IP e os demais parâmetros correspondem à configuração do aplicativo (Figura 32).
    Figura 32. Configurando o endereço IP apropriado para o aplicativo Worklight
  22. Salve o arquivo e desenvolva e execute o aplicativo novamente.
    Figura 33. Listagem do feed RSS no aplicativo
  23. Agora você está vendo os feeds RSS corretamente, mas o que acontece se você clicar no botão Refresh? Você verá que todas as células na tabela tableView desaparecem. Isso é porque você ainda não implementou essa funcionalidade.
    Figura 34. Conteúdo da listagem do feed após clicar no botão de atualizar
  24. Abra o arquivo MasterViewController.m e procure refreshRssFeed (Listagem 12).
    Lista 12. O método refreshRssFeed
    //refresh the rss feed.
    - (void)refreshRssFeed:(id)sender
    {
        //remove all objects & refresh the tableView
        [self.tbViewObjects removeAllObjects];
        [self.tableView reloadData];
        self.tableView.separatorStyle = UITableViewCellSeparatorStyleNone;
    
        [self invokeWorklightProcedure];
        [spinner startAnimating];
    }
  25. Adicione as duas linhas mostradas na Listagem 13 para que, ao atualizar, invokeWorklightProcedure seja executado e bustIndicator seja exibido novamente.
    Lista 13. Novo código para implementar a funcionalidade de atualização
    [self invokeWorklightProcedure];
    [spinner startAnimating];

Gerenciamento de aplicativo do Worklight

Agora que o aplicativo foi implementado e está funcionando corretamente, vamos ver os recursos de gerenciamento de aplicativo do Worklight.

  1. Abra seu navegador da web e acesse http://localhost:10080/WLNativeRssReader/console/#catalog.
  2. Altere o status da versão 1.0 do aplicativo de Active para Active, Notifying Figura 35). Insira a mensagem que o usuário deve ver e clique no botão Save. Deve aparecer uma notificação amarela, indicando que a mudança foi salva.
    Figura 35. Configurando uma regra de notificação no Worklight Console
  3. Desenvolva e execute o aplicativo novamente. Você deve ver agora a mensagem de notificação exibida no simulador do iOS (Figura 36).
    Figura 36. O diálogo de notificação no aplicativo

Conclusão

Este artigo explicou como aplicativos nativos, além de aplicativos remotos híbridos e da web, podem ser desenvolvidos usando a plataforma de aplicativos remotos Worklight. Você também aprendeu sobre as vastas APIs do lado do cliente do Worklight e sobre os sistemas de backend que usam os componentes de API nativa integrada. Da perspectiva de capacidade de gerenciamento, você observou a funcionalidade do Worklight em torno de conectividade de servidor, versão de aplicativo, notificações de serviço e desativação remota. Agora você sabe como migrar aplicativos iOS nativos para o Worklight, ou como começar do zero com um novo projeto.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=WebSphere, Desenvolvimento móvel
ArticleID=964368
ArticleTitle=Desenvolvendo aplicativos nativos para dispositivos remotos com IBM Worklight
publish-date=02282014