Como assim: @foo?

Com o lançamento do ADT12 (API 13, voltada para o Android 3.2) alguns problemas começaram a ocorrer quando tentamos abrir um emulador. Nem sempre acontece o erro. Aparentemente acomete mais pessoas que, como eu, vieram de outras versões do ADT e que foram atualizando o SDK.

Como eu sempre recomendei por aqui, manter os arquivos que você já baixou é a melhor maneira de se agir. Se não a melhor pelo menos a mais rápida, dado que baixar todo o SDK a cada interação do ADT é muito demorado. Afinal, são mais de 2.5Gb de informação!

Então, o que acontece é que para algumas pessoas o seguinte erro aparece quando se tenta abrir o emulador de smartphone ou tablet:

invalid command-line parameter: SDK\android-sdk\tools/emulator-arm.exe
Hint: use '@foo' to launch a virtual device named 'foo'.

please use -help for more information

A questão é: como corrigir esse erro para que você possa continuar a abrir o emulador do Android e poder visualizar suas aplicações na tela do PC? Eu pesquisei na internet e vi algumas formas bem peculiares. Mas a forma mais simples (e que nos polpará de problemas futuros) é a que mostro abaixo.

O que aconteceu é que na atualização do ADT11 para o ADT12, algum bug foi introduzido (ou corrigido, sei lá) que faz com que o emulador cheque o caminho do SDK e não aceite espaços em branco nele. Lembre-se que o caminho padrão de instalação para o SDK é em Arquivos de Programa (ou Program Files). Caso seja um sistema de 64 bits, ele instala ou em Arquivos de Programas (x86) ou em Program Files (x86).

Com isso, passam a existir caracteres em branco no caminho que, se antes ele não se importava que existissem, agora ele passa a se importar.

Solução

Eu fiz algo simples. Criei uma pasta chamada Android em uma partição (eu escolhi a partição C:) e movi a pasta android-sdk que estava em Arquivos de Programa para lá.

Depois, no Eclipse, eu mudei o caminho do SDK em Windows > Preferences > Android para o novo caminho e, voilá!, tudo está funcionando como antes.

Essa solução evita, inclusive, problemas futuros. Caso outras versões do SDK venham com esse problema, não haverá nada que impeça o emulador de ser rodado. 

O único senão é que quando houver atualização você deverá apontar o caminho do SDK para o novo caminho e não mais para o caminho padrão sugerido por ele.

E você, ainda quer comprar um iPad?

Sério, depois de ver esse vídeo, eu não quero mais comprar iPads! Eu quero é um Galaxy Tab 10.1!

Android NDK. Mas, como assim, o nome não era SDK?

É isso mesmo. Existe um SDK no Android e também algo que eu não sabia, chamado NDK.

Olha só o que o site do Android diz a respeito do NDK:

O Android NDK é uma ferramenta companheira que permite a você construir porções de seu código com performance crítica em código nativo. Ele provê headers e bibliotecas que permitem a você construir atividades, gerenciar entrada de dados, usar sensores de hardware, acessar recursos da aplicação e mais programando em C ou C++. Se você escrever código nativo, suas aplicações ainda assim serão empacotadas dentro de um arquivo .apk e vão rodar dentro da máquina virtual do seu dispositivo. O modelo de aplicação fundamental do Android não muda.

Usar código nativo não resulta em aumento automático de performance mas sempre aumenta a complexidade da aplicação. Se você não quer ficar limitado às APIs da Framework do Android não quer dizer que você provavelmente precise do NDK. Para tal, o melhor é entender a fundo o que é o NDK.

O NDK foi criado para ser usado em conjunto com o SDK do Android.

Ou seja, quem quiser se aventurar a programar para Android em C ou C++, é uma boa opção.

Para baixar o NDK, acesse esse link e divirta-se!

Android Hierarchy Viewer

Estava lendo o livro que comprei, Apress Pro Android 3, e li algo que não sabia mas que é uma boa dica para quem está usando o SDK do Android no Eclipse. Existe uma ferramenta chamada Android Hierarchy Viewer que vem com o ADT para o Eclipse.

Quando você instala o SDK do zero, ele é instalado por padrão. No entanto, quando você faz atualização do ADT (e eu venho fazendo desde sempre, dado que não tenho tempo para ficar baixando quase 3Gb de informação se fosse desinstalar e reinstalar todas as vezes), ele não é instalado.

Segundo a página do Android que fala dessa ferramenta, o Hierarchy Viewer permite que você faça debugs e optimize a sua interface. Ele provê uma representação visual da hierarquia do seu layout (o Layout View) e um inspetor lupa para o display (o Pixel Perfect View).

Pelo que eu entendi (já que ainda não o usei) ele permitem, principalmente, que você faça ajustes finos na interface. Essa ferramenta foi adicionada nas ferramentas de desenvolvedor do Android 2.3.

Então, como instalá-la? No caso de ter sido, como disse acima, feita a instalação do zero, essa ferramenta já estará presente. Mas, caso tenha feito atualizações do ADT, você deve fazer assim para instalá-la:

1) Abra o Eclipse
2) Vá na opção Help > Install New Software
3) Escolha, na guia dropdown Work With a opção que tenha o endereço
https://dl-ssl.google.com/android/eclipse/

4) Após isso, escolha a opção Android Hierarchy Viewer e clique em Next.
5) A tela de Install Detail aparecerá. Clique em Next.
6) Uma tela onde há o texto de licença do Hierarchy Viewer aparecerá. Marque a opção em que aceita o termo de licença e clique em Finish.

Pronto, a nova ferramenta estará instalada rapidamente.

Após isso, caso queira ver como são as novas ferramentas (Pixel Viewer e Hierarchy Viewer), clique em Window > Open Perspective e escolha a opção que deseja ver.

Hierarchy Viewer

Pixel Viewer

ADT12 lançado

Para aqueles que querem sempre ter o ADT mais recente na máquina, a notícia não poderia ser melhor: o ADT12 foi lançado. Na prática, o software se mantém o mesmo. Só que algumas mudanças são visíveis, como a melhoria na parte de design das telas.

Na verdade, os últimos releases têm feito isso mesmo: melhorar a parte de desenho de interface das aplicações. Levando-se em conta que agora, mais que antes, o desenho da interface da aplicação ficará mais importante, dado que as telas estão maiores (por conta dos tablets, especificamente), a Google realmente está investindo pesado na melhoria dessa parte que, na minha opinião, sempre foi muito ruinzinha no desenvolvimento para Android.

Quem quiser baixar o novo software, basta clicar no link abaixo:

Installer Release 12 - http://dl.google.com/android/installer_r12-windows.exe

Preparação para o desenvolvimento para Android 3+

Depois de um longo período sumido do blog, resolvi voltar para dizer que não estive tão presente por aqui pois tenho uma filha de quase 7 meses que agora está naquela fase de não dormir direito, de ter um sono agitado, etc, etc. Quem é pai vai entender o meu ponto. Por isso sumi.

Mesmo assim, tenho pesquisado sobre o Android 3.0 e até então não havia encontrado nenhum livro para me basear na programação. Obviamente o blog tem esse intuito, mas eu sempre prefiro ler livros pois eles trazem mais informações e exemplos mais completos e explicados que os desse blog (que eu busco no próprio site do Android).

Mas, foram lançados dois livros que acho interessante divulgar assim. Lembrando que os livros estão em inglês (bem, se quiserem mesmo ter as melhores informações o mais rapidamente possível, é melhor ter os livros em inglês).

Os livros são:

Beginning Android 3.0

Pro Android 3.0

Para quem quer começar realmente a programar seriamente em Android 3.0, ai vão os livros que indico. Já comprei ambos e devem chegar logo em casa.

Android Tools Project Site

Eu só soube disso hoje, mas existe um site do Android chamado Android Tools Project Site que sempre está sendo atualizada pela equipe da Google no que se refere às ferramentas de desenvolvimento para o Android.

Lá eles mostram as inovações que estão fazendo no ADT.

A novidade é que agora eles inseriram o suporte aos fragmentos, como poderá ser visto nessa página (em inglês).

Vale a pena dar uma chegada lá para saber das novidades.

DICA - Colocando numeração de linha no Eclipse

Essa é uma dica boba mas que me facilita demais a vida, que é a de numerar-se as linhas.

Esse é um procedimento simples. Basta ir em Window > Preferences > General > Editors > Text Editor

Procure pela opção Show line numbers. Basta marcá-la e pronto, seu código passará a apresentar a numeração nas linhas.

Usando a perspectiva de Debug do Eclipse para aplicações Android

Depois de se escolher como fará o debug, se via USB ou Wi-Fi, temos de fazer com que a execução do código encontre breakpoints para que possamos, de fato, fazer o debug.

Para tal, siga os passos abaixo:

1) Habilite a perspectiva Debug no seu Eclipse. Você poderá fazer isso clicando em Window > Open Perspective > Debug

2) Veja que uma nova opção (de Debug) aparece na UI do Eclipse, no canto superior direito:

3) E não é só isso que acontece! A perspectiva é aberta na tela do Eclipse:

4) E ai, vamos debuggar? Clique no botão de Java, que fica no canto superior direito. Com o código aberto (nesse caso, estou com o projeto Notepad, que comento o código aqui nesse blog) no arquivo NotesList.java, vamos inserir breakpoints.

Para tal, você tem das possibilidades:

a) Clicando com o botão direito sobre uma linha, escolha Toggle Breakpoint.

b) Clique duas vezes sobre a linha no canto esquerdo dela. Um ícone de círculo, em tonalidade azul, aparecerá. Para se ter certeza que se trata de um breakpoint, basta passar o mouse sobre o ícone em questão.

5) Agora temos de nos certificar que vamos rodar a aplicação em modo de debug para que possamos "andar" nos breakpoints e ver o código sendo executado. Para tal, vamos clicar em Debug Configurations, como mostrado na imagem abaixo:

6) Clique duas vezes sobre Android Application. Uma opção aparecerá aninhada a essa opção e, ao lado direito, a janela será preenchida com os dados que deverão ser usados para o debug. Selecione o projeto clicando em Browse (escolhemos o projeto NoteList) e digitamos Notepad como nome do projeto.

7) Na guia target, escolha um AVD. Caso não tenha um AVD configurado, vá nesse link que explico como fazê-lo.

8) Na guia Common, clique no botão debug e deixe o AVD ser carregado.

9) O Eclipse perguntará se você deseja mudar o foco dele para a perspectiva do Debug. Aceite a opção e prossiga.

10) Pronto! Agora você já pode debuggar sua aplicação!

NotePad da Área de Recursos - Código Comentado - Parte 02

Arquivos de Layout e Menus

Com o Android é possível fazer a separação de áreas da interface em diferentes arquivos xml.

No projeto do NotePad, existem os seguintes arquivos xml:

Layout

• note_editor.xml
• noteslist_item.xml
• title_editor.xml

Menu

• editor_options_menu.xml
• list_context_menu.xml
• list_options_menu.xml

E o que são cada um deles?

note_editor.xml

É o arquivo que é responsável por mostrar o conteúdo da nota para edição no seu aplicativo. O arquivo consiste em um widget View, como mostrado abaixo:

<?xml version="1.0" encoding="utf-8"?>
<view xmlns:android="http://schemas.android.com/apk/res/android"
    class="com.example.android.notepad.NoteEditor$LinedEditText"
    android:id="@+id/note"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@android:color/transparent"
    android:padding="5dp"
    android:scrollbars="vertical"
    android:fadingEdge="vertical"
    android:gravity="top"
    android:textSize="22sp"
    android:capitalize="sentences"
/>

A área em amarelo é a área em questão dessa xml.

noteslist_item.xml

É o arquivo que define o layout da lista de itens (i.e. as notas cadastradas no aplicativo). O arquivo é como está mostrado abaixo:

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@android:id/text1"
    android:layout_width="match_parent"
    android:layout_height="?android:attr/listPreferredItemHeight"
    android:textAppearance="?android:attr/textAppearanceLarge"
    android:gravity="center_vertical"
    android:paddingLeft="5dip"
    android:singleLine="true"
/>

Área onde são mostradas as notas existentes está marcada em amarelo.

title_editor.xml

É o arquivo que responde pela interface da janelinha pop-up que aparece quando o usuário quer editar o título da nota. Consiste em um layout do tipo LinearLayout com dois widgets internos: um EditText, que mostrará o nome do título para que possa ser alterado e um Button para efetivar a alteração.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:paddingLeft="6dip"
    android:paddingRight="6dip"
    android:paddingBottom="3dip">
    <EditText android:id="@+id/title"
        android:maxLines="1"
        android:layout_marginTop="2dp"
        android:layout_marginBottom="15dp"
        android:layout_width="wrap_content"
        android:ems="25"
        android:layout_height="wrap_content"
        android:autoText="true"
        android:capitalize="sentences"
        android:scrollHorizontally="true" />
    <Button android:id="@+id/ok"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="right"
        android:text="@string/button_ok"
        android:onClick="onClickOk" />
</LinearLayout>

O popup está bem em evidência na tela.

Aqui começa algo interessante no Android. Os menus são separados da parte inferior do layout. Com isso, você pode reaproveitar o layout e montar o menu da maneira como achar mais conveniente. 

editor_options_menu.xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/menu_save"
          android:icon="@drawable/ic_menu_save"
          android:alphabeticShortcut='s'
          android:title="@string/menu_save"
          android:showAsAction="ifRoom|withText" />
    <item android:id="@+id/menu_revert"
          android:icon="@drawable/ic_menu_revert"
          android:title="@string/menu_revert" />
    <item android:id="@+id/menu_delete"
          android:icon="@drawable/ic_menu_delete"
          android:title="@string/menu_delete"
          android:showAsAction="ifRoom|withText" />
</menu>

list_context_menu.xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/context_open"
          android:title="@string/menu_open" />
    <item android:id="@+id/context_copy"
          android:title="@string/menu_copy" />
    <item android:id="@+id/context_delete"
          android:title="@string/menu_delete" />
</menu>

list_options_menu.xml


<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <!--  This is our one standard application action (creating a new note). -->
    <item android:id="@+id/menu_add"
          android:icon="@drawable/ic_menu_compose"
          android:title="@string/menu_add"
          android:alphabeticShortcut='a'
          android:showAsAction="always" />
    <!--  If there is currently data in the clipboard, this adds a PASTE menu item to the menu
          so that the user can paste in the data.. -->
    <item android:id="@+id/menu_paste"
          android:icon="@drawable/ic_menu_compose"
          android:title="@string/menu_paste"
          android:alphabeticShortcut='p' />
</menu>


Nas imagens abaixo você pode ver os botões:

Ou seja, cada parte da interface é dividida em trechos pequenos de XML que podem ser customizados  facilmente, fazendo com que qualquer tela que use esse trecho de XML seja atualizado rapidamente. Isso dá uma liberdade maior à interface.

Muito melhor que ter código repetido em todos os layouts, não?

E, com os novos posts onde o código será comentado vocês vão poder ver como integrar os designs (botões e área interna da interface) na tela.

É isso ai pessoal! Até o próximo post!

NotePad da Área de Recursos - Código Comentado - Parte 01

O aplicativo NotePad da área de recursos do Android serve para se cadastrar notas. Essas notas poderão ser incluídas digitando-se valores diretamente na tela ou poderá criar as notas usando o conteúdo presente no clipboard (área de transferência) do Honeycomb.

Como poderá ver nas telas abaixo, a aplicação não é complexa, apesar do código para se criá-la ser bastante extenso (mas não complicadíssimo de se entender, como poderão acompanhar nas diversas partes dessa análise de código).

Aplicação aberta. Percebam o ícone dele no canto superior esquerdo e as opções no canto superior direito. Na direita há o botão para se criar uma nova nota e um menu de contexto.

Ao se pressionar o menu de contexto, existe a opção de se fazer um PASTE (ou colar) um quaisquer valores que estejam no clipboard do Honeycomb.

Ao se clicar no botão para se criar uma nova nota, a tela acima aparece.

Após se inserir uma nota, ela aparece na tela inicial.

Ao se tocar na nota já existente, a tela de edição da nota aparece, com novas opções no canto superior direito: botão de salvar, de excluir e um menu de contexto para edição de título.

Por fim, a tela onde há a opção de edição do título da nota.

Os campos todos ainda se encontram em inglês. Com o passar do tempo, farei a tradução de tudo para o português para que possamos ter maior noção do que acontece na aplicação.

De qualquer forma, o download do projeto completo poderá ser feito nesse link. 

Cada vez que o código for sendo atualizado, eu vou colocando novas versões no mesmo link e dizendo por aqui.

Uma vez que o projeto tenha sido carregado no Eclipse, você terá uma imagem semelhante no Package Explorer:

AndroidManifest.xml

O primeiro arquivo a ser analizado é o AndroidManifest.xml. Abaixo, insiro-o com todos os comentários em português:

<?xml version="1.0" encoding="utf-8"?>
<!--
O arquivo de Manifesto serve para declarar os conteúdos dessa aplicação Android
O atributo de namespace traz o namespace da plataforma Android e o pacote supre um nome
único para a aplicação. Quando escrever suas próprias aplicações, o pacote deverá ser mudado de "com.example.*"
para o nome do seu domínio.
 -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.android.notepad" >
    <uses-sdk android:minSdkVersion="11" />
    <application android:icon="@drawable/app_notes"
        android:label="@string/app_name"
    >
        <provider android:name="NotePadProvider"
            android:authorities="com.google.provider.NotePad"
            android:exported="false">
            <grant-uri-permission android:pathPattern=".*" />
        </provider>
        <activity android:name="NotesList" android:label="@string/title_notes_list">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <action android:name="android.intent.action.EDIT" />
                <action android:name="android.intent.action.PICK" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="vnd.android.cursor.dir/vnd.google.note" />
            </intent-filter>
            <intent-filter>
                <action android:name="android.intent.action.GET_CONTENT" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="vnd.android.cursor.item/vnd.google.note" />
            </intent-filter>
        </activity>
        <activity android:name="NoteEditor"
            android:theme="@android:style/Theme.Holo.Light"
            android:screenOrientation="sensor"
            android:configChanges="keyboardHidden|orientation"
        >
        <!-- Esse filtro diz que podemos ver ou editar dados de uma nota -->
            <intent-filter android:label="@string/resolve_edit">
                <action android:name="android.intent.action.VIEW" />
                <action android:name="android.intent.action.EDIT" />
                <action android:name="com.android.notepad.action.EDIT_NOTE" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="vnd.android.cursor.item/vnd.google.note" />
            </intent-filter>
<!-- Esse filtro diz que nós podemos criar uma nova nota dentro da pasta de notas.
A ação de INSERT cria uma nova vazia; a ação de PASTE inicializa uma nova nota a partir
do clipboard (área de transferência). Lembre-se que o aplicativo é voltado para o Honeycomb e,
como tal, tem uma área de clipboard mais elaborada. Com isso, caso o usuário tenha
copiado algum texto nessa área, ele poderá virar uma nota na aplicação.
-->
            <intent-filter>
                <action android:name="android.intent.action.INSERT" />
                <action android:name="android.intent.action.PASTE" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="vnd.android.cursor.dir/vnd.google.note" />
            </intent-filter>
        </activity>
        <activity android:name="TitleEditor"
            android:label="@string/title_edit_title"
            android:icon="@drawable/ic_menu_edit"
            android:theme="@android:style/Theme.Holo.Dialog"
            android:windowSoftInputMode="stateVisible">
            <!-- Essa atividade implementa uma ação alternativa que pode ser realizada em novas: edição de título.
            Ela poderá ser usada como operação padrão quando o usuário chama essa ação e está disponível
            como ação alternativa para dados da nota
             -->
            <intent-filter android:label="@string/resolve_title">
            <!-- Essa é a ação que nós realizamos. É uma ação customizada que nós definimos em nossa aplicação e
            não uma ação genérica de VIEW ou EDIT já que não somos um visualizador/editor geral de notas -->
                <action android:name="com.android.notepad.action.EDIT_TITLE" />
                <!-- DEFAULT: executar se for diretamente chamada -->
                <category android:name="android.intent.category.DEFAULT" />
                <!-- ALTERNATIVE: mostrado como uma ação alternativa quando o usuário está trabalhando com esse tipo de dados -->
                <category android:name="android.intent.category.ALTERNATIVE" />
                <!--  -->
                <!-- SELECTED_ALTERNATIVE: mostrado como uma ação alternativa que o usuário pode realizar quando está selecionando esse tipo de dados -->
                <category android:name="android.intent.category.SELECTED_ALTERNATIVE" />
                <!-- Esse é o tipo de dados com os quais vamos operar -->
                <data android:mimeType="vnd.android.cursor.item/vnd.google.note" />
            </intent-filter>
        </activity>
        <activity android:name="NotesLiveFolder" android:label="@string/live_folder_name"
            android:icon="@drawable/live_folder_notes">
            <intent-filter>
                <action android:name="android.intent.action.CREATE_LIVE_FOLDER" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>
    </application>
</manifest>

O ideal mesmo é abrir o arquivo no seu Eclipse.

Veja que no arquivo são descritos 4 atividades distintas:

• NotesList
• NoteEditor
• TitleEditor
• NotesLiveFolder

Strings.xml

Já o arquivo strings.xml tem todos as mensagens que serão usadas no aplicativo. Depois de traduzido, o arquivo strings.xml ficará como abaixo:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">NotePad</string>
    <string name="live_folder_name">Notas</string>


    <string name="title_edit_title">Título da Nota:</string>
    <string name="title_create">Nova Nota</string>
    <string name="title_edit">Editar: %1$s</string>
    <string name="title_notes_list">Notas</string>


    <string name="menu_add">Nova Nota</string>
    <string name="menu_save">Salvar</string>
    <string name="menu_delete">Excluir</string>
    <string name="menu_open">Abrir</string>
    <string name="menu_revert">Reverter mudanças</string>
    <string name="menu_copy">Copiar</string>
    <string name="menu_paste">Colar</string>


    <string name="button_ok">OK</string>
    <string name="text_title">Título:</string>


    <string name="resolve_edit">Editar nota</string>
    <string name="resolve_title">Editar título</string>


    <string name="error_title">Erro</string>
    <string name="error_message">Erro ao carregar nota</string>
    <string name="nothing_to_save">Não existe conteúdo a ser salvo</string>
</resources>

No próximo post abrirei cada um dos arquivos XML de layout para mostrar como ele foi criado. Após abrirmos cada um, farei posts separados para cada um dos arquivos .java de controle para a aplicação.

URGENTE - Plataforma Android 3.1 lançada!

Pessoa, foi lançado a plataforma 3.1 do Android! Com muitas novidades, ele traz uma série de novidades.

API Level: 12

Para desenvolvedores, a plataforma Android 3.1 está disponível como um componente que pode ser baixado para o SDK do Android. A plataforma incluí uma biblioteca Android e uma imagem de sistema assim como os skins de emulador e mais. A plataforma não incluirá nenhuma biblioteca externa.

Para baixar a versão mais nova, vá nesse link, baixe o executável e baixe os SDKs. Se você tiver uma versão anterior instalada, basta instalar para que ele faça o update na pasta do Android-SDK.

Overview da API

USB APIs

O Android 3.1 introduz uma nova e poderosa API para integrar periféricos conectados com aplicações rodando na plataforma. As APIs são baseadas na stack USB e serviços que estão disponíveis na plataforma, incluíndo suporte para USB e interação de dispositivos. Usando a API, desenvolvedores poderão criar aplicações capazes de descobrir, comunicar e gerenciar uma variedade de dispositivos conectados por USB.

MTP/PTP API (Media Transfer Protocol e Photo Transfer Protocol)

O Android 3.1 agora expõe uma nova API de MTP que permite as aplicações interagir diretamente com câmeras conectadas e outros dispositivos PTP. A nova API faz com que seja mais fácil para uma aplicação receber notificações quando dispositivos são anexados e removidos, gerenciar arquivos e storage nesses dispositivos, bem como transferir arquivos e metadados para eles e a partir deles. O API MTP implementa o PTP (Picture Transfer Protocolo), que é um subset da especificação do MTP (Media Transfer Protocol).

Suporte a novos dispositivos de entrada e eventos de movimento

O Android 3.1 extende o subsistema de entrada para suportar novos dispositivos de entrada e novos tipos de eventos de movimento em todas as Views ou Janelas. Desenvolvedores podem construir código usando essas novas capacidades para permitir ao usuário interagir com suas aplicações usando mouses, trackballs, joysticks (!!!), gamepads e outros dispositivos em adição a apenas o teclado e tela de toque.

RTP API (Real-time Transport Protocol)

O Android 3.1 expõe uma API para o stack RTP na qual aplicações podem usar para gerenciar data streaming on-demand ou interativo. Em particular, apps que provêem VOIP, push-to-talk, conferencia e audio streaming podem usar a API para iniciar sessões e transmitir ou receber streams de dados a partir da rede de dados disponível (Wi-Fi, 2G, 3G, 4G)

Widgets de apps agora podem ser redimensionados

Agora com o Android 3.1, desenvolvedores podem fazer redimensionamento dos widgets na homescreen - horizontalmente, verticalmente ou em ambas direções.

Todas essas mudanças e outras podem ser lidas, no original em inglês, no site do Android.

NotePad da área de Resources

Ok, voltando à ativa. Baixei hoje todo o conteúdo da aplicação NotePad presente na área de recursos do site developer.android.com.

Já estou fazendo a análise do código e postarei em breve por aqui.

Adianto apenas o seguinte:

1) O código está voltado para o Honeycomb. Então esperem printscreens bacanas por aqui.
2) O fato de estar em API Level 11 faz com que depurar seja um pouco mais lento se você não tem um tablet com a versão 3.0 do Android (o que é meu caso, por enquanto).

O código não é complicado. Como foi o pessoal da Google quem o fez, eles tiveram a excelente boa prática de comentá-lo completamente. Estou fazendo a tradução e colocarei mais outros comentário.

É isso ai pessoal! Vamos que vamos na programação para Android! Em breve um post completo (ou vários posts, dependendo do tamanho dos códigos).