Cómo generar código OTP en Android Desarrollador de registros, desarrollo de aplicaciones

Fuente: https: //www.simplifiedcoding.net…

Creando nuestra API de SMS

Para verificar el número de teléfono del usuario, le enviaremos el código de verificación por SMS. Para enviar SMS necesitamos una API de SMS.
Los SMS son de dos tipos Promocionales: no se enviarán a números de teléfono activados por DND. Por lo tanto, para la verificación por teléfono o OTP no podemos usar sms promocionales. Transaccional: se enviará a todos los números, no importa si un número ha activado DND o no. En este tutorial estoy usando SMS transaccional.
La mala noticia para ustedes es que no he encontrado ningún proveedor que proporcione API de SMS de forma gratuita. Este tutorial está patrocinado por Cheap SMS Bazaar. Me dieron algunos créditos de sms transaccionales gratuitos para escribir este tutorial.
Hay muchos proveedores de API de SMS que puedes buscar en Google. También puede comprarlo de SMS barato bazar. Si te registras en Cheap SMS Bazaar, te darán 10 sms promocionales gratis. También puedes probar este tutorial con sms promocionales. Pero con los sms promocionales, sus sms no se enviarán a números activados por DND.
Supongo que todos ustedes están utilizando Cheap SMS Bazaar . Así que ve a tu tablero. Y luego vaya a Documentos API. Estoy usando el transaccional y mi enlace API es.

http://login.cheapsmsbazaar.com/…

usuario: su nombre de usuario de inicio de sesión.
contraseña: su contraseña de inicio de sesión.
msisdn: número móvil único o múltiples números móviles separados por comas (10 dígitos o +91).
sid: ID del remitente aprobado (solo 6 caracteres).
msg: el contenido de su mensaje (mínimo 459 caracteres / 3 mensajes).
fl: si mensaje flash entonces 1 o 0
gwid: 2 (es para la ruta de Transacciones).
Nota: Solo se permiten 100 números móviles.

Enviaremos los sms a un solo número de teléfono móvil.
Obtendremos el siguiente JSON en respuesta.

{
“ErrorCode”: “000”,
“ErrorMessage”: “Éxito”,
“JobId”: “381a8090-b230-42fa-ac04-157cc2142bfa”,
“MessageData”: [
{
“MobileNumber”: “919898xxxxxx”,
“MessageParts”: [
{
“MessageId”: “919898xxxxxx -67e3765cdf034f438a432eacb88d0c14”,
“MessagePartId”: 1,
“MessageText”: “mensaje de prueba”
}
]
}
]
}

La creación de bases de datos y secuencias de comandos para la aplicación de verificación de SMS Android

Vaya a phpMyAdmin y cree la siguiente tabla. (Estoy usando el alojamiento gratuito de Hostinger).

Base de datos MySql

Como puedes ver tengo 6 columnas. ID es PRIMARY KEY y AUTOINCREMENT Username and Phone está configurado en UNIQUE . verificado es TINY INT y almacenará solo dos valores 0 y 1. (o significa no verificado y 1 significa verificado). El valor predeterminado para verificado se establece en 0, es decir, para cada fila, el valor predeterminado no se verifica. Y cuando el usuario ingrese el código de verificación correcto, lo cambiaremos a 1, es decir, verificado.
Vaya al directorio de su servidor y cree una carpeta para este proyecto. (Creé AndroidOTP)
Primero debemos conectarnos a la base de datos, así que cree un script dbConnect.php y escriba el siguiente código.

dbConnect.php

PHP

<? php
define (‘HOST’, ‘http: //mysql.hostinger.in’);
define (‘USUARIO’, ‘u502452270_andro’);
define (‘PASS’, ‘belal_123’);
define (‘DB’, ‘u502452270_andro’);
// Conectando a la base de datos
$ con = mysqli_connect (HOST, USER, PASS, DB) o die (‘No se puede conectar’);

Ahora para manejar la solicitud de registro, cree un archivo register.php . Este archivo almacenaría los detalles del usuario en la base de datos. También enviará el OTP o el código de verificación por SMS.

registrarse.php

PHP
<? php
// Constantes para nuestra API
// esto solo es aplicable cuando estás usando Cheap SMS Bazaar
define (‘SMSUSER’, ‘su nombre de usuario’);
define (‘CONTRASEÑA’, ‘su contraseña’);
define (‘SENDERID’, ‘su id de remitente’);
// Esta función enviará el otp
función sendOtp ($ otp, $ phone) {
// Este es el texto SMS que se enviará a través de SMS
$ sms_content = “Bienvenido a la codificación simplificada: su código de verificación es $ otp”;
// Codificar el texto en formato url
$ sms_text = urlencode ($ sms_content);
// Esta es la URL real de la API concatenada con los valores requeridos
$ api_url = ‘http://login.cheapsmsbazaar.com/vendorsms/pushsms.aspx?user=’.SMSUSER.’&password=’.PASSWORD.’&msisdn=91′.$phone.’&sid=’.SENDERID.’ & msg = ‘. $ sms_text.’ & fl = 0 & gwid = 2 ‘;
// Envoking la URL de la API y obtener la respuesta
$ respuesta = file_get_contents ($ api_url);
// Devolviendo la respuesta
devolver $ respuesta;
}
// Si llega una solicitud de publicación a este script
if ($ _ SERVER [‘REQUEST_METHOD’] == ‘POST’) {
// obteniendo nombre de usuario, contraseña y número de teléfono
$ username = $ _POST [‘nombre de usuario’];
$ contraseña = $ _POST [‘contraseña’];
$ phone = $ _POST [‘phone’];
// Generación de un Dígitos OTP 6 o código de verificación
$ otp = rand (100000, 999999);
// Importar el script de conexión db
require_once (‘dbConnect.php’);
// Crear una consulta SQL
$ sql = “INSERTAR EN androidotp (nombre de usuario, contraseña, teléfono, otp) valores (‘$ nombre de usuario’, ‘$ contraseña’, ‘$ teléfono’, ‘$ otp’)”;
// Si la consulta se ejecutó en la base de datos con éxito
if (mysqli_query ($ con, $ sql)) {
// imprime la respuesta dada por la función sendOtp pasando la otp y el número de teléfono
echo sendOtp ($ otp, $ teléfono);
}más{
// imprimiendo el mensaje de falla en json
echo ‘{“ErrorMessage”: “Failure”}’;
}
// Cerrar la conexión de la base de datos
mysqli_close ($ con);
}

Después de enviar la OTP al número de teléfono móvil del usuario, debemos confirmar la OTP del usuario. Y para ello necesitamos un archivo de más de php. Cree un nuevo archivo confirm.php y escriba el siguiente código.

confirmar.php

PHP

<? php
// Si se detecta una solicitud posterior
if ($ _ SERVER [‘REQUEST_METHOD’] == ‘POST’) {
// Obtener el nombre de usuario y otp
$ username = $ _POST [‘nombre de usuario’];
$ otp = $ _POST [‘otp’];
// Importar el script dbConnect
require_once (‘dbConnect.php’);
// Creando un SQL para obtener el otp de la tabla
$ sql = “SELECCIONE otp DESDE androidotp DONDE username = ‘$ username'”;
// Obtener la matriz de resultados de la base de datos
$ resultado = mysqli_fetch_array (mysqli_query ($ con, $ sql));
// Obteniendo el otp de la matriz
$ realotp = $ resultado [‘otp’];
// Si la otp dada es igual a otp obtenida de la base de datos
if ($ otp == $ realotp) {
// Crear una consulta sql para actualizar la columna verificada a 1 para el usuario especificado
$ sql = “ACTUALIZAR androidotp SET verificado = ‘1’ WHERE username = ‘$ username'”;
// Si la tabla se actualiza
if (mysqli_query ($ con, $ sql)) {
// mostrando éxito
echo ‘éxito’;
}más{
// mostrando falla
echo ‘fracaso’;
}
}más{
// muestra un error si otp dado no es igual al otp obtenido de la base de datos
echo ‘fracaso’;
}
// Cerrar la base de datos
mysqli_close ($ con);
}

Eso es para la parte del servidor. Tenga en cuenta la URL de los archivos register.php y confirm.php. Y vamos a crear un proyecto de Android.

Proyecto de verificación de SMS de Android

Abra Android Studio y cree un nuevo proyecto y agregue las siguientes dependencias que se utilizarán.

dependencias {
compilar fileTree (dir: ‘libs’, incluir: [‘* .jar’])
testCompile ‘junit: junit: 4.12’
compile ‘com.android.support:appcompat-v7:23.1.0’
compile ‘com.android.support:design:23.0.0’
compile ‘com.mcxiaoke.volley: library-aar: 1.0.0’
}

He agregado volley porque en este tutorial de verificación de SMS de Android estoy usando volley para las operaciones de red. Y para el diseño del diseño, he agregado el diseño: 23.0.0.
Ahora, en su proyecto, cree una clase de Java para almacenar las constantes importantes que se utilizarán en nuestra aplicación. Creé Config.java

Config.java

Java

paquete net.simplifiedcoding.androidotp;
/ **
* Creado por Belal el 18/11/2015.
* /
Configuración de clase pública {
// URL para registrar.php y confirmar archivo .php
public static final String REGISTER_URL = “Error 404 – Página no encontrada”;
public static final String CONFIRM_URL = “Error 404 – Página no encontrada”;
// Teclas para enviar nombre de usuario, contraseña, teléfono y otp
public static final Cadena KEY_USERNAME = “nombre de usuario”;
public static final String KEY_PASSWORD = “contraseña”;
public static final Cadena KEY_PHONE = “teléfono”;
Cadena pública estática final KEY_OTP = “otp”;
// Etiqueta JSON de la respuesta del servidor
public static final String TAG_RESPONSE = “Mensaje de error”;
}

Ahora necesitamos diseñar una actividad de registro. He creado el siguiente diseño para esta verificación de SMS de Android.

Verificación de SMS de Android

Para crear el diseño de arriba se puede utilizar el siguiente código.

activity_main.xml

<android.support.design.widget.TextInputLayout
android: layout_width = “match_parent”
android: layout_height = “wrap_content”
android: layout_marginTop = “8dp”
android: layout_marginBottom = “8dp”>
<EditText android: id = "@ + id / editTextPassword"
android: layout_width = “match_parent”
android: layout_height = “wrap_content”
android: inputType = “textPassword”
android: pista = “Contraseña” />

<android.support.design.widget.TextInputLayout
android: layout_width = “match_parent”
android: layout_height = “wrap_content”
android: layout_marginTop = “8dp”
android: layout_marginBottom = “8dp”>
<EditText android: id = "@ + id / editTextPhone"
android: layout_width = “match_parent”
android: layout_height = “wrap_content”
android: inputType = “textEmailAddress”
Android: pista = “teléfono” />

<android.support.v7.widget.AppCompatButton
android: id = “@ + id / buttonRegister”
android: layout_width = “fill_parent”
android: layout_height = “wrap_content”
android: background = “@ color / colorPrimary”
android: textColor = “@ color / colorAccent”
android: layout_marginTop = “24dp”
android: layout_marginBottom = “24dp”
android: acolchado = “12DP”
android: text = “Registrarse” />
<TextView android: id = "@ + id / linkSignup"
android: layout_width = “fill_parent”
android: layout_height = “wrap_content”
android: layout_marginBottom = “24dp”
android: text = “¿Ya tiene una cuenta? Inicie sesión aquí”
android: gravity = “center”
android: textSize = “16dip” />

Después de que el usuario toque el botón REGISTRO , aparecerá un cuadro de diálogo para ingresar el código de confirmación enviado. Para este cuadro de diálogo, necesitamos crear un archivo de recursos de diseño. Cree el archivo dialog_confirm.xml y escriba el siguiente código.

dialog_confirm.xml

Ahora vienen a MainActivity.java.

ActivityMain.java

Java

paquete net.simplifiedcoding.androidotp;
importar android.app.AlertDialog;
importar android.app.ProgressDialog;
importar android.content.Intent;
importar android.support.v7.app.AppCompatActivity;
importar android.os.Bundle;
importar android.support.v7.widget.AppCompatButton;
importar android.view.LayoutInflater;
importar android.view.View;
importar android.widget.EditText;
android.widget.Toast importación;
import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.StringRequest;
importar com.android.volley.toolbox.Volley;
org.json.JSONException importación;
import org.json.JSONObject;
importar java.util.HashMap;
import java.util.Map;
clase pública MainActivity extiende AppCompatActivity implementa View.OnClickListener {
// Crear vistas
EditText privado editTextUsername;
EditText privado editTextPassword;
EditText privado editTextPhone;
EditText privado editTextConfirmOtp;
Botón privado AppCompatButtonRegister;
botón privado AppCompatButtonConfirmar;
// Volley RequestQueue
RequestQueue privado requestQueue;
// Variables de cadena para guardar la contraseña del usuario y el teléfono
nombre de usuario de cadena privada;
contraseña de cadena privada;
teléfono de cuerda privado;
@Anular
vacío protegido onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
// Inicializando vistas
editTextUsername = (EditText) findViewById (http: //R.id.editTextUsername);
editTextPassword = (EditText) findViewById (http: //R.id.editTextPassword);
editTextPhone = (EditText) findViewById (http: //R.id.editTextPhone);
buttonRegister = (AppCompatButton) findViewById (http: //R.id.buttonRegister);
// Inicializando el RequestQueue
requestQueue = Volley.newRequestQueue (esto);
// Agregar un botón de escucha a
buttonRegister.setOnClickListener (esto);
}
// Este método confirmaría el otp
private void confirmOtp () lanza JSONException {
// Crear un objeto LayoutInflater para el cuadro de diálogo
LayoutInflater li = LayoutInflater.from (esto);
// Crear una vista para obtener el cuadro de diálogo
Ver confirmDialog = li.inflate (R.layout.dialog_confirm, nulo);
// Iniciando el botón de confirmación para el cuadro de diálogo y editando el texto del cuadro de diálogo
buttonConfirm = (AppCompatButton) confirmDialog.findViewById (http: //R.id.buttonConfirm);
editTextConfirmOtp = (EditText) confirmDialog.findViewById (http: //R.id.editTextOtp);
// Crear un generador de cuadros de diálogo de alertas
AlertDialog.Builder alert = new AlertDialog.Builder (this);
// Agregar nuestro cuadro de diálogo a la vista del cuadro de diálogo de alerta
alert.setView (confirmDialog);
// Crear un diálogo de alerta
AlertDialog final alertDialog = alert.create ();
// Mostrar el diálogo de alerta
alertDialog.show ();
// En el clic del botón de confirmación de diálogo de alerta
buttonConfirm.setOnClickListener (nueva View.OnClickListener () {
@Anular
public void onClick (Ver v) {
// Ocultar el diálogo de alerta
alertDialog.dismiss ();
// Mostrar una barra de progreso
cargando ProgressDialog final = ProgressDialog.show (MainActivity.this, “Autenticando”, “Espere mientras verificamos el código ingresado”, falso, falso);
// Obtener el usuario ha introducido OTP de EditarTexto
Cadena final otp = editTextConfirmOtp.getText (). toString (). trim ();
// Crear una solicitud de cadena
StringRequest stringRequest = new StringRequest (Request.Method.POST, Config.CONFIRM_URL,
nueva Response.Listener () {
@Anular
onResponse pública vacío (respuesta String) {
// si la respuesta del servidor es exitosa
if (response.equalsIgnoreCase (“éxito”)) {
// descartando la barra de progreso
loading.dismiss ();
// Comenzando una nueva actividad
startActivity (nueva intención (MainActivity.this, Success.class));
}más{
// Mostrar un brindis si la otp ingresada es incorrecta
Toast.makeText (MainActivity.this, “OTP incorrecto Inténtelo de nuevo”, Toast.LENGTH_LONG) .show ();
tratar {
// Solicitar al usuario que ingrese otp nuevamente
confirmOtp ();
} Catch (JSONException e) {
e.printStackTrace ();
}
}
}
},
nueva Response.ErrorListener () {
@Anular
public void onErrorResponse (error VolleyError) {
alertDialog.dismiss ();
Toast.makeText (MainActivity.this, error.getMessage (), Toast.LENGTH_LONG) .show ();
}
}) {
@Anular
El mapa protegido getParams () arroja AuthFailureError {
Map params = new HashMap ();
// Agregar los parámetros otp y nombre de usuario
params.put (Config.KEY_OTP, otp);
params.put (Config.KEY_USERNAME, nombre de usuario);
parámetros de retorno;
}
};
// Agregar la solicitud a la cola
requestQueue.add (stringRequest);
}
});
}
// este método registrará al usuario
registro privado vacío () {
// Mostrar un diálogo de progreso
cargando ProgressDialog final = ProgressDialog.show (esto, “Registrando”, “Espere …”, falso, falso);
// Obteniendo datos de usuario
username = editTextUsername.getText (). toString (). trim ();
contraseña = editTextPassword.getText (). toString (). trim ();
phone = editTextPhone.getText (). toString (). trim ();
// Nuevamente creando la solicitud de cadena
StringRequest stringRequest = new StringRequest (Request.Method.POST, Config.REGISTER_URL,
nueva Response.Listener () {
@Anular
public void onResponse (respuesta de cadena) {
loading.dismiss ();
tratar {
// Creando el objeto json a partir de la respuesta
JSONObject jsonResponse = nuevo JSONObject (respuesta);
// Si es exitoso
if (jsonResponse.getString (Config.TAG_RESPONSE) .equalsIgnoreCase (“Éxito”)) {
// Solicitar al usuario que confirme otp
confirmOtp ();
}más{
// Si no tiene éxito, el usuario puede haberse registrado
Toast.makeText (MainActivity.this, “Nombre de usuario o número de teléfono ya registrado”, Toast.LENGTH_LONG) .show ();
}
} catch (JSONException e) {
e.printStackTrace ();
}
}
},
nueva Response.ErrorListener () {
@Anular
public void onErrorResponse (error VolleyError) {
loading.dismiss ();
Toast.makeText (MainActivity.this, error.getMessage (), Toast.LENGTH_LONG) .show ();
}
}) {
@Anular
El mapa protegido getParams () arroja AuthFailureError {
Map params = new HashMap ();
// Agregar los parámetros a la solicitud
params.put (Config.KEY_USERNAME, nombre de usuario);
params.put (Config.KEY_PASSWORD, contraseña);
params.put (Config.KEY_PHONE, teléfono);
parámetros de retorno;
}
};
// Agregar solicitud a la cola
requestQueue.add (stringRequest);
}
@Anular
public void onClick (Ver v) {
// Llamando al método de registro al hacer clic en el botón de registro
registro();
}
}

En caso de éxito, estamos comenzando una nueva actividad que aún no se ha creado. Así que cree una nueva actividad llamada éxito. Y escribir el siguiente código XML para el archivo de diseño.

activity_success.xml

El código anterior producirá el siguiente diseño.

Verificación de SMS de Android

Para el archivo java de esta actividad ( Success.java ) no he hecho nada.

Success.java

Java

paquete net.simplifiedcoding.androidotp;
importar android.support.v7.app.AppCompatActivity;
importar android.os.Bundle;
El éxito clase pública se extiende AppCompatActivity {
@Anular
vacío protegido onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_success);
}
}

Por último, agregue permiso de Internet a su archivo de manifiesto.

AndroidManifest.xml

<aplicación
android: allowBackup = “true”
android: icon = “@ mipmap / ic_launcher”
android: label = “Registrarse”
android: supportsRtl = “true”
android: theme = “@ style / AppTheme”>

Ahora ejecuta tu aplicación.

Verificación de SMS de Android

¡Bingo! Funciona absolutamente bien. Puede obtener el proyecto desde el repositorio de GitHub. Solo ve al enlace dado be

AndroidAplicacionesDesarrollo de aplicacionesProgramación de computadoras