Aprendiendo Android

Curso ANDROID – FISI UNMSM Prof. Ing.
Bruno Palacios
Contenido
Clase 1: Introducción a JAVA y carga de Andorid.............................................................3
Clase 2: Estructura Proyecto Android y carga de Emuladores ......................................15
2.1 Como funciona un proyecto android ....................................................................16
2.2 Como Colocar un splash de inicio de proyecto: ...............................................27
a. Referenciar la actividad splash en la configuración del proyecto: ..............27
b. Crear la clase Java ....................................................................................................28
c. Definimos los valores globales del proyecto .......................................................29
d. Creación de los layout de la actividad ................................................................30
e. Creación de las imágenes .......................................................................................32
2.3 Creando un activity para bienvenida: ..................................................................34
a. Creación de la actividad ..........................................................................................34
b. Creación de valores globales .................................................................................37
c. Referenciar la actividad “bienvenido” en la configuración del proyecto: 37
d. Codificamos en la clase Java .................................................................................38
2.4 Creando un Login con motor SQLite: .....................................................................39
a. Configurando Gradle .................................................................................................40
b. Definimos los valores globales a emplear como strings, colors, styles ........41
c. Crear la clase para del objeto Usuario .................................................................42
d. Crear la clase para del objeto DatabaseHelper ................................................44
e. Crear la actividad para el Logeo ...........................................................................50
f. Crear la clase para validar datos ...........................................................................53
g. Crear la Actividad para Registrar datos de inicio de sesión ...........................56
h. Crear la clase para obtener datos de la BD ........................................................62
i. Crear la Actividad Listado de Usuarios .................................................................68
j. Colocamos código a la clase Java para el Logeo ...........................................72
k. Configuramos el proyecto ........................................................................................75
l. Adicionando un Item al Menú .................................................................................76
Clase 3: Referencias de controles y paquetes; Eventos en controles, reconstruir un
proyecto........................................................................................................................................77
Clase 4: Uso de GIT, componentes de Android. ................................................................79
4.1 Configurar cuenta de github: .................................................................................79
Apuntes de Ing. Victor Ybañez R., MPM 1 de 106

Curso ANDROID – FISI UNMSM Prof. Ing. Bruno Palacios
4.2 Descargar proyectos desde repositorio GIT ........................................................81

4.3 Compartir un proyecto en GitHub .........................................................................83
4.4 Actualizar proyecto en github.................................................................................84
Clase 5: Uso de SCRUM para proyectos, Arquitectura de proyectos Android..........89

Clase 1: Introducción a JAVA y carga de Andorid

JAVA I
Palacios estrada, bruno francescoli
bfpalacios@gmail.com - 945936182
Arquitecto SOA (Arquitectura orientada a servicios) - Claro
Crear cuenta en google play us$ 25.00

Crear cuenta en el repositorio de github para cargar y compartir proyectos, se paga 27
soles al mes por cuenta privada.
https://github.com/torvic020/ANDROID.git
USER: torvic020
Existe otro repositorio que es gratuito gitlab, para cuentas privadas.
Tecnología Java, Tiene 3 plataformas: web, escritorio y móviles (esta última ya está
desfasada)
Se empleará la sintaxis de Java escritorio para android.
JVM-
La versión jdk 8 tiene Servicios Rest.
Paquete jar, contiene .class y .java; las class emplea código binario de aplicaciones java
mediante bytecode.
La versión más empleada de JDK es la 6.
Para desarrollar se requiere emplear el JDK completo

Para solo compilar y usar los .jar , .war u .ear se requiere JRE.
James Gosling, creador de Java, inicio 1991 creando un lenguaje para un control remoto
para varios tv.
Libro blanco de java.
- Garbage collector, liberador de memoria automática de app de java.
Robusto, no entra a memoria.
2. PROGRAMACION
Crear comentarios:
// : 1 linea
/* */ : varias líneas
 Identificadores de variables
Deben escribirse empezando solo con los caracteres _ y $
No deben emplearse palabras reservadas.
 Separadores
Especifica hasta donde inicia y termina las linea e código, listado de variables.
 Literales
Son los tipos de atributos

Operadores condicionales
? = entonces
: = else
Enviar correo con cuenta GIT:

Asunto: Alumno Android – UNMSM
USER GITHUB:
N° mobil
Android
Nace para el funcionamiento de cámaras.

Rest Api, para conectartese en la nube.
NDK, para programar en control del hardware de los dispositivos, dentro del ello
está el HAL.
La versión óptima de android para colocar como requisito mínimo de sistema

operativo es de acuerdo al mercado, entonces la 4.0 como minimo y máximo 9.0,
abarcando 80%
SOAP (Simple Object Access Protocol)

ES Un servicio que, define cómo dos objetos en diferentes procesos pueden comunicarse
por medio de intercambio de datos XML
Apk -- XML -- WebService --- BD (marquis, Roya)
Como ejemplo se muestra la forma en que un cliente solicitaría información de un producto a un proveedor de
servicios Web:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<getProductDetails xmlns="http://warehouse.example.com/ws">
<productId>827635</productId>
</getProductDetails>
</soap:Body>
</soap:Envelope>
Y esta sería la respuesta del proveedor:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<getProductDetailsResponse xmlns="http://warehouse.example.com/ws">
<getProductDetailsResult>
<productName>Toptimate 3-Piece Set</productName>
<productId>827635</productId>
<description>3-Piece luggage set. Black Polyester.</description>

<price>96.50</price>
<inStock>true</inStock>
</getProductDetailsResult>
</getProductDetailsResponse>
</soap:Body>
</soap:Envelope>
REST (Representational State Transfer)

ES Un servicio WEB, que contiene una colección de principios para el diseño de
arquitecturas en red para sistemas hipermedia. describe cualquier interfaz entre sistemas
que utilice directamente HTTP para obtener datos o indicar la ejecución de operaciones
sobre los datos, en cualquier formato (XML, JSON, etc) sin las abstracciones adicionales
de los protocolos basados en patrones de intercambio de mensajes.
APK -- tramas Json ---- BD (No SQL, firebase)
Activiy = Pantalla
Intensiones = pasar datos de una pantalla a otra
Componentes de la estructura de una aplicación android

Manifest: archivo de configuración inicial, se puede estipular que pantalla puede
cargar inicialmente.
Resolver laboratorio de java en eclipse. MJAVA1.LAB_1
Ejercicios de Android







COMPILAMOS EL APP



Clase 2: Estructura Proyecto Android y carga de Emuladores
Pre requisitos para Android:
● Java Programming Language
● Object-oriented programming
● XML - properties / attributes (clase - valor)
● Using an IDE for development and debugging
Las app generan un .log que es un archivo de bitacora
Un debug se hace en etapa de desarrollo, compilándola paso a paso para ver

errores posibles.
Ides para Android
- El primer ide fue el eclipse + sdk android (pugin). (esta fuera de uso)
- Luego sale intellij el cual emplea las librerías Gradle, la cual gestiona los
recursos que se requiere para realizar los proyectos descargándolos.
-
1) manifiests:
archivo de manifiesto
de Android:
descripción de la
aplicación leída por
el motor de ejecución
de Android
2) java:
paquetes de código
fuente de Java
3) res — carpeta
que contiene
Recursos como (XML):
diseño, cadenas,
imágenes,
dimensiones, colores
...
4) build.gradle —

archivos de compilación de Gradle, donde especifica la versión de VD a emplear
Pagina = layout
● Buenas prácticas para nombrar proyectos y las páginas:
○ Nombre del menu de actividades: MainActivity
○ Nombre de los diseñadores (layout): activity_main
2.1 Como funciona un proyecto android
a. Manifests: es el archivo principal, contiene el comando intent-filter

b. java: contiene la llamada a los layout de la aplicación, las cuales se compilarán.
Layout: es un objeto que representa el espacio contenedor de todas las vistas
(Views) dentro de la actividad. En él se define la estructura y el orden de los
elementos para que el usuario pueda interactuar con la interfaz. Lógicamente se
representan con subclases Java que heredan de la clase ViewGroup.
View: Es un componente que permite controlar la interacción del usuario con la
aplicación, estan organizados dentro de los Layouts para que el usuario
comprenda los objetivos de la actividad.
c. Rest : contiene los recursos así como las actividades contenidas del proyecto

manisfests
Activity.jar
Podemos debugger el log

visualizando el panel logcat y elegir una linear para reutilizarla y colocarla en la impresión
en pantalla del punto elegido.
// Log.<log-level>(TAG, "Message");
Log.d(TAG, ―Creating the URI…‖);
Material del curso en el driver
https://drive.google.com/drive/folders/1oWx5GP8rt-AMPJ7XloiZ0fJIqdCxh95t



El manifest es el archivo principal, contiene el comando intent-filter
Carpetas principales:

java: contiene la llamada a los layout de la aplicación, las cuales se compilarán.
Al
compilar el app elegimos otro recurso y elegimos el tipo de dispositivo

Seleccionamos la versión de Android: icecream = android 4.0.3
Seleccionamos lo descargado

Para Ver el sitio de descarga del sdk
C:\Users\CENPRO-PC\AppData\Local\Android\system-images

Seleccionamos la orientación del dispositivo
Tomar la consideración de descargar las imágenes de emuladores de acuerdo a la

versión del sistema operativo.

Configuración de una app,
Colocar las versiones del sdk, de la app creada.
Tarea 5.1 y 5.2 de la guía pdf: UNIT 1 Android Developer Fundamentals (V2)
Diseño y recursos
Ellos son las pantallas donde se programará, dentro de ellas se puede utilizar controles los
que son llamados vistas.
Las vistas con subclases.
TextView, Button, ScrollView, etc.
Teclas de acceso rápido: presionar control y clic sobre el nombre del archivo donde se
navegara.
What is the name of the layout file for the main activity?
● MainActivity.java
● activity_main.xml
Ejercicio pag. 33

En la vista de diseñador mostrar la pantalla de diseño y pantalla herramientas
Bases de datos no sql:
 Real time: Estructura de árboles (en desuso)

 Fire store: se organiza en documentos y listas.
Proyecto SEGSIL_MOVIL
User: acortez / dlovera / hvega / Admin
Pass: 1 al 6

Teclas calientes: ctrl + clic sobre la palabra
Ventana de búsqueda de archivos: Shift + shift
2.2 Como Colocar un splash de inicio de proyecto:
a. Referenciar la actividad splash en la configuración del proyecto:
Ir a la carpeta manifest -> AndroidManifest.xml para colocar las líneas de código que
llaman al layout mediante un activity.
Dentro del tag Application colocar la actividad para el splash

<activity
android:name=".SplashActivity"
android:label="@string/app_name"
android:screenOrientation="portrait"
android:theme="@style/AppTheme.NoActionBar">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
b. Crear la clase Java
Crear el archivo de clase java SplashActivity .java y colocar su Código, este archivo debe
crearse en la carpeta: JAVA -> dominio_de_la_compañia_colocado
Clic derecho sobre la carpeta del dominio
Colocar el nombre de la clase
Opcionalmente el archivo creado puede estar dentro de otra carpeta, para definir ello
solo colocar un punto seguido del nombre de esta.
Copiamos el Código:

package pe.edu.unmsm.sistemas.segsil;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
//import com.google.firebase.auth.FirebaseAuth;
import java.util.Timer;
import java.util.TimerTask;
//import pe.edu.unmsm.sistemas.segsil.R;
public class SplashActivity extends AppCompatActivity {
final int tiempoEspera = 3000;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_splash); //carga el layout del activity
//carga la siguiente actividad mediante intenciones

TimerTask timerTask = new TimerTask() {
@Override
public void run() {
Intent intent = new Intent(getApplicationContext(),BienvenidoActivity.class);
startActivity(intent);
finish();
}
};
Timer timer = new Timer();
timer.schedule(timerTask, tiempoEspera);
/*
FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
if (firebaseAuth.getCurrentUser() != null){
Intent intent = new Intent(getApplicationContext(),BienvenidoActivity.class);
finish();
}else{
@Override
public void run() {
Intent intent = new Intent(getApplicationContext(),LoginActivity.class);
finish();
}
};
}
}
*/
}
Nota: en el ejemplo se adiciona las líneas de código para el empleo de base de datos firebase y un
activity para el login, puede comentarlos si no los empleará o continuar con la guía para su
desarrollo.
c. Definimos los valores globales del proyecto

En la sub carpeta values contenida en la carpeta de recursos ―Res‖ contiene todas las
configuraciones de variables generales para su uso en el proyecto.
 colocar el tema para el splash, para ello agregar el siguiente código en el

archivo “styles.xml”, esto debajo del tema base de la aplicación: styles.xml
<style name="AppTheme.NoActionBar">
<item name="windowActionBar">false</item>
<item name="windowNoTitle">true</item>
</style>
 dimensionar el tamaño del texto del nombre del titulo de la aplicación, para
ello agregar el siguiente código al archivo ―dimens.xml‖:
 <dimen name="texto_medio">20sp</dimen>
d. Creación de los layout de la actividad
Creamos el layout del activity: activity_splash.xml en la carpeta rest/layout
Clic derecho sobre la carpeta layout

Colocamos el código
<?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"
android:gravity="center"
tools:context=".SplashActivity">
<LinearLayout
android:orientation="vertical"
android:layout_height="wrap_content"
android:gravity="center">
<ImageView
android:layout_width="150dp"
android:layout_height="150dp"
android:src="@drawable/logo_escudo_unmsm"/>
<TextView
android:textSize="@dimen/texto_medio"
android:textStyle="bold"
android:text="UNMSM- YBAÑEZ 2019"/>
</LinearLayout>
</LinearLayout>

e. Creación de las imágenes
Adicionamos las imágenes faltantes:
Crear en la carpeta drawable la carpeta logo_escudo_unmsm, para ello solo arrastre la

carpeta que contienen las imágenes hacia el contenedor Android o abra la ubicación de
la carpeta contenedora.
Ejemplo sin ningún XML
Ponga su imagen tu_image.jpg en la carpeta res/drawable/tu_imagen.jpg y para

emplear siga el siguiente código:
import android.app.Activity;
import android.widget.ImageView;
public class Main extends Activity {

@Override
final ImageView imageView = new ImageView(this);
imageView.setImageResource(R.drawable.tu_imagen);
setContentView(imageView);
}
}

La forma clásica que Android maneja para agregar imágenes y permitirle que las
redimensione, esto con la opción activo de imágenes (image asset)
La configuración para el paquete de imágenes es de tipo ―action bar and tab icons‖
(barra de acción e iconos de pestañas)

2.3 Creando un activity para bienvenida:

Permite mostrar un saludo de ingreso a la app, para su explicación se continuará
con el ejemplo anterior.
a. Creación de la actividad
Creamos la actividad BienvenidoActivity, para ello clic derecho sobre la carpeta principal
del proyecto y creamos una actividad en blanco.
Colocamos el nombre de la actividad y se creará su layout, esta acción creará la clase java.

Esta acción crea 2 objetos, el layout .xml y el java . java, nótese que el nombre que le coloque a la
actividad será asignado al archivo Java, mientras que el nombre del layout será para el
propiamente dicho.
La personalización de esta pantalla dependerá de la funcionalidad de la aplicación, puede

colocar un menú de opciones o simplemente un saludo con una imagen.

Para este ejemplo colocaremos una imagen de bienvenida, para ello descargar su imagen
previamente. Copiar su imagen y hacer clic sobre la carpeta drawable y pegar
Creamos el fondo de pantalla, adicionando un archivo de recurso de dibujo, clic derecho sobre la
carpeta drawable, llamado ―fondo_patanlla_bienvenida.xml‖

Copiamos el siguiente código al archivo: fondo_pantalla_bienvenida.xml

<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >

<item android:drawable="@color/colorPantallaBienvenida" />

<item>
<bitmap android:src="@drawable/dog_loader2_250x250" android:gravity="center" />
</item>
</layer-list>
b. Creación de valores globales

Son valores que emplearemos en todo el proyecto y son reutilizables.
 Colocamos el color para el fondo de pantalla de bienvenida, abriendo el archivo

colors.xml que está en la carpeta res/values, y adicionamos solo la línea color a los
valores ya existentes.
<resources>


<color name="colorPantallaBienvenida">#FBE39D</color>
</resources>
 Creamos un tema para el proyecto, abriendo el archivo styles.xml que está en la

carpeta res/values, y adicionamos solo la línea debajo de los valores ya existentes.

<style name="TemaPantallaBienvenida" parent="Theme.AppCompat.Light.NoActionBar">
<item name="android:windowBackground">
@drawable/fondo_patanlla_bienvenida
</item>
</style>
c. Referenciar la actividad “bienvenido” en la configuración del proyecto:

Ir a la carpeta manifest -> AndroidManifest.xml para colocar las líneas de código que
llaman al layout mediante un activity.
Dentro del tag Application después la actividad ―splash‖ colocar crear la actividad
bienvenidoActivity a la cual le añadiremos el tema creado en la sección creación de
valores globales.


<activity
android:name=".BienvenidoActivity"
android:screenOrientation="portrait"
android:Theme="@style/TemaPantallaBienvenida" />
d. Codificamos en la clase Java
Finalmente, Abrimos la clase java BienvenidoActivity.class, configuramos con el comando

startActivity cuál será la siguiente actividad a cargar, el siguiente código:
public class BienvenidoActivity extends AppCompatActivity {

final int tiempoEspera = 3000;
@Override
//Metodo principal
setContentView(R.layout.activity_bienvenido);
// después que carga el splash de la aplicación

// iniciamos la pantalla de bienvenida y cerramos la anterior splashactivity

@Override
public void run() {
Intent intent = new Intent(BienvenidoActivity.this, CatalogActivity.class);

finish();
}
};
}
}
2.4 Creando un Login con motor SQLite:

Esta pantalla permitirá acceder a los usuarios a la aplicación, así mismo, registrar sus datos
en la base relacional interna SQLite, para ello:
 se creará la clase para el usuario,
 la clase auxiliar de base de datos, que contiene las acciones a realizar en ella,
 la clase login,
 la clase para registrar al usuario.

 Finalmente, la clase adaptador, para pasar la información de la base de datos a

los activity.
a. Configurando Gradle
Debemos configurar el gradle para que sepa que trabajaremos una aplicación
con SQLite. Abrir el archivo build.gradle (module:app) para adicionar los paquetes
que emplearemos y copiar el siguiente código:
dependencies {
classpath 'com.android.tools.build:gradle:3.2.1'
//NOTA: No coloque sus dependencias de aplicaciones aquí;

// Pertenecen al módulo individual de archivos build.gradle.
implementation'com.android.support:appcompat-v7:27.1.1'
implementation'com.android.support:design:27.1.1'
implementation'com.android.support:cardview-v7:27.1.1'
Nota: debe tomar en cuenta la versión que use del Android SDK Plataform- Tools
para evita error en la reconstrucción.
Para configurar las dependencias correctamente, abrimos la estructura del

proyecto, es importante buscar la versión adecuada de la dependencia de
acuerdo a la versión del sdk colocado.

Nos dirigimos al tab Dependencias y clic en el signo más para buscar la dependencia, la ir
buscando mostrará las versiones disponibles de acuerdo al SDK instalado, seleccionamos
la que necesitamos y aceptamos.
Luego para que el Proyecto reconozca las líneas adicionadas hay que volver a
reconstruirlo.
b. Definimos los valores globales a emplear como strings, colors, styles
Para estos registros contenidos en la carpeta Rest/values
 En strings.xml, adicionamos:

//constantes
<string name="text_accounts">Todas las cuentas</string>
<string name="hint_name">Nombres</string>
<string name="hint_email">Email</string>
<string name="hint_password">contraseña</string>
<string name="error_message_password">Ingrese contraseña</string>
<string name="hint_confirm_password">Confirmar contraseña</string>
<string name="error_password_match">La contraseña no coincide</string>
<string name="error_valid_email_password">Correo o contraseña equivocada</string>

<string name="error_email_exists">Email Existente</string>
<string name="error_message_email">Ingrese Validaciòn de Email</string>
<string name="text_login">Iniciar sesión</string>

<string name="text_register">Registro</string>
<string name="error_message_name">Ingrese Nombre Completo</string>
<string name="error_message_age">Ingrese Edad</string>
<string name="success_message">Registro Satisfactorio</string>
<string name="text_not_member">¿No tienes cuenta aún? Crea una</string>
<string name="text_already_member">¿Ya eres usuario? Iniciar sesión</string>
<string name="action_settings">Settings</string>
<string name="text_hello">Hola,</string>
<string name="text_title">Validación de Acceso</string>
<string name="action_lista_usuarios">Listar usuarios</string>
 En colors.xml, adicionamos:
// colores adicionales
<color name="colorBackground">#FBE39D</color>
<color name="colorText">#A49E9E</color>
<color name="colorTextHint">#CE2B27</color>
 En styles.xml, adicionamos en AppTheme:
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">

// adicionamos mas estilos
<item name="android:textColor">@color/colorText</item>
<item name="android:textColorHint">@color/colorText</item>
<item name="colorControlNormal">@color/colorText</item>
<item name="colorControlActivated">@color/colorText</item>
</style>
c. Crear la clase para del objeto Usuario
Para organizar las clases creamos un paquete llamado ―model‖ clic derecho sobre la
carpeta java/tudominio y nuevo package:

Ahora creamos la clase dentro de este paquete, clic derecho sobre la carpeta (paquete)
creada y nueva clase java, la cual se llamará User,

Adicionamos el siguiente código a la clase:
public class User {
private int id;

private String name;
private String email;
private String password;
public int getId() {

return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
d. Crear la clase para del objeto DatabaseHelper
Esta clase nos permite realizar los comandos de base de datos. Para organizar las clases
creamos un paquete llamado ―sql‖ clic derecho sobre la carpeta java/tudominio y nuevo
package:

Ahora creamos la clase dentro de este paquete, clic derecho sobre la carpeta (paquete)
creada y nueva clase java, la cual se llamará DatabaseHelper
Adicionamos el siguiente código a la clase:
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;

import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
// tenga en cuenta que en cambiar el dominio de acuerdo al nombre que coloc al crear la app
import com.example.android.pets.model.User;
import java.util.ArrayList;
import java.util.List;
public class DatabaseHelper extends SQLiteOpenHelper {
// Database Version
private static final int DATABASE_VERSION = 1;
// Database Name
private static final String DATABASE_NAME = "UserManager.db";
// User table name

private static final String TABLE_USER = "user";
// User Table Columns names

private static final String COLUMN_USER_ID = "user_id";
private static final String COLUMN_USER_NAME = "user_name";
private static final String COLUMN_USER_EMAIL = "user_email";
private static final String COLUMN_USER_PASSWORD = "user_password";
// create table sql query

private String CREATE_USER_TABLE = "CREATE TABLE " + TABLE_USER + "("
+ COLUMN_USER_ID + " INTEGER PRIMARY KEY AUTOINCREMENT," + COLUMN_USER_NAME + "
TEXT,"
+ COLUMN_USER_EMAIL + " TEXT," + COLUMN_USER_PASSWORD + " TEXT" + ")";
// drop table sql query

private String DROP_USER_TABLE = "DROP TABLE IF EXISTS " + TABLE_USER;
/**
* Constructor
*
* @param context
*/
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(CREATE_USER_TABLE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//Drop User Table if exist

db.execSQL(DROP_USER_TABLE);
// Create tables again

onCreate(db);

/**
* This method is to create user record
*
* @param user
*/
public void addUser(User user) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();

values.put(COLUMN_USER_NAME, user.getName());
values.put(COLUMN_USER_EMAIL, user.getEmail());
values.put(COLUMN_USER_PASSWORD, user.getPassword());
// Inserting Row
db.insert(TABLE_USER, null, values);
db.close();
}
/**
* This method is to fetch all user and return the list of user records
*
* @return list
*/
public List<User> getAllUser() {
// array of columns to fetch
String[] columns = {
COLUMN_USER_ID,
COLUMN_USER_EMAIL,
COLUMN_USER_NAME,
COLUMN_USER_PASSWORD
};
// sorting orders
String sortOrder =
COLUMN_USER_NAME + " ASC";
List<User> userList = new ArrayList<User>();
SQLiteDatabase db = this.getReadableDatabase();
// query the user table

/**
* Here query function is used to fetch records from user table this function works like we use sql
query.
* SQL query equivalent to this query function is
* SELECT user_id,user_name,user_email,user_password FROM user ORDER BY user_name;
*/
Cursor cursor = db.query(TABLE_USER, //Table to query
columns, //columns to return
null, //columns for the WHERE clause
null, //The values for the WHERE clause
null, //group the rows
null, //filter by row groups
sortOrder); //The sort order
// Traversing through all rows and adding to list

if (cursor.moveToFirst()) {

do {
User user = new User();
user.setId(Integer.parseInt(cursor.getString(cursor.getColumnIndex(COLUMN_USER_ID))));
user.setName(cursor.getString(cursor.getColumnIndex(COLUMN_USER_NAME)));
user.setEmail(cursor.getString(cursor.getColumnIndex(COLUMN_USER_EMAIL)));
user.setPassword(cursor.getString(cursor.getColumnIndex(COLUMN_USER_PASSWORD)));
// Adding user record to list
userList.add(user);
} while (cursor.moveToNext());
}
cursor.close();
db.close();
// return user list

return userList;
}
/**
* This method to update user record
*
* @param user
*/
public void updateUser(User user) {
ContentValues values = new ContentValues();

values.put(COLUMN_USER_NAME, user.getName());
values.put(COLUMN_USER_EMAIL, user.getEmail());
values.put(COLUMN_USER_PASSWORD, user.getPassword());
// updating row
db.update(TABLE_USER, values, COLUMN_USER_ID + " = ?",
new String[]{String.valueOf(user.getId())});
db.close();
}
/**
* This method is to delete user record
*
* @param user
*/
public void deleteUser(User user) {
// delete user record by id
db.delete(TABLE_USER, COLUMN_USER_ID + " = ?",
new String[]{String.valueOf(user.getId())});
db.close();
}
/**
* This method to check user exist or not
*
* @param email
* @return true/false
*/
public boolean checkUser(String email) {

COLUMN_USER_ID
};
// selection criteria
String selection = COLUMN_USER_EMAIL + " = ?";
// selection argument
String[] selectionArgs = {email};
// query user table with condition

/**
query.
* SELECT user_id FROM user WHERE user_email = 'jack@androidtutorialshub.com';
*/
selection, //columns for the WHERE clause
selectionArgs, //The values for the WHERE clause
null); //The sort order
int cursorCount = cursor.getCount();
cursor.close();
db.close();
if (cursorCount > 0) {
return true;
}
return false;
}
/**
* This method to check user exist or not
*
* @param email
* @param password
* @return true/false
*/
public boolean checkUser(String email, String password) {

COLUMN_USER_ID
};
// selection criteria
String selection = COLUMN_USER_EMAIL + " = ?" + " AND " + COLUMN_USER_PASSWORD + " = ?";
// selection arguments
String[] selectionArgs = {email, password};
// query user table with conditions

/**

query.
* SELECT user_id FROM user WHERE user_email = 'jack@androidtutorialshub.com' AND
user_password = 'qwerty';
*/
selection, //columns for the WHERE clause
selectionArgs, //The values for the WHERE clause
null); //The sort order
int cursorCount = cursor.getCount();
cursor.close();
db.close();
if (cursorCount > 0) {
return true;
}
return false;
}
}
e. Crear la actividad para el Logeo
Creamos la actividad LoginActivity, para ello clic derecho sobre la carpeta principal del
proyecto y creamos una actividad en blanco.

Copiamos el código para la actividad creada activiy_login.xml
<android.support.v4.widget.NestedScrollView
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/nestedScrollView"
android:background="@color/colorBackground"
android:paddingBottom="20dp"
android:paddingLeft="20dp"
android:paddingRight="20dp"
android:paddingTop="20dp"
tools:context=".LoginActivity">
<android.support.v7.widget.LinearLayoutCompat
android:orientation="vertical">
<android.support.v7.widget.AppCompatImageView
android:layout_width="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="40dp"

android:src="@drawable/logo" />
<android.support.design.widget.TextInputLayout
android:id="@+id/textInputLayoutEmail"
android:layout_marginTop="40dp">
<android.support.design.widget.TextInputEditText
android:id="@+id/textInputEditTextEmail"
android:hint="@string/hint_email"
android:inputType="text"
android:maxLines="1"
android:textColor="@android:color/white" />
</android.support.design.widget.TextInputLayout>
android:id="@+id/textInputLayoutPassword"
android:id="@+id/textInputEditTextPassword"
android:hint="@string/hint_password"
android:inputType="textPassword"
<android.support.v7.widget.AppCompatButton
android:id="@+id/appCompatButtonLogin"
android:background="@color/colorTextHint"
android:text="@string/text_login" />
<android.support.v7.widget.AppCompatTextView
android:id="@+id/textViewLinkRegister"
android:layout_width="fill_parent"
android:text="@string/text_not_member"
android:textSize="16dp" />
</android.support.v7.widget.LinearLayoutCompat>
</android.support.v4.widget.NestedScrollView>

Antes de continuar copiando el contenido de la clase java para esta actividad

seguiremos unos pasos previos.
f. Crear la clase para validar datos
Esta clase nos permite validar los valores ingresados en las cajas de textos. Para ello lo
alojaremos en un paquete de ayuda llamado ―helpers‖
clic derecho sobre la carpeta java/tudominio y nuevo package:
Ahora creamos la clase dentro de este paquete, clic derecho sobre la carpeta(paquete)
creada y nueva clase java, la cual se llamará InputValidation,

Adicionamos el siguiente
código que contiene
métodos de validación para
el campo de entrada.
Validación como entrada
vacía, correo electrónico
válido y etc.
import android.app.Activity;
import android.content.Context;
import android.support.design.widget.TextInputEditText;
import android.support.design.widget.TextInputLayout;
import android.view.View;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
public class InputValidation {

private Context context;
/**
* constructor
*
* @param context
*/
public InputValidation(Context context) {
this.context = context;
}

/**
* method to check InputEditText filled .
*
* @param textInputEditText
* @param textInputLayout
* @param message
* @return
*/
public boolean isInputEditTextFilled(TextInputEditText textInputEditText, TextInputLayout
textInputLayout, String message) {
String value = textInputEditText.getText().toString().trim();
if (value.isEmpty()) {
textInputLayout.setError(message);
hideKeyboardFrom(textInputEditText);
return false;
} else {
textInputLayout.setErrorEnabled(false);
}
return true;
}
/**
* method to check InputEditText has valid email .
*
* @param textInputEditText
* @param textInputLayout
* @param message
* @return
*/
public boolean isInputEditTextEmail(TextInputEditText textInputEditText, TextInputLayout
textInputLayout, String message) {
String value = textInputEditText.getText().toString().trim();
if (value.isEmpty() || !android.util.Patterns.EMAIL_ADDRESS.matcher(value).matches()) {
hideKeyboardFrom(textInputEditText);
return false;
} else {
}
return true;
}
public boolean isInputEditTextMatches(TextInputEditText textInputEditText1, TextInputEditText

textInputEditText2, TextInputLayout textInputLayout, String message) {
String value1 = textInputEditText1.getText().toString().trim();
String value2 = textInputEditText2.getText().toString().trim();
if (!value1.contentEquals(value2)) {
hideKeyboardFrom(textInputEditText2);
return false;
} else {
}
return true;
}

/**
* method to Hide keyboard
*
* @param view
*/
private void hideKeyboardFrom(View view) {
InputMethodManager imm = (InputMethodManager)
context.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(),
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
}
}
g. Crear la Actividad para Registrar datos de inicio de sesión
Permite escribir la información a la base sqlite, para ello creamos la actividad

RegisterActivity, para ello clic derecho sobre la carpeta principal del proyecto y creamos
una actividad en blanco.

Copiamos el código para la actividad creada activiy_register.xml
<android.support.v4.widget.NestedScrollView
android:id="@+id/nestedScrollView"
android:background="@color/colorBackground"
android:paddingRight="20dp"
tools:context=".LoginActivity">
<android.support.v7.widget.AppCompatImageView
android:layout_gravity="center_horizontal"
android:src="@drawable/logo_escudo_unmsm" />
android:id="@+id/textInputLayoutName"

android:id="@+id/textInputEditTextName"
android:hint="@string/hint_name"
android:id="@+id/textInputLayoutEmail"
android:id="@+id/textInputEditTextEmail"
android:hint="@string/hint_email"
android:id="@+id/textInputLayoutPassword"
android:id="@+id/textInputEditTextPassword"
android:hint="@string/hint_password"
android:id="@+id/textInputLayoutConfirmPassword"
android:id="@+id/textInputEditTextConfirmPassword"
android:hint="@string/hint_confirm_password"

<android.support.v7.widget.AppCompatButton
android:id="@+id/appCompatButtonRegister"
android:background="@color/colorTextHint"
android:text="@string/text_register" />
android:id="@+id/appCompatTextViewLoginLink"
android:layout_width="fill_parent"
android:text="@string/text_already_member"
android:textSize="16dp" />
</android.support.v4.widget.NestedScrollView>
Ahora abrimos la clase java RegisterActivity ubicada en la carpeta

JAVA/NOMBRE_DOMINIO y adicionamos el siguiente código:
import android.support.annotation.Nullable;
import android.support.design.widget.Snackbar;
import android.support.v4.widget.NestedScrollView;
import android.support.v7.widget.AppCompatButton;
import android.support.v7.widget.AppCompatTextView;
// importamos las clases creadas de acuerdo al nombre de dominio del proyecto

import com.example.android.pets.helpers.InputValidation;
import com.example.android.pets.sql.DatabaseHelper;
import com.example.android.pets.R;
public class RegisterActivity extends AppCompatActivity implements View.OnClickListener {
private final AppCompatActivity activity = RegisterActivity.this;
private NestedScrollView nestedScrollView;

private TextInputLayout textInputLayoutName;

private TextInputLayout textInputLayoutEmail;
private TextInputLayout textInputLayoutPassword;
private TextInputLayout textInputLayoutConfirmPassword;
private TextInputEditText textInputEditTextName;

private TextInputEditText textInputEditTextEmail;
private TextInputEditText textInputEditTextPassword;
private TextInputEditText textInputEditTextConfirmPassword;
private AppCompatButton appCompatButtonRegister;

private AppCompatTextView appCompatTextViewLoginLink;
private InputValidation inputValidation;

private DatabaseHelper databaseHelper;
private User user;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
setContentView(R.layout.activity_register);
getSupportActionBar().hide();
initViews();
initListeners();
initObjects();
}
/**
* This method is to initialize views
*/
private void initViews() {
nestedScrollView = (NestedScrollView) findViewById(R.id.nestedScrollView);
textInputLayoutName = (TextInputLayout) findViewById(R.id.textInputLayoutName);

textInputLayoutEmail = (TextInputLayout) findViewById(R.id.textInputLayoutEmail);
textInputLayoutPassword = (TextInputLayout) findViewById(R.id.textInputLayoutPassword);
textInputLayoutConfirmPassword = (TextInputLayout)
findViewById(R.id.textInputLayoutConfirmPassword);
textInputEditTextName = (TextInputEditText) findViewById(R.id.textInputEditTextName);

textInputEditTextEmail = (TextInputEditText) findViewById(R.id.textInputEditTextEmail);
textInputEditTextPassword = (TextInputEditText) findViewById(R.id.textInputEditTextPassword);
textInputEditTextConfirmPassword = (TextInputEditText)
findViewById(R.id.textInputEditTextConfirmPassword);
appCompatButtonRegister = (AppCompatButton)
findViewById(R.id.appCompatButtonRegister);
appCompatTextViewLoginLink = (AppCompatTextView)
findViewById(R.id.appCompatTextViewLoginLink);
/**
* This method is to initialize listeners
*/

private void initListeners() {

appCompatButtonRegister.setOnClickListener(this);
appCompatTextViewLoginLink.setOnClickListener(this);
/**
* This method is to initialize objects to be used
*/
private void initObjects() {
inputValidation = new InputValidation(activity);
databaseHelper = new DatabaseHelper(activity);
user = new User();
/**
* This implemented method is to listen the click on view
*
* @param v
*/
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.appCompatButtonRegister:
postDataToSQLite();
break;
case R.id.appCompatTextViewLoginLink:
finish();
break;
}
}
/**
* This method is to validate the input text fields and post data to SQLite
*/
private void postDataToSQLite() {
if (!inputValidation.isInputEditTextFilled(textInputEditTextName, textInputLayoutName,
getString(R.string.error_message_name))) {
return;
}
if (!inputValidation.isInputEditTextFilled(textInputEditTextEmail, textInputLayoutEmail,
getString(R.string.error_message_email))) {
return;
}
if (!inputValidation.isInputEditTextEmail(textInputEditTextEmail, textInputLayoutEmail,
return;
}
if (!inputValidation.isInputEditTextFilled(textInputEditTextPassword, textInputLayoutPassword,
getString(R.string.error_message_password))) {
return;
}
if (!inputValidation.isInputEditTextMatches(textInputEditTextPassword,
textInputEditTextConfirmPassword,

textInputLayoutConfirmPassword, getString(R.string.error_password_match))) {
return;
}
if (!databaseHelper.checkUser(textInputEditTextEmail.getText().toString().trim())) {
user.setName(textInputEditTextName.getText().toString().trim());
user.setEmail(textInputEditTextEmail.getText().toString().trim());
user.setPassword(textInputEditTextPassword.getText().toString().trim());
databaseHelper.addUser(user);
// Snack Bar to show success message that record saved successfully

Snackbar.make(nestedScrollView, getString(R.string.success_message),
Snackbar.LENGTH_LONG).show();
emptyInputEditText();
} else {
// Snack Bar to show error message that record already exists
Snackbar.make(nestedScrollView, getString(R.string.error_email_exists),
}
/**
* This method is to empty all input edit text
*/
private void emptyInputEditText() {
textInputEditTextName.setText(null);
textInputEditTextEmail.setText(null);
textInputEditTextPassword.setText(null);
textInputEditTextConfirmPassword.setText(null);
}
}
h. Crear la clase para obtener datos de la BD
Esta clase nos permite validar obtener valores de la BD y colocarlos en las cajas de textos.
Para ello lo alojaremos en un paquete de ayuda llamado ―adapters‖
clic derecho sobre la carpeta java/tudominio y nuevo package:

Antes de copiar el código JAVA a la clase adaptador se requiere de un layout para

colocar temporalmente la información recibida para luego colocarla en los controles
necesarios por lo que se empleara cardview, para ello en la carpeta layout creamos el
archivo xml
item_user_recycler.xml

Copiamos el siguiente código:
<android.support.v7.widget.CardView
xmlns:card_view="http://schemas.android.com/apk/res-auto"
card_view:cardCornerRadius="4dp">
<LinearLayout
android:orientation="vertical"
android:padding="16dp">
<LinearLayout
android:orientation="horizontal">
android:layout_weight="2"
android:text="@string/hint_name"
android:textColor="@color/colorTextHint" />
android:id="@+id/textViewName"
android:text="@string/hint_name"
android:textColor="@android:color/darker_gray" />
</LinearLayout>
<LinearLayout

android:text="@string/hint_email"
android:id="@+id/textViewEmail"
android:text="@string/hint_email"
</LinearLayout>
<LinearLayout
android:text="@string/hint_password"
android:id="@+id/textViewPassword"
android:text="@string/hint_password"
</LinearLayout>
</LinearLayout>
</android.support.v7.widget.CardView>
El cardview es un componente nuevo que no "actualiza" un componente existente y

muestra información dentro de las tarjetas.
Ahora crearemos la clase llamada UsersRecyclerAdapter y adicionamos el siguiente

código.

import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.ViewGroup;
// tener encuenta el nombre de dominio que le puse al app

public class UsersRecyclerAdapter extends

RecyclerView.Adapter<UsersRecyclerAdapter.UserViewHolder> {
private List<User> listUsers;

public UsersRecyclerAdapter(List<User> listUsers) {

this.listUsers = listUsers;
}
@Override
public UserViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
// inflating recycler item view
View itemView = LayoutInflater.from(parent.getContext())
.inflate(R.layout.item_user_recycler, parent, false);
return new UserViewHolder(itemView);

}
@Override
public void onBindViewHolder(UserViewHolder holder, int position) {
holder.textViewName.setText(listUsers.get(position).getName());
holder.textViewEmail.setText(listUsers.get(position).getEmail());
holder.textViewPassword.setText(listUsers.get(position).getPassword());
}
@Override
public int getItemCount() {
Log.v(UsersRecyclerAdapter.class.getSimpleName(),""+listUsers.size());
return listUsers.size();
}
/**
* ViewHolder class
*/
public class UserViewHolder extends RecyclerView.ViewHolder {
public AppCompatTextView textViewName;

public AppCompatTextView textViewEmail;
public AppCompatTextView textViewPassword;
public UserViewHolder(View view) {

super(view);
textViewName = (AppCompatTextView) view.findViewById(R.id.textViewName);
textViewEmail = (AppCompatTextView) view.findViewById(R.id.textViewEmail);
textViewPassword = (AppCompatTextView) view.findViewById(R.id.textViewPassword);
}
}

i. Crear la Actividad Listado de Usuarios
Permite mostrar la información de la base sqlite, creamos la actividad UsersListActivity,

para ello clic derecho sobre la carpeta principal del proyecto y creamos una actividad
en blanco.
Colocamos el nombre
de la actividad y se
creará su layout, esta
acción creará la clase
java.

Al layout creado activity_user_list.xml adicionamos el siguiente código:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="150dp"
android:background="@color/colorPrimary"
android:text="@string/text_title"
android:textSize="20sp" />
android:text="@string/text_hello" />
android:id="@+id/textViewName"
android:layout_height="wrap_content" />
android:text="@string/text_accounts"
android:textColor="@android:color/black" />
<android.support.v7.widget.RecyclerView
android:id="@+id/recyclerViewUsers"
android:layout_height="match_parent" />
</LinearLayout>

A su clase java UsersListActivity.java copiamos el siguiente código:
import android.os.AsyncTask;
import android.support.v7.widget.DefaultItemAnimator;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
// tener en cuenta el nombre del dominio que coloco para el proyecto

import com.example.android.pets.adapters.UsersRecyclerAdapter;
import java.util.ArrayList;
public class UsersListActivity extends AppCompatActivity {
private AppCompatActivity activity = UsersListActivity.this;

private AppCompatTextView textViewName;
private RecyclerView recyclerViewUsers;
private List<User> listUsers;
private UsersRecyclerAdapter usersRecyclerAdapter;
@Override
setContentView(R.layout.activity_users_list);
getSupportActionBar().setTitle("");
initViews();
initObjects();
/**
*/
textViewName = (AppCompatTextView) findViewById(R.id.textViewName);
recyclerViewUsers = (RecyclerView) findViewById(R.id.recyclerViewUsers);
}
/**
*/
listUsers = new ArrayList<>();
usersRecyclerAdapter = new UsersRecyclerAdapter(listUsers);
RecyclerView.LayoutManager mLayoutManager = new

LinearLayoutManager(getApplicationContext());
recyclerViewUsers.setLayoutManager(mLayoutManager);

recyclerViewUsers.setItemAnimator(new DefaultItemAnimator());
recyclerViewUsers.setHasFixedSize(true);
recyclerViewUsers.setAdapter(usersRecyclerAdapter);
String emailFromIntent = getIntent().getStringExtra("EMAIL");

textViewName.setText(emailFromIntent);
getDataFromSQLite();
}
/**
* This method is to fetch all user records from SQLite
*/
private void getDataFromSQLite() {
// AsyncTask is used that SQLite operation not blocks the UI Thread.
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
listUsers.clear();
listUsers.addAll(databaseHelper.getAllUser());
return null;
}
@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
usersRecyclerAdapter.notifyDataSetChanged();
}
}.execute();
}
}

j. Colocamos código a la clase Java para el Logeo
Abrimos la clase java LoginActivity, para colocar su código
import android.support.design.widget.Snackbar;
import android.support.v4.widget.NestedScrollView;
import android.support.v7.widget.AppCompatButton;
// tener en cuenta el nombre del dominio del app

import com.example.android.pets.helpers.InputValidation;
public class RegisterActivity extends AppCompatActivity implements View.OnClickListener {
private final AppCompatActivity activity = RegisterActivity.this;
private NestedScrollView nestedScrollView;
private TextInputLayout textInputLayoutName;

private TextInputLayout textInputLayoutEmail;
private TextInputLayout textInputLayoutPassword;
private TextInputLayout textInputLayoutConfirmPassword;
private TextInputEditText textInputEditTextName;

private TextInputEditText textInputEditTextEmail;
private TextInputEditText textInputEditTextPassword;
private TextInputEditText textInputEditTextConfirmPassword;
private AppCompatButton appCompatButtonRegister;

private AppCompatTextView appCompatTextViewLoginLink;
private InputValidation inputValidation;

private User user;
@Override
setContentView(R.layout.activity_register);
getSupportActionBar().hide();
initViews();
initListeners();
initObjects();
}
/**


*/
nestedScrollView = (NestedScrollView) findViewById(R.id.nestedScrollView);
textInputLayoutName = (TextInputLayout) findViewById(R.id.textInputLayoutName);

textInputLayoutEmail = (TextInputLayout) findViewById(R.id.textInputLayoutEmail);
textInputLayoutPassword = (TextInputLayout) findViewById(R.id.textInputLayoutPassword);
textInputLayoutConfirmPassword = (TextInputLayout)
findViewById(R.id.textInputLayoutConfirmPassword);
textInputEditTextName = (TextInputEditText) findViewById(R.id.textInputEditTextName);

textInputEditTextEmail = (TextInputEditText) findViewById(R.id.textInputEditTextEmail);
textInputEditTextPassword = (TextInputEditText) findViewById(R.id.textInputEditTextPassword);
textInputEditTextConfirmPassword = (TextInputEditText)
findViewById(R.id.textInputEditTextConfirmPassword);
appCompatButtonRegister = (AppCompatButton)
findViewById(R.id.appCompatButtonRegister);
appCompatTextViewLoginLink = (AppCompatTextView)
findViewById(R.id.appCompatTextViewLoginLink);
/**
* This method is to initialize listeners
*/
private void initListeners() {
appCompatButtonRegister.setOnClickListener(this);
appCompatTextViewLoginLink.setOnClickListener(this);
/**
*/
inputValidation = new InputValidation(activity);
user = new User();
/**
* This implemented method is to listen the click on view
*
* @param v
*/
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.appCompatButtonRegister:
postDataToSQLite();
break;

case R.id.appCompatTextViewLoginLink:
finish();
break;
}
}
/**
* This method is to validate the input text fields and post data to SQLite
*/
private void postDataToSQLite() {
if (!inputValidation.isInputEditTextFilled(textInputEditTextName, textInputLayoutName,
getString(R.string.error_message_name))) {
return;
}
if (!inputValidation.isInputEditTextFilled(textInputEditTextEmail, textInputLayoutEmail,
return;
}
if (!inputValidation.isInputEditTextEmail(textInputEditTextEmail, textInputLayoutEmail,
return;
}
if (!inputValidation.isInputEditTextFilled(textInputEditTextPassword, textInputLayoutPassword,
getString(R.string.error_message_password))) {
return;
}
if (!inputValidation.isInputEditTextMatches(textInputEditTextPassword,
textInputEditTextConfirmPassword,
textInputLayoutConfirmPassword, getString(R.string.error_password_match))) {
return;
}
if (!databaseHelper.checkUser(textInputEditTextEmail.getText().toString().trim())) {
user.setName(textInputEditTextName.getText().toString().trim());
user.setEmail(textInputEditTextEmail.getText().toString().trim());
user.setPassword(textInputEditTextPassword.getText().toString().trim());
databaseHelper.addUser(user);
// Snack Bar to show success message that record saved successfully

Snackbar.make(nestedScrollView, getString(R.string.success_message),
emptyInputEditText();
} else {
// Snack Bar to show error message that record already exists
Snackbar.make(nestedScrollView, getString(R.string.error_email_exists),
}
/**
* This method is to empty all input edit text
*/

private void emptyInputEditText() {

textInputEditTextName.setText(null);
textInputEditTextEmail.setText(null);
textInputEditTextPassword.setText(null);
textInputEditTextConfirmPassword.setText(null);
}
}
k. Configuramos el proyecto
Abrimos el archivo manifests para adicionar la actividad que hemos creado, adicionar
estos códigos debajo de la actividad splash:


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

</intent-filter>
</activity>


<activity
android:name=".RegisterActivity"
android:screenOrientation="portrait" />


<activity
android:name=".UsersListActivity"
android:screenOrientation="portrait" />
Cambiar las intenciones en la clase splash.java para que llame a la siguiente actividad
que es Loginactivity.class
Intent intent = new Intent(getApplicationContext(),LoginActivity.class);

l. Adicionando un Item al Menú
El Proyecto app Mascotas tiene un menú en el cual podremos registrar una mascota y
adicionar un registro, podemos adicionar más ítems, en este caso dado que hemos
colocado un login tenemos una relación de usuarios, ya que hemos creado la actividad
para ello faltaría usarla, colocando un ítem más al menú existente, para esto realizamos lo
siguiente:
En la clase CatalogActivity.java Adicionamos un item del menú:

public boolean onOptionsItemSelected(MenuItem item)
case R.id.action_lista_usuarios:
Intent Catalogousuarios = new Intent(getApplicationContext(),

UsersListActivity.class);
startActivity(Catalogousuarios);
return true;
En la actividad menu_catalogo.xml adicionamos el ítem:
<item
android:id="@+id/action_lista_usuarios"
android:title="@string/action_lista_usuarios"
app:showAsAction="never" />

http://www.androidtutorialshub.com/android-login-and-register-with-sqlite-database-
tutorial/
Para manejar la concurrencia de múltiples usuarios a la app es mediante GAE, que es la

clusterizacion
Revisar :
Intenciones y service providers
Clase 3: Referencias de controles y paquetes; Eventos en controles,

reconstruir un proyecto.
REFERENCIAR VALORES AL NOMBRE DE CONTROLES

Podemos hacer los nombres de los controles de manera que sea configurable y
no este en duro para ello creamo primero las variables en la carpeta res/values
archivo string.xml
<resources>
<string name="app_name">Hello FISI</string>
<string name="button_label_toast">Toast</string>
<string name="button_label_count">Count</string>
<string name="count_initial_value">0</string>
<string name="toast_message">Hello Toast!</string>
</resources>
Luego en el layout res/layout archivo activity_main.xml vista de texto cambiar al

propiedad text del control, para ello borramos el contenido en duro e iniciamos a
referenciar su valor con una @ esta mostrarà un listado de cadenas.
android:text="@string/button_label_toast"
Programando Los Eventos De Los Botones

Para ello debemos adicionar un evento al botón, entramos al layout que contiene en vista
de texto nos posicionamos a la estructura del control y adicionamos la línea que contiene
el evento ―showtoast‖:
<Button
… android:onClick="showToast" />
La programación de este evento se hace en el main activity al que hace referencia el

layout

<android.support.constraint.ConstraintLayout …… tools:context=".MainActivity">
Abrimos el archivo java y agregamos la estructura de las funciones, primero debemos

importar la interacción de vistas para el procedimiento
package com.example.cenpro_pc.hellotoast6;
import android.view.View; //referencia a la vista
public class MainActivity extends AppCompatActivity {

…
En caso de errores compilación volver a construir la aplicación, ir al menú build/

make Project ò Ctrl + F9
Ninjamock
Es un Diseñador de layout. wireframe and mockup tool
Intents
Cuando se emplea:
Cuando empleamos una actividad, servicio, broacast
Para su uso se debe importar el paquete:
import android.content.Intent;

Clase 4: Uso de GIT, componentes de Android.
TEMARIO
GIT
Intenciones de la guía
Compilar proyectos completos
Diseñar app de venta de libros
Componentes en Android:
- Actividades
- Servicios
- Content provider
- Consumidores (service provider)
1. Git (repositorio)
4.1 Configurar cuenta de github:
Setting -> versión control -> github

Creamos el token
Clic en share
Aceptar el token enviado a la cuenta de github
https://github.com/settings/tokens
(compartir)

4.2 Descargar proyectos desde repositorio GIT
https://github.com/bfpalacios/APPMOVILCITAS
https://github.com/bfpalacios/DISDOC_MOVIL
https://github.com/bfpalacios/SEGSIL_MOVIL
USER GITHUB: torvic020

https://github.com/torvic020/ANDROID.git

instalar git y reiniciar android
Testiar el enlace
Base de datos
Firebase, Versiones:
Realtime: bd no sql , en árbol, versión antigua, es más lenta
El proyecto de citas esta hecho en esta versión.
Fire store: bd no sql, se organiza en documentos y listas.
Al cargar los proyectos verificar la versión mínima de emulador
SEGSIL_MOVIL (seguimiento de silabus)

Pass: 1 al 6
SEGSIL_MOVIL (seguimiento de silabus)
DOCKER: Maneja servicios para las múltiples concurrencias mediante cluster.
JSON para servicios rest
Creamos repositorio en la web
https://github.com/new

4.3 Compartir un proyecto en GitHub
Creamos el proyecto laboratorio4 para subirlo al git
1. Creamos el repositorio
2. Subimos el proyecto mediante el menú VSC ->import into versión control ->
share Project on github

Configuramos correo de github en android
En la pc pueden existir otros proyectos vinculados a cuentas específicas de github

al abrirlo puede ocasionar error, pero para cargar nuestra app a la web de github
debemos cambiar la cuenta, para ello haremos uso de comandos.
git config --global
user.email
"mike@gmail.com"
git config --global
user.name "mike"
4.4 Actualizar
proyecto en github

En caso que necesitemos volver a cargar el proyecto por causas de un error, se

debe eliminar el acceso remoto. GIT -< Remotes


TIPOS COMPONENTES
Actividades
Servicios
Servicios de contenido
LINK del pdf de clase con sus link activados
https://codelabs.developers.google.com/codelabs/android-training-create-an-
activity/index.html?index=..%2F..%2Fandroid-training#6
Importar proyecto de GIThub
https://github.com/google-developer-training/android-fundamentals-apps-
v2/tree/master/TwoActivities
Web de todos los proyectos del manual
https://github.com/google-developer-training/android-fundamentals-apps-v2

Abrir el proyecto twoactivities

 Revisar la versión de AVD (Administrado de dispositivos virtuales) a emplear
ir a la carpeta : gradle scripts -> build.gradle (module app)
 Abrir el archivo activity_main.xml

Para ver el comportamiento de los 2 activity
Ir a al evento del botón
<Button
android:onClick="launchSecondActivity"
control + clic sobre el nombre de la vista para abrir el

archivo java vinculado mainactivity.java.
Uso de intenciones entre vistas
// vista EditText para mensajes aquí se alojara la clase

editText_main
private EditText mMessageEditText;
Public void launchSecondActivity(View view) {
startActivityForResult(intent, TEXT_REQUEST);
}
captura el valor del control de acuerdo al id definido
<EditText
android:id="@+id/editText_main"
Clase R
Se aloja en generatedJava -> com.example.android.twoactivities->R
Próxima clase
Aplicativos para diseñar Pantallas en NinjaMock

Clase 5: Uso de SCRUM para proyectos, Arquitectura de proyectos Android.
Principios
Scrum Alliance
Scrum org
Scrum study
Metodologías de proyectos, Con ellos las entregas se minimizan a 6 entregables.
En RUP el ciclo comprende:
 Análisis
 Diseño
 Construcción
 Pruebas
Para documentar se emplea la app web como trello o desktop TFS
Artefactos Scrum
Para ser catalogado como proyecto ágil, se necesita:
1. VISION
2. Product Backlog: todas tareas que involucran el desarrollo, ejemplo 100 tareas se le
puede asignar pesos, estas se escriben en cartas de cartulina.
3. Sprint: tiempo de entrega del producto, de 4 a 6 semanas de duración del sprint
Del ejemplo si son 6 sprint, lo dividimos entre las tareas para agruparlas.
4. Product Backlog priorizado
De la relación de sprint de prioriza por tareas complejas
Ejemplo:
Sprint 1: 17 tareas (+ complejas)
Sprint 2: 16 tareas (- complejas)
Documento a entregar: historia de usuarios.
Scrum meeting, permite interrelacionarse con el equipo, dura 10min max..
Roles de Scrum:
 Scrum master: facilitador, líder que lleva el proyecto. Participa en lo meeting.

 Product owner: usuario o dueño del producto (alguien que conoce del negocio)
 Scrum team: formado por AP, Analista, DBDA, Arquitecto.
 Stakeholder: los interesados en el producto o usuario final.

Dar examen de Scrum: https://www.scrumstudy.com/
Certificados:
 SFC – Fundamentos ($0)

 SDC - Developement ($200)
 SMC – Master ($400)
 POC – Owner ($370)
 Professional I (2 días)
 Professional II (2 días)

PROYECTO: APP Mascotas con SQLite, base de datos local en el movil.
TAREA:
 Colocar splash de san marcos al app mascotas

 Login
 Dimensionar para tableta la app de encuentas venecos.
 Publicar en la Play store
Esta aplicación puede reenviar su datos a la nube en BD no sql, esto se realiza mediante
REST (.jar) la cual es el nexo entre los datos JSON de la bd sqlite
ARQUITECTURA:
SERVER BD
Servicio: NO SQL
SQLlite
JSON REST Firebase
APP Google
D .JAR AWS (amazon)
MOVIL A AZURE
T
A
Comunicación en entre BD ORACLE y una APP Movil
SERVER web
APP
Tomcat
MOVIL SERVER BD
Jboss
weblogic ORACLE
SQL

D
A
T Servicio:
A REST
SOAP
W.S
.WAR
Cud (crea, edita y elimina)
REVISAR:
LA VERSION DE SDK:
DEPENDENCIAS: de librerias para la base datos
Ir lal archivo androindManisfest.xsml
<activity
android:name=".CatalogActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
Abrir el modulo para conezion a base datos
CatalogActivity
Abrir CatalogActivity.java
Ir a la referencia al layout CatalogActivity
PROYECTO FINAL: SISTEMA DE VENTAS DE LIBROS UNMSM
VISION: venta de libros a la comunidad san marquina.
Identificar los stakeholder:
(profesores, alumnos y admnistrativos) , el administrador, Tesorera.
Estos usuarios se convertiran en arboles no sql.
Funcionalidad:
1. Login, Crear usuarios

2. Visualizar libros por texto

3. Mostar una lista de 5 libros en cada layout. (filtro intuitivo de acuerdo a edad)
4. Detalle del libro: autor, año, descripcion, codigo ISBN, precio, pagar.
a. Pantalla encriptada de pago (java)
5. Envio por correo (pago exitoso)
PRODUCT BACKLOG:

SPRINT Nombre de Tarea Descripción TIPO Responsable

HU - Gestion de usuario permitir desarrollar Requierimient
pantallas y o
modulo de
aceptacion del
modulo de
1 HU - Visualizacion de libros usuarios

Determina los dennith
datos necesario
para poder
desarrollar esta
funcionalidad
1 HU - Pago con v isa detalle del pago a Bruno
realizar para la
compra del libro
confirmaciòn del
HU - Confirmaciòn del pago e env io del
1 producto correo
1 Creaciòn de datos para documento de
firebases analisis de arboles
a crear
2 Programacion de las HU Desarrollo de las
HU en Android
2 Creaciòn de Arboles en Desarrollo de
firebase Arboles en firebase
1 Creación de Prototipos Pantallas de bajo
niv el para la
creacion del
sistema
Clase 6: Proyecto final, Mockup, Scrum

Verificamos las pantallas creadas seguna los spring asignados en SCRUM
Maquetas de pantallas
Dos opciones:
 Crear cuenta web en: https://ninjamock.com/account/login
User: correo
Pass: dnitani
 emplear Balsamiq Mockups Project, aplicacion de escritorio
https://balsamiq.com/wireframes/desktop/#
Proyecto final
ARQUITECTURA
Data
Presentación Firebase
Get: listar obtener

REST Post: Crear, escribir
APK BD AUTH
JSON HOST STORAGE

(tramas posicionales) LIB
REST
(Este paquete de conexión lo maneja GRADLE)
APK: es el empaquetado que contiene .class que son archivos compilados, los .apk no se
ejecuta sino se interpreta mediante las maquina virtuales.
Sqlite: es data estática.
Google es el propietario de Android y Data Firebase
BASE DE DATOS: Amazon, AWS, Microsoft Azure, Red Hat Open Shift.

El tipo Firebase tiene:
BD: contiene los documentos q son los datos
Realtime: es menos rápido el acceso de información. El sistema de citas usa esta base
datos, pero para aumentar el tiempo de transacción emplea Kunernetes, el cual maneja
clusterización, en donde la petición lo convierte en ½ petición.
Asociar proyectos a Firebase
 Crear proyecto en la web firebase

 Tener el ID de la aplicación, el cual es el nombre del dominio que uno coloca al
crear al app. Esto lo crear el gradle
Entrar a build.gradle
android {
compileSdkVersion 27
defaultConfig {
applicationId "pe.edu.unmsm.sistemas.appclinica"
minSdkVersion 21
targetSdkVersion 27
versionCode 21
versionName "2.1"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

}
}
}
 Tener una carpeta JSON, esta permite también conectarse a base de datos
normalizadas como Oracle, SQL Server
App web
 Capara de presentación
 CaPA Controlador
 Capa de Negocio
 Capa acceso de datos (hacia una BD o Rest, SOAP)
FIREBASE - realtime
Revisaremos el app de reserva de citas

Ingresar a la consola de firebase:
FIREB
ASE -
REAL reservaci tp2.2018i.reservacitas.un https://console.firebase.google.com/u/1/project/reserv
TIME tas@$ msm@gmail.com a-de-cit/database/reserva-de-cit/data
GOO
GLE
APP
ENGI reservaci tp2.2018i.reservacitas.un https://console.cloud.google.com/home/dashboard?a
NE tas@$ msm@gmail.com uthuser=2&hl=es&project=reserva-de-cit

Para crear documentos (tablas) colocarse sobre el

nombre de la bd y clic en +
Para autentificarse a cuentas para que la app cargue

FIREBASE - Document
Abrimos la BD de seguimiento de silabus
https://accounts.google.com/ServiceLogin/signinchooser?passive=1209600&osid=
1&continue=https%3A%2F%2Fconsole.firebase.google.com%2F&followup=https%3
A%2F%2Fconsole.firebase.google.com%2F&flowName=GlifWebSignIn&flowEntry=S
erviceLogin
Fireb fisi.segsil.2018@ sistemas https://console.firebase.google.com/u/1/project/proyectosegsil

ase gmail.com 2018 /database/firestore/data~2Fusuarios
Proyecto SEGSIL_MOVIL
Pass: 1 al 6

Creación de base nueva:
Apuntes de Ing. Victor Ybañez R., MPM 100 de

106
https://console.firebase.google.com/u/1/
Creamos el proyecto android, vamos al gradle para ver el id creado.
android {
compileSdkVersion 28
defaultConfig {
applicationId
"pe.edu.unmsm.libroscentroprduccion.ventavirtuallibrossanmarcos"
minSdkVersion 15
targetSdkVersion 28
versionCode 1
versionName "1.0"
testInstrumentationRunner
"android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'),
'proguard-rules.pro'
}
}
}
Sincronizamos la app con el firestore

106
pe.edu.unmsm.libroscentroprduccion.ventavirtuallibrossanmarcos
LA CADENA DE CONEXIÓN al servicio CREADA EN JSON se deberá copiar al

proyecto

106
En la app copiar el código:
C++
El complemento de los servicios de Google para Gradle carga el archivo google-

services.json que acabas de descargar. Para utilizar dicho complemento, debes modificar tus
archivos build.gradle.
Build.gradle de nivel de proyecto (<proyecto>/build.gradle):
content_copy
Copiar
buildscript {
dependencies {
// Add this line
classpath 'com.google.gms:google-services:4.0.1'
}
}
Build.gradle de nivel de aplicación (<proyecto>/<app-module>/build.gradle):
content_copy
Copiar
content_copy
Copiado
dependencies {
// Add this line
implementation 'com.google.firebase:firebase-core:16.0.1'
}
...
// Add to the bottom of the file
apply plugin: 'com.google.gms.google-services'
Incluye Analytics de forma predeterminada help_outline
Por último, pulsa Sincronizar ahora en la barra que aparece en el IDE:
Compilar el apk y logearse para que recién puede el firebase conectare

106
SI NO muestra el ACCESO a FIREBASE, hay q instalar el plugin

106
Líneas de conexión para firebase
firebaseAuth = FirebaseAuth.getInstance();
db = FirebaseFirestore.getInstance();

106

106

Aprendiendo Android

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Aprendiendo Android

Cargado por

Copyright:

Formatos disponibles

Curso ANDROID – FISI UNMSM Prof. Ing.

Apuntes de Ing. Victor Ybañez R., MPM 1 de 106

4.2 Descargar proyectos desde repositorio GIT ........................................................81

Apuntes de Ing. Victor Ybañez R., MPM 2 de 106

Clase 1: Introducción a JAVA y carga de Andorid

Crear cuenta en google play us$ 25.00

Para desarrollar se requiere emplear el JDK completo

Apuntes de Ing. Victor Ybañez R., MPM 3 de 106

Enviar correo con cuenta GIT:

Nace para el funcionamiento de cámaras.

La versión óptima de android para colocar como requisito mínimo de sistema

SOAP (Simple Object Access Protocol)

Apk -- XML -- WebService --- BD (marquis, Roya)

Y esta sería la respuesta del proveedor:

Apuntes de Ing. Victor Ybañez R., MPM 4 de 106

REST (Representational State Transfer)

APK -- tramas Json ---- BD (No SQL, firebase)

Componentes de la estructura de una aplicación android

Resolver laboratorio de java en eclipse. MJAVA1.LAB_1

Apuntes de Ing. Victor Ybañez R., MPM 5 de 106

Apuntes de Ing. Victor Ybañez R., MPM 6 de 106

Apuntes de Ing. Victor Ybañez R., MPM 7 de 106

Apuntes de Ing. Victor Ybañez R., MPM 8 de 106

Apuntes de Ing. Victor Ybañez R., MPM 9 de 106

Apuntes de Ing. Victor Ybañez R., MPM 10 de 106

Apuntes de Ing. Victor Ybañez R., MPM 11 de 106

Apuntes de Ing. Victor Ybañez R., MPM 12 de 106

Apuntes de Ing. Victor Ybañez R., MPM 13 de 106

Apuntes de Ing. Victor Ybañez R., MPM 14 de 106

Clase 2: Estructura Proyecto Android y carga de Emuladores

Pre requisitos para Android:

● Java Programming Language

● XML - properties / attributes (clase - valor)

● Using an IDE for development and debugging

Las app generan un .log que es un archivo de bitacora

Un debug se hace en etapa de desarrollo, compilándola paso a paso para ver

Ides para Android

Apuntes de Ing. Victor Ybañez R., MPM 15 de 106

archivos de compilación de Gradle, donde especifica la versión de VD a emplear

● Buenas prácticas para nombrar proyectos y las páginas:

○ Nombre del menu de actividades: MainActivity

○ Nombre de los diseñadores (layout): activity_main

2.1 Como funciona un proyecto android

a. Manifests: es el archivo principal, contiene el comando intent-filter

Apuntes de Ing. Victor Ybañez R., MPM 16 de 106

Podemos debugger el log

Log.d(TAG, ―Creating the URI…‖);

Material del curso en el driver

Apuntes de Ing. Victor Ybañez R., MPM 17 de 106

Apuntes de Ing. Victor Ybañez R., MPM 18 de 106

Apuntes de Ing. Victor Ybañez R., MPM 19 de 106

El manifest es el archivo principal, contiene el comando intent-filter

Apuntes de Ing. Victor Ybañez R., MPM 20 de 106

java: contiene la llamada a los layout de la aplicación, las cuales se compilarán.

compilar el app elegimos otro recurso y elegimos el tipo de dispositivo

Apuntes de Ing. Victor Ybañez R., MPM 21 de 106

Seleccionamos la versión de Android: icecream = android 4.0.3

Apuntes de Ing. Victor Ybañez R., MPM 22 de 106

Para Ver el sitio de descarga del sdk

Apuntes de Ing. Victor Ybañez R., MPM 23 de 106

Seleccionamos la orientación del dispositivo

Tomar la consideración de descargar las imágenes de emuladores de acuerdo a la