Compartilhar via

Adicionar autenticação ao seu aplicativo Android

Resumo

Neste tutorial, você adicionará autenticação ao projeto de início rápido da lista de tarefas pendentes no Android usando um provedor de identidade com suporte. Este tutorial baseia-se no tutorial Introdução aos Aplicativos Móveis, que você deve concluir primeiro.

Registrar seu aplicativo para autenticação e configurar o Serviço de Aplicativo do Azure

Primeiro, você precisa registrar seu aplicativo no site de um provedor de identidade e, em seguida, definirá as credenciais geradas pelo provedor no back-end dos Aplicativos Móveis.

  1. Configure seu provedor de identidade preferencial seguindo as instruções específicas do provedor:

  2. Repita as etapas anteriores para cada provedor que você deseja dar suporte em seu aplicativo.

Adicionar seu aplicativo às URLs de Redirecionamento Externo Permitidas

A autenticação segura requer que você defina um novo esquema de URL para seu aplicativo. Isso permite que o sistema de autenticação redirecione de volta para seu aplicativo depois que o processo de autenticação for concluído. Neste tutorial, usamos o esquema de URL nome do aplicativo ao longo de todo o texto. No entanto, você pode usar qualquer esquema de URL escolhido. Ele deve ser exclusivo para seu aplicativo móvel. Para habilitar o redirecionamento no lado do servidor:

  1. No portal do Azure, selecione seu Serviço de Aplicativo.

  2. Clique na opção de menu Autenticação/Autorização.

  3. Na seção URLs de Redirecionamento Externo Permitidas, insira appname://easyauth.callback. O nome do aplicativo nessa cadeia de caracteres é o Esquema de URL para seu aplicativo móvel. Ele deve seguir a especificação de URL normal para um protocolo (usar somente letras e números e começar com uma letra). Você deve anotar a cadeia de caracteres escolhida, pois precisará ajustar o código do aplicativo móvel com o Esquema de URL em vários locais.

  4. Clique em OK.

  5. Clique em Save (Salvar).

Restringir permissões a usuários autenticados

Por padrão, as APIs em um back-end dos Aplicativos Móveis podem ser invocadas anonimamente. Em seguida, você precisa restringir o acesso somente a clientes autenticados.

  • Node.js back end (por meio do portal do Azure):

    Em suas configurações de Aplicativos Móveis, clique em Tabelas Fáceis e selecione sua tabela. Clique em Alterar permissões, selecione Acesso autenticado apenas para todas as permissões e clique em Salvar.

  • Back-end .NET (C#)

    No projeto do servidor, navegue até Controllers>TodoItemController.cs. Adicione o atributo [Authorize] à classe TodoItemController, da seguinte maneira. Para restringir o acesso apenas a métodos específicos, você também pode aplicar esse atributo apenas a esses métodos em vez da classe. Publique novamente o projeto do servidor.

      [Authorize]
  public class TodoItemController : TableController<TodoItem>

  • Node.js backend (via código Node.js):

    Para exigir autenticação para acesso à tabela, adicione a seguinte linha ao script do servidor Node.js:

      table.access = 'authenticated';

    Para obter mais detalhes, consulte Como exigir autenticação para acesso a tabelas. Para saber como baixar o projeto de código de início rápido do seu site, consulte Como baixar o projeto de código de início rápido de back-end Node.js usando o Git.

  • No Android Studio, abra o projeto concluído com o tutorial Introdução aos Aplicativos Móveis. No menu Executar , clique em Executar aplicativo e verifique se uma exceção sem tratamento com um código de status 401 (não autorizado) é gerada após o início do aplicativo.

    Essa exceção ocorre porque o aplicativo tenta acessar o back-end como um usuário não autenticado, mas a tabela TodoItem agora requer autenticação.

Em seguida, você atualiza o aplicativo para autenticar usuários antes de solicitar recursos do back-end dos Aplicativos Móveis.

Adicionar autenticação ao aplicativo

  1. Abra o projeto no Android Studio.

  2. No Project Explorer no Android Studio, abra o ToDoActivity.java arquivo e adicione as seguintes instruções de importação:

    import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceAuthenticationProvider;
import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceUser;

  3. Adicione o seguinte método à classe ToDoActivity :

    // You can choose any unique number here to differentiate auth providers from each other. Note this is the same code at login() and onActivityResult().
public static final int GOOGLE_LOGIN_REQUEST_CODE = 1;

private void authenticate() {
    // Sign in using the Google provider.
    mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the login request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

    Esse código cria um método para lidar com o processo de autenticação do Google. Uma caixa de diálogo exibe a ID do usuário autenticado. Você só pode continuar com uma autenticação bem-sucedida.

    Observação

    Se você estiver usando um provedor de identidade diferente do Google, altere o valor passado para o método de logon para um dos seguintes valores: MicrosoftAccount, Facebook, Twitter ou windowsazureactivedirectory.

  4. No método onCreate , adicione a seguinte linha de código após o código que cria uma instância do MobileServiceClient objeto.

    authenticate();

    Essa chamada inicia o processo de autenticação.

  5. Mova o código restante depois authenticate(); no método onCreate para um novo método createTable :

    private void createTable() {

    // Get the table instance to use.
    mToDoTable = mClient.getTable(ToDoItem.class);

    mTextNewToDo = (EditText) findViewById(R.id.textNewToDo);

    // Create an adapter to bind the items with the view.
    mAdapter = new ToDoItemAdapter(this, R.layout.row_list_to_do);
    ListView listViewToDo = (ListView) findViewById(R.id.listViewToDo);
    listViewToDo.setAdapter(mAdapter);

    // Load the items from Azure.
    refreshItemsFromTable();
}

  6. Para garantir que o redirecionamento funcione conforme o esperado, adicione o seguinte snippet de RedirectUrlActivity para AndroidManifest.xml.

    <activity android:name="com.microsoft.windowsazure.mobileservices.authentication.RedirectUrlActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="{url_scheme_of_your_app}"
            android:host="easyauth.callback"/>
    </intent-filter>
</activity>

  7. Adicione redirectUriScheme ao build.gradle seu aplicativo Android.

    android {
    buildTypes {
        release {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
        debug {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
    }
}

  8. Adicione com.android.support:customtabs:23.0.1 às dependências em seu build.gradle:

    dependencies {
    // ...
    compile 'com.android.support:customtabs:23.0.1'
}

  9. No menu Executar , clique em Executar aplicativo para iniciar o aplicativo e entrar com o provedor de identidade escolhido.

Aviso

O Esquema de URL mencionado diferencia maiúsculas de minúsculas. Certifique-se de que todas as ocorrências de {url_scheme_of_you_app} usem o mesmo caso.

Quando você estiver conectado com êxito, o aplicativo deverá ser executado sem erros e você poderá consultar o serviço de back-end e fazer atualizações nos dados.

Tokens de autenticação de cache no cliente

O exemplo anterior mostrou uma entrada padrão, que exige que o cliente entre em contato com o provedor de identidade e o serviço de back-end do Azure sempre que o aplicativo for iniciado. Esse método é ineficiente e você pode ter problemas relacionados ao uso se muitos clientes tentarem iniciar seu aplicativo simultaneamente. Uma abordagem melhor é armazenar em cache o token de autorização retornado pelo serviço do Azure e tentar usá-lo primeiro antes de usar uma entrada baseada em provedor.

Observação

Você pode armazenar em cache o token emitido pelo serviço do Azure de back-end, independentemente de você estar usando a autenticação gerenciada pelo cliente ou pelo serviço. Este tutorial usa a autenticação gerenciada pelo serviço.

  1. Abra o arquivo ToDoActivity.java e adicione as seguintes instruções de importação:

    import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

  2. Adicione os seguintes membros à ToDoActivity classe.

    public static final String SHAREDPREFFILE = "temp";
public static final String USERIDPREF = "uid";
public static final String TOKENPREF = "tkn";

  3. No arquivo ToDoActivity.java, adicione a definição a seguir para o cacheUserToken método.

    private void cacheUserToken(MobileServiceUser user)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    Editor editor = prefs.edit();
    editor.putString(USERIDPREF, user.getUserId());
    editor.putString(TOKENPREF, user.getAuthenticationToken());
    editor.commit();
}

    Esse método armazena a ID do usuário e o token em um arquivo de preferência marcado como privado. Isso deve proteger o acesso ao cache para que outros aplicativos no dispositivo não tenham acesso ao token. A preferência é em área restrita para o aplicativo. No entanto, se alguém obtiver acesso ao dispositivo, é possível que ele possa obter acesso ao cache de token por outros meios.

    Observação

    Você pode proteger ainda mais o token com criptografia, se o acesso de token aos seus dados for considerado altamente confidencial e alguém puder obter acesso ao dispositivo. No entanto, uma solução completamente segura está além do escopo deste tutorial e depende de seus requisitos de segurança.

  4. No arquivo ToDoActivity.java, adicione a definição a seguir para o loadUserTokenCache método.

    private boolean loadUserTokenCache(MobileServiceClient client)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    String userId = prefs.getString(USERIDPREF, null);
    if (userId == null)
        return false;
    String token = prefs.getString(TOKENPREF, null);
    if (token == null)
        return false;

    MobileServiceUser user = new MobileServiceUser(userId);
    user.setAuthenticationToken(token);
    client.setCurrentUser(user);

    return true;
}

  5. No arquivo ToDoActivity.java, substitua os métodos authenticate e onActivityResult pelos seguintes, que usam um cache de token. Altere o provedor de logon se você quiser usar uma conta diferente do Google.

    private void authenticate() {
    // We first try to load a token cache if one exists.
    if (loadUserTokenCache(mClient))
    {
        createTable();
    }
    // If we failed to load a token cache, sign in and create a token cache
    else
    {
        // Sign in using the Google provider.
        mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the sign-in request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                cacheUserToken(mClient.getCurrentUser());
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

  6. Crie o aplicativo e teste a autenticação usando uma conta válida. Execute pelo menos duas vezes. Durante a primeira execução, você deve receber um prompt para entrar e criar o cache de token. Depois disso, cada execução tenta carregar o cache de token para autenticação. Você não deve ser obrigado a entrar.

Próximas etapas

Agora que você concluiu este tutorial básico de autenticação, considere continuar em um dos seguintes tutoriais: