Crie um aplicativo de anotações para Android com o MongoDB Stitch

Pré-requisitos

• Android Studio 3.1 ou superior
• uma conta do MongoDB Atlas
• um dispositivo ou emulador com Android 5.0 ou superior

1. Criando um aplicativo de costura

• MongoDBCcriar um cluster de banco de dados na nuvem com o MongoDB AtlasAshraff Hathibelagal

2. Configurando a autenticação

keytool -exportcert -alias androiddebugkey \-keystore ~/.android/debug.keystore \-list

3. Adicionando uma regra

4. Configurando um projeto Android

implementação 'org.mongodb:stitch-android-sdk:4.0.5'

implementação 'com.google.android.gms:play-services-auth:15.0.1'

implementação 'com.android.support:design:27.1.1'implementação 'com.android.support:cardview-v7:27.1.1'implementação 'com.afollestad.material-dialogs:core:0.9.6.0' 
 Por fim, adicione o ID do seu aplicativo Stitch e o ID do cliente que você mencionou no console de administração do Stitch como itens no strings.xml Arquivo. 
 
YOUR_APP_IDYOUR_CLIENT_ID
 
5. Criando layouts
 
 Os usuários só poderão usar o aplicativo de anotações se estiverem conectados. Portanto, assim que o aplicativo for aberto, você deverá mostrar a eles um botão de login. A maneira mais rápida de fazer isso é usar o SignInButton widget no layout da atividade principal:
 
 
 Após um login bem-sucedido, você redirecionará o usuário para outra atividade contendo um ListView widget, que exibirá as notas do usuário e um FloatingActionButton widget, que o usuário pode pressionar para criar uma nova nota. Portanto, crie outra atividade vazia e adicione o seguinte código ao arquivo XML de layout:
 
  
 
 Cada item do ListView widget será uma nota. Para simplificar, digamos que o layout da nota tenha apenas um CardView widget contendo um TextView ferramenta. Portanto, crie um novo arquivo XML de layout chamado layout_note.xml e adicione o seguinte código a ele:
 
 
 
6. Implementando o Login do Google
 
 Quando o usuário pressiona o botão de login, você deve iniciar o fluxo de trabalho de login do Google. Portanto, dentro da primeira atividade, adicione um manipulador de eventos ao clicar no botão. 
 
 Dentro do gerenciador, você pode criar um GoogleSignInOptions objeto configurado para usar as opções de entrada padrão. Como seu aplicativo Stitch, que pode ser considerado seu servidor de back-end, também deve fazer parte do processo de login, certifique-se de chamar o método requestServerAuthCode() e passe seu ID de cliente para ele. O código a seguir mostra como:
 
val signInOptions =GoogleSignInOptions.Builder( GoogleSignInOptions.DEFAULT_SIGN_IN ).requestServerAuthCode( getString(R.string.google_client_id) ).build()
 
 Agora você pode criar um GoogleSignIn cliente chamando o getClient() e passando o método GoogleSignInOptions contestá-lo como argumento. Usando o cliente, você pode iniciar facilmente o fluxo de trabalho de login obtendo um intent de login dele e passando-o para o startActivityForResult() da atividade método. Veja como:
 
val signInClient =GoogleSignIn.getClient( this@MainActivity, signInOptions)startActivityForResult( signInClient.signInIntent, 1 // código de solicitação)
 
 Para receber o resultado da atividade que você acabou de disparar, você deve substituir o onActivityResult() método. Dentro dele, você terá acesso a um novo Intent objeto, que você pode passar para o getSignedInAccountFromIntent() método para identificar seu usuário. 
 
substituir fun onActivityResult(requestCode:Int, resultCode:Int, data:Intent?) { super.onActivityResult(requestCode, resultCode, data) val assinadoInAccount =GoogleSignIn.getSignedInAccountFromIntent(data) // Mais código aqui}
 
 Caso o usuário falhe ou se recuse a entrar, você terá uma exceção agora. Lide com isso exibindo um Toast informativo mensagem e fechando o aplicativo. 
 
if(signedInAccount.exception !=null) { Toast.makeText(this, "Você deve fazer login primeiro", Toast.LENGTH_LONG).show() finish() return}
 
 No entanto, em caso de login bem-sucedido, você terá acesso a um código de autenticação do servidor que pode ser usado para criar uma GoogleCredential objeto. Ao passar o objeto para o loginWithCredential() do cliente Stitch padrão do seu projeto, você pode registrar e fazer login do usuário em seu aplicativo. 
 
 Depois que o método for concluído com êxito, o aplicativo deverá alternar para a segunda atividade, que possui os elementos da interface do usuário para exibir notas e adicionar novas notas. O código a seguir mostra como fazer isso de forma concisa:
 
Stitch.getDefaultAppClient().auth .loginWithCredential( GoogleCredential(signedInAccount.result.serverAuthCode) ) .addOnSuccessListener { // Abre a atividade que mostra as notas startActivity( Intent(this@MainActivity, NotesActivity::class.java ) ) } 
 
 Se você criar e executar o aplicativo agora, poderá usar uma de suas contas do Google para fazer login nele. 
    
7. Adicionando notas
 
 Na segunda atividade, você precisará de um cliente Stitch e um cliente MongoDB Atlas. Você precisará do primeiro para obter o ID de autenticação do usuário e do último para executar operações de leitura e gravação em seu cluster MongoDB Atlas. Portanto, adicione-os como campos privados da atividade. 
 
valor privado stitchClient =Stitch.getDefaultAppClient() valor privado atlasClient =stitchClient.getServiceClient(RemoteMongoClient.factory, "mongodb-atlas")
 
 Quando os usuários pressionam o botão de ação flutuante, você deve exibir uma caixa de diálogo que solicita que eles digitem suas anotações. Com a biblioteca Material Dialogs, que você adicionou como uma dependência anteriormente, isso é muito intuitivo. 
 
 O código a seguir mostra como adicionar um ouvinte ao clicar no botão e criar uma caixa de diálogo de entrada básica:
 
add_note_button.setOnClickListener { val dialog =MaterialDialog.Builder(this@NotesActivity) .title("New Note") .input("Digite algo", null, false, { _, note -> // Mais código aqui } ).build() dialog.show()}
 
 Dentro do manipulador de eventos da caixa de diálogo, você terá acesso à nota que o usuário digitou. Para armazená-la em seu cluster MongoDB Atlas, você deve colocá-la dentro de um novo documento MongoDB. Além disso, para garantir que a nota seja visível apenas para o usuário que a criou, o documento deve incluir um user_id campo cujo valor corresponde ao ID de autenticação do usuário. O código a seguir, que fica dentro do manipulador de eventos, mostra como criar o documento:
 
val document =Document()document["text"] =note.toString()document["user_id"] =stitchClient.auth.user!!.id
 
 Agora que o documento está pronto, você deve inseri-lo nas notes coleção, que pertence ao notes_db base de dados. Veja como você pode obter referências ao banco de dados e à coleção e usar o insertOne() método para inserir o documento:
 
val collection =atlasClient.getDatabase("notes_db") .getCollection("notes")collection.insertOne(document).addOnSuccessListener { Toast.makeText(this@NotesActivity, "Uma nota salva", Toast.LENGTH_LONG).show). ()}
 
 Se você executar o aplicativo agora, poderá criar novas notas e salvá-las. 
    
8. Exibindo notas
 
 Para poder exibir as notas que um usuário criou, você deve primeiro buscar todos os documentos em notes coleção que pertence ao usuário. No entanto, você não precisa escrever uma consulta complexa para fazer isso. Devido à regra que você criou anteriormente, o Stitch garante automaticamente que qualquer consulta executada na coleção retornará apenas os documentos que o usuário possui. 
 
 Crie um novo método para exibir as notas. 
 
private fun showNotes() { // Mais código aqui}
 
 Dentro do método, você pode chamar diretamente o find() método nas notes coleção para criar uma consulta que pode buscar as notas do usuário. Para executar a consulta de forma assíncrona, você deve chamar o método into() método e passar uma lista vazia para ele. Os resultados da consulta estarão disponíveis na lista assim que ela for concluída com sucesso. 
 
val notes =mutableListOf()atlasClient.getDatabase("notes_db") .getCollection("notes") .find() .into(notes) .addOnSuccessListener { // Mais código aqui }
 
 Dentro do listener on-success, você deve agora criar uma instância do ArrayAdapter class para renderizar a lista de notas. No entanto, você não pode passar uma lista de Document objetos diretamente para o construtor da classe. Você deve primeiro convertê-lo em uma lista de String objetos. O código a seguir mostra como fazer isso usando o map() método:
 
val adapter =ArrayAdapter(this@NotesActivity, R.layout.layout_note, R.id.note_text, notes.map { it.getString("text") // Extraia apenas o campo 'text' // de cada documento })
 
 Quando o adaptador estiver pronto, você poderá colocá-lo em funcionamento atribuindo-o ao adapter propriedade do ListView ferramenta. 
 
notes_container.adapter =adaptador
 
 O showNotes() agora está pronto. Adicione uma chamada a ele dentro do onCreate() método para que os usuários possam ver suas notas assim que a atividade for aberta. Além disso, se você quiser que a lista exiba novas notas assim que elas forem criadas, sugiro que você também adicione uma chamada a ela dentro do listener on-success que você anexou ao insertOne() método. 
 
 Com as alterações acima, se você executar o aplicativo novamente, poderá adicionar novas notas e visualizar as existentes.