Adicione autenticação à sua aplicação Android

  • Artigo

Resumo

Neste tutorial, adiciona-se a autenticação ao projeto de arranque rápido da lista todolist no Android, utilizando um fornecedor de identidade suportado. Este tutorial baseia-se no Introdução com o tutorial de Mobile Apps, que deve completar primeiro.

Registe o seu aplicativo para autenticação e configuração Serviço de Aplicações do Azure

Primeiro, precisa de registar a sua aplicação no site de um fornecedor de identidade, e depois vai definir as credenciais geradas pelo fornecedor nas Aplicações Móveis.

  1. Configure o seu fornecedor de identidade preferido seguindo as instruções específicas do fornecedor:

  2. Repita os passos anteriores para cada fornecedor que pretende suportar na sua aplicação.

Adicione a sua aplicação aos URLs de redirecionamento externo permitidos

A autenticação segura requer que defina um novo esquema de URL para a sua aplicação. Isto permite que o sistema de autenticação redirecione de volta para a sua aplicação uma vez que o processo de autenticação esteja concluído. Neste tutorial, usamos o appname do esquema URL em toda a parte. No entanto, pode utilizar qualquer esquema de URL que escolha. Deve ser exclusivo da sua aplicação móvel. Para ativar a reorientação no lado do servidor:

  1. Na portal do Azure, selecione o seu Serviço de Aplicações.

  2. Clique na opção menu autenticação/autorização .

  3. Nos URLs de redirecionamento externo permitidos, insiraappname://easyauth.callback . O nome desta cadeia é o URL Scheme para a sua aplicação móvel. Deve seguir a especificação normal de URL para um protocolo (use apenas letras e números, e comece com uma letra). Deve tomar nota da cadeia que escolher, pois terá de ajustar o seu código de aplicação móvel com o Url Scheme em vários locais.

  4. Clique em OK.

  5. Clique em Guardar.

Restringir permissões a utilizadores autenticados

Por padrão, as APIs numa parte traseira de Aplicações Móveis podem ser invocadas de forma anónima. Em seguida, tem de restringir o acesso apenas a clientes autenticados.

  • Node.js parte de trás (através do portal do Azure) :

    Nas definições de Aplicações Móveis, clique em Tabelas Fáceis e selecione a sua tabela. Clique em Alterar permissões, selecione acesso autenticado apenas para todas as permissões e, em seguida, clique em Guardar.

  • .NET back end (C#):

    No projeto do servidor, navegue para ControllersTodoItemController>.cs. Adicione o [Authorize] atributo à classe TodoItemController , da seguinte forma. Para restringir o acesso apenas a métodos específicos, também pode aplicar este atributo apenas a esses métodos em vez da classe. Republicar o projeto do servidor.

      [Authorize]
  public class TodoItemController : TableController<TodoItem>

  • Node.js backend (através do código Node.js) :

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

      table.access = 'authenticated';

    Para mais detalhes, consulte Como: Requera autenticação para acesso às tabelas. Para aprender a descarregar o projeto de código quickstart do seu site, consulte Como: Descarregue o projeto de código de arranque rápido de backend Node.js usando Git.

  • No Android Studio, abra o projeto que completou com o tutorial Introdução com Aplicações Móveis. A partir do menu Executar , clique na aplicação Executar e verifique se uma exceção não manipulada com um código de estado de 401 (Não Autorizado) é levantada após o início da aplicação.

    Esta exceção acontece porque a aplicação tenta aceder à parte traseira como utilizador não autenticado, mas a tabela TodoItem agora requer autenticação.

Em seguida, atualiza a aplicação para autenticar os utilizadores antes de solicitar recursos a partir do final das Aplicações Móveis.

Adicionar autenticação à app

  1. Abra o projeto no Android Studio.

  2. Em Project Explorer no Android Studio, abra o ToDoActivity.java ficheiro e adicione as seguintes declaraçõ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");
            }
        }
    }
}

    Este código cria um método para lidar com o processo de autenticação do Google. Um diálogo mostra o ID do utilizador autenticado. Só pode proceder a uma autenticação bem sucedida.

    Nota

    Se estiver a utilizar um fornecedor de identidade diferente do Google, altere o valor passado para o método de login 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 instantaneamente o MobileServiceClient objeto.

    authenticate();

    Esta 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 a reorientação funcione como esperado, adicione o seguinte corte de RedirectUrlActivityAndroidManifest.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 à build.gradle sua aplicação 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 do seu build.gradle:

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

  9. A partir do menu Executar , clique na aplicação Executar para iniciar a aplicação e inicie sôm no seu fornecedor de identidade escolhido.

Aviso

O esquema url mencionado é sensível a casos. Certifique-se de que todas as ocorrências de {url_scheme_of_you_app} utilização do mesmo caso.

Quando estiver assinado com sucesso, a aplicação deverá funcionar sem erros, e deverá ser capaz de consultar o serviço back-end e fazer atualizações aos dados.

Fichas de autenticação de cache no cliente

O exemplo anterior mostrou um login padrão, o que requer que o cliente contacte tanto o fornecedor de identidade como o serviço Azure de back-end sempre que a aplicação começa. Este método é ineficiente, e pode ter problemas relacionados com o uso se muitos clientes tentarem iniciar a sua aplicação simultaneamente. Uma melhor abordagem é cache o sinal de autorização devolvido pelo serviço Azure, e tentar usá-lo primeiro antes de usar um início de súm in baseado no fornecedor.

Nota

Pode cache o token emitido pelo serviço back-end Azure, independentemente de estar a utilizar a autenticação gerida pelo cliente ou gerida pelo serviço. Este tutorial utiliza a autenticação gerida pelo serviço.

  1. Abra o ficheiro .java ToDoActivity e adicione as seguintes declaraçõ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 ficheiro ToDoActivity.java, adicione a seguinte definição 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();
}

    Este método armazena o ID do utilizador e o token num ficheiro de preferência que é marcado como privado. Isto deve proteger o acesso à cache para que outras aplicações no dispositivo não tenham acesso ao token. A preferência é de sandboxed para a aplicação. No entanto, se alguém tiver acesso ao dispositivo, é possível que possa ter acesso à cache simbólica através de outros meios.

    Nota

    Pode ainda proteger o token com encriptação, se o acesso simbólico aos seus dados for considerado altamente sensível e alguém puder ter acesso ao dispositivo. Uma solução completamente segura está fora do âmbito deste tutorial, no entanto, e depende dos seus requisitos de segurança.

  4. No ficheiro ToDoActivity.java, adicione a seguinte definição 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 ficheiro ToDoActivity.java , substitua os authenticate métodos e onActivityResult métodos pelos seguintes, que utiliza uma cache simbólica. Mude o fornecedor de login se quiser utilizar uma conta diferente da 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. Construa a aplicação e teste a autenticação utilizando uma conta válida. Executar pelo menos duas vezes. Durante a primeira execução, deverá receber um pedido para iniciar sessão e criar a cache simbólica. Depois disso, cada execução tenta carregar o cache simbólico para autenticação. Não deve ser obrigado a entrar.

Passos seguintes

Agora que completou este tutorial de autenticação básica, considere continuar com um dos seguintes tutoriais: