Sistema de Permissões em Tempo de Execução, Android M

Tudo bem?

O sistema de permissões do Android mantém todo o sistema consistente fazendo com que aplicativos que necessitem de acesso a dados, dados não produzidos por eles, ou necessitem de acesso a funcionalidades não disponíveis neles, que esses aplicativos definam permissões para que o acesso, consumo, seja possível.

Dentre as categorias de permissões, duas categorias são mais comuns e merecem sua atenção:

• Categoria de permissões normais;
• e Categoria de permissões perigosas.

Com o release do Android Marshmallow, Android 6 (API 23), o sistema de permissões no Android, que tinha o formato de apresentar todos os grupos de permissões necessárias logo no momento de instalação do aplicativo - direto na Google Play Store:

Esse formato de solicitação de permissão foi agora substituído pelo modelo de requisição de permissão em tempo de execução, digo, requisição de permissões que estão dentro da categoria de permissões perigosas (dangerous permissions).

As permissões dentro da categoria de permissões normais não precisam mais ser de conhecimento do usuário, não há mais a tela de permissões sendo apresentada para este tipo de permissão e o aplicativo continua com o uso delas - mas note que a definição em AndroidManifest.xml ainda é necessária para permissões de qualquer categoria.

Além de acelerar o processo de instalação do aplicativo por parte do usuário, no aparelho dele, esse novo modelo de permissões, que funciona somente quando a versão do Android é igual ou superior à versão 6 (Marshmallow) e ao mesmo tempo o targetSdkVersion do aplicativo é igual ou superior a API 23.

Este modelo traz também a necessidade de um esforço extra por parte do desenvolvedor Android que terá de solicitar cada permissão necessária (podendo ser mais de uma em uma só solicitação) para a execução de funcionalidades que utilizam entidades que somente com algumas permissões perigosas liberadas podem ser acessadas.

Isso assumindo que o desenvolvedor Android está seguindo as "Permissions Best Practices" indicadas na documentação e assim não requisitando todas as permissões necessárias logo na inicialização do aplicativo (You do not do that, pls!).

Antes de prosseguir, não esqueça de se inscrever ðŸ“«na lista de e-mails do Blog para receber, em primeira mão, todas as novidades sobre o desenvolvimento de aplicativos Android.

A partir daqui vamos configurar um projeto Android de exemplo para conter algoritmos do novo sistema de solicitação de permissão em tempo de execução.

Você quer saber o nome do projeto? ðŸ¤”

Pode acreditar: PermissionTarget23 project 😂.

Vamos iniciar pelo AndroidManifest.xml. Temos as declarações de permissões como já utilizado no modelo antigo:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    xmlns:android="http://schemas.android.com/apk/res/android"
    package="br.com.thiengo.permissiontarget23">

    <!-- NORMALS PERMISSIONS -->
    <uses-permission android:name="android.permission.INTERNET"/>

    <!-- DANGEROUS PERMISSIONS -->
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

        <activity android:name=".MainActivity">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

O próximo arquivo em configuração é o Gradle Nível de Aplicativo, ou build.gradle (Module: app), note que o targetSdkVersion é que passa por atualização, este deve ser 23, ou inferior.

Thiengo, "inferior"?

No caso de ser "inferior", somente se seu aplicativo ainda não estiver com o novo padrão de solicitação de permissão já configurado nos scripts dele, algo comum se o aplicativo não está com um código tão simples como no exemplo.

Segue a configuração do build.gradle (Module: app):

apply plugin: 'com.android.application'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.1"

    defaultConfig {
        applicationId "br.com.thiengo.permissiontarget23"
        minSdkVersion 10
        targetSdkVersion 22
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])

    testCompile 'junit:junit:4.12'

    compile 'com.android.support:appcompat-v7:23.1.0'

    compile 'me.drakeet.materialdialog:library:1.2.2'
    compile 'com.squareup.picasso:picasso:2.5.2'
}

Note que utilizei, além das bibliotecas padrões que já vêm com a criação de um novo projeto no Android Studio, as libraries MaterialDialog (me.drakeet.materialdialog:library:1.2.2) e Picasso (com.squareup.picasso:picasso:2.5.2) para auxiliarem na execução de algoritmos de apresentação de dialog secundária e carregamento de imagem remota, respectivamente.

Este último, carregamento de imagem remota, para demonstrar que a permissão de Internet roda sem necessidade de requisição em tempo de execução, isso por ela fazer parte da categoria de permissões normais.

Abaixo a lista de permissões dentro do conjunto de Permissões Normais:

A outra categoria de permissões, permissões perigosas, necessita que você dê uma maior importância ao termo "grupo de permissões".

Pois assim que é permitido, ou negado, o acesso a determinada permissão (READ_EXTERNAL_STORAGE, por exemplo) todas as permissões do mesmo grupo de permissões (no caso do READ_EXTERNAL_STORAGE o grupo é o STORAGE) têm agora o mesmo resultado de acesso: permitido ou não.

Logo, não será mais necessária a caixa de diálogo de permissão para utilizar WRITE_EXTERNAL_STORAGE caso READ_EXTERNAL_STORAGE já tenha sido concedida pelo usuário, e vice-versa.

Abaixo a lista de Permissões Perigosas e seus respectivos grupos:

Note que existem mais categorias de permissões além das Normais e Perigosas, porém para esse novo modelo, solicitação de permissão em tempo de execução, somente essas duas categorias é que importam.

As permissões normais também têm cada uma seus grupos, mas o entendimento de "grupos de permissões" ganha importância mesmo quando se trabalhando com permissões perigosas.

Pois como será apresentado no decorrer deste artigo, assim que é solicitada, em tempo de execução, o acesso a permissões individuais, o sistema Android apresenta ao usuário uma caixa de diálogo com a chamada ao grupo da permissão solicitada, fazendo com que a ação do usuário (permitir ou negar) seja refletida em todas as outras permissões do mesmo grupo de permissões.

Assim evitando, novamente, a chamada à caixa de diálogo de permissão caso uma outra permissão do mesmo grupo seja requisitada - ela então já estará disponível, ou não, dependendo da resposta do usuário à solicitação anterior.

A seguir o layout, activity_main.xml, que estaremos utilizando na aplicação de exemplo:

<?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"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="br.com.thiengo.permissiontarget23.MainActivity">

    <ImageView
        android:id="@+id/iv_logo"
        android:layout_width="60dp"
        android:layout_height="60dp"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="30dp"/>

    <TextView
        android:id="@+id/tv_title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="Hello World!" />

    <Button
        android:id="@+id/bt_load_img"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/tv_title"
        android:layout_centerHorizontal="true"
        android:onClick="callLoadImage"
        android:text="Load Image" />

    <Button
        android:id="@+id/bt_write"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/bt_load_img"
        android:layout_centerHorizontal="true"
        android:onClick="callWriteOnSDCard"
        android:text="Write on SDCard" />

    <Button
        android:id="@+id/bt_read"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/bt_write"
        android:layout_centerHorizontal="true"
        android:onClick="callReadFromSDCard"
        android:text="Read from SDCard" />

    <Button
        android:id="@+id/bt_location"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/bt_read"
        android:layout_centerHorizontal="true"
        android:onClick="callAccessLocation"
        android:text="Access Location" />

</RelativeLayout> 

Abaixo segue um trecho de código da MainActivity do projeto de exemplo, porém sem a utilização dos algoritmos de solicitação de permissão em tempo de execução.

Isso já simulando em um aparelho Android 6.0, Marshmallow, com o targetSdkVersion em 23:

...
private void readMyCurrentCoordinates() {

    LocationManager locationManager = (LocationManager) getSystemService( LOCATION_SERVICE );
    boolean isGPSEnabled = locationManager.isProviderEnabled( LocationManager.GPS_PROVIDER );
    boolean isNetworkEnabled = locationManager.isProviderEnabled( LocationManager.NETWORK_PROVIDER );

    Location location = null;
    double latitude = 0;
    double longitude = 0;

    if( !isGPSEnabled && !isNetworkEnabled ){

        Log.i( TAG, "No geo resource able to be used." );
    }
    else{
        if( isNetworkEnabled ){

            locationManager.requestLocationUpdates(
                LocationManager.NETWORK_PROVIDER,
                2000,
                0,
                this
            );
                
            Log.d( TAG, "Network" );

            location = locationManager.getLastKnownLocation( LocationManager.NETWORK_PROVIDER );

            if( location != null ){

                latitude = location.getLatitude();
                longitude = location.getLongitude();
            }
        }

        if( isGPSEnabled ){

            if( location == null ){

                locationManager.requestLocationUpdates(
                     LocationManager.GPS_PROVIDER,
                     2000,
                     0,
                     this
                );

                Log.d( TAG, "GPS Enabled" );

                location = locationManager.getLastKnownLocation( LocationManager.GPS_PROVIDER );

                if( location != null ){

                    latitude = location.getLatitude();
                    longitude = location.getLongitude();
                }
            }
        }
    }

    Log.i( TAG, "Lat: " + latitude + " | Long: " + longitude );
}
...

No final do método temos nosso print das coordenadas via LogCat code.

Tenha em mente que esse método, readMyCurrentCoordinates(), será acionado pelo listener de clique do Button de ID bt_location (apresentado no layout activity_main.xml anteriormente):

...
public void callAccessLocation( View view ) {

    Log.i( TAG, "callAccessLocation()" );
    
    readMyCurrentCoordinates();
}
...

O resultado, quando tentamos acessar as últimas coordenadas, de nosso emulador de testes, guardadas no sistema, é o seguinte: 

No LogCat temos na pilha de exceção o seguinte:

Mesmo com as permissões de LOCATION definidas no AndroidManifest.xml, ainda não é possível acessar as funcionalidades abaixo da liberação delas.

Então devemos solicitar a permissão ao usuário do aplicativo, utilizando os métodos das classes públicas ContextCompat e ActivityCompat (com fragmentos você consegue o mesmo efeito utilizando a classe FragmentCompat).

Vamos seguir com o código anterior, porém com a solicitação de permissão da maneira correta, segundo o novo modelo:

...
public void callAccessLocation( View view ) {

    Log.i( TAG, "callAccessLocation()" );

    if( ContextCompat.checkSelfPermission( this, Manifest.permission.ACCESS_FINE_LOCATION ) != PackageManager.PERMISSION_GRANTED ){

        if( ActivityCompat.shouldShowRequestPermissionRationale( this, Manifest.permission.ACCESS_FINE_LOCATION ) ){
            
            callDialog(
                "É preciso a permission ACCESS_FINE_LOCATION para apresentação dos eventos locais.",
                new String[]{
                    Manifest.permission.ACCESS_FINE_LOCATION
                }
            );
        }
        else{
            
            ActivityCompat.requestPermissions(
                this,
                new String[]{
                    Manifest.permission.ACCESS_FINE_LOCATION
                },
                REQUEST_PERMISSIONS_CODE
            );
        }
    }
    else{

        readMyCurrentCoordinates();
    }
}
...

O método readMyCurrentCoordinates() continua da mesma maneira, aliás, caso esteja com o Android Studio e o targetSdkVersion em 23, este IDE vai lhe apresentar as linhas de acesso aos providers NETWORK_PROVIDER e GPS_PROVIDER sublinhadas de vermelho.

Não se preocupe, na verdade o IDE está lhe informando que seu código precisa primeiro verificar se a permissão foi concedida, exatamente o que estamos fazendo no listener de clique do Button de ID bt_location, onde chamamos o método readMyCurrentCoordinates().

As classes ContextCompat e ActivityCompat nos permitem manter o código rodando, compatível, para versões anteriores ao Android 6.0, pois os métodos utilizados para verificação e solicitação de permissão foram adicionados somente a partir desta versão do Android.

O método checkSelfPermission() recebe como parâmetro o contexto atual (em nosso caso a Activity) e a permissão que devemos verificar para as funcionalidades seguintes serem utilizadas sem problemas caso a permissão tenha sido concedida.

Caso o valor retornado seja diferentes de PackageManager.PERMISSION_GRANTED, então devemos seguir para dentro do bloco condicional.

O método shouldShowRequestPermissionRationale() tem a mesma configuração de parâmetros do método anterior, porém esse é responsável por informar se a caixa de diálogo de permissão nativa do Android já foi ou não apresentada ao usuário, caso sim e o usuário tenha negado a permissão, esse método retorna true.

O método shouldShowRequestPermissionRationale() é utilizado para que nós desenvolvedores possamos, a partir da segunda tentativa de acesso a funcionalidade que necessita do conjunto de permissões, apresentar ao usuário o porquê das permissões solicitadas.

Ou seja, é a oportunidade que temos de antes de abrir o dialog nativo de permissão do Android, abrirmos nossa própria caixa de diálogo personalizada informando esse porquê das permissões, dando a chance ao usuário de aceitar e assim seguir para acesso à funcionalidade do app.

O método shouldShowRequestPermissionRationale() retorna false quando o método requestPermissions() ainda não foi chamado, ou quando o usuário marcou o dialog nativo de permissão para nunca mais ser apresentado para a permissão solicitada, "Never ask again box".

Ou quando o aplicativo está requisitando permissões que fogem do escopo de autorização do usuário e das categorias Normais e Perigosas - estas têm um modelo próprio de solicitação ao sistema.

O método requestPermissions() é o responsável por chamar a caixa de diálogo nativa de permissão:

Em casos onde o checkbox "Never ask again" tenha sido selecionado anteriormente ou a permissão já tenha sido concedida, a chamada ao dialog é ignorada e nada é apresentado.

Note que o segundo parâmetro é um array de Strings que contém todas as permissões necessárias para a execução da funcionalidade que o usuário solicitou no aplicativo.

O terceiro parâmetro é um int de 8 bits que será utilizado no método onRequestPermissionsResult() para verificar-mos se a permissão foi concedida ou não, caso sim, nesse método mesmo podemos chamar a funcionalidade requisitada pelo usuário.

Abaixo segue o algoritmo do método callDialog():

...
private void callDialog(
    String message,
    final String[] permissions ){

    mMaterialDialog = new MaterialDialog( this )
        .setTitle( "Permission" )
        .setMessage( message )
        .setPositiveButton( "Ok", new View.OnClickListener() {

            @Override
            public void onClick( View v ) {

                ActivityCompat.requestPermissions(
                    MainActivity.this,
                    permissions,
                    REQUEST_PERMISSIONS_CODE
                );

                mMaterialDialog.dismiss();
            }
        })
        .setNegativeButton( "Cancel", new View.OnClickListener() {

            @Override
            public void onClick( View v ) {

                mMaterialDialog.dismiss();
            }
        });

    mMaterialDialog.show();
}
...

No código acima a biblioteca MaterialDialog sendo utilizada quando o usuário já teve a caixa de diálogo nativa de permissão sendo apresentada e então ele negou a permissão.

A partir da segunda chamada a documentação oficial Android informa que nós desenvolvedores devemos apresentar uma caixa de diálogo de explicação, isso antes da chamada ao dialog nativo de permissão.

Caso o usuário escolha "Ok", então devemos invocar novamente o método requestPermissions().

Note que mesmo precisando das permissões ACCESS_FINE_LOCATION e ACCESS_COARSE_LOCATION, somente a utilização de uma das duas é o suficiente para a utilização do método readMyCurrentCoordinates(). Pois ambas vão acionar a mesma funcionalidade e estão no mesmo grupo de permissões.

💡 Informação importante: na verdade o Google Android recomenda que todas as permissões necessárias sejam configuradas mesmo que elas sejam de mesmo grupo, pois a regra de negócio "permissões de mesmo grupo sempre estarão liberadas se ao menos uma tiver sido concedida" pode mudar a qualquer momento.

Em caso de "Ok", a caixa de diálogo nativa com o checkbox "Never ask again" é apresentada:

Antes o dialog, do nosso MaterialDialog, é apresentada ao usuário:

Assim, logo depois da caixa de diálogo nativa ter algum dos Buttons clicado, o método onRequestPermissionsResult() é acionado.

Segue código dele:

...
@Override
public void onRequestPermissionsResult(
    int requestCode,
    String[] permissions,
    int[] grantResults ){

    Log.i( TAG, "test" );

    switch( requestCode ){
        case REQUEST_PERMISSIONS_CODE:
            for( int i = 0; i < permissions.length; i++ ){

                if( permissions[i].equalsIgnoreCase( Manifest.permission.ACCESS_FINE_LOCATION )
                    && grantResults[i] == PackageManager.PERMISSION_GRANTED ){

                    readMyCurrentCoordinates();
                }
            }
    }

    super.onRequestPermissionsResult(
        requestCode,
        permissions,
        grantResults
    );
}
...

Então é verificado no switch() se é o requestCode correto que definimos nas chamadas ao método requestPermissions().

Se sim, é o requestCode correto, verificamos no for() se a permissão no array permissions bate com alguma das permissões solicitadas no momento.

Caso o acesso tenha sido concedido, grantResults[i] == PackageManager.PERMISSION_GRANTED, devemos chamar o método correto para evitar que o usuário tenha de clicar novamente no botão de acionamento do método para a execução do mesmo, pois isso certamente, aos olhos do usuário, iria parecer um bug.

Para os testes do projeto de exemplo foi criado um emulador no AVD Manager com as configurações:

• Android 6.0;
• e Google APIs setadas no device.

Os passos são:

• 1º - Clique no ícone do AVD Manager:

• 2º - Clique em "Create Virtual Device..." como na imagem a seguir:

• 3º - Escolha o device que você quer montar e então clique em "Next":

• 4º - Escolha a versão / API do device. Fique com a Versão 6.0 (ou superior) e com Google APIs já instalada:

• 5º - Altere as configurações que achar necessário (eu mantive as padrões) e então clique em "Finish":

Depois é somente acionar o emulador pela mesma janela do AVD Manager e utiliza-lo.

Note que caso a sistema seja inferior ao Android 6.0 ou o targetSdkVersion do aplicativo seja inferior a API 23, então o sistema de requisição em tempo de execução será ignorado e as permissões serão concedidas.

Porém a partir da versão 6.0 do Android o usuário poderá mesmo assim revogar permissões liberadas ao aplicativo na área de permissões de apps do sistema Android.

Note também que o Android informará ao usuário que o aplicativo foi construído com um modelo configuração antigo de permissões e que isso pode ocasionar em crash.

Na verdade a Exception que ocorrerá não será a SecurityException pela falta de algoritmos de solicitação de permissão e sim, provavelmente (caso seu aplicativo não tenha um código protegido), alguma outra devido retorno não esperado dos métodos utilizados.

Métodos que somente poderiam ser utilizados depois de certas permissões terem sido concedidas em tempo de execução.

Logo, migrar seu aplicativo para o novo modelo de permissões é uma escolha inteligente.

Caso o app esteja com o código legado ou muito grande para uma alteração rápida, mantenha o targetSdkVersion abaixo da API 23 e então trate casos em que os valores null ou 0 são retornados dos métodos das entidades acessadas devido as permissões concedidas.

Há algumas bibliotecas que podem agilizar a codificação para você com o uso de annotations e outros, veja as três bibliotecas a seguir:

• GitHub EasyPermissions;
• GitHub WPAndroidPermissions;
• GitHub PermissionsDispatcher.

💎 Curtiu o conteúdo? Não esqueça de compartilha-lo. E, por fim, de se inscrever na 📩 lista de e-mails, respondo às suas dúvidas também por lá.

Abraço.

Vídeo

A seguir o vídeo de implementação do projeto de exemplo com os algoritmos de solicitação de permissão em tempo de execução:

O código completo do projeto de exemplo pode ser encontrado no GitHub dele em: https://github.com/viniciusthiengo/PermissionTarget23

Fontes

Trabalhando com o sistema de permissões do Android, tutorial na doc do Android

Grupo de permissões normais no Android

Grupo de permissões perigosas no Android, sesssão "Permission groups"

Everything every Android Developer must know about new Android's Runtime Permission - The Cheese Factory Blog post

Sistema de permissões do Android 6.0 - Ricardo Lecheta Blog post

Relacionado

GCM Downstream Messages. Push Message Android - Parte 1Android

Injeção de Dependência Com a lib Dagger 2 no AndroidAndroid

Library Retrofit 2 no AndroidAndroid

Sites, Canais e Blogs Gringos Para Estudar Desenvolvimento AndroidAndroid

Comentários Blog (14)

Para código / script, coloque entre [code] e [/code] para receber marcação especifica.

Forneça seu nome válido.

Forneça seu email válido.

Forneça o comentário.

Enviar

Enviando, aguarde...

Valdir (1) (0)

24/06/2018

Olá, Thiengo!
Mais uma vez parabéns pelos videos!

Estou com um problema em um app que estou criando para abrir conteúdo pdf em um app externo (adobe). Ocorre que já fiz as implementações de permissões, mas ele só funciona com o targetSdkVersion 22, já a partir da targetSdkVersion 23 não funciona apesar de ter feito a implementação das permissões como segue abaixo:

NA MAINACTIVITY:

package com.itextpdf.br.pdfteste;

import android.Manifest;
import android.app.Dialog;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.Manifest;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Environment;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;

import com.squareup.picasso.Picasso;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;

import me.drakeet.materialdialog.MaterialDialog;

import java.util.ArrayList;

import static android.location.LocationManager.NETWORK_PROVIDER;

public class MainActivity extends AppCompatActivity {


    public static final String TAG = "LOG";
    public static final int REQUEST_PERMISSIONS_CODE = 128;

    private MaterialDialog mMaterialDialog;


    private String[] header = {"Id", "Nome", "Apelido"};
    private String shortText = "Olá olá olá";
    private String longText = "Especificação da Infração: Violar, adulterar ou declarar dados incorretos ou falsos nos sistemas de informações da Semad ou de suas entidades vinculadas e/ou conveniadas para validar informações ou para emissão de documentos ambientais obrigatórios ou para obter proveito para si ou para outrem.\n" +
            "Classificação: Gravíssima.\n" +
            "Incidência da Pena: Por ato.\n";
    private TemplatePDF templatePDF;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        templatePDF = new TemplatePDF(getApplicationContext());
        templatePDF.openDocument();
        templatePDF.addMetaData("Clientes", "Ventas", "Marines");
        templatePDF.addTitles("Tienda CodigoFacilito", "Clientes", "06/12/2017");
        templatePDF.addParagraph(shortText);
        templatePDF.addParagraph(longText);
        templatePDF.createTable(header, getClients());
        templatePDF.closeDocument();
    }


    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        Log.i(TAG, "test");
        switch (requestCode) {
            case REQUEST_PERMISSIONS_CODE:
                for (int i = 0; i < permissions.length; i++) {

                    if (permissions[i].equalsIgnoreCase(Manifest.permission.WRITE_EXTERNAL_STORAGE)
                            && grantResults[i] == PackageManager.PERMISSION_GRANTED) {

                        templatePDF.appviewPDF(this);
                    } else if (permissions[i].equalsIgnoreCase(Manifest.permission.READ_EXTERNAL_STORAGE)
                            && grantResults[i] == PackageManager.PERMISSION_GRANTED) {

                        templatePDF.viewPDF();
                    }
                }
        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    // LISTENERS
    public void  pdfApp(View view) {
        Log.i(TAG, " pdfApp()");

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {

            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                callDialog("É preciso a permission WRITE_EXTERNAL_STORAGE para apresentação do contexto.", new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE});
            } else {
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_PERMISSIONS_CODE);
            }
        } else {
            templatePDF.appviewPDF(this);
        }

    }

    public void pdfView(View view) {
        Log.i(TAG, " pdfView()");

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {

            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.READ_EXTERNAL_STORAGE)) {
                callDialog("É preciso a permission READ_EXTERNAL_STORAGE para apresentação do conteúdo.", new String[]{Manifest.permission.READ_EXTERNAL_STORAGE});
            } else {
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, REQUEST_PERMISSIONS_CODE);
            }
        } else {
            templatePDF.viewPDF();
        }
    }


    // UTIL
    private void callDialog( String message, final String[] permissions ){
        mMaterialDialog = new MaterialDialog(this)
                .setTitle("Permission")
                .setMessage( message )
                .setPositiveButton("Ok", new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {

                        ActivityCompat.requestPermissions(MainActivity.this, permissions, REQUEST_PERMISSIONS_CODE);
                        mMaterialDialog.dismiss();
                    }
                })
                .setNegativeButton("Cancel", new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        mMaterialDialog.dismiss();
                    }
                });
        mMaterialDialog.show();
    }


    private ArrayList<String[]>getClients(){
        ArrayList<String[]>rows=new ArrayList<>();

        rows.add(new String[]{"1","VALDIR","Teste"});
        rows.add(new String[]{"2","Sofia","Hernandez"});
        rows.add(new String[]{"3","Naomi","Alfaro"});
        rows.add(new String[]{"4","Lorena","Espejel"});
        return rows;

    }
}




NO TEMPLATEPDF.JAVA:

package com.itextpdf.br.pdfteste;

import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.util.Log;
import android.widget.Toast;

import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Element;
import com.itextpdf.text.Font;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfWriter;

import org.w3c.dom.Document;

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;

public class TemplatePDF {
    private Context context;
    private File pdfFile;
    private com.itextpdf.text.Document document;
    private PdfWriter pdfWriter;
    private Paragraph paragraph;
    private Font fTitle=new Font(Font.FontFamily.TIMES_ROMAN, 20,Font.BOLD);
    private Font fSubTitle=new Font(Font.FontFamily.TIMES_ROMAN, 18,Font.BOLD);
    private Font fText=new Font(Font.FontFamily.TIMES_ROMAN, 12,Font.BOLD);
    private Font fHighText=new Font(Font.FontFamily.TIMES_ROMAN, 15,Font.BOLD, BaseColor.RED);
    public TemplatePDF(Context context) {
        this.context=context;
    }
    public void openDocument(){
        createFile();
        try {
            document=new com.itextpdf.text.Document(PageSize.A4);
            pdfWriter=PdfWriter.getInstance(document,new FileOutputStream(pdfFile));
            document.open();

        }catch (Exception e){
            Log.e("openDocument",e.toString());
        }
    }

    private void createFile(){
        File folder=new File(Environment.getExternalStorageDirectory().toString(),"PDF");

        if (!folder.exists())
            folder.mkdirs();
        pdfFile=new File(folder, "Template.pdf");

    }

    public void closeDocument(){
        document.close();
    }
    public void addMetaData(String title, String subject, String author){
        document.addTitle(title);
        document.addSubject(subject);
        document.addAuthor(author);
    }
    public void addTitles(String title, String subTitle, String date){
        try {
        paragraph=new Paragraph();
        addChildP(new Paragraph(title, fTitle));
        addChildP(new Paragraph(subTitle, fSubTitle));
        addChildP(new Paragraph( "Gerado: "+date, fHighText));
        paragraph.setSpacingAfter(30);
        document.add(paragraph);
        }catch (Exception e){
            Log.e("addTitles",e.toString());
        }
    }
    private void addChildP(Paragraph childParagraph){
        childParagraph.setAlignment(Element.ALIGN_CENTER);
        paragraph.add(childParagraph);
    }
    public void addParagraph(String text){
        try {
        paragraph=new Paragraph(text,fText);
        paragraph.setSpacingAfter(5);
        paragraph.setSpacingBefore(5);
        document.add(paragraph);
        }catch (Exception e){
            Log.e("addParagraph",e.toString());
        }
    }
    public void createTable(String[]header, ArrayList<String[]>clients){
        try {
        paragraph=new Paragraph();
        paragraph.setFont(fText);
        PdfPTable pdfPTable=new PdfPTable(header.length);
        pdfPTable.setWidthPercentage(100);
        pdfPTable.setSpacingBefore(20);
        PdfPCell pdfPCell;
        int indexC=0;
        while (indexC<header.length){
            pdfPCell=new PdfPCell(new Phrase(header[indexC++],fSubTitle));
            pdfPCell.setHorizontalAlignment(Element.ALIGN_CENTER);
            pdfPCell.setBackgroundColor(BaseColor.GREEN);
            pdfPTable.addCell(pdfPCell);
        }
        for (int indexR=0;indexR<clients.size();indexR++){
            String[]row=clients.get(indexR);
            for ( indexC=0;indexC<header.length;indexC++){
                pdfPCell=new PdfPCell(new Phrase(row[indexC]));
                pdfPCell.setHorizontalAlignment(Element.ALIGN_CENTER);
                pdfPCell.setFixedHeight(40);
                pdfPTable.addCell(pdfPCell);
            }
        }

        paragraph.add(pdfPTable);
        document.add(paragraph);
        }catch (Exception e){
            Log.e("createTable",e.toString());
        }

    }

    public void viewPDF(){
        Intent intent=new Intent(context,ViewPDFActivity.class);
        intent.putExtra("path",pdfFile.getAbsolutePath());
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(intent);
    }

    public void appviewPDF(Activity activity){
       if (pdfFile.exists()){
           Uri uri=Uri.fromFile(pdfFile);
           Intent intent=new Intent(Intent.ACTION_VIEW);
           intent.setDataAndType(uri,"application/pdf");
           try {
               activity.startActivity(intent);
           }catch (ActivityNotFoundException e){
               activity.startActivity(new Intent(Intent.ACTION_VIEW,Uri.parse("https://play.google.com/store/apps/details?id=com.adobe.reader&hl=pt_BR ")));
               Toast.makeText(activity.getApplicationContext(),"Você não tem um aplicativo para visualizar PDF",Toast.LENGTH_LONG).show();
           }

       }else {
           Toast.makeText(activity.getApplicationContext(),"O arquivo não foi encontrado",Toast.LENGTH_LONG).show();
       }

    }
}





NO VIEWPDFACTIVITY.JAVA:

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import com.github.barteksc.pdfviewer.PDFView;

import java.io.File;

public class ViewPDFActivity extends AppCompatActivity {

    private PDFView pdfView;
    private File file;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_view_pdf);
        pdfView=(PDFView)findViewById(R.id.pdfView);

        Bundle bundle=getIntent().getExtras();
        if (bundle!=null){
            file=new File(bundle.getString("path",""));
        }

        pdfView.fromFile(file)
                .enableSwipe(true)
                .swipeHorizontal(false)
                .enableDoubletap(true)
                .enableAntialiasing(true)
                .load();
    }
}





NA ACTIVITY_MAIN.XML:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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 "
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">


    <Button
        android:onClick="pdfView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="@string/local" />

    <Button
        android:onClick="pdfApp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Externo" />


</LinearLayout>



NA ACTIVITY_VIEW_PDF.XML:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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 "
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".ViewPDFActivity">

<com.github.barteksc.pdfviewer.PDFView
    android:id="@+id/pdfView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

</LinearLayout>


NO BUILD:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 27
    defaultConfig {
        applicationId "com.itextpdf.br.pdfteste"
        minSdkVersion 16
        targetSdkVersion 27
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    productFlavors {
    }
}

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation 'com.android.support:appcompat-v7:27.1.1'
    implementation 'com.android.support:design:27.1.1'
    implementation 'com.android.support.constraint:constraint-layout:1.1.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
    implementation 'com.itextpdf:itextg:5.5.10'
    implementation 'com.github.barteksc:android-pdf-viewer:3.0.0-beta.5'
    implementation 'com.android.support:appcompat-v7:27.1.1'


    implementation 'me.drakeet.materialdialog:library:1.2.2'
    implementation 'com.squareup.picasso:picasso:2.5.2'
}



NO ANDROIDMANIFEST:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android "
    package="com.itextpdf.br.pdfteste">
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

    <uses-permission android:name="android.permission.INTERNET"/>

    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>


    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".ViewPDFActivity" />
    </application>

</manifest>


Quando é clicado nos botões é solicitado as permissões. Após dado as permissões o botão Local gera o pdf e é exibido o documento, mas já o botão Externo, depois de dado as permissões, simplesmente da erro. Como disse antes, quando coloco o targetSdkVersion 22, ele funciona normal sem pedir permissões.

Peço desculpa por colocar tanto código, mas sou iniciante e não sei praticamente nada. Por favor me dê essa ajuda! Obrigado!

Responder

Vinícius Thiengo (0) (0)

31/07/2018

Valdir, tudo bem?

Se possível, informe o erro que está sendo gerado quando você tenta a execução com o targetSdkVersion 23+ definido.

O erro deve apontar o que está faltando.

Caso ainda não saiba obter erros pelos logs do Android Studio, não deixe de acessar o conteúdo do link a seguir: https://developer.android.com/studio/debug/am-logcat?hl=pt-br

Abraço.

Responder

Reinaldo (1) (0)

28/04/2018

Blz Thiengo?

Ótimo tutorial!

Estou criando um app soundboard e estou tendo problemas com permissões, para que o audio seja salvo como ringtone. O aplicativo em si funciona perfeitamente, mas ocorre problemas no momento de salvar o audio.

Estou usando essas 2 no manifest:  

  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

    <uses-permission android:name="android.permission.WRITE_SETTINGS" />

O problema ocorre com o "...permission..WRITE_SETTINGS", aparece a mensagem "permission is only granted to system apps".

Já fui em lint, desmarquei a caixa de seleção, escolhi uma gravidade menor que o erro, mas nada adiantou. Inclusive usei o comando tools:ignore="ProtectedPermissions".

Tem alguma sugestão de como fazer funcionar essa permissão no Manifest?

Utilizo Android Studio 3.1.2.

Grato

Responder

Vinícius Thiengo (0) (0)

28/04/2018

Reinaldo, tudo bem aqui.

Utilize o passo a passo do link a seguir para conseguir a permissão WRITE_SETTINGS:

https://stackoverflow.com/a/32083622/2578331

O usuário é que terá de dar a permissão em uma atividade fora de seu aplicativo, logo, é inteligente, antes de invocar essa atividade, apresentar um Dialog informando o porquê da necessidade de confirmar a permissão.

Abraço.

Responder

Erik Ramos (1) (0)

28/12/2017

Muito top seus tutoriais, sou iniciante em android e esta me ajudando muito, PARABÉNS !!!!!!!

Responder

Tiago (1) (0)

24/04/2017

Bom thiengo. Tudo certo?

Restou uma duvida, na sua video aula nao vi a parte do "never ask again".

Na decisao é abordado o negar com aquela dialog que nos fizemos, da segunda negacao em diante.

Mas quando volta a dialog padrao do android vem com essa opcao, mas quando é flegado no " never ask again" e negado nao aparece mais opcoes.


Como ficaria pra abordar essa negacao?

Responder

Vinícius Thiengo (0) (0)

27/04/2017

Tiago, tudo bem?

Seu código somente deve utilizar o Dialog personalizado, o criado por ti, caso a permissão solicitada não tenha haver com o domínio do problema do aplicativo. Por exemplo:

Solicitar a permissão de acesso a câmera do device em um aplicativo de game é algo que deveria ter antes uma Dialog explicando o porquê dessa solicitação e ai sim, caso o usuário escolhe ?Ok?, abrir o Dialog nativo, o que realmente libera a permissão.

Mesmo assim o usuário ainda tem a oportunidade de negar colocando a opção "never ask again? no segundo Dialog.

Para respeitar a decisão dele, utilize a verificação shouldShowRequestPermissionRationale() antes do primeiro dialog.

Assim, se me lembro bem, caso o usuário tem negado a permissão e ainda marcado o check "never ask again?, você saberá que pode apresentar um outro Dialog (caso veja a necessidade) informando que o usuário deve ir nas configurações do aplicativo no app de configurações do device e assim liberar a permissão, caso contrário o aplicativo será utilizado com certas limitações.

Não sei se conseguir informar isso no texto e vídeo acima, mas seguindo as regras de negócio da documentação, é assim que devemos prosseguir com a solicitação de permissões em tempo de execução. Abraço.

Responder

Vinícius Thiengo (0) (0)

27/04/2017

O ?Ok? na verdade é: aspas duplas Ok fecha aspas duplas.

Responder

Tiago (1) (0)

27/04/2017

Entendi, nao é preciso mostrar uma dialog de aviso no comeco, so depois que ele dar check no "never ask again".

Ou ate algo bacana q vi no album da SONY, ou no instagram, que é quando o user abre o app com tal permissao negada ja abre um aviso dizendo q permissao X deve ser ativada nas cfg do android.

Responder

Vinícius Thiengo (0) (0)

27/04/2017

Isso, seu segundo parágrafo é o que disse no comentário anterior.

O entendimento que descreveu no primeiro parágrafo está errado. Somente apresente o Dialog personalizado se a permissão não condiz com o domínio do problema do aplicativo, caso contrário invoque diretamente o Dialog de permissão nativo do Android.

Com o método shouldShowRequestPermissionRationale() você conseguirá saber se o usuário já negou tal permissão e então, posteriormente, apresentar um outro Dialog dizendo o que o App da Sony e Instagram fazem: que o user deve acessar as configurações do device e liberar as permissões. Abraço.

Responder

Patricia Aparecida (1) (0)

13/04/2016

Olá Thiengo

Estou estudando o novo sistema de permissões em tempo de execução e para isso criei um dispositivo virtual com o Genymotion (Google Nexus 7). Mas quando fui instalar o pacote gapps6.0 eu recebo a seguinte mensagem de erro: Failed to flash file open_gapps-arm-6.0-stock-20160413.zip.  Você saberia qual a causa do erro e como resolvê-lo?

Obrigada

Responder

Vinícius Thiengo (0) (0)

16/04/2016

Fala Patricia, blz?
Baixou o gapps na versão correta para sua instalação android? E outra, tente utilizando o AVD (emulador que já vem junto ao AndroidStudio), pois ele na nova versão do AS está bem mais eficiente. Abraço

Responder

andre (1) (0)

30/10/2015

Fala Thiengo, tudo bem?
Cara, não sei se você pode me ajudar, estou tentando implementar em um APP aqui como exercício, uma activity que trás meus últimos posts no YouTube, facebook, Twitter e instagram, você tem alguma dica, por onde iniciar?
Curto muito seu trabalho, está mais do que parabéns!
Abraço

Responder

Vinícius Thiengo (0) (0)

31/10/2015

Fala Andre, blz?
Uma opção é utilizar libraries que lhe permite acesso a "n" social networks, como essa (https://github.com/gorbin/ASNE ). Mas dê uma pesquisada aqui tb (https://android-arsenal.com/search?q=social+network ). Outra opção é utilizar a library nativa de cada network, provavelmente com o YouTube vc terá de fazer isso (https://developers.google.com/youtube/android/player/ ). Abraço

Responder