segunda-feira, 8 de junho de 2015

Desenvolvimento para Windows Phone

História


Após muito investimento da Microsoft, finalmente o desenvolvimento para Windows Phone está enchendo os olhos de muitos desenvolvedores. Foi lançado em 21 de outubro de 2010 para concorrer diretamente com os sistemas operacionais móveis que dominam o mundo, Android e IOS.
O Windows Phone, ao contrário do que muitos pensam, não é uma continuação do Windows Mobile. Entrando em completa ruptura com as antigas versões, a Microsoft tem agora o foco diretamente no mercado consumidor, apresentando uma nova interface gráfica.

Aparelho com Windows Phone 8

Figura 1: Aparelho com Windows Phone 8


Tela inicial – Live Tiles


O principal foco da Microsoft no Windows Phone é a personalização do aparelho, o tornando bem pessoal e cada um com sua identidade visual. Por isso, temos os Live Tiles que garantem que o usuário esteja sempre atualizado e conectado com as coisas que mais lhe importam, desde os textos publicados em redes sociais pelos seus melhores amigos ao horário da sua próxima reunião.
Os Live Tiles são blocos dinâmicos que atualizam informações constantemente sobre o que está acontecendo no “seu mundo”.

Recursos


Os recursos e experiências de usuários variam de acordo com o idioma, localidade, operadora, fabricante de hardware, modelo do aparelho e a versão do sistema. Alguns dos recursos do Windows Phone: Exibição e teclado na tela (em diversas línguas), sugestões de textos inteligentes, músicas, vídeos e podcasts, pesquisa direta no Bing, pesquisa local, pesquisa visual e por voz, mapas, controle por voz, conexão com rede e serviços Xbox Live.

Iniciando com Windows Phone


Para iniciar o desenvolvimento para Windows Phone é necessário ter alguma base de conhecimento em C# ou VB, que são as duas possíveis linguagens de desenvolvimento. As ferramentas de desenvolvimento são o Visual Studio 2010 ou 2012, e o SDK do Windows Phone. É possível também usar o Visual Studio Community 2013 que fornece tudo de que você precisa para começar a desenvolver aplicativos e ainda melhor, tudo gratuitamente. O SDK integra ao Visual Studio os templates de Windows Phone, as ferramentas no ToolBox e o Emulador usado para testar, simular e depurar suas aplicações, já que alguns podem se interessar em desenvolver sem ainda possuir um dispositivo real.

Linguagem da interface – XAML


Baseada em XML, a XAML ou Extensible Application Markup Language (pronunciada zammel), é a linguagem criada pela Microsoft e usada para criar interfaces de forma simples e é utilizada em diversos produtos da Microsoft.

Criar o projeto

A primeira etapa na criação de um aplicativo do Windows Phone é criar um novo projeto no Visual Studio.

Para criar o projeto
  1. Certifique-se de ter baixado e instalado o Windows Phone SDK. Para saber mais, veja Obter o SDK.
  2. Inicie o Visual Studio na tela inicial do Windows. Se a janela de Registro aparecer, você pode registrar o produto, ou pode ignorar temporariamente o prompt.
  3. Crie um novo projeto selecionando o comando de menu ARQUIVO | Novo | Projeto.
  4. Na janela Novo Projeto, expanda os modelos de Visual C# ou Visual Basic instalados e depois expanda Aplicativos da Loja. Selecione os modelos dos Aplicativos do Windows Phone.
  5. Na lista de modelos dos Aplicativos do Windows Phone, selecione o modelo Aplicativo em Branco (Windows Phone).
  6. Na parte inferior da janela Novo projeto, digite MiniBrowser como o Nome do projeto.
    Selecionar um modelo de aplicativo do Windows Phone
  7. Clique em OK. O novo projeto é criado e abre em Visual Studio. Você pode ver os itens a seguir:
    • A janela principal contém o editor de código e exibe App.xaml.cs ou App.xaml.vb. Nesse arquivo de código, você pode definir manipuladores de eventos globais.
    • O painel direito inclui o Gerenciador de Soluções, que lista os arquivos no projeto.
    A página App.xaml.cs é aberta no Visual Studio

  • No Gerenciador de Soluções, clique duas vezes em MainPage.xaml para abri-lo. Essa página contém a interface do usuário da primeira página de seu aplicativo. A janela principal está dividida em duas partes:
    • O painel direito contém a marcação XAML que define a interface do usuário para a página.
    • O painel esquerdo contém uma aparência que mostra a saída da marcação XAML.
    A página por trás do código associado, MainPage.xaml.cs ou MainPage.xaml.vb, que contém o código para manipular a interação do usuário com a página, não é aberta ou exibida por padrão.
    MainPage.xaml é aberta no Visual Studio

  • Criar a interface do usuário

    A etapa seguinte é para dispor os controles que compõem a interface do usuário do aplicativo usando o designer do Visual Studio. Depois de adicionar os controles, o layout final ficará semelhante à seguinte captura de tela.
    Interface de usuário final do aplicativo
    Para criar a interface do usuário
    1. Abra a Caixa de Ferramentas no Visual Studio, caso ainda não esteja aberta, selecionando o comando de menu EXIBIR | Caixa de Ferramentas. A Caixa de Ferramentas normalmente é aberta no lado esquerdo da janela do Visual Studio e exibe a lista de controles disponíveis para criar a interface do usuário. Por padrão, a Caixa de Ferramentas fica recolhida quando você não a está usando.
    2. Adicione um título ao aplicativo.
      1. Do grupo Controles XAML comuns na Caixa de ferramentas, adicione um controle TextBlock à superfície do designer arrastando-o da Caixa de ferramentas e soltando-o na superfície do designer. Coloque o TextBlock na parte superior do espaço disponível. Use o mouse para dimensionar o controle à largura da página.
        Caixa de ferramentas do Visual Studio
      2. Abra a janela Propriedades no Visual Studio, caso ainda não esteja aberta, selecionando o comando de menuEXIBIR | Janela Propriedades. A janela Propriedades é aberta no canto inferior direito da janela do Visual Studio. Se o TextBlock ainda estiver selecionado, as propriedades do TextBlock serão exibidas na janela Propriedades.
        Janela de propriedades do Visual Studio
      3. Na janela Propriedades, altere as propriedades a seguir para o novo TextBlock.
    PropriedadeCategoriaValor
    TextoComumMini navegador
    AlturaLayoutAuto
    LarguraLayoutAuto
    Alinhamento horizontalLayoutAmpliar
    Tamanho da fonteTexto48 px


    Com essas configurações, o controle pode dimensionar e posicionar a si próprio corretamente nos modos de retrato e paisagem.
    Aplicativo com título



  • Adicione uma caixa de texto para o URL.
    1. Do grupo Controles XAML comuns na Caixa de ferramentas, adicione um controle TextBox à superfície do designer arrastando-o da Caixa de ferramentas e soltando-o na superfície do designer. Coloque o TextBox logo abaixo do texto Mini Browser. Use o mouse para dimensionar o controle à largura aproximada mostrada na imagem de layout acima. Deixe espaço à direita do botão Ir.
    2. Na janela Propriedades, altere as propriedades a seguir para a nova caixa de texto.
      Propriedade
      Categoria
      Valor
      Nomen/aURL
      TextoComumhttp://windows.microsoft.com /
      AlturaLayoutAuto
      LarguraLayoutAuto
      Alinhamento horizontalLayoutAmpliar
      TextWrappingTextoNoWrap

      Com essas configurações, o controle pode dimensionar e posicionar a si próprio corretamente nos modos de retrato e paisagem.
  • Adicione o botão Ir.
    1. Redimensione a caixa de texto para criar o espaço para o botão Ir. Em seguida, do grupo de Controles XAML comuns na Caixa de Ferramentas, adicione um controle de Botão arrastando e soltando-o. Coloque-o à direita da caixa de texto que acabou de adicionar. Dimensione o botão para encaixá-lo ao espaço disponível.
    2. Na janela Propriedades, altere as propriedades a seguir para o novo botão.
      Propriedade
      Categoria
      Valor
      Nomen/aIr
      ConteúdoComumIr
      AlturaLayoutAuto
      LarguraLayoutAuto
      Alinhamento horizontalLayoutDireita

      Com essas configurações, o controle pode dimensionar e posicionar a si próprio corretamente nos modos de retrato e paisagem.
    Aplicativo com controles
  • Adicione o controle WebView.

    1. Em seguida, do grupo de Controles XAML comuns na Caixa de Ferramentas, adicione um controle WebView arrastando e soltando-o. Coloque-o abaixo dos controles que você adicionou nas etapas anteriores. Use seu mouse para dimensionar o controle para preencher o espaço restante.
    2. Na janela Propriedades, altere as propriedades a seguir para o novo controle WebView.
      Propriedade
      Valor
      NomeMini navegador
      AlturaAuto
      LarguraAuto
      Alinhamento horizontalAmpliar
      Alinhamento verticalAmpliar

    Seu layout agora está concluído!
    No código XAML em MainPage.xaml, procure pela grade que contém seus controles. Ela é semelhante ao seguinte. Se deseja um layout exatamente como mostrado na ilustração acima, copie o seguinte XAML e cole-o para substituir a Grade em seu arquivo MainPage.xaml.
            <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
            <TextBlock Margin="10,10,10,0" TextWrapping="Wrap" Text="MiniBrowser" VerticalAlignment="Top" FontSize="48"/>
            <TextBox x:Name="URL" Margin="10,95,124,0" Text="http://windows.microsoft.com/" VerticalAlignment="Top"/>
            <Button x:Name="Go" Content="Go" HorizontalAlignment="Right" Margin="0,85,10,0" VerticalAlignment="Top" Width="109"/>
            <WebView x:Name="MiniBrowser" Margin="10,150,10,10"/>
        </Grid>
    
    
    


    Adicionar o código

    A etapa final antes de testar seu aplicativo é adicionar o código que implementa o botão Ir.
    Para adicionar o código
    1. No designer, clique duas vezes no controle de botão Ir que você adicionou. Isso cria um manipulador de eventos vazio para o evento Clique do botão. Você verá o manipulador de eventos vazio em uma página de código C# na guiaMainPage.xaml.cs, ou em uma página de código Visual Basic na guia MainPage.xaml.vb.
      using System;
      using System.Collections.Generic;
      using System.IO;
      using System.Linq;
      using System.Runtime.InteropServices.WindowsRuntime;
      using Windows.Foundation;
      using Windows.Foundation.Collections;
      using Windows.UI.Xaml;
      using Windows.UI.Xaml.Controls;
      using Windows.UI.Xaml.Controls.Primitives;
      using Windows.UI.Xaml.Data;
      using Windows.UI.Xaml.Input;
      using Windows.UI.Xaml.Media;
      using Windows.UI.Xaml.Navigation;
      
      // The Blank Page item template is documented at http://go.microsoft.com/fwlink/p/?LinkID=234238
      
      namespace MiniBrowser
      {
          /// <summary>
          /// An empty page that can be used on its own or navigated to within a Frame.
          /// </summary>
          public sealed partial class MainPage : Page
          {
              public MainPage()
              {
                  this.InitializeComponent();
              }
      
              /// <summary>
              /// Invoked when this page is about to be displayed in a Frame.
              /// </summary>
              /// <param name="e">Event data that describes how this page was reached.  The Parameter
              /// property is typically used to configure the page.</param>
              protected override void OnNavigatedTo(NavigationEventArgs e)
              {
              }
      
              private void Go_Click(object sender, RoutedEventArgs e)
              {
      
              }
          }
      }
      
      
      
      Quando você clica duas vezes no botão Ir, o Visual Studio também atualiza o XAML em MainPage.xaml para conectar o evento Clique do botão ao manipulador de eventos Go_Click.
      <Button x:Name="Go" Content="Go" ... Click="Go_Click"/>
      
      
    2. Em MainPage.xaml.cs ou em MainPage.xaml.vb, adicione as duas linhas de código exibidas abaixo dentro do manipulador de eventos Go_Click vazio. Esse código pega a URL que o usuário insere na caixa de texto e navega para a URL no controle de WebView chamado de MiniBrowser.
              private void Go_Click(object sender, RoutedEventArgs e)
              {
                  string site = URL.Text;
                  MiniBrowser.Navigate(new Uri(site, UriKind.Absolute));
              }
      
      
      

    Execute o aplicativo

    Agora, você terminou seu primeiro aplicativo Windows Phone! Agora você irá compilar e depurar o aplicativo.
    Antes de testar o aplicativo, certifique-se que seu computador tem acesso a Internet para poder testar o controle WebView.
    Para executar seu aplicativo no emulador
    1. Crie a solução ao selecionar o menu de comando BUILD | Build Solution.
      Se um erro ocorrer, eles estarão listado na janela Lista de erros. Você pode abrir a janela Lista de erros se ela não estiver aberta, selecionando o menu de comando VISUALIZAR | Lista de erros. Caso haja erros, revise as etapas acima, corrija os erros e então crie a solução novamente.
    2. Na barra de ferramentas Padrão, certifique-se que o alvo de implantação para o aplicativo está definido para um dos valores para o Emulador do Windows Phone, por exemplo,, Emulador 8.1 WVGA 4 polegadas 512MB.
      Lista de emuladores no Visual Studio
    3. Execute o aplicativo pressionando F5 ou selecionando o menu de comando DEPURAR | Começar a depurar.
      Isto abre a janela do emulador e inicia o aplicativo. Se for a primeira vez que você está iniciando o emulador, leva vários segundos para o emulador iniciar e abrir seu aplicativo.
    4. Para testar seu aplicativo, clique no botão Ir e verifique se o controle WebView carrega o web site especificado.
      Aplicativos executados no emulador
    5. Para testar o aplicativo no modo paisagem, pressione um dos controles de rotação na barra de ferramentas do emulador.
      Controles de rotação para o emulador
      O emulador gira para o modo paisagem. O controle redimensiona-se para ajustar ao formato de tela paisagem.
    6. Para parar de depurar, você pode selecionar o menu de comando DEPURAR | Parar de depurar no Visual Studio.
      É melhor sair do emulador rodando quando você terminar uma sessão de depuração. A próxima vez que você executar seu aplicativo, este iniciará mais rapidamente, pois o emulador já está sendo executado.
    Parabéns! Agora, você completou com êxito seu primeiro aplicativo Windows Phone.

    Fonte: https://msdn.microsoft.com/pt-br/library/windows/apps/dn631251.aspx

    Gameficação e padrões de interface em dispositivos móveis

    Padrões de projeto são soluções passíveis de replicação para a resolução de um problema particular em um contexto específico. Podem ser vistos como a reutilização da essência de uma solução para problemas similares. Logo, um padrão resolve um problema recorrente, em um determinado contexto de uso e fornece uma solução viável de ser aplicada e fornecendo subsídios para se adaptar esta solução a variantes de um determinado problema (Dantas, 2002) (Nudelman, 2013). Ao se abordar padrões de projeto no desenvolvimento de interfaces, Nudelman (2013) salienta a importância de se considerar não somente padrões, mas também anti-padrões. Para o autor um anti-padrão resulta da falta de conhecimento de uma solução mais adequada, ou ainda da aplicação de um padrão no contexto errado ao qual deveria ser utilizado. Assim, anti-padrões são soluções inadequadas a um problema que acaba por resultar em uma situação ruim, ou então descrevem como sair de uma situação ruim e chegar a uma boa solução. A presença de “bons”padrões em um sistema bem sucedido pode não ser suficiente. É preciso mostrar que estes padrões geralmente não ocorrem em sistemas mal sucedidos e que determinadas construções inadequadas (anti-padrões) encontradas em sistemas mal sucedidos geralmente não estão presentes em sistemas bem sucedidos (Dantas, 2002).

    Neste contexto, padrões de projeto são parte fundamental para o desenvolvimento de sistemas, especialmente em dispositivos móveis, nos quais há a necessidade de se dispor de soluções recorrentes devido a características específicas destes dispositivos tais como a fragmentação de modelos (tipos diferentes) ou às limitações físicas e de desempenho dos mesmos. De forma paralela, a utilização de padrões de projeto contribui para a utilização de técnicas de gameficação possibilita um maior direcionamento do processo de desenvolvimento do sistema para a utilização de estratégias de gameficação. Com o grande número de modelos diferentes de dispositivos móveis, especialmente com sistema operacional Android, fica cada vez mais complexo o desenvolvimento de uma interface compatível com a maioria dos
    dispositivos presentes no mercado (Figura1).


    Figura 1. Diferentes tamanhos de dispositivos e suas respectivas “Áreas quentes” de acessibilidade ao toque. 
    Fonte: Adaptado de (Nudelman, 2013)

    Interfaces de usuário carecem de atenção especial na utilização de técnicas de gameficação e determinados padrões de desenvolvimento de interfaces de usuário fazem-se necessários, pois dispositivos distintos e seus correspondentes tamanhos de telas apresentam diferentes formas de interação ao usuário (Figura 1). A forma de acesso a determinadas aplicações e o posicionamento das mãos, principalmente os polegares, sobre o dispositivo são referenciados como “áreas quentes”. Estas áreas viabilizam a utilização de um padrão de navegação de interface denominado “canivete-suíço”, o qual esconde o menu principal da aplicação (Nudelman, 2013). Posteriormente, o acesso a este menu pode ser realizado por meio de botão sem ocupar espaço desnecessário, o que viabiliza a sua utilização em diferentes tamanhos de telas. Baseando-se neste padrão inicial percebeu-se a necessidade de uma melhor adequação da interface decorrente do modelo MobilEduc, visto que as interfaces que o compõem foram desenvolvidas sem considerar padrões de desenvolvimento. 


    Fonte: SIIMI . 2014 . III Símpósio internacional de novação em mídias interativas

    Ferramenta do Google para desenvolvimento Android


    Android Studio é o ambiente de desenvolvimento integrado (IDE) oferecido pela Google para desenvolvedores que desejam criar aplicações para o Android. O programa tem como base o INtelliJ IDEA e ele oferece uma ferramenta completa para lidar com as mais variadas aplicações criadas para o SO citado.
    Para que o aplicativo funcione corretamente, é preciso ter o Java SE Development Kit (JDK) instalado no computador. No entanto, o Android SDK já está presente na ferramenta (não é necessário baixá-lo e fazer a instalação manual). Esta já é uma primeira versão estável do programa.
    O software oferece várias ferramentas para facilitar o trabalho dos novos devs, como um editor de código, modelos prontos de alguns aplicativos similares e também um emulador capaz de simular tamanhos variados de tela nas mais diversas resoluções. Isto inclui suporte não apenas para smartphones, mas também para tablets, TVs e até dispositivos vestíveis com os smartwatches.
    A interface do programa lembra outras IDEs, trazendo certa familiaridade com o seu estilo de uso. Assim, na parte superior da tela você tem acesso a todas as funções disponíveis, separadas em menus bem como a uma barra de ferramentas. Na porção direita da tela você possui o espaço destinado ao código, enquanto na esquerda é possível visualizar o conteúdo do seu projeto.

    Criando código

    Porém, a forma na qual cada programa é visualizado, aqui, é um pouco diferente do Eclipse, por exemplo. No Android Studio, cada projeto contém vários módulos de código, enquanto na outra ferramenta citada, cada um desses itens seria tratado individualmente como um projeto. O aplicativo também permite ver o seu trabalho como texto ou design.

    Ferramentas essenciais

    Ao abrir a aplicação, basta iniciar um projeto para começar as suas experiências. É possível desenvolver completamente do zero ou importar um item já existente, mesmo que ele tenha sido montado em outro editor. Além disso, o programa também oferece a importação de códigos de exemplo para funções com as quais você não esteja muito familiarizado.

    Usando o programa

    O programa traz uma estrutura completa com as ferramentas mais utilizadas para o desenvolvimento. Além disso, ele conta com com modelos, sistemas para gerar APKs múltiplas, suporte ao desenvolvimento em outros idiomas, depurador e opções para a detecção de outros problemas (como compatibilidade de versão, performance e usabilidade).
    O programa foi desenvolvido com suporte ao Google Cloud Platform, permitindo integrar facilmente ao sistema do Google Cloud Messaging.

    Fontes: http://www.tudocelular.com/android/noticias/n46869/google-lanca-ferramenta-de-desenvolvimento-android.html; http://www.baixaki.com.br/download/android-studio.htm; http://www.tecmundo.com.br/android/69111-android-studio-ferramenta-criacao-apps-google-ganha-versao-1-0.htm

    Introdução ao Desenvolvimento do Android

    Uma Breve História do Android

    A plataforma Android é o produto do Open Handset Alliance, um grupo de organizações colaborando para a construção de um telefone móvel melhor. O grupo, liderado pelo Google, inclui operadores de telefonia móvel, fabricantes de aparelhos portáteis,fabricantes de componentes, provedores de plataformas e soluções de software e empresas de marketing. A partir de um ponto de vista de desenvolvimento de software, o Android fica bem ao centro do mundo do software livre.
    O primeiro telefone portátil com capacidade para Android no mercado foi o dispositivo G1 fabricado pela HTC e fornecido pela T-Mobile. O dispositivo se tornou disponível após quase um ano de especulações, quando as únicas ferramentas de desenvolvimento de software disponíveis eram alguns releases do SDK em constante aprimoramento. Conforme a data de release do G1 se aproximava, a equipe do Android liberou o SDK V1.0 e os aplicativos começaram a aparecer para a nova plataforma.
    Para estimular a inovação, o Google patrocinou duas séries do "Android Developer Challenges," onde milhões de dólares foram envolvidos nas melhores participações. Alguns meses depois do G1, o Android Market foi lançado, permitindo que os usuários navegassem e fizessem o download de aplicativos diretamente em seus telefones. Após cerca de 18 meses, uma nova plataforma móvel entrava na arena pública.

    A Plataforma Android

    Com a variedade de recursos do Android, seria fácil confundi-lo com um sistema operacional desktop. O Android é um ambiente em camadas baseado em kernel Linux e que inclui funções ricas. O subsistema da UI inclui:
    • Janelas
    • Visualizações
    • Widgets para a exibição de elementos comuns como caixas de edição, listas e listas suspensas
    O Android inclui um navegador incorporável baseado em WebKit, o mesmo mecanismo navegador de software livre equipando o navegador Mobile Safari do iPhone.
    O Android ostenta uma rica array de opções de conectividade, incluindo WiFi, Bluetooth e dados wireless através de uma conexão celular (por exemplo, GPRS, EDGE e 3G). Uma técnica popular em aplicativos Android é estabelecer um link com o Google Maps para exibir um endereço diretamente em um aplicativo. O suporte para serviços baseados em locais (como GPS) e acelerômetros também está disponível na pilha de software Android, embora nem todos os dispositivos Android sejam equipados com o hardware necessário. Existe também suporte para câmera.
    Historicamente, duas áreas onde aplicações móveis lutaram para acompanhar suas contrapartes de desktop são gráfico/mídia e métodos de armazenamento de dados. O Android aborda o desafio dos gráficos com suporte integrado para gráficos em 2-D e 3-D, incluindo a biblioteca OpenGL. O peso do armazenamento de dados é amenizado porque a plataforma Android inclui o banco de dados SQLite de software livre popular. A Figura 1 mostra uma visualização simplificada das camadas do software Android.
    Figura 1. Camadas do Software Android

    Arquitetura do Aplicativo

    Conforme mencionado, o Android é executado sobre um kernel Linux. Os aplicativos Android são gravados na linguagem de programação Java e são executados em uma máquina virtual (VM). É importante observar que a VM não é uma JVM, como você pode esperar, mas é uma Dalvik Virtual Machine, uma tecnologia de software livre. Cada aplicativo Android é executado em uma instância da Dalvik VM, que, por sua vez, reside em um processo gerenciado por kernel Linux, conforme mostrado abaixo.
    Figura 2. Dalvik VM
    Dalvik VM

    Um aplicativo Android consiste em uma ou mais das classificações a seguir:
    Atividades
    Um aplicativo que possui uma UI visível é implementado com uma atividade. Quando um usuário seleciona um aplicativo da tela inicial ou de um ativador de aplicativo, uma atividade é iniciada.
    Serviços
    Um serviço deve ser utilizado para qualquer aplicativo que precise persistir por um longo período de tempo, como um monitor de rede ou um aplicativo de verificação de atualização.
    Provedores de conteúdo
    Você pode pensar em provedores de conteúdo como um servidor de banco de dados. O trabalho de um provedor de conteúdo é gerenciar o acesso aos dados que persistem, como um banco de dados SQLite. Se seu aplicativo for muito simples, você não precisa necessariamente criar um provedor de conteúdo. Se estiver construindo um aplicativo maior, ou um que disponibilize dados para várias atividades ou aplicativos, um provedor de conteúdo será o meio de você acessar seus dados.
    Receptores de transmissão
    Um aplicativo Android pode ser ativado para processar um elemento de dados ou para responder a um evento, como o recebimento de uma mensagem de texto.
    Um aplicativo Android, junto com um arquivo chamado AndroidManifest.xml, é implementado em um dispositivo. O AndroidManifest.xml contém as informações de configuração necessárias para você instalá-lo corretamente no dispositivo. Ele inclui os nomes de classes necessários e os tipos de eventos que o aplicativo está pronto para processar, além das permissões necessárias que o aplicativo precisa para execução. Por exemplo, se um aplicativo exigir acesso à rede — para fazer o download de um arquivo, por exemplo — essa permissão deve ser declarada explicitamente no arquivo de manifesto. Muitos aplicativos podem ter essa permissão específica ativada. Tal segurança declarativa ajuda a reduzir a probabilidade de um aplicativo perigoso causar danos em seu dispositivo.
    A próxima seção discute o ambiente de desenvolvimento necessário para a construção de um aplicativo Android.

    Ferramentas Necessárias

    A maneira mais fácil para você começar a desenvolver aplicativos Android é fazer o download do Android SDK e do IDE do Eclipse (consulte Recursos). O desenvolvimento do Android pode acontecer no Microsoft® Windows®, Mac OS X ou Linux.
    Este artigo supõe que você esteja utilizando o IDE do Eclipse e o plug-in Android Developer Tools para Eclipse. Os aplicativos Android são gravados na linguagem Java, mas são compilados e executados em Dalvik VM (uma máquina virtual não Java). A codificação na linguagem Java dentro do Eclipse é bastante intuitiva; o Eclipse fornece um ambiente Java rico, incluindo ajuda sensível ao contexto e sugestões de códigos. Após seu código Java ser claramente compilado, o Android Developer Tools se certifica de que o aplicativo esteja empacotado corretamente, incluindo o arquivo AndroidManifest.xml.
    É possível desenvolver aplicativos Android sem o Eclipse e o plug-in Android Developer Tools, mas você precisaria estar familiarizado com o Android SDK.
    O Android SDK é distribuído como um arquivo zip que é descompactado em um diretório em sua unidade de disco rígido. Como já houve várias atualizações do SDK, é recomendado que você mantenha seu ambiente de desenvolvimento bem organizado para poder se alternar facilmente entre instalações do SDK. O SDK inclui:
    android.jar
    O arquivo Java archive contendo todas as classes do Android SDK necessárias para a construção do seu aplicativo.
    documention.html e diretório de documentos
    A documentação do SDK é fornecida localmente e na Web. Ela tem, em grande parte, forma de JavaDocs, facilitando a navegação em vários pacotes no SDK. A documentação também inclui um Guia de Desenvolvimento de alto nível e links para a comunidade mais ampla do Android.
    Diretório de amostras
    O subdiretório de amostras contém código de origem completo para uma variedade de aplicativos, incluindo ApiDemo, que exercita muitas APIs. O aplicativo de amostra é um excelente lugar para você explorar quando começar a desenvolver seu aplicativo Android.
    Diretório de ferramentas
    Contém todas as ferramentas de linha de comando para construir aplicativos Android. A ferramenta mais útil e usada com mais frequência é o utilitário adb (Android Debug Bridge).
    usb_driver
    Diretório contendo os drivers necessários para conectar o ambiente de desenvolvimento a um dispositivo ativado por Android, como G1 ou o telefone de desenvolvimento desbloqueado Android Dev 1. Esses arquivos só são necessários para desenvolvedores que utilizam a plataforma Windows.
    Os aplicativos Android podem ser executados em um dispositivo real ou no Android Emulator, que é fornecido com o Android SDK. A Figura 3 mostra a tela inicial do Android Emulator.
    Figura 3. Android Emulator
    Android Emulator


    Android Debug Bridge

    O utilitário adb suporta vários argumentos de linha de comando opcionais que fornecem recursos poderosos, como cópia de arquivos a partir de e para o dispositivo. O argumento de linha de comando shell permite que você se conecte ao próprio telefone e emita comandos shell fundamentais. A Figura 4 mostra o comando shell adb com relação a um dispositivo real conectado a um laptop Windows com um cabo USB.
    Figura 4. Utilizando o Comando Shell adb
    Utilizando o Comando Shell adb
    Dentro deste ambiente shell, você pode:
    • Exibir a configuração de rede que mostra várias conexões de rede. Observe as várias conexões de rede:
      • lo é a conexão local ou loopback.
      • tiwlan0 é a conexão WiFi com um endereço fornecido por um servidor DHCP local.
    • Exibe o conteúdo da variável de ambiente PATH.
    • Execute o comando su para se tornar o superusuário.
    • Altere o diretório para /data/app, em que aplicativos do usuário são armazenados.
    • Faça uma listagem de diretórios onde você veja um único aplicativo. Os arquivos de aplicativo Android são, de fato, arquivos de archive visualizados com WinZip ou equivalente. A extensão é apk.
    • Emita um comando ping para ver se o Google.com está disponível.
    Neste mesmo ambiente de prompt de comandos, você também pode interagir com bancos de dados SQLite, iniciar programas e muitas outras tarefas no nível do sistema. Esta é uma função absolutamente notável, considerando o fato de você estar conectado a um telefone.
    Na próxima seção, você vai criar um aplicativo Android simples.

    Codificando um Aplicativo Básico

    Esta seção apresenta um rápido tour pela construção de um aplicativo Android. O aplicativo de exemplo é tão simples quanto você pode imaginar: um aplicativo "Hello Android" modificado. Você vai incluir uma pequena modificação para deixar a cor do plano de fundo da tela toda branca para poder utilizar o telefone como uma lanterna. Nada muito original, mas será útil como exemplo. Faça download do código fonte completo.
    Para criar um aplicativo no Eclipse, selecione File > New > Android project, que inicia o assistente New Project Android.
    Figura 5. Assistente New Project Android
    Assistente New Project Android

    Em seguida, você cria um aplicativo simples com uma única atividade, junto com um layout de UI armazenado em main.xml. O layout contém um elemento de texto que você vai modificar para chamar de Android FlashLight. O layout simples é mostrado abaixo.

    Listagem 1. Layout do FlashLight

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:background="@color/all_white">
    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" android:textColor="@color/all_black"
       android:gravity="center_horizontal"/>
    </LinearLayout>
    Crie alguns recursos de cor em strings.xml.

    Listagem 2. Cor em strings.xml

    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="hello">Android FlashLight</string>
        <string name="app_name">FlashLight</string>
        <color name="all_white">#FFFFFF</color>
        <color name="all_black">#000000</color>
    </resources>
    O layout da tela principal possui uma cor de plano de fundo definida como all_white. No arquivo strings.xml, você vê que all_white é definida como um valor trio RGB de #FFFFFF ou toda branca.
    O layout contém um único TextView, que é, de fato, apenas uma parte de um texto estático; ele não é editável. O texto é configurado para ser preto e centralizado horizontalmente com o atributo gravity.
    O aplicativo possui um arquivo de origem Java chamado FlashLight.java, conforme mostrado abaixo.

    Listagem 3. Flashlight.java

    package com.msi.flashlight;
    import android.app.Activity;
    import android.os.Bundle;
    public class FlashLight extends Activity {
        /** Called when the activity is first created. */
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
        }
    }
    O código básico é gerado diretamente a partir do assistente New Project:
    • Ele faz parte de um pacote Java chamado com.msi.flashlight.
    • Ele possui duas importações:
      • Uma para a classe de atividade
      • Uma para a classe de pacote configurável
    • Quando essa atividade é iniciada, o método onCreate é invocado, passando um savedInstanceState. Não se preocupe com esse pacote configurável em relação aos nossos propósitos; ele será utilizado quando uma atividade for suspensa e depois continuada.
    • O método onCreate é uma substituição do método de classes de atividade de mesmo nome. Ele chama o método onCreate da superclasse.
    • Uma chamada para setContentView() associa o layout da UI definido no arquivo main.xml. Tudo que estiver no main.xml e no strings.xml é automaticamente mapeado para as constantes definidas no arquivo de origem R.java. Nunca edite esse arquivo diretamente, já que ele é alterado em cada compilação.
    A execução do aplicativo apresenta uma tela branca com texto preto.
    Figura 6. Tela Branca da Lanterna
    Tela Branca da Lanterna

    A configuração do arquivo AndroidManifest.xml para o aplicativo FlashLight é mostrada abaixo.

    Listagem 4. AndroidManifest.xml para FlashLight

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.msi.flashlight"
          android:versionCode="1"
          android:versionName="1.0.0">
        <application android:icon="@drawable/icon" android:label="@string/app_name">
            <activity android:name=".FlashLight"
                      android:label="@string/app_name">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
        </application>
    </manifest>
    
    
    
    
    Este arquivo foi criado automaticamente pelo plug-in Android Developer Tools para Eclipse. Você não precisou fazer nada.
    É claro que o aplicativo não é absolutamente magnífico. Mas ele seria conveniente se você quisesse ler algo sem atrapalhar o sono de seu(sua) companheiro(a), ou se você precisasse se localizar na caixa do fusível no porão durante uma queda de energia.

    Fonte: http://www.ibm.com/developerworks/br/library/os-android-devel/

    quinta-feira, 4 de junho de 2015

    Frameworks para Desenvolvimento

    Segundo SMUTNÝ (2012), os frameworks de desenvolvimento móvel apresentam características em comum:
    - Suporte a várias plataformas, que permite maior abrangência do aplicativo aos usuários;
    - Aplicativos leves, devido à necessidade de transferência de dados via bandas de internet limitadas;
    - Otimização para funcionalidade touchscreen, onde é necessário adaptar o design da aplicação para não considerar cursores de mouse, bem como tratar eventos especialmente para dispositivos móveis;
    - Utilização de HTML5 e CSS3, pois são padrões compatíveis com a maioria dos navegadores móveis.

    PhoneGap

    PhoneGap, também conhecido como Cordova, é uma ferramenta open source para desenvolvimento multiplataforma baseada em HTML5, CSS3 e Javascript. Aplicativos móveis criados com esta ferramenta são executados simulando o ambiente nativo de cada plataforma. Esta funcionalidade deve-se à utilização de APIs que possibilitam o acesso aos recursos dos dispositivos. Para recursos específicos em certos dispositivos, que não são atendidos via APIs existentes, há a possibilidade de criação de plugins para comunicação entre a ferramenta e o componente nativo. Este encapsulamento das aplicações nos ambientes nativos possibilita também a distribuição dos aplicativos nas lojas virtuais.

    O desenvolvimento de aplicativos utilizando o Cordova pode ser realizado em dois fluxos distintos de trabalho: centralizado em uma plataforma específica ou multiplataforma. O desenvolvimento centralizado é indicado quando o aplicativo necessita de codificação específica em funcionalidades da plataforma utilizada, tornando-se de baixo nível. Na grande maioria das vezes, esta codificação é realizada no próprio SDK da plataforma. O desenvolvimento multiplataforma não é indicado para este tipo de fluxo de trabalho, pois a codificação torna-se específica por plataforma. Neste caso seria necessária a criação de plugins para integração de cada plataforma, e a realização de compilações distintas.

    Para o desenvolvimento multiplataforma, a ferramenta disponibiliza um utilitário chamado Cordova CLI. O CLI permite abstrair os comandos específicos para acesso aos recursos, tornando-se uma ferramenta de programação de alto nível. As customizações necessárias são realizadas automaticamente pelo CLI. Este utilitário copia os comandos padrões para pastas específicas criadas cada plataforma, ajusta a compatibilidade do código conforme a necessidade, e gera os respectivos arquivos para execução.

    Para uma plataforma ser atendida pelo CLI, é necessário que seu respectivo SDK esteja instalado no computador em que será desenvolvido o aplicativo. É importante considerar que a compilação dos programas para algumas plataformas depende diretamente do SO instalado na máquina utilizada para o desenvolvimento.

    Para utilização do CLI é necessária à instalação de dois outros programas: Node.js e um cliente Git (PHONEGAP, 2014). O Node.js é uma ferramenta baseada em Javascript, que permite a criação de conexões de rede não bloqueantes ao servidor. É orientada a eventos, o que a torna leve e eficiente, indicada para aplicações com grande quantidade de conexões simultâneas (NODE.JS, 2014). Git é um sistema para controle de versionamento de código.
    Apresenta código aberto e é indicado para controle de projetos com grande velocidade (GIT, 2014).

    Appcelerator

    Appcelerator, também conhecido como Titanium, é uma ferramenta de desenvolvimento open source, que permite a criação de aplicativos móveis nativos e híbridos com a utilização de HTML5. Possui suporte para os ambientes iOS, Android e BlackBerry. (APPCELERATOR, 2014).

    Adobe AIR

    O Adobe AIR é formado pelo conjunto de duas outras ferramentas, Flex e Adobe Flash Builder, adaptadas para o desenvolvimento móvel. A programação é realizada em Flex e a depuração e o encapsulamento com o Flash Builder. É uma ferramenta paga e suporta as plataformas Android, iOS e BlackBerry Tablet OS (ADOBE, 2014).

    Sencha

    Sencha Touch é uma ferramenta para desenvolvimento móvel baseado em HTML5, CSS3 e Javascript, que possui suporte às plataformas Android, iOS, Windows Phone, Microsoft Surface Pro e RT, e BlackBerry.

    Permite o desenvolvimento de aplicativos que respondam às requisições do usuário e trocas de layout de forma instantânea. O tratamento visual dos aplicativos conta com animações e rolagem de tela suaves, com alta precisão de imagem. Para cada dispositivo, o framework seleciona a melhor forma de rolagem da tela, ampliando a experiência do usuário na utilização dos aplicativos. Estão disponíveis também, temas pré-definidos para utilização nas plataformas iOS, Android, BlackBerry e Windows Phone.

    Juntamente com a utilização da ferramenta, programas complementares necessitam ser instalados, atendendo assim todas as funcionalidades possíveis. São necessários o Sencha Cmd, disponibilizado pela mesma empresa, o Java Runtime Environment (JRE) para a execução do Sencha Cmd, e o Ruby para compilar informações CSS utilizadas. Quando realizado um aplicativo Android em Windows, também é necessária a instalação do Java SDK.

    Sencha Cmd é uma ferramenta de linha de comando multiplataforma que fornece tarefas automatizadas e recursos para economia de tempo de desenvolvimento em aplicações criadas pelo Sencha Touch. Alguns exemplos de recursos disponíveis são: ferramenta de geração de código, servidor Web para manter dos arquivos do localhost e encapsulamento nativo, para as aplicações possuírem acesso aos recursos dos dispositivos e distribuição nas lojas virtuais. Sua utilização está disponível para Windows, Mac OS X e Linux.

    Ao compilar e empacotar aplicativos desenvolvidos com o Sencha Touch há possibilidade de escolha do método mais adequado. No modo padrão da ferramenta, há a opção de compilação e criação de somente um pacote contendo os arquivos de todas as plataformas atendidas, ou realizar o processo separadamente para cada ambiente. Outra opção é a compilação e empacotamento compatíveis com os ambientes nativos, que fornece também o carregamento do simulador apropriado. O empacotamento nativo está disponível a partir da inicialização do PhoneGap ou Apache Cordova na execução do Sencha Touch.

    Apache Cordova permite que sejam utilizados os recursos nativos e empacotamento para as plataformas Android, iOS, BlackBerry e Windows Phone. É a base para a criação do PhoneGap, estendendo suas funcionalidades ao framework (SENCHA TOUCH, 2014)

    Qt

    Qt disponibiliza ferramenta específica para desenvolvimento mobile, o Qt Mobile. É uma ferramenta para desenvolvimento de aplicativos nativos multiplataforma, baseada em C++. Atende somente as plataformas iOS e Android, e possui licenciamento pago (QT DIGIA, 2014).

    Unity

    Unity é uma ferramenta especializada em desenvolvimento de aplicativos 2D e 3D, mais especificamente jogos. Possui suporte para aplicativos desktop, Web, Android, iOS, Windows Phone 8 e BlackBerry 10 (UNITY, 2014). É uma ferramenta paga.

    Corona

    Ferramenta indicada para o desenvolvimento de aplicativos na área de jogos 2D, educação, negócios e eBooks. Utiliza como padrão, a linguagem Lua. Suporta as plataformas iOS e Android. O suporte à plataforma Windows Phone está em construção. É uma ferramenta paga (CORONA, 2014).

    Mono

    Mono é uma versão open source do framework .NET da Microsoft. Apresenta a linguagem C# para desenvolvimento e tem recebido apoio dos entusiastas da área para tornar-se a principal ferramenta para o desenvolvimento de aplicações Linux. Suporta as plataformas Android e iOS. Não disponibiliza encapsulamento para tornar os aplicativos híbridos (MONO, 2014).

    Marmalade

    Formado por um conjunto de ferramentas para desenvolvimento móvel que permitem o desenvolvimento de aplicativos, incluindo jogos, utilizando a linguagem C/C++. Possibilita a criação de aplicativos multiplataforma para dispositivos móveis, desktop, e Smart TV. Aplicativos híbridos escritos em HTML5, CSS3 e Javascript podem ser criados utilizando uma ferramenta em específico do pacote, a Web Marmalade. O framework possui suporte as plataformas Android, iOS e Windows Phone 8, entre outros. É uma ferramenta paga (MARMALADE, 2014).

    MoSync

    MoSync é uma ferramenta open source para desenvolvimento de aplicativos multiplataforma. Está dividido em duas funcionalidades: MoSync SDK e MoSync Reload. Apresenta licenciamento gratuito, com a condição que os aplicativos distribuídos sejam disponibilizados para os demais usuários MoSync, com abertura de código. Para os desenvolvedores/empresas que não desejam tornar público seu código, há a opção de aquisição de licenças anuais para distribuição dos aplicativos.

    MoSync SDK é uma IDE para desenvolvimento nas linguagens C/C++ ou HTML5/ Javascript, ou uma combinação das duas. Suporta nove plataformas, entre elas, Android, iOS e Windows Phone, permitindo que o código seja escrito somente uma vez e empacotado no formato de cada plataforma. A utilização de APIs permite que sejam acessados recursos nativos dos dispositivos, como gráficos, localização e câmera, entre outros.

    Para aplicativos escritos em HTML5, juntamente com Javascript e CSS, a ferramenta disponibiliza emuladores para as plataformas Android e Windows Phone, onde é necessária a instalação e seus respectivos SDKs. Para o iOS, é disponibilizado um simulador que deve ser utilizado no sistema operacional OS X, com o Xcode instalado.

    O MoSync Reload permite que aplicativos em HTML5, Javascript e CSS escritos em qualquer IDE ou editor de texto sejam recarregados de forma instantânea em todos os emuladores ou dispositivos em que estejam vinculados. Possui compatibilidade com as plataformas Android, iOS e Windows Phone 7. É formado pelo Reload Server, que deve ser executado na máquina em que as aplicações serão salvas, tornando-se o servidor dos aplicativos; Reload Client, um cliente que deve ser instalado em todos os emuladores e dispositivos que estarão vinculados ao servidor; e por fim o Reload Development UI, que é a interface instalada juntamente com o Reload Server, para controle das aplicações instaladas (MOSYNC, 2014).


    Fontes:

    ADOBE. Disponível em: <http://www.adobe.com/devnet/devices/mobile-apps.html>. Acesso em 08/06/2015.

    APPCELERATOR. Disponível em: <http://www.appcelerator.com/titanium/>. Acesso em 08/06/2015.

    BASSOTTO, Helena. DESENVOLVIMENTO DE UM PROTÓTIPO DE APLICATIVO MÓVEL UTILIZANDO FERRAMENTA MULTIPLATAFORMA. Trabalho de Conclusão de Curso - Curso de Ciências da Computação, Universidade de Caxias do Sul, Caxias do Sul

    CORONA. Disponível em: <http://coronalabs.com/>. Acesso em 08/06/2015.

    GIT. Disponível em: <http://git-scm.com/>. Acesso em 08/06/2015.

    SENCHA TOUCH. Disponível em: <http://www.sencha.com/products/touch/>. Acesso em 08/06/2015.

    MARMALADE. Disponível em: <https://www.madewithmarmalade.com/>. Acesso em 08/06/2015.

    MONO. Disponível em: <http://mono-project.com/Main_Page>. Acesso em 08/06/2015.

    MOSYNC. Disponível em: <http://www.mosync.com/>. Acesso em 08/06/2015.

    PHONEGAP. Disponível em: <http://phonegap.com/>. Acesso em 08/06/2015.

    QT DIGIA. Disponível em: <http://qt.digia.com/>. Acesso em 08/06/2015.

    SMUTNÝ, Pavel. Mobile development tools and cross-platform solutions in 13th International Carpathian Control Conference (ICCC), 2012.

    UNIT. Disponível em: <http://unity3d.com/>. Acesso em 08/06/2015.




    quarta-feira, 3 de junho de 2015

    Projeto com o usuário em mente




    O Xcode fornece ferramentas para gerenciar todo o seu desenvolvimento de fluxo de trabalho desde a criação de seu aplicativo e projetar a sua interface de usuário, para testes, otimização e enviar seu aplicativo para o Mac App Store. Você pode personalizar o Xcode para se adequar ao seu estilo de trabalho, mantendo-se focado na tarefa de desenvolvimento na mão.

    Interface Humano Computador com Xcode

    Não é o suficiente apenas criar um aplicativo que funcione. Os usuários esperam aplicativos para Mac poderosos, intuitivos e envolventes. Deve-se pensar sobre a experiência do usuário quando você projetar todos os aspectos da sua aplicação com o Xcode.
    O guia “iOS Human Interface Guidelines” fornece diversas dicas sobre o que podemos fazer para que as aplicações (também chamadas de apps) possam ser aceitas na “App Store” (loja de aplicativos da Apple). Vale lembrar que para ser aceito na App Store existe uma rigorosa avaliação realizada por especialistas contratados pela Apple. O guia também trás muitos detalhes e recomendações. Algumas recomendações são mais genéricas e outras mais específicas detalhando mais como realizar determinada funcionalidade, por isso o guia caracteriza-se por ser bastante completo. O guia sempre é adaptado para a última versão do sistema operacional, atualmente iOS 7. Segue partes do texto retirado do link [1]:

    O sucesso de um aplicativo Mac depende em grande parte da qualidade de sua interface de usuário. Se os usuários não encontrarem um aplicativo atraente e fácil de usar, mesmo o mais rápido, mais poderoso, mais app full-featured pode ser um fracasso na Mac App Store. Há muitas maneiras de obter uma inspiração inicial para uma app popular, e não há um caminho único que garante o sucesso. Mas há uma directiva sobre a qual o desenvolvimento bem sucedido depende app: Projeto com o usuário em mente. As estratégias e melhores práticas resumidos a seguir são baseadas nesta directiva, e eles representam alguns dos muitos princípios e diretrizes que você precisa seguir como você projeta um aplicativo. Quando você estiver pronto para começar a trabalhar, certifique-se de ler OS X Human Interface Guidelines [2]

    Entenda o OS X Ambiente

    Se você é novo no desenvolvimento de aplicativos OS X, o primeiro passo é tornar-se um usuário do OS X você mesmo. Então, tanto quanto possível, explorar as características da plataforma OS X como um usuário, não como um desenvolvedor. Se você é um usuário de longa data Mac ou você é novo para a plataforma, o tempo necessário para articular as suas expectativas e analisar as ações depende do quanto você está disposto a explorar.



    Por exemplo, considere como os seguintes recursos da plataforma afetam a experiência do usuário: 
    • OS X inclui muitas características que aliviam os usuários de tarefas comuns de gerenciamento de aplicativo. Por exemplo, Auto Save e Versões de documentos e controle de versão contribui para que os usuários possam se concentrar em seu conteúdo. 
    • Todos os aplicativos com os seus menus em uma única barra de menu. Com uma única barra de menus, os usuários sempre sabem onde procurar os comandos da aplicação. 
    • OS X oferece suporte a vários monitores de diferentes tamanho e resolução. Os usuários podem personalizar seu espaço de trabalho, adicionando e exposições rotativas. 
    • OS X aplicativos responder aos gestos, cliques e teclas sem fazer quaisquer suposições sobre o tipo de dispositivo de entrada o usuário está usando. Os usuários esperam serem capazes de interagir com seu Mac usando o dispositivo de entrada de sua escolha. 
    • OS X é compatível com um ambiente de janela imersiva e em tela cheia. Uma experiência janela de tela cheia faz sentido para aplicações em que os usuários querem se concentrar em tarefas específicas e evitar distrações. 
    • OS X é um sistema de múltiplos usuários. Ele suporta diferentes contas de usuário e permite que vários usuários sejam conectados ao mesmo tempo. Os usuários esperam serem capazes de compartilhar o mesmo computador rapidamente sem sair. 
    • Preferências permitem aos usuários personalizar a forma como eles experimentam um aplicativo. Além do built-in Preferências do Sistema app, apps de Mac podem oferecer suas próprias preferências, que permitem aos usuários fazer alterações em comportamentos e aparências específicas da aplicação. 
    • Um ótimo aplicativo aproveita os recursos da plataforma e fornece uma experiência de usuário que se integra perfeitamente com o ambiente OS X.

    Saiba os Princípios Fundamentais de Interface Humana




    Ao projetar seu aplicativo, tenha em mente os seguintes princípios de design HI: 
    • Metáforas. Quando objetos e ações virtuais em um aplicativo são metáforas para objetos e ações no mundo real, os usuários rapidamente compreendem como usar o app. As metáforas mais adequadas sugerem uma utilização ou experiência sem impor as limitações do objeto do mundo real ou ação sobre a qual eles estão baseados. 
    • Modelo mental. A maioria dos usuários já tem um modelo mental que descreve a tarefa executada por um aplicativo. Um aplicativo que se baseia no modelo mental de seus usuários tende a ser intuitivo para as pessoas usarem. 
    • Ações explícitas e implícitas. Cada operação OS X envolve a manipulação de um objeto usando uma ação. Ações explícitas indica, claramente o resultado da manipulação de um objeto, enquanto as ações implícitas transmitem o resultado de uma ação através de pistas visuais ou contexto. 
    • Manipulação direta. Quando as pessoas manipulam diretamente os objetos na tela e as suas mudanças são imediatamente visíveis, eles estão mais envolvidos com a tarefa e mais facilmente compreendem os resultados de suas ações. 
    • Controle de usuário. Embora um aplicativo pode sugerir um curso de ação ou advertir sobre conseqüências adversas, geralmente é um erro para o aplicativo tirar a facilidade de tomada de decisão. Os melhores aplicativos encontram o equilíbrio correto entre dar às pessoas as capacidades de que precisam e ajudá-los a evitar desfechos desfavoráveis. 
    • Feedback e comunicação. Qualificações reconhecem as ações das pessoas e asseguram-lhes que o processamento está ocorrendo. Por exemplo, as pessoas esperam feedback imediato quando operam um controle, e eles apreciam atualizações de status durante operações longas. 
    • Consistência. Consistência na interface permite que as pessoas transfiram seus conhecimentos e habilidades a partir de um aplicativo para outro. O ideal é que um aplicativo é compatível com os padrões OS X, consigo mesmo, e com versões anteriores do próprio. 
    • WYSIWYG (o que você vê é o que você obtém). Os usuários esperam aplicativos para mostrar os resultados reais das ações que eles tomam e fornecer pré-visualizações precisas do conteúdo que eles criam. Por exemplo, quando os usuários personalizam um documento na tela, eles esperam encontrar as suas alterações na versão impressa do documento. 
    • Desfazer. As pessoas precisam sentir que eles podem experimentar coisas sem danificar o sistema ou comprometer o seu conteúdo. Aplicativos de sucesso incentivam os usuários a explorar através da construção no desfazer e fazer a maioria das ações facilmente reversível. 
    • Estabilidade percebida. Para dar aos usuários um sentido conceitual de estabilidade, a interface fornece um conjunto claro, finito de objetos e um conjunto de ações a serem executadas nesses objetos. Elementos e ações padrão criar um ambiente familiar em que os usuários saibam como as coisas se comportam e o que fazer. 
    • Integridade estética. Integridade estética não é uma medida de quão bonito é um aplicativo; é uma medida de quão bem a aparência de um aplicativo combina com a sua função. 

    Siga as orientações

    OS X Human Interface Guidelines contém diretrizes que vão desde a experiência do usuário, recomendações para regras específicas que regem o uso de tecnologias OS X e elementos na tela. Grandes aplicativos OS X dão às pessoas acesso simplificado ao conteúdo que eles se preocupam. Para fazer isso, esses aplicativos incorporam diretrizes de experiência do usuário, como estes:
    • Concentre-se em soluções, não características.
    • Lidar com gestos de forma adequada.
    • Cativar com belos gráficos.
    • Usar elementos da interface do usuário padrão corretamente.
    • Use o ponteiro certa para o trabalho.
    • Ajudar os usuários a ser produtivo imediatamente.
    • Faça exploração segura.
    • Adaptar-se às mudanças no ambiente do usuário.
    • Ganhar a confiança dos usuários com fiabilidade, a previsibilidade e a estabilidade.
    Quando um aplicativo usa corretamente elementos de interface do usuário, como botões e barras de ferramentas, os usuários são propensos a notar apenas que o aplicativo se comporta como eles esperam. Mas quando um aplicativo usa elementos da interface do usuário incorretamente, os usuários são muitas vezes rápido para expressar sua insatisfação e deixar feedback negativo na Mac App Store. Grande aplicações Mac tomar cuidado para seguir as diretrizes de uso de elemento de interface do usuário. As diretrizes listadas nesta seção representam uma fração das orientações contidas no OS X Human Interface Guidelines. Lendo esse documento na sua totalidade é um passo essencial no processo de desenvolvimento de aplicativos. 

    E aí, achou que era só baixar o Xcode e começar a fazer uma App né? 


    [1] http://developer.apple.com/library/mac/referencelibrary/GettingStarted/RoadMapOSX/books/DesignwiththeUserinMind_Mac/DesignwiththeUserinMind/DesignwiththeUserinMind.html
    [2] http://developer.apple.com/library/mac/documentation/UserExperience/Conceptual/OSXHIGuidelines/index.html


    Fonte: http://developer.apple.com/library/mac/referencelibrary/GettingStarted