sexta-feira, 23 de dezembro de 2016

2016 foi Loko!

Olá povo,

Primeiramente peço desculpas por não ter postado muito esse ano, mas se vocês lerem esse texto, vão entender um pouquinho o motivo. 2016 foi um ano muito intenso, com muitas mudanças que exigiram bastante de mim.

Dominando o Android 2ª edição

No começo do ano saiu a 2ª edição do meu livro, o "Dominando o Android" com uma série de correções e novos conteúdos. Muitas coisas que eu gostaria ter colocado na primeira edição entraram nessa edição e eu fiquei muito feliz com o resultado. Ainda não estou trabalhando na 3ª edição, mas creio que teremos novidades em junho ou julho de 2017.

Despedida do CESAR

Sem sombra de dúvida o evento mais marcante para mim foi minha saída do CESAR. No mês de março, após 10 anos, resolvi pedir demissão, simplesmente porque o que a instituição esperava de mim não estava alinhado com os meus objetivos profissionais. Então, ao invés de ficar reclamando pelos corredores ou fazer um trabalho mau feito, resolvi sair. Mas o CESAR estará sempre no meu coração por ser um lugar muito legal e cheio de pessoas bacanas. Tanto que, pelo menos uma vez por semana, saio de casa apenas para almoçar com amigos que trabalham ou trabalharam no CESAR :)

Equipe do projeto HP no CESAR

Mesa e Mokriya
Quando estava querendo sair do CESAR, meu amigo Leocádio Tiné me convidou para para substituí-lo lá na Mesa. Uma empresa muito bacana aqui de Recife com cerca de 12 pessoas. Então em abril comecei a trabalhar lá. O desafio era bem diferente do CESAR, onde normalmente tínhamos equipes com várias pessoas trabalhando em um mesmo projeto. A demanda de aplicativos lá era/é bem grande e cada desenvolvedor ficava responsável por fazer um app do começo ao fim. Achei isso bem bacana e isso me motivou bastante.
Equipe da Mesa

Com certeza eu ficaria na Mesa por um bom tempo, devido ao ambiente e o trabalho que eram bem legais. Mas o meu grande amigo Douglas Drummond ficou sabendo que eu tinha saído do CESAR e me convidou para entrar no processo seletivo da Mokriya, uma empresa de Cupertino onde a maioria dos funcionários trabalha remotamente. Participei do processo, fui aprovado e como a proposta foi bem interessante, tive que deixar a Mesa para trabalhar de casa, mais uma experiência nova para mim... Tenho que escrever um post sobre isso :)
Pranil, eu e Sunil. Donos da Mokriya.

Quero aproveitar para agradecer a Antônio, Arthur e Tiago que me deram essa oportunidade de fazer parte da Mesa. Infelizmente foi por pouco tempo, mas foi muito bom. E um agradecimento muito especial a Douglas por ter apostado em mim, mesmo tendo conversado pessoalmente comigo apenas duas ou três vezes. Valeu mesmo! ;)

Eventos nacionais
Em termos de eventos, esse ano eu não participei tanto, comparado aos anos anteriores.
Em parceria com o GDG Recife, pelo segundo ano consecutivo eu fui mentor do Study Jam que é uma iniciativa do Google em parceria com a Udacity para ministrar cursos gratuitos sobre tecnologias Google. No meu caso, de Android. :P

Turma do Study Jam

No mês de junho participei de um dos eventos de Android que eu mais gosto: o Androidos day. O evento esse ano contou com a participação de três GDEs de Android. Além de mim, o Quinta e o Bira também estavam lá e enriqueceram demais o evento com suas palestras. Sem contar os outros palestrantes que deram show lá! Parabéns Josias e demais integrantes da organização! Foi muito legal o evento.
E você que está lendo esse post, não perca a edição de 2017! ;)

Palestrantes e organização do Androidos

A partir do mês de julho, o GDG Recife começou a fazer mensalmente meetups de Android onde participei com algumas palestras e sugerindo o conteúdo que seria apresentado. Infelizmente não consegui organizar nada para Novembro e Dezembro, mas prometo voltar com essa iniciativa em 2017.

Em Outubro teve o GDG DevFest Nordeste que foi simplesmente fodástico! O evento aconteceu em um resort em Maceió. Um lugar fenomenal, duas trilhas de conteúdo, muuuuita gente boa palestrando. Enfim, um evento memorável. Parabéns Juarez, Juninho e todos da organização! ;)

Palestrantes e organização do DevFest Nordeste

Eventos internacionais
Em maio participei mais uma vez do Google I/O. Dessa vez em Mountain View (nos outros anos foi em San Francisco) e em um local ao ar livre: o Shoreline Amphitheatre. O evento foi bem bacana, onde o pessoal apresentou todas (ou quase todas) as novidades do Google: Google Home, Alo/Duo, Tango/Daydream, Firebase, Android Wear 2.0, Android Studio 2.2, Android N, ... Enfim, foi muito foda como sempre. \o/
Eu no Google I/O

No mês de novembro, participei do GDE Summit lá no Google, em Mountain View. Esse evento é fantástico para conhecer e rever GDEs de todo mundo, pois muitos deles já trabalharam no Google ou desempenham um papel fundamental na comunidade mundial de desenvolvedores. Além é claro, de ter contato direto com o advocates e o pessoal de produto do Google. Então você pode conversar e saber mais sobre a tendências e a direção que as tecnologias do Google estão tomando. Acho que esse foi o melhor summit que já participei. Muito conteúdo, dicas, conversas e coisas novas para brincar como o Google Home, Tango e Android Things.

GDEs brasileiros no GDE Summit

Também participei do DevFest Silicon Valley. Foi legal, mas nem se compara aos nossos DevFests ;)

Certificação Android
No Google I/O desse ano, o Google anunciou uma parceria com a Udacity para elaborar uma certificação oficial para desenvolvedores Android: a Associate Android Developer. Eu fiz esse exame e escrevi esse post aqui para explicar como funciona todo o processo.

Aulas na Unibratec
Esse ano assumi apenas uma turma de pós graduação, mas que durou quase 4 meses. A coordenação da Unibratec está de parabéns por ter designado 72 horas para a disciplina de Android. Isso me permitiu trabalhar muito bem o conteúdo e foi muito enriquecedor porque a turma estava muito interessada.
Turma de pós graduação da Unibratec

E para finalizar o ano, mais uma despedida: esse será meu último semestre como professor da Unibratec. Devido a viagens que eu tenho que fazer no meu emprego atual e por precisar dedicar mais tempo a algumas outras coisas da minha carreira, tive que me desligar da Unibratec. Ainda ficarei com as turmas de pós-graduação, mas vou dar um tempo nas turmas de graduação.

--

Bem pessoal, essa foi a retrospectiva de 2016. E como vocês puderam ver, esse ano foi muito LOKO! Mas foi muito bom para mim.
Espero que 2017 seja muito bom também para nós todos.

4br4ç05,
nglauber

quarta-feira, 30 de novembro de 2016

Tchau Unibratec :(

Olá povo,

2016 foi realmente o ano de encerrar ciclos na minha vida profissional. Depois de ter saído do CESAR, chegou a vez de dar mais um "até breve".

Após mais de 5 anos, esse será o meu último semestre como professor da Unibratec. Foi um grande orgulho para mim, lecionar na instituição na qual fui aluno entre os anos de 2002 e 2004 no "Curso Técnico de Informática com ênfase em Desenvolvimento de Software" (ou simplesmente CTI-DS). Mas acima de tudo, foi uma ótima experiência ser docente no ensino superior e trocar conhecimento com centenas de alunos durante todo esse tempo.

Comecei a ministrar aulas na Unibratec no segundo semestre de 2011, sempre com a disciplina de Programação Mobile (PGM) do curso de Análise e Desenvolvimento de Sistemas (ADS). E apesar de já ter sido convidado a ministrar outras disciplinas, preferi ficar apenas com Mobile, que é o assunto que motiva e no qual minha carreira está direcionada.

Exitem várias razões me fizeram tomar a decisão de dar uma pausa nas aulas. A principal delas é que estou viajando a trabalho com uma certa frequência e está difícil conciliar as aulas com o trabalho. Outro motivo é que estou querendo estudar alguns assuntos que estão despertando meu interesse. Também preciso escrever a próxima edição do livro, melhorar meu inglês, ... enfim, preciso de mais tempo. :)

Apesar dessa pausa nas aulas de graduação, continuarei ministrando aulas em turmas de pós-graduação (se me chamarem :), pois o período de dedicação (elaboração de material, correção de prova e trabalhos, lançamento de notas, etc) é menor para essas turmas.

É isso pessoal! Queria agradecer a todos que me ajudaram durante esses mais de cinco anos em que fiz parte do corpo docente da Unibratec: aos meus ex-alunos, aos professores, a assistência pedagógica e todos que os que cruzaram o meu caminho nessa jornada. Mas queria deixar um agrdecimento especial aos coordenadores Hemir e a Aldo por toda paciência, aprendizado e experiência que me passaram durante esses anos.

Um grande abraço e até breve!

4br4ç05,
nglauber

terça-feira, 20 de setembro de 2016

Constraint Layout no Android Studio 2.2

Olá pessoal,

Com o lançamento do Android Studio 2.2, resolvi fazer um vídeo falando um pouquinho sobre o novo gerenciador de layouts do Android: o ConstraintLayout.
O vídeo é um pouquinho longo (25min) e mostra como criar um layout de uma tela do aplicativo do Netflix utilizando o ConstraintLayout no novo editor visual do Android Studio.
Como é algo relativamente novo, qualquer feedback é muito bem vindo.


Esqueci de falar no vídeo que o ConstraintLayout é compatível com o Android 2.3 e superior.

Mais informações:



Bug report:



Errata:

  • No vídeo foi quando falei "Auto run" ao invés de "Instant Run".


Qualquer dúvida, deixem seus comentários.

4br4ç05,
nglauber

segunda-feira, 5 de setembro de 2016

DevFest Nordeste 2016




Olá povo,

GDG DevFest é uma iniciativa do Google em parceira com os GDGs (Google Developer Groups) de todo o mundo para oferecer grandes eventos para a comunidade de desenvolvedores. A temporada dos DevFests acontece entre 1 de setembro e 30 de novembro, e no Brasil ele acontecerá em diversas regiões do país. No nordeste, o evento já aconteceu em Aracajú (2014), Recife (2015) e esse ano o DevFest Nordeste será realizado em Maceió-AL, nos dias 21 e 22 de outubro no Pratagy Beach Resort e contará com grandes palestrantes de várias partes do Brasil. Serão discutidos temas relacionados as tecnologias web, backend, mobile, UX e muito mais.
Eu participarei do evento com a palestra "Dominando o Data Binding no Android" onde veremos como otimizar a implementar a lógica da interface gráfica do aplicativo de forma mais fácil, rápida e menos sujeita a bugs. Para conferir a programação completa, clique aqui.

Para obter mais informações, consulte o site oficial do evento.
Você não vai perder essa oportunidade de aprender e fazer parte dessa grande comunidade de desenvolvedores, não é?

Nos vemos lá! ;)

[EDITADO 25/10/2016]

Slides da minha palestra.


Fotos do evento aqui.

4br4ç05,
nglauber

terça-feira, 30 de agosto de 2016

Certificação Android da Udacity

Olá pessoal,

No Google I/O 2016 foi anunciada a primeira certificação para desenvolvedores Android. O nome da prova é Associate Android Developer Exam e é mantida pela Udacity em parceria com o Google. O intuito dessa certificação é tornar mais fácil para empresas encontrar desenvolvedores qualificados, e obviamente, "provar" que o desenvolvedor possui o conhecimento necessário para criar aplicativos seguindo os padrões recomendados.



Por curiosidade, resolvi fazer essa prova para saber o nível de dificuldade e até orientar meus alunos e demais desenvolvedores interessados na certificação. Sendo assim, o objetivo desse post é dar meu feedback sobre essa prova.
A preparação sugerida para a prova é fazer os cursos da Udacity, que em sua maioria tem o material (vídeos) gratuitos. Mas você pode fazer os cursos de formação conhecidos como Nanodegree, que atualmente estão divididos em Android Basics e Android Developer.

O básico possui:
Enquanto que o segundo contém:
Creio que apenas os cursos básicos são necessários para a prova, então recomendo bastante vocês assistirem. Mas pela minha experiência nessa prova, se você aprendeu Android com o livro do Ricardo Lecheta ou com o "Dominando o Android", fará esse exame sem problema. Creio que esses outros cursos serão abordados nas próximas certificações (que ainda não foram lançadas).

A avaliação é bem diferente das provas de certificação Java (Mobile, Programmer e Web) da Sun/Oracle, pois não é composta de uma série de perguntas de múltipla escolha e com um monte de "pegadinhas". Na certificação Android você recebe um projeto (bem pequeno, com cerca de 12 classes) com algum código já pronto. Então você precisa implementar funcionalidades e corrigir alguns bugs. O prazo para isso é de 48 horas, então reserve um tempo livre para fazer o exame.

Os assuntos utilizados na prova estão em um nível bem básico. São eles: criação de layouts simples, utilização da pasta de recursos, criação de adapter para RecyclerView, definição de menu, ContentProvider usando SQLite, SharedPreferences, trabalhar em background, IntentService, JobScheduler, Notification, AppWidgets e testes com Espresso. Ou seja, a prova é bem abrangente, mas não exige um profundo conhecimento desses assuntos (principalmente sobre testes). Achei interessante eles não cobrirem/pedirem nada sobre fragments.

Uma vez preparado para realizar a prova, basta se registrar e pagar a taxa. O valor é de US$149 mas, segundo a Udacity, até 31 de dezembro de 2016, o valor cobrado será de US$ 99.
Ao começar a prova, será exibida uma lista de requisitos a serem implementados na aplicação. Você terá que: alterar telas existentes, criar uma nova tela, implementar um adapter, alterar um Content Provider, executar um Service, disparar notificações, agendar serviços, corrigir alguns bugs e escrever um teste simples.

Concluído o projeto, você terá que enviá-lo em um arquivo zip (apague as pastas build e app/build), escanear um documento seu (eu usei minha CNH) e enviá-lo em formato PDF. Feito isso, será feita uma avaliação (tanto automática, quanto por pessoas) do seu projeto e você receberá o resultado para saber se seu projeto cumpre o que foi requisitado ou se precisa de modificações. Se ele cumprir todas as especificações, você irá para a fase de entrevista onde você poderá explicar como você implementou seu projeto. Pelo que sei, por enquanto a entrevista é apenas em inglês, mas parece que a Udacity já está trabalhando para fazê-la também em português. Sendo aprovado na entrevista, você receberá sua certificação. Segundo a Udacity, espera-se que todo esse processo dure no máximo 45 dias.

Ainda estou aguardando o resultado da avaliação e consequentemente a entrevista. Assim que for andando o processo, vou atualizando o post aqui.

Enfim, achei o nível da prova bem bacana para uma certificação de entrada. E acho que qualquer dev com 1 ano (ou até menos) de experiência consegue fazer.

[ATUALIZAÇÃO 27/09/2016]
Recebi um email da Udacity para “verificar minha identidade”. Basicamente eles pedem para que você envie uma foto da sua identidade/carteira de motorista/passaporte. Pode ser tirada com a webcam do computador ou escaneada. Enviei a foto do passaporte para não ter o risco de problema com “documento brasileiro”. Após enviar a foto do documento, eles pedem uma foto sua. Tirei ambas com a webcam e enviei. Minutos depois, recebi um email informando que minha identificação tinha sido confirmada com sucesso. Agora creio que a próxima etapa será a entrevista

[ATUALIZAÇÃO 17/10/2016]
Após 47 dias, ainda não recebi nenhum feedback sobre a certificação. Após dar aquela boa e velha "xingada no twitter", o JP (o cara do vídeo acima) respondeu...
Vamos ver quanto tempo demora esse "breve".

[ATUALIZAÇÃO 25/10/2016]
Eis que após 55 dias recebo o email para agendar a entrevista da Certificação Android. Tentei três datas diferentes e em todas só havia um horário disponível.
No email eles deixam bem claro que você precisará de um documento para comprovar sua identidade (passaporte ou carteira de motorista de preferência). Você precisará de uma webcam e de uma boa conexão de internet para não haver problema de comunicação na entrevista.
Fiz o agendamento para o dia 28/10 às 20h (horário de Brasília). Vamos ver como me saio :)

[ATUALIZAÇÃO 28/10/2016]
Chegou o dia da entrevista. Esqueci de mencionar na atualização anterior que no momento do agendamento, é informado o link para o aplicativo Zoom (https://zoom.us/) que você deve ter instalado na sua máquina.
Minha entrevista durou exatos 5 minutos :) isso mesmo. O camarada me deu boa-noite, pediu para eu mostrar minha identidade e disse que iria me fazer 5 perguntas. Todas extremamente fáceis e nada de mostrar ou explicar código.
Respondidas as questões, o entrevistador me deu os parabéns, disse que eu era um dos primeiros a terminar o processo e que em breve eu receberia um email com mais informações.

[ATUALIZAÇÃO 04/11/2016]
Após uma semana de espera, chegou o email da Udacity com o resultado da avaliação.
Agora tenho que aguardar outro email para pegar minha badge... :)

[ATUALIZAÇÃO 23/11/2016]
Chegou o email com a badge! Até que é bonitinha :)


No email, chegam as instruções para você adicionar a certificação no seu perfil do LinkedIn. Basicamente você clicar em um link, então o LinkedIn vai perguntar se você quer adicionar essa certificação ao seu perfil e pronto! Vai aparecer isso no seu perfil, na seção de certificações :)


Acho que esse será o último update desse post. Ciclo completo depois de 83 dias (ao contrário dos 45 prometidos pela Udacity). Espero que venham novas certificações mais exigentes e mais organizadas que essa.

[ATUALIZAÇÃO 22/11/2017]
Há um tempo atrás recebi um email da Udacity pedindo algumas informações, entre elas o tamanho de camiseta. Eis que um ano após a certificação, acabam de chegar alguns "mimos" :)
Uma camiseta, um bonequinho do Android e um adesivo. Achei bacaninha :) Valeu Google/Udacity!

4br4ç05,
nglauber

terça-feira, 12 de julho de 2016

Minhas Aulas de Android no YouTube

Olá pessoal,

Quando estava preparando minhas aulas de iOS (isso mesmo, já ministrei aulas de iOS ;) procurei por uma boa referência atualizada sobre o assunto e achei as aulas da Universidade de Stanford disponíveis no iTunes. Ótimas por sinal.
Seguindo esse exemplo, resolvi também gravar minhas aulas de Android na Unibratec e disponibiliza-las no YouTube. A gravação não tem nenhuma edição, é apenas meu desktop com o áudio no microfone embutido do computador. São 19 vídeos com mais de 20h de conteúdo.
As aulas mostram desde os conceitos mais básicos, com a construção de pequenos aplicativos de exemplo, até o desenvolvimento de um projeto simples, mas que possui: uma UI diferenciada para smartphones e tablets; acesso a um servidor web para realizar a leitura de um arquivo JSON; utilização de algumas bibliotecas famosas do Android como Butter Knife, Otto, OkHttp, etc.; e persistência de dados no banco de dados SQLite.


Espero que gostem!

4br4ç05,
nglauber

segunda-feira, 20 de junho de 2016

Androidos 2016

Olá pessoal,

No próximo dia 02 de julho, na Unipê em João Pessoa - PB, participarei pelo segundo ano consecutivo do Androidos! Um dos melhores eventos do Nordeste voltados para desenvolvedores Android e abordará temas muito legais do desenvolvimento de aplicações Android tais como: arquitetura, programação reativa, serviços de cloud, e muito mais.
Este ano, o Androidos contará com a participação de três Google Developer Experts em Android do Brasil: Marcelo Quinta (de Goiás), Ubiratan Soares (de São Paulo) e eu ;) Isso sem falar na ilustre participação do Josias Paes (Unipê) e do Gustavo Soares (IFPB).


Farei duas participações durante o evento: a primeira com uma palestra sobre Data Binding e log em seguida participarei de um Fireside chat, onde o público poderá fazer perguntas e tirar suas próprias dúvidas sobre Android.

Se você é desenvolvedor Android, não poder perder essa oportunidade. Mais informações no site do evento. Nos vemos lá!

[EDITADO 08/07/2016]
Slides da minha palestra.


O código-fonte do projeto mostrado nos slides está no meu GitHub.
https://github.com/nglauber/playground/tree/master/android/LivrosFirebase

4br4ç05,
nglauber

sexta-feira, 17 de junho de 2016

Firebase com Android

Olá povo,

Estava com vontade de escrever uns posts sobre Firebase aqui para o blog, mas achei que eles ficariam muito grandes. Então resolvi gravar alguns vídeos, com praticamente nenhuma edição, exceto alguns cortes que eu fiz pela demora na compilação/execução da aplicação.

É uma série com quatro vídeos onde abordo três dos principais serviços do Firebase: autenticação (Auth), armazenamento de arquivos (Storage) e o banco de dados em tempo real (RealTime database).

A ideia aqui foi criar um cadastro de livros do zero, onde o usuário deve realizar o login utilizando sua conta do Google para acessar a aplicação. O cadastro permite digitar o título do livro, o autor, e fazer o upload da capara do livro, obtida tirando uma foto com a câmera do aparelho. Para persistir as informações utilizamos o banco de dados do firebase, e para armazenar as imagens das capas do livro usamos o serviço de storage. O resultado ficou como abaixo:

     

Como vocês podem/vão notar, não me preocupei muito com a UI. Mas isso é uma melhoria que posso fazer nos próximos vídeos. Se vocês gostarem, posso evoluir esse aplicativo e/ou mostrando mais recursos do Firebase (como o analytics, crash report, login com facebook, etc).
Então, deixem seus comentários e espero que gostem! ;)



[EDITADO 08/07/2016]
O código desse exemplo (melhorado) encontra-se no meu GitHub:
https://github.com/nglauber/playground/tree/master/android/LivrosFirebase

4br4ç05,
nglauber

segunda-feira, 13 de junho de 2016

Chrome Custom Tabs para Android

Olá povo,

Mais um post rápido :) Quando precisamos abrir uma URL dentro de uma aplicação Android normalmente utilizamos uma Intent como a seguir:
Intent it = new Intent(Intent.ACTION_VIEW, 
                       Uri.parse("http://www.nglauber.com.br"));
startActivity(it);
O problema de usar essa abordagem é que exige o carregamento de outro aplicativo (o que é pesado computacionalmente falando) e fará com que o usuário deixe seu aplicativo, o que não é bom. Outro ponto negativo é que uma vez que você não tem acesso ao outro aplicativo (o browser nesse caso), você não consegue fazer nenhuma customização.

Uma outra abordagem é utilizar o componente WebView.
WebView webView = (WebView)findViewById(R.id.webView);
webView.loadUrl("http://www.nglauber.com.br");
webView.setWebViewClient(new WebViewClient() {
    public boolean shouldOverrideUrlLoading(WebView view, String url){
        view.loadUrl(url);
        return false; 
    }
});
Nesse caso você possui um controle maior, uma vez que tudo é feito dentro do seu aplicativo. Entretanto, você terá que fazer vários controles para a navegação (como eu fiz aqui tratando o redirecionamento de página). Um problema aqui é que o WebView não compartilha a sessão do browser.

Chrome Custom Tabs junta os pontos positivos de ambas as abordagens, pois permite o controle da experiência web dentro do seu aplicativo. Com essa API podemos: definir transições customizadas; personalizar título; adicionar ações personalizadas; fazer um pré-carregamento da página para agilizar o carregamento; entre outros.
Como pode-se imaginar, esse recurso só funcionará se o usuário possuir o Chrome instalado no aparelho. Caso contrário, será disparada a Intent que mostramos no início do post.
 Para usar o Chrome Custom Tabs, a primeira coisa a fazer é adicionar a dependência no build.gradle.
dependencies {
    ...
    compile 'com.android.support:customtabs:23.3.0'
}
Então é só chamar a aba como a seguir:
String url = "http://www.nglauber.com.br";
CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();

// Definindo a cor da toolbar (opcional)
builder.setToolbarColor(ActivityCompat.getColor(this, R.color.colorPrimary));

// Adicionando uma ação/menu (opcional)
Bitmap icon = BitmapFactory.decodeResource(
        getResources(), android.R.drawable.ic_menu_agenda);
PendingIntent pit = PendingIntent.getActivity(
        this, 0, new Intent(this, MainActivity.class), 0);

// Ação
builder.setActionButton(icon, "Ação", pit, true);
// Menu
builder.addMenuItem("Menu", pit);

// Definindo animações (opcional)
builder.setStartAnimations(this, 
        R.anim.slide_in_right, R.anim.slide_out_left);
builder.setExitAnimations(this, 
        R.anim.slide_in_left, R.anim.slide_out_right);

// Abrindo a "aba"
CustomTabsIntent customTabsIntent = builder.build();
customTabsIntent.launchUrl(this, Uri.parse(url));

Como podemos observar, é bastante simples criar as custom tabs do Chrome. Criamos uma instância da classe CustomTabsIntent.Builder e com ela criamos podemos customizar a aba da maneira que desejarmos. Primeiro definimos a cor do título usando o método setToolbarColor(int). Em seguida instancimamos um Bitmap e uma PendingIntent que podem ser utilizadas para adicionar uma ação ou uma opção de menu na barra de título. A ação é adicionada por meio do método setActionButton(Bitmap,String,PendingIntent,boolean) e o menu por meio do método addMenuItem(String,PendingIntent).
As animações foram definidas utilizando o método setStartAnimations e setExitAnimations. Essas animações foram definidas como a seguir:
// res/anim/slide_in_left.xml
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <translate android:fromXDelta="-100%p" android:toXDelta="0"
        android:duration="@android:integer/config_mediumAnimTime"/>
</set>

// res/anim/slide_in_right.xml
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <translate android:fromXDelta="100%p" android:toXDelta="0"
        android:duration="@android:integer/config_mediumAnimTime"/>
</set>

// res/anim/slide_out_left.xml
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <translate android:fromXDelta="0" android:toXDelta="-100%p"
        android:duration="@android:integer/config_mediumAnimTime"/>
</set>

// res/anim/slide_out_right.xml
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <translate android:fromXDelta="0" android:toXDelta="100%p"
        android:duration="@android:integer/config_mediumAnimTime"/>
</set>
Por fim, criamos uma instância da classe CustomTabsIntent e com o método launchUrl(Activity, Uri) abrimos essa nova aba.
Abaixo podemos ver a aplicação em execução.

Mais detalhes aqui:
https://developer.chrome.com/multidevice/android/customtabs

4br4ç05,
nglauber

terça-feira, 7 de junho de 2016

Carregando imagens da galeria do Android

Olá povo,

Nesse post rápido vou mostrar como carregar imagens da galeria de mídia do Android. O único detalhe a observar nesse post é que estamos carregando imagens tanto locais quando as que estão em algum serviço da nuvem como DropBox e Google Photos. Por isso, para começar coloque as permissões necessárias no AndroidManifest.xml.
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.INTERNET"/>
Lembrando que para o Android 6 (API Level 23) você deve checar essas permissões em tempo de execução.

Em seguida, inicie uma nova activity utilizando a ação ACTION_GET_CONTENT.
private static final int IMAGE_GALLERY_REQUEST = 1;
...
public void selectImageClick(View view) {
    if (ActivityCompat.checkSelfPermission(this, 
            Manifest.permission.READ_EXTERNAL_STORAGE) ==
            PackageManager.PERMISSION_GRANTED) {
        Intent intent = new Intent();
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_GET_CONTENT);
        startActivityForResult(
                Intent.createChooser(
                        intent,
                        getString(R.string.select_picture_title)),
                IMAGE_GALLERY_REQUEST);
    } else {
        ActivityCompat.requestPermissions(this,
                new String[]{ Manifest.permission.READ_EXTERNAL_STORAGE },
                IMAGE_GALLERY_REQUEST);
    }
}
Ao selecionarmos uma imagem, o método onActivityResult será chamado.
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == IMAGE_GALLERY_REQUEST && resultCode == RESULT_OK){
        new LoadImageTask(this).execute(data.getData());
    }
}

Como falamos anteriormente, carregaremos as imagens do sistema de arquivos ou da web. Por isso, devemos realizar essa operação fora da UI thread, então definimos a classe LoadImageTask.
class LoadImageTask extends AsyncTask<Uri, Void, Bitmap> {

    WeakReference<PickImageActivity> mActivity;

    public LoadImageTask(PickImageActivity activity) {
        this.mActivity = new WeakReference<>(activity);
    }

    public PickImageActivity getActivity() {
        return mActivity.get();
    }

    @Override
    protected Bitmap doInBackground(Uri... params) {
        if (getActivity() != null) {
            try {
                return BitmapFactory.decodeStream(
                        getActivity().getContentResolver().openInputStream(params[0]));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        super.onPostExecute(bitmap);
        if (getActivity() != null){
            getActivity().showImage(bitmap);
        }
    }
}
Temos algumas coisas interessantes aqui. A primeira é essa classe não deve ser uma inner class da Activity/Fragment, pois uma inner class sempre contém uma referência para sua outer class. Uma vez que ela não é uma inner class, devemos passar a referência da activity/fragment para essa classe. Estamos utilizando uma WeakReference para armazenar a instância da activity, o motivo disso é evitar o leak de memória, já que se o usuário sair da tela antes da imagem ser baixada aquela memória ficará alocada desnecessariamente durante algum tempo.
Outra coisa interessante é que estamos utilizando o método openInputStream() da classe ContentResolver para obter a imagem propriamente dita.
A imagem retornada terá o seu tamanho original, se você preferir, pode utilizar a técnica de redimensionamento de imagem que eu mostrei nesse post.
Por fim, no onPostExecute, invocamos o método showImage da Activity.
public void showImage(Bitmap bitmap) {
    ImageView imageView = (ImageView)findViewById(R.id.imageView);
    if (imageView != null){
        imageView.setImageBitmap(bitmap);
    }
}
Qualquer dúvida, deixe seu comentário ;)

 4br4ç05,
nglauber

segunda-feira, 2 de maio de 2016

Android Data Binding

Olá pessoal,

A API de DataBinding foi lançada no Google I/O de 2015 e tem o intuito de facilitar a vida dos desenvolvedores removendo da Activity/Fragment muita da lógica de UI feitas por esses componentes. Apesar de ter sido lançado juntamente com o Android 6, a API de Data Binding é uma biblioteca separada do sistema operacional e pode ser utilizada a partir do Android 2.1 (API Level 7). Três coisas que por si só já valem a utilização do Data Binding são: (1) não utilizar findViewById [tchau ButterKnife], (2) associação de eventos a componentes e (3) sincronização de valores do model para a view.

Apesar desses três pontos já serem fantásticos, o Data Binding tem muito mais a oferecer. O objetivo desse post é mostrar como dar os primeiros passos com essa API por meio de um exemplo simples, mas funcional. O código-fonte desse exemplo está disponível no meu github, por isso, vou omitir algumas partes do código que não estão relacionadas ao Data Binding.

Classes básicas e configuração

O exemplo consta de uma listagem de livros utilizando a API do Google Books. Então defini duas classes básicas: Book e Thumbnail.
// Thumbnail.java
@Parcel
public class Thumbnail {
    private String smallThumbnail;
    private String thumbnail;
    // gets e sets...
}

// Book.java
@Parcel
public class Book {
    private String title;
    private String subtitle;
    private String publisher;
    private String description;
    private String[] authors;
    private String publishedDate;
    private int pageCount;
    private Thumbnail imageLinks;
    // gets e sets
}

A única observação sobre essa classe é que estou utilizando a biblioteca Parceler que facilita a implementação do Parcelable do Android. No mais, são classes Java simples.

A única configuração que deve ser feita no projeto Android é adicionar o recurso de Data Binding ao build.gradle do módulo da sua aplicação.
android {
    ...

    dataBinding {
        enabled = true
    }
Pronto! Podemos começar a implementar a UI do nosso projeto.

Um adapter utilizando Data Binding

A primeira tela do exemplo exibe uma listagem de livros retornadas pela API do Google Books. No nosso exemplo, exibiremos a capa, título e os autores do livro. Para exibir essa listagem, usaremos um adapter, no qual o arquivo de layout utilizado para representar cada linha da lista é exibido a seguir (res/layout/item_book.xml).
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <import type="java.util.Arrays"/>
        <variable
            name="book"
            type="nglauber.android.databinding.model.Book" />
    </data>

    <RelativeLayout ... >
        <ImageView ...
            android:id="@+id/image_capa"
            android:src="@{book.imageLinks.smallThumbnail}"/>
        <TextView ...
            android:id="@+id/text_titulo"
            android:text="@{book.title}" />
        <TextView ...
            android:id="@+id/text_autor"
            android:text="@{Arrays.toString(book.authors)}" />
    </RelativeLayout>
</layout>

Os arquivos de layout que utilizam o recurso de Data Binding devem iniciar com a tag <layout>. Dentro da tag <data> devemos declarar as variáveis e importar as classes que serão utilizadas no arquivo de layout. Perceba que estamos declarando uma <variable> chamada "book" da classe Book que criamos anteriormente.
No TextView que exibirá o título do livro, setamos a propriedade android:text com o valor @{book.title}. Desta forma, o título do livro será exibido automaticamente no componente.
Ótimo, mas se você notar na nossa classe Book, o atributo "authors" é um array de strings. Para exibir os autores separado por vírgula, podemos utilizar a classe java.utils.Arrays. Mas como usá-las dentro de um arquivo de layout? Basta importamos essa classe por meio da tag <import>.
Outro ponto curioso nesse arquivo é que no ImageView estamos definindo na propriedade android:src a imagem que será exibida. Mas se você desenvolve em Android (nem que seja a um pouquinho de tempo) deve lembrar que nessa propriedade devemos passar uma imagem que está dentro do projeto (um Drawable normalmente) e não uma URL. Mas no nosso exemplo, temos apenas o link da imagem. E agora?
Com data binding, podemos definir adapters para propriedades utilizando BinderAdapters! Vejamos a classe a seguir:

public class ImageBinding {
    @BindingAdapter({"android:src"})
    public static void loadImage(ImageView imageView, String url){
        Glide.with(imageView.getContext()).load(url).into(imageView);
    }
}
Com a anotação @BindingAdapter, informamos que estamos tratando a propriedade android:src recebendo a url como parâmetro. O carregamento da imagem é feito utilizando a biblioteca Glide. Tudo isso é feito "automagicamente" pelo plugin do Data Binding! Muito bom hein!?
Veremos agora como utilizar esse arquivo de layout em um adapter.
public class BookAdapter extends 
        RecyclerView.Adapter<BookAdapter.ViewHolder> {

    List<Book> mBooks;
    BookClickListener mListener;

    public BookAdapter(List<Book> books,
                       BookClickListener listener) {
        mBooks = books;
        mListener = listener;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, 
                                         int viewType) {
        ItemBookBinding binding = DataBindingUtil.inflate(
                LayoutInflater.from(parent.getContext()),
                R.layout.item_book,
                parent,
                false);

        final ViewHolder vh = new ViewHolder(binding);
        vh.itemView.setOnClickListener(... );
        return vh;
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int pos) {
        Book book = mBooks.get(pos);
        holder.binding.setBook(book);
        holder.binding.executePendingBindings();
    }

    @Override
    public int getItemCount() {
        return mBooks != null ? mBooks.size() : 0;
    }

    public static class ViewHolder extends
            RecyclerView.ViewHolder {

        ItemBookBinding binding;

        public ViewHolder(ItemBookBinding binding) {
            super(binding.getRoot());
            this.binding = binding;
        }
    }
}
Esse é um adapter de uma RecyclerView, se você ainda não mexeu com esse componente, dê uma olhada nesse post aqui.
Percebam que na classe ViewHolder, temos uma instância da classe ItemBookBinding. Mas de onde saiu essa classe? Ela é gerada automaticamente pelo plugin do Data Binding e é baseada no nome do arquivo de layout (res/layout/item_book.xml => ItemBook + Binding) e contém todas as Views declaradas nele! ADEUS findViewById!!!
Notem que estamos passando o elemento raiz do arquivo de layout utilizando o método getRoot().
No método onCreateViewHolder, utilizamos o método inflate da classe DataBindingUtil para carregar o arquivo de layout e obter o objeto ItemBookBinding.
Por fim, no método onBindViewHolder, onde devemos preencher as views do layout, nós simplesmente atribuímos o objeto Book do ItemBookBinding (que definimos na tag ) no ViewHolder. O data binding vai preencher todas as View baseado no objeto Book! <3. Para que essa atualização seja feita imediatamente, invocamos o método executePendingBindings().


Fragment de listagem

Para utilizar o adapter que acabamos de criar, crie um novo fragment (BookListFragment) e deixe o arquivo de layout (res/layout/fragment_book_list.xml) como a seguir:
<layout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools">

    <FrameLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".BookListFragment">

        <android.support.v7.widget.RecyclerView
            android:id="@+id/list_livro"
            android:layout_width="match_parent"
            android:layout_height="match_parent" 
            app:layout_manager='@{"linear"}' />
    </FrameLayout>
</layout>
Temos uma propriedade interessante nesse arquivo de layout: app:layout_manager, pois ela na verdade não existe nativamente! #confuso. Mas assim como fizemos com o carregamento da imagem, vamos utilizar o BinderAdapter para resolver essa propriedade para nós. Veja a classe a seguir.
public class LayoutManagerBiding {
    @BindingAdapter({"bind:layout_manager"})
    public static void setLayoutManager(
            RecyclerView recyclerView, String layout){
        setLayoutManager(recyclerView, layout, 1);
    }
    
    @BindingAdapter({"bind:layout_manager", "bind:columns"})
    public static void setLayoutManager(
            RecyclerView recyclerView, 
            String layout, int columns){

        if ("linear".equalsIgnoreCase(layout)){
            recyclerView.setLayoutManager(
                    new LinearLayoutManager(
                            recyclerView.getContext(), 
                            LinearLayoutManager.VERTICAL, false));
        } else if ("grid".equalsIgnoreCase(layout)){
            recyclerView.setLayoutManager(
                    new GridLayoutManager(
                            recyclerView.getContext(), columns));
        }
    }
} 
Essa classe configurará o layout manager do RecyclerView. Aqui, apenas para fins de exemplo, estamos tratando os layouts linear e de grid. Sendo que para utilizarmos grid, podemos opcionalmente passar a propriedade (também customizada) app:columns.

Vamos agora para a implementação da classe do Fragment.
public class BookListFragment extends Fragment {

    List<Book> mBooks;
    BookAdapter mAdapter;
    BookTask mTask;
    FragmentListBookBinding mBinding;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
        mBooks = new ArrayList<>();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, 
                             ViewGroup container,
                             Bundle savedInstanceState) {
        mBinding = DataBindingUtil.inflate(
                inflater, R.layout.fragment_list_book, container, false);

        mAdapter = new BookAdapter(mBooks, mListener);
        mBinding.listLivro.setAdapter(mAdapter);
        return mBinding.getRoot();
    }

    // Os dados são baixados assincronamente 
    // utilizando a API do Google Books
    public void search(String term){
        mTask = new BookTask(this);
        mTask.execute(term);
    }

    public void setLivros(List<Book> books){
        if (books != null) {
            mBooks.clear();
            mBooks.addAll(books);
        }
        mAdapter.notifyDataSetChanged();
    }

    // ...
}
Assim como fizemos no Adapter utilizamos a classe DataBindingUtil para carregar o arquivo de layout e obter a instância da "binding class" FragmentListBookBinding.

Activity principal

Na activity principal, temos um campo onde o usuário poderá digitar o nome do livro a ser pesquisado. Ao clicar no botão iniciamos que é processada no fragment de listagem.
Vejamos o arquivo de layout (activity_book.xml)
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <data>
        <variable
            name="handler"
            type="nglauber.android.databinding.BookActivity"/>
    </data>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".BookActivity">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">

            <EditText
                android:id="@+id/edit_search"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1" />

            <ImageButton
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:onClick="@{handler::onSearchClick}"
                android:src="@android:drawable/ic_menu_search" />
        </LinearLayout>

        <fragment
            android:id="@+id/fragment_list"
            android:name="nglauber.android.databinding.BookListFragment"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1" />
    </LinearLayout>
</layout>
Definimos aqui uma variável "handler" que é do tipo BookActivity. Com essa variável podemos definir QUALQUER evento no próprio arquivo de layout. No nosso exemplo definimos que o método onSearchClick da activity (o handler) será chamado quando o botão for clicado utilizando a propriedade android:onClick. Perceba que a separação do objeto com o nome do método é feita por "::".
Vamos ver o código da BookActivity.
public class BookActivity extends AppCompatActivity
    implements BookClickListener {

    ActivityBookBinding mBinding;
    BookListFragment mListFragment;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(
                this, R.layout.activity_book);
        mBinding.setHandler(this);

        mListFragment = (BookListFragment)
                getSupportFragmentManager()
                        .findFragmentById(R.id.fragment_list);
    }

    public void onSearchClick(View view){
        mListFragment.search(
                mBinding.editSearch.getText().toString());
    }

    @Override
    public void onBookClick(Book book) {
        Intent it = new Intent(this, BookDetailActivity.class);
        Parcelable p = Parcels.wrap(book);
        it.putExtra(BookDetailActivity.EXTRA_BOOK, p);
        startActivity(it);
    }
}
No onCreate, utilizamos mais uma vez a classe DataBindingUtil, mas dessa vez chamando o método setContentView. Notem mais uma vez a classe que foi gerada: ActivityBookBinding. Setamos o "handler" do mBinding para podemos tratar o evento de clique que é feito no método onSearchClick (como definimos no arquivo de layout).

Detalhes do Livro

Na tela de detalhes do livro temos oito campos que devem ser exibidos para o usuário. Sem o data binding teríamos que pegar cada referência do componente de UI via findViewById, e atribuir o conteúdo ao componente. Aqui é outro ponto onde o benefício do Data Binding é mais evidente.
Vejamos o arquivo de layout (
<layout 
  xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools">
  <data>
    <import type="java.util.Arrays" />

    <variable
        name="book"
        type="nglauber.android.databinding.model.Book" />
  </data>

  <ScrollView ... >
    <LinearLayout ... >
      <ImageView ...
        android:id="@+id/img_capa"
        android:src="@{book.imageLinks.thumbnail}" />

      <TextView ...
        android:id="@+id/text_titulo"
        android:text="@{book.title}" />

      <TextView ...
        android:id="@+id/text_titulo"
        android:text="@{book.title}" />

      <TextView ...
        android:id="@+id/text_subtitulo"
        android:text="@{book.subtitle}" />

      <TextView ...
        android:id="@+id/text_autor"
        android:text="@{@string/format_authors(Arrays.toString(book.authors))}" />

      <TextView ...
        android:id="@+id/text_ano"
        android:text="@{@string/format_publish_date(book.publishedDate)}" />

      <TextView ...
        android:id="@+id/text_pages"
        android:text="@{@string/format_pages(book.pageCount)}" />

      <TextView ...
        android:id="@+id/text_description"
        android:text="@{book.description}" />
    </LinearLayout>
  </ScrollView>
</layout>
Todas a propriedades do livro estão sendo atribuídas diretamente no arquivo de layout. A curiosidade aqui fica por conta das strings formatadas que utilizamos para os atributos autores, data de publicação e número de páginas. Essas strings estão no res/values/strings.xml como a seguir.
<string name="format_authors">Autores: %1$s</string>
<string name="format_pages">Páginas: %1$d</string>
<string name="format_publish_date">Data de publicação: %1$s</string>
Vamos agora para o fragment de detalhe BookDetailFragment.
public class BookDetailFragment extends Fragment {
    private static final String EXTRA_BOOK = "livro";

    public static BookDetailFragment newInstance(Book book) {
        BookDetailFragment fragment = new BookDetailFragment();
        Bundle args = new Bundle();
        Parcelable p = Parcels.wrap(book);
        args.putParcelable(EXTRA_BOOK, p);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, 
                             ViewGroup container,
                             Bundle savedInstanceState) {
        Book book = null;
        if (getArguments() != null) {
            Parcelable p = getArguments().getParcelable(EXTRA_BOOK);
            book = Parcels.unwrap(p);
        }
        View view = inflater.inflate(
                R.layout.fragment_detail_book, container, false);

        FragmentDetailBookBinding fdlb = 
                FragmentDetailBookBinding.bind(view);
        fdlb.setBook(book);

        return view;
    }
}
Nada de especial nessa classe que já não vimos anteriormente. Mas já pensou como ela seria sem o data binding? :) 8 findViewById + 7 setText + 1 Image load...
Abaixo temos a aplicação em execução.
Aplicação no Nexus 7

Tela de Listagem no Nexus 5

Tela de detalhes no Nexus 5

Ao terminar de escrever esse artigo só fiquei com uma dúvida: Data Binding, porque você não existe desde a versão 1.5 :) onde você estava???

Mais informações

Minha palestra sobre Data Binding
http://www.nglauber.com.br/2016/06/androidos-2016.html
Palestra sobre Data Binding no Android Dev Summit (em inglês)
https://www.youtube.com/watch?v=NBbeQMOcnZ0
Hangout com o Neto Marin (Google Developer Advocate)
https://www.youtube.com/watch?v=JWpn4yyIJxc
Data Binding Guide (Documentação oficial)
http://developer.android.com/intl/pt-br/tools/data-binding/guide.html

Qualquer dúvida, deixem seus comentários.

4br4ç05,
nglauber

segunda-feira, 4 de abril de 2016

Carregando imagens de outras fontes com o Picasso

Olá pessoal,

As bibliotecas de carregamento de imagens são utilizadas em praticamente todos os projetos Android. Elas facilitam o carregamento de imagens a partir de diversas fontes como: web, sistema de arquivos e até de banco de dados. Possuem recursos de redimensionamento, crop, placeholder, animação, etc. As mais famosas desse segmento são: Picasso, Glide e Universal Image Loader (UIL). Todas são ótimas, já resolvi uns problemas com uma, outros problemas com outra e por aí vai.
No projeto que estou atualmente estou usando o Picasso, e estava precisando carregar imagens de um local não suportado nativamente por ele: o arquivo de expansão de APK.
Graças ao grande mestre Jake Wharton, podemos implementar isso de uma forma muito fácil. Basta criar uma subclasse de RequestHandler.
import com.squareup.picasso.Request;
import com.squareup.picasso.RequestHandler;

public class MeuRequestHandler extends RequestHandler {

    public MeuRequestHandler() {
    }

    @Override
    public boolean canHandleRequest(Request data) {
        // Retorne true se essa classe pode tratar a leitura da imagem
        return data != null
                && data.uri != null
                && data.uri.getScheme() != null
                && data.uri.getScheme().startsWith("ngvl");
    }

    @Override
    public Result load(Request request, int networkPolicy) 
            throws IOException {
        Bitmap imagem = metodoQueCarregaSeuBitmap(request.uri);
        Result result = new Result(imagem, Picasso.LoadedFrom.DISK);
        return result;
    }
}
Essa classe possui apenas dois métodos:
  • canHandleRequest(Request) define se essa classe é capaz de carregar uma determinada imagem. Nesse exemplo, estou usando o parâmetro Request para checar se o endereço (definido por uma Uri) começa com "ngvl". 
  • Já o método load(Request, int) carrega a imagem em si e a retorna por meio de um objeto Result, que recebe o Bitmap da imagem e de onde ela foi carregada (memória, disco ou rede).
Criado o handler, basta adicioná-lo a uma instância do Picasso.
Picasso = mPicassoInstance = 
    new Picasso.Builder(mContext.getApplicationContext())
        .addRequestHandler(new MeuRequestHandler())
        .build();
Com isso, você está adicionando uma nova fonte de imagens à sua instância do Picasso, ou seja, você pode usar todos os schemas já suportados pelo Picasso (http, file, content, ...) e esse que acabamos de criar.
Agora, se invocarmos o código a seguir, o nosso handler tratará essa requisição.
mPicassoInstance
        .load("ngvl://minhaimagem/logo.jpg")
        .into(imageView);

#perfmatters #protip É importante que só haja uma instância desse objeto para evitar problemas de memória! Sendo assim, implemente um Singleton, e caso precise de um Context, passe o getApplicationContext() para ele ;)

4br4ç05,
nglauber

sábado, 19 de março de 2016

Customizando o TextInputLayout com ImageSpan

Olá povo,

 Post curto do dia. Estava querendo customizar o erro do TextInputLayout (TIL) e só consegui graças a ajuda da Lisa Wray, que deu a ótima sugestão de utilizar as classes SpannableStringBuilder + ImageSpan, que eu não conhecia.

 Muitos devs Android, quando vêm algum método que recebe um objeto CharSequence como parâmetro, pensam imediatamente é o mesmo que passar uma String. Mas na verdade o CharSequence é bem mais poderoso, pois permite ir além de textos planos. A classe SpannableStringBuilder é uma subclasse de CharSequence que permite adicionar Spannable's como o ImageSpan.
Vejamos o código a seguir.
TextInputLayout textInputLayout = (TextInputLayout) editText.getParent();
if (campoInvalido()) { // sua verificação do campo vem aqui.
    // Cria a imagem que será incluída no texto do erro.
    // O alinhamento poderia ser ALIGN_BASELINE
    ImageSpan imageSpan = new ImageSpan(
        this, R.drawable.ic_erro, DynamicDrawableSpan.ALIGN_BOTTOM);
    // O SpannableStringBuilder substituirá o primeiro caracter pela imagem
    // por isso o " " no começo.
    SpannableStringBuilder ssbErrorMessage = 
        new SpannableStringBuilder(" "+ getString(R.string.msg_erro));
    // Adicionando a imagem como texto do erro
    ssbErrorMessage.setSpan(imageSpan, 0, 1, 0);

    // Habilita o erro do TIL
    textInputLayout.setErrorEnabled(true);
    // define a mensagem de erro
    textInputLayout.setError(ssbErrorMessage);
    // Atualiza o componente
    textInputLayout.refreshDrawableState();
}
O resultado ficará como a imagem abaixo.
Dois detalhes importantes nesse exemplo:
1) essa abordagem pode ser utilizada por qualquer componentes que receba um CharSequence \o/
2) Podemos utilizar qualquer Bitmap como imagem ;)

 4br4ç05,
nglauber

terça-feira, 15 de março de 2016

ViewPager sem FragmentPagerAdapter + Indicator

Olá povo,

Resolvi escrever esse post porque toda vez que eu preciso disso tenho que procurar na internet. Não que seja difícil de achar, mas me vi na obrigação moral de fazer :)
Quando utilizamos o ViewPager, normalmente estamos fazendo alguma tela de abas ou algo similar. Nesse caso é recomendado fazer com que cada aba/página seja um Fragment. Mas se não houver nenhuma lógica nessas páginas, criar um fragment pode ser desnecessário.
Posso dar como exemplo aquelas telas de boas-vindas que mostram um breve tutorial de como utilizar a aplicação, onde cada passo é uma página com as instruções. Nesse caso, utilizar um layout (definido em um arquivo de layout) para cada página seria o suficiente, e não precisaríamos de Fragment para tal.
Vamos ver como fazer isso,  começando pelo arquivo de layout a seguir.

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <android.support.v4.view.ViewPager
        android:id="@+id/viewpager"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"/>

    <com.viewpagerindicator.CirclePageIndicator
        android:id="@+id/indicator"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:paddingBottom="10dp"
        android:paddingTop="10dp"
        android:background="@color/colorPrimary"/>
</LinearLayout>

Esse arquivo possui um ViewPager e um CirclePageIndicator (criado por Jake Wharton) que servirá para exibir um indicador da página atual. Para utiliza-lo, basta adicionar no build.gradle a dependência do componente.
dependencies {
    ...
    compile 'com.android.support:appcompat-v7:23.2.0' 
    compile 'com.github.JakeWharton:ViewPagerIndicator:2.4.1@aar'
}
Vejamos agora o código que cria as páginas do ViewPager.
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ViewPager viewPager = (ViewPager)findViewById(R.id.viewpager);
        viewPager.setAdapter(new ViewSimplesAdapter());

        CirclePageIndicator indicator = 
                (CirclePageIndicator)findViewById(R.id.indicator);
        indicator.setViewPager(viewPager);
    }

    private class ViewSimplesAdapter extends PagerAdapter {
        @Override
        public int getCount() {
            return 3;
        }

        @Override
        public boolean isViewFromObject(View view, Object object) {
            return view == object;
        }

        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            int layout;
            if (position == 0){
                layout = R.layout.layout_pagina1;
            } else if (position == 1){
                layout = R.layout.layout_pagina2;
            } else {
                layout = R.layout.layout_pagina3;
            }
            View view = LayoutInflater.from(container.getContext())
                    .inflate(layout, container, false);
            container.addView(view);
            return view;
        }

        @Override
        public void destroyItem(ViewGroup container, int position, 
                                Object object) {
            container.removeView((View)object);
        }
    }
}
A classe ViewSimplesAdapter herda de PagerAdapter e nela, temos o método getCount() que retorna a quantidade páginas que iremos exibir e mais três métodos:
  • isViewFromObject() - basicamente determina se uma View está relacionada com o objeto retornado pelo método instantiateItem().
  • instantiateItem() carrega o arquivo de layout da página específica. Perceba que a View carregada é adicionada ao ViewGroup recebido como parâmetro e é retornada pelo método.
  • destroyItem() vai ser responsável por destruir os itens criados. É importante ressaltar que o ViewPager mantém no máximo três páginas ativas: a que está sendo exibida, a anterior e a posterior.
Qualquer dúvida, deixem seus comentários.

4br4ç05,
nglauber

quinta-feira, 10 de março de 2016

Tchau CESAR :(

Olá povo,

No dia 16 de janeiro de 2006 eu começava a trabalhar no Centro de Estudos e Sistemas Avançados do Recife. Ainda estava terminando a faculdade e lembro que meu sonho era "usar o crachá laranja".
Hoje, 10 de março de 2016 é o meu último dia de trabalho no CESAR. Foram mais de 10 anos de muito desafios, aprendizados, crescimento pessoal e profissional, e muita história boa para contar.
Tive a satisfação de trabalhar com muita gente boa (e outras nem tão legais assim) e fiz muitas amizades em todos os projetos em que passei eu acho.

O nome do CESAR estará cravado na minha história para sempre, com muito orgulho, pois foi nessa empresa fantástica que construí a maior e melhor parte da minha carreira. Isso sem contar a parte acadêmica, já que eu cursei o mestrado no CESAR.edu.

Mas como é evidente a todos que me conhecem, estou fortemente envolvido com a área de desenvolvimento para dispositivos móveis, e nos últimos meses não estava tendo a oportunidade de trabalhar com mobile e nem com desenvolvimento de software (codificação em si). Isso acabou me deixando um pouco desmotivado, então resolvi conversar com meus superiores e verificar a possibilidade de me alocar em um projeto mobile dentro da instituição. Mas infelizmente, fui informado de que não havia previsão de novos projetos com mobile no curto/médio prazo. Sendo assim, chegamos a conclusão de que meu plano de carreira não estava alinhado com as expectativas do CESAR, então resolvi procurar novos desafios em um novo lugar.

Espero de todo coração estar deixando as portas abertas, pois o CESAR é um lugar incrível para trabalhar, que eu considero minha segunda casa, onde (quem sabe?) um dia terei a satisfação de voltar.
Obrigado a todos vocês que fizeram parte da minha vida durante esses 10 anos, vocês me fizeram muito feliz. :)

Chegou a hora de começar uma nova etapa(!) e escrever um novo capítulo da minha história.

4br4ç05,
nglauber

domingo, 28 de fevereiro de 2016

CursorAdapter para RecyclerView (parte 2)

Olá povo,

Na primeira parte desse post, implementamos as classes básicas, conexão com o banco de dados e o ContentProvider. Partiremos agora para a implementação da interface gráfica.

Adapter

Vamos começar a implementação da UI pelo adapter que utilizaremos na lista. Adicione a classe MensagemCursorAdapter e deixe-a como a seguir.
public class MensagemCursorAdapter extends
        RecyclerView.Adapter<MensagemCursorAdapter.VH> {

    private Cursor mCursor;
    private AoClicarNoItem mListener;

    public MensagemCursorAdapter(AoClicarNoItem listener) {
        mListener = listener;
    }

    @Override
    public VH onCreateViewHolder(ViewGroup parent, int viewType) {
        View v = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_mensagem, parent, false);

        final VH vh = new VH(v);
        v.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                int position = vh.getAdapterPosition();
                mCursor.moveToPosition(position);
                if (mListener != null) mListener.itemFoiClicado(mCursor);
            }
        });

        return vh;
    }

    @Override
    public void onBindViewHolder(VH holder, int position) {
        mCursor.moveToPosition(position);
        int idx_titulo = mCursor.getColumnIndex(MensagemContract.TITULO);
        int idx_descr = mCursor.getColumnIndex(MensagemContract.DESCRICAO);

        String titulo = mCursor.getString(idx_titulo);
        String descricao = mCursor.getString(idx_descr);

        holder.mText1.setText(titulo);
        holder.mText2.setText(descricao);
    }

    @Override
    public int getItemCount() {
        return (mCursor != null) ? mCursor.getCount() : 0;
    }

    @Override
    public long getItemId(int position) {
        if (mCursor != null) {
            if (mCursor.moveToPosition(position)) {
                int idx_id = mCursor.getColumnIndex(MensagemContract._ID);
                return mCursor.getLong(idx_id);
            } else {
                return 0;
            }
        } else {
            return 0;
        }
    }

    public Cursor getCursor(){
        return mCursor;
    }

    public void setCursor(Cursor newCursor){
        mCursor = newCursor;
        notifyDataSetChanged();
    }

    public interface AoClicarNoItem {
        void itemFoiClicado(Cursor cursor);
    }

    public static class VH extends RecyclerView.ViewHolder {
        public TextView mText1;
        public TextView mText2;

        public VH(View v) {
            super(v);
            mText1 = (TextView) v.findViewById(R.id.text1);
            mText2 = (TextView) v.findViewById(R.id.text2);
        }
    }
}
Vou ressaltar apenas os pontos mais importantes do Adapter, pois uma explicação mais introdutória sobre RecyclerView.Adapter foi feita nesse post aqui.
  • Ao invés de termos uma lista de objetos, o Adapter utilizará um cursor para retornar/preencher as views da RecyclerView. Isso pode ser percebido nos métodos onCreateViewHolder() e onBindViewHolder() e no getItemCount().
  • Esse cursor será atribuído por meio do método setCursor(). Utilizaremos esse método no Fragment que mostraremos a seguir. Ao atualizarmos o cursor, chamamos o notifyDatasetChanged() para que a RecyclerView seja atualizada.
  • ATENÇÃO! Não esqueçam de implementar o método getItemId()! Ele é utilizado internamente para atualizar a RecyclerView. Dessa forma, esse método está retornando o ID do registro correspondente.
Como podemos ver, a implementação não é nada complexa comparada ao que fazemos com uma lista de objetos.
A adapter está utilizando o arquivo de layout item_mensagem.xml descrito a seguir.

<android.support.v7.widget.CardView
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginTop="8dp"
    android:layout_marginLeft="8dp"
    android:layout_marginRight="8dp"
    android:orientation="vertical"
    android:foreground="?android:attr/selectableItemBackground"
    app:cardCornerRadius="5dp">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:padding="8dp">

        <TextView
            android:id="@+id/text1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:textSize="20sp"/>

        <TextView
            android:id="@+id/text2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:textSize="16sp"/>
    </LinearLayout>
</android.support.v7.widget.CardView>
Utilizamos o CardView para dar um visual mais interessante para o nosso modesto aplicativo :)

Um DialogFragment para inserir

Vamos utilizar um Dialog para inserir, mas você pode utilizar o componente que preferir.
Deixe o arquivo de layout conforme a seguir.
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              xmlns:tools="http://schemas.android.com/tools"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical"
              android:padding="16dp"
              tools:context=".MensagemFragment">

    <android.support.design.widget.TextInputLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <EditText
            android:id="@+id/edtTitulo"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="@string/titulo"/>
    </android.support.design.widget.TextInputLayout>

    <android.support.design.widget.TextInputLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <EditText
            android:id="@+id/edtDescricao"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="@string/descricao"/>
    </android.support.design.widget.TextInputLayout>

</LinearLayout>
Estamos utilizando o TextinputLayout para dar um toque de Material Design ao nosso aplicativo :) Ele fará uma animação ao preenchermos o conteúdo do EditText. No mais, o arquivo de layout não possui nada de muito especial.
Vamos adicionar no strings.xml as strings utilizadas no layout e as que vamos utilizar no código do Fragment.
<string name="titulo">Título</string>
<string name="descricao">Descrição</string>
<string name="nova_mensagem">Nova mensagem</string>
<string name="editar_mensagem">Editar mensagem</string>
<string name="salvar">Salvar</string>
<string name="cancelar">Cancelar</string>

Vamos agora a implementação da classe MensagemFragment.
public class MensagemFragment extends DialogFragment
        implements DialogInterface.OnClickListener {

    private static final String EXTRA_ID = "id";

    EditText mEdtTitulo;
    EditText mEdtDescricao;
    long id;

    public static MensagemFragment newInstance(long id){
        Bundle bundle = new Bundle();
        bundle.putLong(EXTRA_ID, id);

        MensagemFragment mensagemFragment = new MensagemFragment();
        mensagemFragment.setArguments(bundle);
        return mensagemFragment;
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        View view = getActivity().getLayoutInflater()
                .inflate(R.layout.fragment_mensagem, null);

        mEdtTitulo = (EditText)view.findViewById(R.id.edtTitulo);
        mEdtDescricao = (EditText)view.findViewById(R.id.edtDescricao);

        boolean novaMensagem = true;
        if (getArguments() != null && getArguments().getLong(EXTRA_ID) != 0){
            id = getArguments().getLong(EXTRA_ID);
            Uri uri = Uri.withAppendedPath(
                    MensagemContract.URI_MENSAGENS, String.valueOf(id));

            Cursor cursor = getActivity().getContentResolver()
                    .query( uri, null, null, null, null);
            if (cursor.moveToNext()) {
                novaMensagem = false;
                mEdtTitulo.setText(cursor.getString(
                        cursor.getColumnIndex(MensagemContract.TITULO)));
                mEdtDescricao.setText(cursor.getString(
                        cursor.getColumnIndex(MensagemContract.DESCRICAO)));
            }
            cursor.close();
        }

        return new AlertDialog.Builder(getActivity())
                .setTitle(novaMensagem ? 
                        R.string.nova_mensagem : R.string.editar_mensagem)
                .setView(view)
                .setPositiveButton(R.string.salvar, this)
                .setNegativeButton(R.string.cancelar, null)
                .create();
    }

    @Override
    public void onClick(DialogInterface dialog, int which) {
        ContentValues values = new ContentValues();
        values.put(MensagemContract.TITULO, 
                mEdtTitulo.getText().toString());
        values.put(MensagemContract.DESCRICAO, 
                mEdtDescricao.getText().toString());
        if (id != 0){
            Uri uri = Uri.withAppendedPath(
                    MensagemContract.URI_MENSAGENS, String.valueOf(id));
            getContext().getContentResolver().update(uri, values, null, null);
        } else {
            getContext().getContentResolver().insert(
                    MensagemContract.URI_MENSAGENS, values);
        }
    }
}
A classe é bem simples e será utilizada tanto para inserir quanto para atualizar uma mensagem. Por isso, no método newIntance() estamos recebendo um parâmetro que representa o ID da mensagem. Se passarmos um ID válido, as informações da mensagem serão exibidas na tela. Isso é feito no método onCreateDialog(). Já no método onClick, estamos inserindo/atualizando o registro no banco banco de dados. Perceba que aqui não estou utilizando o AsyncQueryHandler que falei nesse post para simplificar o exemplo, mas ela seria a melhor opção.

Fragment de Listagem

Implementado o adapter, vamos criar o Fragment que utilizará o Adapter para exibir a listagem de mensagens vindas do banco de dados. Vamos começar por seu arquivo de layout.

<android.support.design.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".ListaMensagensFragment">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/recycler_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scrollbars="vertical"/>

    <android.support.design.widget.FloatingActionButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/fabAdd"
        android:src="@drawable/ic_add_white_24dp"
        app:fabSize="normal"
        android:layout_gravity="bottom|right"
        android:layout_margin="16dp" />
</android.support.design.widget.CoordinatorLayout>
Estamos utilizando o FloatActionButton e o CoordinatorLayout da biblioteca de design.
Partiremos agora para a implementação da classe ListaMensagensFragment.
public class ListaMensagensFragment extends Fragment
        implements LoaderManager.LoaderCallbacks<Cursor< {

    private RecyclerView mRecyclerView;
    private MensagemCursorAdapter mAdapter;
    private LinearLayoutManager mLayoutManager;

    @Override
    public View onCreateView(LayoutInflater inflater, 
                             ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(
            R.layout.fragment_lista_objetos, container, false);

        view.findViewById(R.id.fabAdd).setOnClickListener(
            new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    new MensagemFragment()
                        .show(getFragmentManager(), "dialog");
                }
            });

        mRecyclerView = (RecyclerView) view.findViewById(R.id.recycler_view);
        mRecyclerView.setHasFixedSize(true);

        configuraSwipe();

        mLayoutManager = new LinearLayoutManager(getActivity());
        mRecyclerView.setLayoutManager(mLayoutManager);

        mAdapter = new MensagemCursorAdapter(
            new MensagemCursorAdapter.AoClicarNoItem() {
                @Override
                public void itemFoiClicado(Cursor cursor) {
                    long id  = cursor.getLong(
                        cursor.getColumnIndex(MensagemContract._ID));
                    MensagemFragment f = MensagemFragment.newInstance(id);
                    f.show(getFragmentManager(), "dialog");
            }
        });
        mAdapter.setHasStableIds(true);
        mRecyclerView.setAdapter(mAdapter);

        getLoaderManager().initLoader(0, null, this);

        return view;
    }

    private void configuraSwipe() {
        ItemTouchHelper.SimpleCallback simpleItemTouchCallback = 
            new ItemTouchHelper.SimpleCallback(
                0, ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT) {
            @Override
            public boolean onMove(RecyclerView recyclerView, 
                                  RecyclerView.ViewHolder viewHolder, 
                                  RecyclerView.ViewHolder target) {
                return false;
            }

            @Override
            public void onSwiped(RecyclerView.ViewHolder 
                                 viewHolder, 
                                 int swipeDir) {
                final int x = viewHolder.getLayoutPosition();
                Cursor cursor = mAdapter.getCursor();
                cursor.moveToPosition(x);
                final long id = cursor.getLong(
                        cursor.getColumnIndex(MensagemContract._ID));

                Uri uriToDelete = Uri.withAppendedPath(
                        MensagemContract.URI_MENSAGENS, String.valueOf(id));
                getActivity().getContentResolver().delete(
                        uriToDelete,
                        null, null);
            }
        };
        ItemTouchHelper itemTouchHelper = 
                new ItemTouchHelper(simpleItemTouchCallback);
        itemTouchHelper.attachToRecyclerView(mRecyclerView);
    }

    @Override
    public Loader onCreateLoader(int id, Bundle args) {
        return new CursorLoader(getActivity(), 
                                MensagemContract.URI_MENSAGENS, 
                                null, null, null, 
                                MensagemContract.TITULO);
    }

    @Override
    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
        mAdapter.setCursor(data);
    }

    @Override
    public void onLoaderReset(Loader loader) {
        mAdapter.setCursor(null);
    }
}
Vamos as explicações.
  • No método onCreateView(), definimos o evento de clique do FAB onde criamos uma nova instância do MensagemFragment sem passar um ID pois queremos criar uma nova mensagem (e que obviamente não possui um ID).
  • Um detalhe importante aqui é a chamada ao método setHasStableIds() para indicar que cada item da lista possui um identificador único, que no nosso caso é a coluna "_id" da tabela.
  • O método configuraSwipe() é usado para definir o comportamento ao fazermos swipe sobre os itens da lista. No nosso caso, estamos excluindo um registro. Perceba que estamos obtendo a posição do item da lista utilizando o método getLayoutPosition().
  • Voltando ao onCreateView(), estamos criando uma instância do nosso adapter passando como parâmetro um objeto que tratará o evento de clique no item da lista. Note que estamos criando a instância de MensagemFragment passando o ID do item que foi clicado.
  • Após atribuir o adapter à RecyclerView, invocamos o LoaderManager para iniciar o processo de busca no banco de dados de forma assíncrona utilizado o método initLoader(). Quando o Loader estiver criado, o método onCreateLoader será invocado, e nele instanciamos um CursorLoader apontando para URI do provider. Quando a busca no provider é concluída, o método onLoadFinish() é invocado, e onde finalmente atribuímos o Cursor recebido como parâmetro ao nosso adapter.
Precisamos adicionar esse fragment à nossa activity. Abra o arquivo activity_main.xml.
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="ngvl.android.exrecyclerview.MainActivity">

    <fragment
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:name="ngvl.android.exrecyclerview.ListaMensagensFragment"
        android:id="@+id/fragment"/>
</RelativeLayout>

Execute a aplicação e o resultado será similar ao vídeo a seguir.
O código completo da aplicação está disponível no meu github.
https://github.com/nglauber/playground/tree/master/android/ExRecyclerView

4br4ç05,
nglauber