Android

Por que estudar Flutter?

Criar um app do zero com muita facilidade e rapidez é o desejo de todo desenvolvedor. Porém, atingir este objetivo pode ser complicado, pois os diferentes ambientes dos sistemas operacionais mobile atuais são completamente heterogêneos…

Para sanar este problema, o Flutter veio como uma nova alternativa para o desenvolvimento mobile multiplataforma. O Flutter foi desenvolvido pelo Google, sendo gratuito, de código aberto e ainda possui uma ótima documentação.

Você consegue fazer aplicativos para iOS e Android usando uma mesma base de código onde, na hora de compilar, ele transforma o código em uma versão nativa de cada plataforma, o que agiliza a abertura e o desempenho do aplicativo.

O Flutter utiliza uma linguagem também criado pelo próprio Google, chamada Dart., sendo essa linguagem compatível com a orientação a objetos e programação funcional (o que diminui a curva de aprendizado). Apesar de ser nova para muitos, o Dart é uma linguagem simples e fácil de se aprender. Mesmo que você tenha somente o mínimo conhecimento de programação, verá que, com pouco tempo de estudo, você já se sentirá confortável com a linguagem.

O Flutter é dividido em duas camadas principais, sendo:

  • Engine: Responsável pela estrutura de execução, composta pela Skia (a biblioteca de renderização do Flutter) e pelo Dart (linguagem utilizada no desenvolvimento);
  • Framework: escrito em Dart e onde estão os widgets.

É importante saber que todos os componentes do Flutter são widgets. Sendo assim, um label, um campo de entrada de texto e até mesmo o processo de detecção de um gesto na interface são tratados como widgets dentro do Flutter. Uma aplicação Flutter, no final, é uma árvore hierárquica e coordenada destes widgets.

No Flutter, você consegue testar seu aplicativo igual fazemos em uma aplicação web. Você pode alterar seu código e ver a modificação em tempo real.

Com o Flutter você poderá ter agilidade, performance e praticidade, fazendo com que o desenvolvimento seja mais rápido e reutilizável com o melhor desempenho possível. Além de tudo, você pode possuir widgets próprios que constituem os componentes da UI do aplicativo, sendo baseados no Material Design do próprio Google, o que deixa o visual de seu aplicativo bem bonito.

Conclusão

O Flutter veio como uma excelente alternativa para o desenvolvimento mobile, pois oferece desempenho, integração de plataformas móveis e desenvolvimento rápido. Se você deseja ter os primeiros contatos com o Flutter, não deixe de conferir nosso curso 😊

Até mais!

Carreira de desenvolvedor de aplicativos: como começar

Apesar de não ser uma tecnologia tão recente, os aplicativos móveis ainda estão em alta no mercado de software. Muitos apps surgem todos os dias, seja resolvendo nossos problemas do dia-a-dia, ou nos entretendo de alguma maneira.

Quem deseja começar uma carreira de desenvolvedor de aplicativos do zero deve ter ciência dos desafios. Além da necessidade de aprendizado das tecnologias atuais, trata-se de um mercado muito volátil em que os avanços tecnológicos e novos frameworks surgem a cada dia.

Desde o começo em lógica de programação, vários desafios serão encontrados. Cabe ao desenvolvedor de aplicativos não se intimidar e enfrentar esses obstáculos de cabeça erguida.

Pensando em ajudar quem quer começar essa carreira, vamos apresentar algumas dicas.

Aprendendo lógica de programação

Quando pensamos em resolver problemas do dia a dia com software, precisamos pensar que existem passos lógicos. Assim como fazer uma receita de bolo, no desenvolvimento de software há uma sequência de ações para chegar a um resultado final.

As sequências lógicas bem estruturadas da programação, que chamamos de algoritmos, são aprendidas quando estudamos lógica de programação. Na jornada para se tornar um desenvolvedor de aplicativos, esse é com certeza o primeiro passo, que na verdade acaba valendo para qualquer área e setor quando falamos sobre desenvolvimento de software.

Paradigmas de programação

Um paradigma de programação é a maneira como o desenvolvedor pensa e age para resolver um problema quando está programando – é o seu guia para o desenvolvimento. Esses paradigmas são diferentes em relação aos seus conceitos, aplicações e técnicas.

Um problema pode ser resolvido baseado em diversos paradigmas. Assim como quando falamos sobre linguagens de programação ou IDEs, é difícil falar que um é melhor que o outro. Cada um é mais adequado para resolver determinado problema.

Quando falamos de desenvolvimento de aplicativos móveis, os principais paradigmas de programação são:

Orientação a objetos

Se formos considerar os aplicativos para smartphones atuais, grande parte deles utilizam a orientação a objetos. Essa metodologia permite ao programador o encapsulamento de regras de negócio, além da escrita de códigos menores e mais limpos.

Por isso fazer um curso de lógica orientada a objetos, é um passo importante na jornada como desenvolvedor de aplicativos.

Paradigma funcional

O paradigma funcional tem ganhado espaço no desenvolvimento mobile, principalmente com a vinda de linguagens como o Kotlin e o Swift. Ele baseia-se no conceito matemático de função, em que essas funções são utilizadas para resolver problemas.

O paradigma funcional possibilita a escrita de um código menor e mais expressivo algumas vezes. Por isso, linguagens funcionais são uma opção interessante para quem deseja começar a carreira como desenvolvedor de aplicativos.

Trade off: Qual linguagem escolher? Híbrido, nativo ou cross-platform?

Este é o momento em que o caminho dos desenvolvedores de aplicativos tomam rumos diferentes: a hora da escolha da linguagem de programação e frameworks.

Atualmente, existe no mercado a possibilidade de você ser um desenvolvedor de aplicações móveis nativas, híbridas ou cross-platform.

Quando você escolhe ser um desenvolvedor nativo você tem as seguintes opções:

1) Desenvolvedor android

Para ser um desenvolvedor Android, o programador deve ter domínio das linguagens de programação Java e/ou Kotlin. Essa é uma carreira que ainda possui uma alta taxa de empregabilidade, já que o Android é a plataforma que domina o mercado brasileiro de smartphones.

2) Desenvolvedor iOS

Os iPhones e outros gadgets mobile da Apple possuem grande aceitação no mercado e são considerados por muitos os melhores aparelhos disponíveis. Caso você opte por essa carreira, há duas opções de linguagem: Objective-c ou Swift.

A linguagem mais recente dentro das apresentadas é a Swift, portanto, tende a ser a única utilizada para desenvolvimento iOS no futuro.

Já quando a escolha é pelo desenvolvimento híbrido ou cross-platform, contamos com vários frameworks no mercado que cada vez mais se mostram como excelentes opções ao desenvolvimento nativo. Os principais frameworks híbridos e cross-platform usados atualmente no mercado são:

1) Ionic (híbrido)

O Ionic é uma opção já com um pouco mais tempo de mercado e que está em sua terceira versão. Esse framework é baseado no Angular, framework JavaScript do Google. Todo o código gerado é executado em cima do Cordova, um “super framework” para desenvolvimento mobile híbrido que serve de base para outros frameworks híbridos, como o próprio Ionic.

2) PhoneGap (híbrido)

PhoneGap também é um framework para o desenvolvimento híbrido de aplicativos, tendo sido uma das primeiras soluções nesse sentido. Assim como o Ionic e outros frameworks híbridos, ele suporta as plataformas Android, iOS e Windows Phone. A biblioteca também utiliza o Cordova, e as linguagens utilizadas são HTML, CSS e JavaScript.

3) React Native (cross-platform)

Esse framework, que é baseado em Javascript, é uma grande tendência para o mercado de desenvolvimento de apps. Criado como uma derivação do React, uma biblioteca desenvolvida pela equipe de engenheiros do Facebook, o React Native possui várias características de uma aplicação nativa em sua composição. Além disso, ele abandona o uso de web apps, o que não ocorre nos frameworks híbridos.

4) Xamarin (cross-platform)

O Xamarin é um framework que também gera versões de aplicativos para Android, iOS e Windows. Assim, como o React Native, o código escrito utilizando-se o Xamarin é compilado de maneira nativa, não ficando atrelado às chamadas WebViews – algo que ocorre nos frameworks híbridos. A linguagem padrão de programação utilizada no desenvolvimento com o Xamarin é o C#. Como opção, o F# (linguagem funcional da plataforma .NET) também pode ser utilizado.

IDE’s – Ambientes de desenvolvimento para desenvolvedores de aplicativos

Quando desenvolvemos uma aplicação móvel, é muito importante otimizar todos os processos: desde quando tratamos da escrita do código até quando falamos em execução e testes.

Apesar das IDEs não serem obrigatórias, elas podem acelerar – e muito – o processo de desenvolvimento de um aplicativo. Cada plataforma (Android ou iOS) acaba tendo uma IDE que se mostra mais adequada quando falamos de desenvolvimento nativo. No caso do Android, essa IDE é o Android Studio, recomendado pela própria Google.

No caso do iOS, essa IDE é o XCode, IDE da própria Apple. Isso também acaba acontecendo na utilização de ferramentas cross-platform: no caso do Xamarin, por exemplo, é muito comum a opção pelo Visual Studio. Já no caso de ferramentas híbridas, geralmente um editor de código (que pode ser entendido como uma versão mais simplificada de uma IDE) é geralmente a ferramenta utilizada.

Esses ambientes possuem as seguintes características de maneira geral:

  • Editor de código;
  • Compilador, onde se compila o código para a linguagem da máquina (somente no desenvolvimento nativo e/ou cross-platform);
  • Depurador, onde encontramos defeitos no código-fonte;
  • Mecanismos de refatoração que ajudam na melhora e otimização do código-fonte;

Esses são os passos básicos para se tornar um desenvolvedor de aplicativos móveis. Se você pretende se tornar um desenvolvedor, o estudo e atualização profissional nunca podem ser deixados de lado, assim você conseguirá se destacar no mercado e ter uma carreira de sucesso!

Esse texto foi escrito por Daniel Martins, analista de marketing na Vulpi, plataforma de recrutamento e seleção de desenvolvedores de software.

Conheça as novidades que estão por vir no Android Studio 3.0

Para quem acompanha de perto os serviços da Google para desenvolvedores, sabe que a equipe do Android Studio está trabalhando a todo vapor para lançar em breve a nova versão: Android Studio 3.0.

Vejamos as principais novidades e atualizações que estão por vir! o/

Mudanças no core da IDE

Houve uma atualização do core passando do IntelliJ 2016.2 para 2017.1.2. Essa atualização trará novas funcionalidades ao Android Studio, como dicas de parâmetro, realce semântico, resultados imediatos em busca, entre outros.

Além disso, a nova versão promete resolver o bug no Instant Run. Se um app está pausado em um breakpoint, espera-se que o aplicativo reinicie. Mas, se o aplicativo não está em pausa em um breakpoint, ele não deve reiniciar e o hot swap deve funcionar quando você faz apenas uma mudança na implementação do método.

Linguagem Kotlin

Agora o Android Studio trará 100% de suporte a linguagem Kotlin, sem a necessidade de instalar plug-ins adicionais, o que acontecia na versão 2.3.

Assim você poderá incorporar códigos Kotlin ao seu projeto convertendo arquivos Java para Kotlin através da opção de conversão de código. E também você terá a opção de criar um novo projeto Kotlin habilitando o suporte à linguagem pelo assistente quando for iniciar um novo projeto.

Novo Android Profiler

Na nova versão, o Android Profiler irá fornecer em tempo real uma visão unificada da atividade do seu aplicativo, como o consumo de CPU, memória e rede. O Android Profiler irá substituir o Android Monitor.

Ele poderá ser aberto através do menu View > Tool Windows > Android Profiler. Através de gráficos em tempo real ele exibirá as informações sobre o app que está sendo executado naquele momento. Conforme imagem abaixo disponibilizado no site para desenvolvedores Android Developers.

Como parte desta atualização, o logcat mudou-se para uma janela separada.

Suporte a Instant Apps

Agora será possível criar Instant Apps em seu projeto usando dois novos tipos de módulos: o Instant App e o Feature Module . Conforme imagem abaixo retirada do Android Developers.

Novo Device File Explorer

A nova janela de ferramenta Device File Explorer traz novidades interessantes. Com ela é possível que você interaja perfeitamente com o sistema de arquivos do seu dispositivo conectado. Conforme imagem abaixo retirada do Android Developers.

Desta forma, você poderá clicar para visualizar vários arquivos dentro do Android Studio e copiar os arquivos para o seu computador.

Esta característica substitui interações do sistema de arquivos do dispositivo anteriormente realizada por meio de DDMS.

Suporte para o Android O Developer Preview

O Android Studio 3.0 adiciona suporte para Android O, incluindo as seguintes novidades:

  • Um novo assistente para Adaptive Icon que permitirá criar novos Launcher Icons e visualizá-los como eles aparecerão em dispositivos diferentes;
  • Novo XML fonts preview, ferramenta de seleção de fonte e suporte para tipos de fontes que podem ser efetuado downloads.

Melhorias no Editor de Layout

O Editor de Layout no Android Studio 3.0 contém uma série de novas melhorias de recursos, incluindo:

  • Árvore de componentes atualizada com inserções de visualização aprimoradas de arrastar e soltar;
  • Novo painel de erros;
  • Novo suporte para view Barriers e Groups

Conclusão

Não tem como negar que a equipe de developers do Android Studio está trazendo muitas novidades para nós desenvolvedores Android. Em breve, ele já estará disponível para download no lançamento oficial. Mas, já é possível testar as novidades através da versão beta disponibilizada no site Android Developers.

Compartilhe com a gente o que você achou da nova versão do Android Studio. Um abraço e até a próxima!

Kotlin: A nova linguagem oficial para desenvolvimento Android

Não é novidade para nós, desenvolvedores mobile, que a linguagem de programação Kotlin foi integrada ao time de linguagens oficiais para desenvolver apps Android. Agora o time conta com Java, C++ e Kotlin. Lembrando que a Kotlin é a nova linguagem oficial para desenvolvimento de aplicativos Android, ela não é substituta de nenhuma outra existente.

História

Kotlin é uma linguagem de programação criada em 2011 pela JetBrains, empresa conhecida pelas IDEs comercializadas. Esta linguagem recebeu o nome de uma ilha russa situada próximo à costa de São Petersburgo, onde a equipe Kotlin reside.

Em julho de 2011 a JetBrains revelou que estava trabalhando em uma nova linguagem (Kotlin) com o objetivo de suprir características que não eram encontradas em outras. No ano seguinte, o projeto Kotlin foi colocado sob a licença Apache de código aberto. Porém, apenas em 2016 foi lançada a primeira versão estável.

Aos poucos, ela foi conquistando seu lugar na comunidade de desenvolvedores de aplicativos Android, muito devido à sua qualidade e as ferramentas e IDEs que a atendem. E também, talvez um dos principais fatores, ela possui 100% de interoperabilidade com o Java. Ou seja, 100% compatível.

Contudo, a grande notícia veio em 2017, no Google I/O 17. Onde os engenheiros do Google Android anunciaram a Kotlin como a mais nova linguagem oficial da plataforma.

Principais características

Como mostrado anteriormente, uma das principais características do Kotlin, talvez a mais marcante, é a compatibilidade com o Java. Assim, todas as APIs que rodam no Java também rodam no Kotlin. Também é possível destacar outras características, como:

  • Compatível com o JDK 6, desta forma os programas escritos em Kotlin são compatíveis com qualquer versão do Android;

  • A linguagem é type-safe como o Java, e também null-safe, ou seja não admite valor null para as variáveis e caso precise informar um valor nulo é necessário definir isto de forma explícita;

  • Trabalha com os paradigmas de Programação Orientada a Objetos e Programação Funcional;

  • O Android Studio tem 100% de suporte a ela;

  • Utiliza inferência para definir tipos de dados quando o mesmo é evidente;

  • Os códigos getters e setters estão presentes de forma implícita, desta forma não é necessário criá-los na classe.

Por que desenvolver para Android com Kotlin?

Devido às suas características, ela demostra ser uma ótima opção para o desenvolvimento de aplicativos Android, trazendo todas as vantagens de uma linguagem moderna para a plataforma e sem apresentar novas restrições:

Compatibilidade: Kotlin é totalmente compatível com o JDK 6, garantindo que os aplicativos possam ser executados em dispositivos Android mais antigos, sem problemas. A ferramenta Kotlin é totalmente suportada no Android Studio e compatível com o sistema de compilação do Android.

Desempenho: um aplicativo Kotlin é tão rápido quanto um Java equivalente, graças a uma estrutura de bytecodes muito semelhante. Com o suporte da Kotlin para funções inline, o código usando lambdas geralmente é executado ainda mais rápido que o mesmo código escrito em Java.

Interoperabilidade: o Kotlin é interoperável a 100% com Java, permitindo usar todas as bibliotecas Android existentes em um aplicativo Kotlin.

Tempo de compilação: o Kotlin suporta compilação incremental eficiente, por isso, enquanto há algumas sobrecargas adicionais para construções limpas, as compilações incrementais geralmente são tão rápidas ou mais rápidas do que com o Java.

Curva de aprendizado: para um desenvolvedor Java começar com o Kotlin é muito fácil. O conversor automático Java para Kotlin incluído no plugin Kotlin ajuda com os primeiros passos.

Compatibilidade com o Android Studio

Atualmente Kotlin é 100% compatível com o Android Studio e para utilizá-lo basta instalar um plugin que se encontra disponível na área de plug-ins da IDE.

Pensando em mais praticidade para os desenvolvedores Android que utilizam esta IDE, em breve será lançada a nova versão do Android Studio (Android Studio 3.0 Canary) que trará nativamente suporte ao Kotlin, sem a necessidade de instalar plugins adicionais. Atualmente já está disponível para download o preview, que você pode ver no site oficial.

Quer aprender a desenvolver com Kotlin? Veja o nosso curso:

O que você acha sobre essa parceria entre Kotlin e Android? Compartilhe conosco a sua opinião. 🙂

Uma abraço e até a próxima!

Implementando uma notificação simples no Android

A notificação é uma forma de informar o usuário sobre eventos do aplicativo. Geralmente é exibida quando ele está fora da aplicação. Desta forma, elas são fortes aliadas para tornar as aplicações mais interativas e aumentar o engajamento com seu usuário.

Quando uma notificação é lançada pela aplicação, ela é tratada pelo Notification Manager, que possui a capacidade de exibir um ícone na área de notificação, exibir a notificação na tela, piscar a tela, vibrar o dispositivo, iniciar um alerta sonoro, exibir informações adicionais quando a área de notificação é exibida, etc.

Como as notificações são formas de informar ao usuário sobre eventos da aplicação, elas são utilizadas, praticamente, por todos os aplicativos. Com este recurso o usuário não precisa abrir a aplicação para saber se novas informações foram recebidas ou se algum evento lançado por ele foi finalizado, ele consegue visualizar estes dados pela própria notificação lançada.

Ao trabalharmos com notificações, é comum implementar uma ação ao evento click. Geralmente, ao receber um click, a aplicação que lançou aquela notificação é aberta exibindo maiores detalhes. Para isso, precisamos passar para a notificação uma PendingIntent.

A PendingIntent especifica uma ação que será executada no futuro. Ela passa uma “futura” intent para outra aplicação e permite que esta aplicação execute a intent como se tivesse as mesmas permissões da sua aplicação. Ela é um token que você informa para uma outra aplicação, que permite que ela execute um pedaço de código com as mesmas permissões que a sua aplicação.

Ao fornecer um PendingIntent para outra aplicação, você garante a execução correta da operação especificada pela outra aplicação, como se fosse a sua (com as mesmas permissões e identidade).

Implementação:

public void criarNotificacaoSimples(){
    int id = 1;
    String titulo = "Título da Notificação";
    String texto = "Texto da notificação Simples";
    int icone = android.R.drawable.ic_dialog_info;

    Intent intent = new Intent(this, TextoActivity.class);
    PendingIntent p = getPendingIntent(id, intent, this);

    NotificationCompat.Builder notificacao = new NotificationCompat.Builder(this);
    notificacao.setSmallIcon(icone);
    notificacao.setContentTitle(titulo);
    notificacao.setContentText(texto);
    notificacao.setContentIntent(p);

    NotificationManagerCompat nm = NotificationManagerCompat.from(this);
    nm.notify(id, notificacao.build());
}

private PendingIntent getPendingIntent(int id, Intent intent, Context context){
    TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
    stackBuilder.addParentStack(intent.getComponent());
    stackBuilder.addNextIntent(intent);

    PendingIntent p = stackBuilder.getPendingIntent(id, PendingIntent.FLAG_UPDATE_CURRENT);
    return p;
}

No método criarNotificacaoSimples(), inicialmente, temos a criação de todas as variáveis que serão usadas para criar e configurar a notificação. O id que irá identificar a notificação, o título, texto e ícone que serão exibidos nela. E no fim deste trecho, é criada a Pending Intent, retornada pelo método getPendingIntent():

int id = 1;
String titulo = "Título da Notificação";
String texto = "Texto da notificação Simples";
int icone = android.R.drawable.ic_dialog_info;

Intent intent = new Intent(this, TextoActivity.class);
PendingIntent p = getPendingIntent(id, intent, this);

Em seguida, no mesmo método, temos a criação e a configuração das propriedades da notificação. Para criá-la, é utilizado a Classe de compatibilidade NotificationCompat e assim é possível configurar o ícone (setSmallIcon()), o título da notificação (setContentTitle()), o conteúdo (setContentText) e a intent que será disparada ao clicar sobre a notificação (setContentIntent()):

NotificationCompat.Builder notificacao = new NotificationCompat.Builder(this);
notificacao.setSmallIcon(icone);
notificacao.setContentTitle(titulo);
notificacao.setContentText(texto);
notificacao.setContentIntent(p);

E para exibir a notificação para o usuário, precisamos de um gerenciador de notificações, no caso o NotificationManagerCompat, ele será responsável por exibir a notificação para o usuário através do notify() passando por parâmetro o id que identificará a notificação e a notificação criada anteriormente:

NotificationManagerCompat nm = NotificationManagerCompat.from(this);
nm.notify(id, notificacao.build());

Agora você já é capaz de implementar uma notificação no seu app. o/

Um abraço e até a próxima!

Novidades do Android O para desenvolvedores

Não é novidade que a Google está a todo vapor para lançar o Android O, previsto para o terceiro trimestre deste ano (2017). Mesmo antes da Final Release, já é possível conferir as novidades que o robozinho verde traz para nós. Vejamos algumas delas para desenvolvedores.

Notificações

As notificações foram reestruturadas para oferecer uma forma mais fácil e uniforme de gerenciar e configurá-las.

Foram adicionados canais de notificação. Estes canais permitem criar um canal personalizável pelo usuário para cada tipo de notificação que for exibir. Assim os usuário podem gerenciar a maioria das configurações associadas a notificação usando uma UI do sistema. Todas as notificações que pertencem ao mesmo canal se comportarão da mesma forma e quando o usuário faz alguma modificação, ela se aplica ao canal da notificação. Como por exemplo uma mudança no som, luz, vibração, etc.

Agora os usuários também podem adiar as notificações para uma nova exibição mais tarde. Assim, elas reaparecem com o mesmo nível de importância da primeira exibição. Também é possível determinar um tempo limite na criação de uma notificação. Desta forma você pode especificar um período de tempo para que uma notificação seja cancelada.

Foi adicionado também a possibilidade de determinar uma cor de fundo para a notificação. A recomendação para utilizar este recurso é que seja implementado apenas para notificações de tarefas contínuas e essenciais em que o usuário deve ver rapidamente.

Acessibilidade

O Android O passa a oferecer os seguintes recursos para desenvolvedores que criam seus próprios serviços de acessibilidade:

  • Detecção de Idioma: Foi introduzida a classe TextClassificationManager que permite através do método detectLanguages() identificar os idiomas que a ferramenta Text-to-Speech (TTS) identificou em um intervalo de texto.

  • Botão de Acessibilidade: Agora é possível que seu serviço solicite que um botão de acessibilidade apareça na área de navegação do sistema. Esse botão oferece aos usuário uma maneira rápida de ativar a funcionalidade do seu serviço de qualquer tela do dispositivo.

  • Gestos de impressão digital: Os gestos de deslizamento direcionais (para cima, para baixo, para a esquerda e para a direita) juntamente com o sensor de impressão digital de um dispositivo, agora pode ser um mecanismo de entrada alternativo para seu serviço de acessibilidade.

  • Texto de dica: Através do método getHintText() da classe AccessibilityNodeInfo é possível acessar o texto de dica de um objeto EditText mesmo que o texto de dica não esteja exibido naquele momento.

  • Envio de gesto continuado: Com o Android O é possível também, especificar sequências de movimento que pertencem ao mesmo gesto programático.

Permissões

Agora é possível que aplicativos atendam a chamadas telefônicas recebidas programaticamente através da nova permissão introduzida: android.permission.ANSWER_PHONE_CALLS. Esta permissão é classificada como “dangerous”.

Aprimoramento de mídia

  • Métricas de mídia: Foi adicionado um novo método getMetrics() que retorna um objeto Bundle contendo informações de configuração e desempenho. Este método pode ser acessado através das classes: MediaPlayer, MediaRecorder, MediaCodec e MediaExtractor.

  • MediaPlayer: Para melhorar a forma como o seu app gerencia a reprodução de mídia, foi adicionado uma série de novos métodos à classe MediaPlayer, desta forma será possível aumentar a capacidade de desempenho controlando o comportamento de armazenamento de buffer, controle detalhado durante a busca de um quadro e a capacidade de reproduzir material protegido por DRM.

  • MediaRecorder: A partir de agora o MediaRecorder oferece suporte ao formato MPEG2_TS, para utilizar basta coloca-lo no formato de saída: mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_2_TS);. Através do MediaMuxer também foi adicionada a possibilidade de trabalhar com qualquer quantidade de streams de áudio e vídeo, não existe mais a limitação de uma faixa de áudio e/ou vídeo.

Dados em cache

O Android O ainda trouxe melhorias no sistema de cache para as aplicações. Agora, cada app recebe uma cota de espaço em disco para armazenar seu dados de cache.

Caso o sistema necessite de liberar espaço em disco, os arquivos em cache dos aplicativos que mais ultrapassaram a cota alocada serão os primeiros a serem excluídos. Assim, se os seus dados de cache sempre ficarem dentro da cota alocada, eles serão alguns dos últimos a serem excluídos pelo sistema (se necessário).

Foi incluído também dois novos comportamentos que podem ser ativados com base no diretório para controlar como o sistema libera seus dados em cache:

  • StorageManager.setCacheBehaviorAtomic(): pode ser usado para indicar um diretório e todo o seu conteúdo deverá ser excluído como uma só unidade atômica.

  • setCacheBehaviorTombstone(File, boolean): pode ser usado para indicar que, em vez de excluir arquivos dentro de um diretório, eles deverão ser truncados para terem 0 bytes de tamanho, deixando o arquivo vazio intacto.

Estas são apenas algumas das novidades já definidas para o novo sistema operacional, você pode conferir muito mais no site oficial Android O Developer Preview.

Um abraço e até a próxima!

Utilizando o Firebase Authentication em uma aplicação Android

O Firebase é uma excelente plataforma que auxilia desenvolvedores web e mobile na criação de aplicações de alta qualidade e performance, desde a concepção, monitoramento até a publicação. Você pode conhecer um pouco mais sobre ele no post: Firebase: descubra no que esta plataforma pode te ajudar.

Hoje veremos como implementar o Firebase em uma aplicação Android através do Android Studio e utilizar o serviço de autenticação Firebase Authentication.

Step 1: Acesse https://console.firebase.google.com e faça login com um conta do Google. Após o login será disponibilizado para você a opção de criar um novo projeto no Firebase.

Step 2: Após clicar na opção Novo Projeto no passo anterior, você deve informar o nome do projeto e o País/Região para criá-lo.

Depois de criado, você já tem acesso a todas as opções disponíveis.

Step 3: Agora, você deve criar um projeto no Android Studio que integre o Firebase. No meu caso, criei um projeto com o nome Artigo Firebase e package br.com.treinaweb.artigofirebase.

Step 4: Após o projeto criado no Android Studio, é hora de integrar o Firebase. Para isso, clique no menu Tools > Firebase.

Ao clicar nesta opção, irá aparecer no lado direto, no Android Studio, o assistente de configuração do Firebase. Clique na opção Authentication.

Step 5: Após clicar na opção de autenticação, você tem a opção de conectar o projeto ao Firebase. É isto que faremos agora clicando na opção Connect to Firebase.

Step 6: Neste momento o seu navegador será aberto e solicitará algumas permissões de acesso a sua conta.

Após as permissões serem concedidas deverá aparecer para você uma mensagem de sucesso:

Depois de visualizar a mensagem, volte ao Android Studio.

Step 7: Ao retornar para o Android Studio, você terá as opções de criar um novo projeto ou escolher um projeto existente. No nosso caso, vamos escolher o projeto existente que criamos no Firebase e conectá-lo efetivamente ao projeto no Android Studio, clicando na opção Connet to Firebase.

Depois de processar a sua solicitação será exibido no assistente que o seu projeto está conectado.

Step 8: Agora que o projeto no Android Studio está vinculado ao projeto no Firebase, é hora de utilizar os recursos de Autenticação. Para isso, clique na opção Authentication na página do seu projeto no Firebase. E, para escolhermos as formas de autenticação que iremos utilizar, clique na opção Configurar método de login.

Step 9: Neste exemplo vamos utilizar a autenticação de E-mail/Senha. Sendo assim, ative-a.

Step 10: Após ativar a opção no passo anterior, vá até a guia Usuários e adicione um novo para utilizarmos na aplicação clicando na opção 2 Adicionar Usuário. Informe um e-mail e senha e adicione-o.

Step 11: Depois de criar o usuário, volte ao Android Studio e adicione o SDK do Firebase contendo o módulo de Autenticação na aplicação. Para isto basta clicar na opção Add Firebase Authentication to your app e aceitar as modificações em Accept Changes.

Step 12: Agora basta implementar os códigos necessários para realizar o login através do Firebase Auth. Neste caso, não utilizaremos uma tela de login para o usuário informar os dados de acesso. O foco é mostrar o que é preciso para fazer a autenticação utilizando o Firebase. Vamos através da do Log informar se os dados de login informados são válidos ou não.

Primeiro precisamos recuperar a instância do Firebase Auth. Basta criar a variável global:

private FirebaseAuth mAuth;

E, no método onCreate(), recuperar a instância:

mAuth = FirebaseAuth.getInstance();

Para monitorar as mudanças no estado da autenticação, vamos adicionar um Listener para isso. Vamos criar a variável no escopo global:

private FirebaseAuth.AuthStateListener mAuthListener;

E no método onCreate() adicione:

mAuthListener = new FirebaseAuth.AuthStateListener() {
    @Override
    public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
        FirebaseUser user = firebaseAuth.getCurrentUser();
        if (user != null) {
            Log.d("AUTH", "onAuthStateChanged:signed_in:" + user.getUid());
        } else {
            Log.d("AUTH", "onAuthStateChanged:signed_out");
        }

    }
};

Agora nos métodos onStart() e onStop() devemos adicionar e remover, respectivamente, o monitoramento através do Listener:

@Override
public void onStart() {
    super.onStart();
    mAuth.addAuthStateListener(mAuthListener);
}

@Override
public void onStop() {
    super.onStop();
    if (mAuthListener != null) {
        mAuth.removeAuthStateListener(mAuthListener);
    }
}

E para fazer o login, propriamente dito, basta utilizar o seguinte código no método onCreate():

mAuth.signInWithEmailAndPassword("testeteste@treinaweb.com.br", "thmpv77d6f").addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
    @Override
    public void onComplete(@NonNull Task<AuthResult> task) {

        if (!task.isSuccessful()) {
            Log.w("AUTH", "Falha ao efetuar o Login: ", task.getException());
        }else{
            Log.d("AUTH", "Login Efetuado com sucesso!!!");
        }
    }
});

Ao executar esta aplicação temos o seguinte resultado no Log:

Desta forma o nosso login utilizando a autenticação do Firebase já está funcional. o/

Você pode consultar a documentação oficial através do site do Firebase.

Ah, claro, você também pode fazer o nosso curso Firebase com Android:

Um abraço e até a próxima!

Criando um botão customizado no Android via XML

Ao adicionarmos um botão no layout pelo Android Studio ele fica com a seguinte aparência:

Mas não quer dizer que devemos utilizá-la em todos os botões do aplicativo. É possível modificá-la (tamanho, cor, borda, alinhamento etc) por meio de arquivos XML. Para entender melhor as propriedades que definem a aparência, vamos criar um botão como o da imagem abaixo:

Para isso, crie um novo arquivo do tipo Drawable Resource File. Basta clicar com o botão direito sobre a pasta drawable > New:

Depois basta definir o nome do arquivo que deseja criar:

Neste caso, criei o arquivo com o nome botao_customizado e implementei o seguinte código:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle"
    >

    <corners
        android:radius="5dp"
        />

    <solid
        android:color="@android:color/holo_red_light"
        />

    <stroke
        android:width="2dp"
        android:color="@android:color/background_dark"
        />
</shape>

Primeiro é montado um shape, que define a forma geométrica do botão, neste caso é um retângulo (android:shape="rectangle"). Está propriedade também aceita os valores line, oval e ring que definem outras geometrias para o botão.

No elemento <corners ... /> definimos a propriedade android:radius="..." para determinar o valor do arredondamento dos cantos do botão.

O elemento <solid... /> determina a cor de fundo do botão por meio da propriedade android:color="..."/>.

E por fim, o elemento <stroke ... /> define a espessura da borda (android:width="...") e a cor para a mesma (android:color="...").

Para que o botão passe a ter esse novo modelo, basta definir o arquivo criado na propriedade android:background="@drawable/botao_customizado" do botão.

Além dos elementos utilizados até agora, temos o elemento <gradient ... /> para definir o fundo do botão com cores formando um gradiente ao invés de utilizar uma cor sólida. Como neste exemplo:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle"
    >

    <corners
        android:radius="5dp"
        />

    <stroke
        android:width="2dp"
        android:color="@android:color/background_dark"
        />

    <gradient
        android:startColor="#fff"
        android:endColor="#363636"
        android:angle="45"
        android:centerColor="#FFA500"/>
</shape>

Neste elemento temos as propriedades android:startColor="...", android:endColor="..." e android:centerColor="..." para definir a cor inicial, final e central do gradiente, respectivamente. E também é utilizado a propriedade android:angle="..." que determina o ângulo do gradiente.

Com estes elementos e suas propriedades é possível criar uma infinidade de modelos diferentes para utilizar nos botões.

Para automatizar parte do processo de customização de um botão, é possível utilizar o site AngryTools que determina os valores da propriedade e ele vai te mostrando um preview do botão e ao finalizar ele gera os arquivos XML para utilizar. o/

Agora que você conhece um pouco sobre esta customização, faça diversos exemplos, modifique as propriedades e veja a diferença entre elas. Afinal, nada melhor que praticar para aprender!

Um abraço e até a próxima!

Google lança o Android Studio 2.3

O Android Studio é a IDE oficial para desenvolvimento Android. Inclui tudo o que o desenvolvedor precisa para criar os aplicativos. No inicio deste mês (Março/2017) o Google lançou a nova versão da IDE, o Android Studio 2.3. Uma versão baseada na correção de bugs e estabilidade, além de incluir novos recursos.

Principais mudanças

A partir desta versão a paleta de Widgets no editor de layout foi redesenhada.

Todos os templates agora usam o ConstraintLayout como layout padrão.

Os botões AVD Manager e SDK Manager agora estão incluídos na barra de navegação, assim como a barra de ferramentas completa.

Também foi adicionado um novo botão para visualizar as modificações rapidamente com o Instant Run. Depois de fazer o deploy do app basta clicar em Aplicar alterações (ícone e um raio) para visualizar as modificação. Este recurso tem suporte apenas a dispositivos com Android 5.0 (API Level 21) ou superior.

Novidades

Agora com o Android Studio é possível converter arquivos PNG, BMP, JPG e GIF estático para o formato WebP. WebP é um formato de arquivo de imagem do Google que fornece compressão com perdas (como o JPEG) e com transparência (como o PNG).

Com o novo editor de Layout é possível criar uma lista de atributos favoritos para que você não tenha que clicar em Ver todos os atributos para ter acesso aos que você mais usa.

Agora, ao adicionar um Material Icon usando o Vector Import Dialog, é possível filtrar a lista de ícones disponíveis por categoria ou pelo nome do ícone.

Também, para esta nova versão, foi incluído suporte para dois novos recursos do ConstraintLayout:

  • Definir o tamanho da view com base em uma proporção da tela.
  • Criar packed, spread, e weighted linear groups com constraint chains.

Você pode fazer o download do Android Studio através do site oficial para Desenvolvedores Android e conferir as novas atualizações.

Um abraço e até a próxima!

Android Things e a Internet das Coisas

O Android é conhecido por dominar o mercado de smartphones e tablets, sendo o sistema operacional para mobile mais utilizado nos últimos anos. E não parou por aí, o robozinho verde está ampliando e quer estar presente em todos os dispositivos possíveis! Depois do Android Auto (para carros) e o Android Wear (para dispositivos vestíveis como os relógios) o Google lançou o Android Things, uma versão do sistema operacional para a Internet das Coisas, também conhecida como IoT (Internet of Things).

A Internet das Coisas

Essa tecnologia está surgindo para revolucionar o nosso dia a dia. Tem como objetivo conectar todos, sim, você leu certo, todos os dispositivos que utilizamos à rede mundial de computadores. Geladeiras, televisão, micro-ondas, relógios, alarmes, ar-condicionado, termostatos, máquinas de lavar, carros, máquinas industriais, enfim, TUDO! A ideia vai além de simplesmente conectar todos os dispositivos a internet, mas sim, torná-los mais eficientes e fazer com que comuniquem entre si.

Imagine sair de casa e, quando estiver voltando, acionar pelo celular o ar-condicionado que consultará o termostato para identificar a temperatura ideal para o ambiente. Ou então, toda a rede elétrica da sua casa ser cortada automaticamente em caso de vazamento de gás e você ser notificado pelo celular. São inúmeras as aplicações que podem surgir a partir de todos os equipamentos conectados. Esta revolução tecnológica vai além de residências, também pode atuar em lojas, indústrias, hospitais, transporte público, fazendas, plantações, etc.

Mas, é claro, não será tão simples assim, se tudo está conectado e dependente da rede, existem riscos caso algum equipamento falhe, seja um erro de software ou até mesmo uma invasão hackers. Por isso, há muito o que discutir sobre o assunto, afinal, não queremos ser vítimas da nossa própria tecnologia.

Android Things

Como todas as coisas conectadas à internet precisarão de um sistema operacional, a gigante da tecnologia não demorou e lançou o Android Things. Este SO é dedicado exclusivamente para a IoT.

A ideia do Google é de que qualquer desenvolvedor Android possa desenvolver um dispositivo inteligente utilizando as APIs disponibilizadas, além de tornar a integração com os outros dispositivos, que já utilizam outras versões do sistema, de forma simples e fácil. Por isso, o Google já disponibiliza tudo o que você precisa para começar a desenvolver com o Android Things através do site para desenvolvedores.

Até o momento, existem quatro plataformas de hardware disponíveis para o Android Things:

  • Intel® Edison: Possui um processador Intel® Atom™ de 500MHz dual-core x86 e 1 GB de RAM;
  • Intel® Joule: Possui um processador Intel® Atom™ de 1.5GHz/1.7GHz quad-core x86 e 3GB/4GB de RAM;
  • NXP Pico i.MX6UL: Processador NXP i.MX6Ultralite de 500MHz ARM Cortex A7 e 512MB de RAM;
  • Raspiberry Pi 3: Com um processador Broadcom BCM2837 de 1.2GHz quad-core Cortex A53 e 1GB de RAM.

Para cada um destes hardwares existe uma imagem do sistema operacional para download.

A arquitetura do Android Things não é muito diferente do convencional. Ele estende o core do framework do Android com um adicional das APIs fornecidas pela Things Support Library. Essas APIs permitem que haja integração dos aplicativos com novos tipos de hardware que não são encontrados em dispositivos móveis.

Além disso, esta plataforma é simplificada e trabalha com single application. Não possui aplicativos de sistema e o seu app é iniciado automaticamente na inicialização do SO. Possui suporte para alguns serviços do google como as APIs de Localização, Mobile Vision, Firebase Storage, FCM, Firebase Realtime Database, entre outras. As APIs que requerem autenticação não estão disponíveis como AdMob, Firebase Authentication, Maps, etc.

Enfim, o Android Things está vindo com tudo para impulsionar a IoT e mostrar para o que veio. Então é bom ficar atento às novidades que, com certeza, não pararão de surgir.

Um abraço, e até a próxima!

JUNTE-SE A MAIS DE 150.000 PROGRAMADORES