Johnattan Jaramillo G.
jjaramillo238@misena.edu.co
1- Introducción
2- Layouts y widgets
3- Actividades y fragmentos
4- Almacenamiento local
5- Almacenamiento remoto
6- Material design
7- Publicación y marketing de apps
Es un grupo de vistas (ViewGroup) que muestra una lista de elementos desplazable
Los elementos de la lista son insertados de un origen de datos usando un adaptador de clase (Class Adapter)
Origen de Datos
Adaptador
ListView
ORIGEN DE DATOS (DATA SOURCE)
ADAPTADOR (ADAPTER)
VISTA DE ADAPTADOR (LISTVIEW)
1- Definir el origen de datos (array)
ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, dias);
2- Definir el adaptador y proporcionarle
String[] dias = {"Domingo","Lunes","Martes","Miércoles","Jueves","Viernes","Sábado"};
3- Establecer el adaptador del ListView
ListView lv = (ListView) findViewById(R.id.idListView);
lv.setAdapter(adapter);
4- Asociar un onItemClickListener para definir que acción se debería ejecutar al momento de dar click sobre un elemento de la lista
lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView adapterView, View view, int i, longo l){
//Acciónes a ejecutar al seleccionar el elemento
}
}
1- Preparar los orígenes de datos
2- Crear un layout personalizado (custom_row.xml) el cual definirá como los elementos de la lista aparecerán en cada fila.
String[] artistas = {"Nach","ZPU","Canserbero","Lil Supa","Rocca"};
String[] descripciones = {"MC Español","MC Español","MC Venezolano","MC Venezolano","MC Colombiano"};
int [] imagenes ={R.drawable.img1,R.drawable.img2,R.drawable.img3,R.drawable.img4,R.drawable.img5};
<?xml version="1.0" encoding="utf-8" ?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ImageView android:id="@+id/idImagen"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/ic_launcher" />
<TextView android:id="@+id/idArtista"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Artista"
android:textSize="20sp"
android:layout_toRightOf="@id/idImagen"/>
<TextView android:id="@+id/idDescripcion"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Descripción"
android:layout_below="@id/idArtista"
android:layout_toRightOf="@id/idImagen"/>
</RelativeLayout>
3- Definir un adaptador personalizado (Custom Adapter) que extienda el adaptador por defecto (Array Adapter) ya que el adaptador por defecto muestra solo un TextView en cada fila
4- Crear una clase de Java (Custom Adapter) que extienda de la clase del adaptador por defecto (Array Adapter)
5- Sobrescribir el constructor por defecto del adaptador por defecto (Array Adapter)
6- Inflar el layout personalizado en el método getView() el cuál obtendrá la vista de una posición específica
7- Obtener referencias a objetos de la vista (XML) y asignarle a cada uno un elemento de la lista (Data Source)
class MyAdapter extends ArrayAdapter{
int[] arrayImagenes;
String[] arrayArtistas;
String[] arrayDescripciones;
public MyAdapter(Context context, String[] artistas, String[] descripciones, int[] imagenes){
//Sobrescribir el constructor por defecto del ArrayAdapter
super(context, R.layout.custom_row,R.idArtista,artistas);
this.arrayImagenes = imagenes;
this.arrayArtistas = artistas;
this.arrayDescripciones = descripciones;
}
@NonNull
@Override
public View getView(int position, View convertView, ViewGroup parent){
//Inflar el layout
LayoutInflater inflater = (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View row = inflater.inflate(R.layout.custom_row,parent,false);
//Obtener la referencia a los objetos de la vista
ImageView myImage = (ImageView) row.findViewById(R.id.idImagen);
TextView myArtist = (TextView) row.findViewById(R.id.idArtista);
TextView myDescription = (TextView) row.findViewById(R.id.idDescripcion);
//Proporcionar un elemento del arreglo especificando su posición
myImage.setImageResource(arrayImagenes[position]);
myArtist.setText(arrayArtistas[position]);
myDescription.setText(arrayDescripciones[position]);
return row;
}
}
MyAdapter adapter = new MyAdapter (this, artistas, descripciones, imagenes);
8- Definir el adaptador personalizado y proporcionarle sus parámetros
9- Establecer el adaptador del ListView
ListView lv = (ListView) findViewById(R.id.idListView);
lv.setAdapter(adapter);
<?xml version="1.0" encoding="utf-8" ?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:id="@+id/idLayout">
<ExpandableListView android:id="@+id/idListView"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
</LinearLayout>
1- Crear archivo XML con el ExpandableListView
<?xml version="1.0" encoding="utf-8" ?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:id="@+id/idLayout">
<TextView android:id="@+id/idTitle"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Title"
android:padding="2dp"/>
</RelativeLayout>
2- Crear archivo XML para mostrar el encabezado de categorías (Categories header)
<?xml version="1.0" encoding="utf-8" ?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:id="@+id/idLayout">
<TextView android:id="@+id/idChildItem"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Child"
android:padding="2dp"/>
</RelativeLayout>
3- Crear archivo XML para mostrar los elementos de cada categoría (Categories items)
4- Crear una clase de Java (Adapter Class) que extienda de la clase base del adaptador de lista expandible (BaseExpandableListAdapter) e implemente todos sus métodos
package sena.android.com.expandablelistview;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseExpandableListAdapter;
public class MyAdapter extends BaseExpandableListAdapter{
@Override
public int getGroupCount(){
return 0;
}
@Override
public int getChildrenCount(int i){
return 0;
}
@Override
public Object getGroup(int i){
return null;
}
@Override
public Object getChild(int i, int i1){
return null;
}
@Override
public Object getGroupId(int i){
return 0;
}
@Override
public Object getChildId(int i, int i1){
return 0;
}
@Override
public boolean hasStableIds(){
return false;
}
@Override
public View getGroupView(int i, boolean b, View view, ViewGroup viewgroup){
return null;
}
@Override
public View getChildView(int i, int i1, boolean b, View view, ViewGroup viewgroup){
return null;
}
@Override
public boolean isChildSelectable(int i, int i1){
return false;
}
}
5- Sobrescribir el constructor por defecto (Default Constructor) de la clase adaptador (Adapter Class) con tres parámetros
private Context ctx;
private HashMap<String,List<String>> ChildTitles;
private List<String> HeaderTitles;
MyAdapter(Context ctx, HashMap<String,List<String>> ChildTitles, List<String> HeaderTitles){
this.ctx=ctx;
this.ChildTitles = ChildTitles;
this.HeaderTitles = HeaderTitles;
}
6- Pasar la cuenta del encabezado de categorías (Categories header) en el método getGroupCount()
public int getGroupCount(){
return HeaderTitles.size();
}
7- Pasar la cuenta de los elementos de las categorías (Categories items) de cada encabezado de grupo (Group header) en el método getChildrenCount()
public int getChildrenCount(int i){
return ChildrTitles.get(HeaderTitles.get(i)).size();
}
8- Pasar la posición de cada vista de encabezado (Header view)
public Object getGroup(int i){
return HeaderTitles.get(i);
}
9- Pasar la posición de cada elemento hijo (Children) para cada vista de encabezado (Header view) respectiva
public int getChild(int i, int i1){
return ChildTitles.get(HeaderTitles.get(i)).get(i1);
}
10- Inflar el layout para la vista de encabezado (HeaderView) y las vistas de elementos (ChildViews).
Convertir las vistas XML en objetos de Java
public View getGroupView(int i, boolean b, View view, ViewGroup viewGroup){
String title = (String) this.getGroup(i);
if(view == null){
LayoutInflater inflater = (LayoutInflater) this.ctx.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
view = inflater.inflate(R.layout.custom_header, null);
}
TextView txt = (TextView) view.findViewById(R.id.idTitle);
txt.setTypeface(null, Typeface.BOLD);
txt.setText(title);
return view;
}
public View getChildView(int i, int i1, boolean b, View view, ViewGroup viewGroup){
String child = (String) this.getChild(i, i1);
if(view == null){
LayoutInflater inflater = (LayoutInflater) this.ctx.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
view = inflater.inflate(R.layout.custom_child, null);
}
TextView txt = (TextView) view.findViewById(R.id.idChildItem);
txt.setText(child);
return view;
}
11- Crear el proveedor de datos (DataProvider) para proporcionar la información a las vistas
public class DataProvider {
public static HashMap> getInfo(){
HashMap> HeaderDetails = new HashMap>();
List ChildDetails1 = new ArrayList();
ChildDetails1.add("This id Children11");
ChildDetails1.add("This id Children12");
ChildDetails1.add("This id Children13");
ChildDetails1.add("This id Children14");
List ChildDetails2 = new ArrayList();
ChildDetails2.add("This id Children21");
ChildDetails2.add("This id Children22");
ChildDetails2.add("This id Children23");
ChildDetails2.add("This id Children24");
List ChildDetails3 = new ArrayList();
ChildDetails3.add("This id Children31");
ChildDetails3.add("This id Children32");
ChildDetails3.add("This id Children33");
ChildDetails3.add("This id Children34");
List ChildDetails4 = new ArrayList();
ChildDetails4.add("This id Children41");
ChildDetails4.add("This id Children42");
ChildDetails4.add("This id Children43");
ChildDetails4.add("This id Children44");
HeaderDetails.put("Header 1",ChildDetails1);
HeaderDetails.put("Header 2",ChildDetails2);
HeaderDetails.put("Header 3",ChildDetails3);
HeaderDetails.put("Header 4",ChildDetails4);
return HeaderDetails;
}
}
MyAdapter adapter = new MyAdapter (this, myHeader, MyChild);
13- Definir el adaptador personalizado y proporcionarle sus parámetros
14- Establecer el adaptador del ListView
ExpandableListView expList = (ExpandableListView ) findViewById(R.id.idListView);
expList.setAdapter(adapter);
HashMap> myHeader = DataProvider.getInfo();
List myChild = new ArrayList(myHeader.keySet());
12- Preparar origen de datos (Data Source)
<?xml version="1.0" encoding="utf-8" ?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:id="@+id/idLayout">
<GridView android:id="@+id/idGridView"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:numColumns="2"/>
</LinearLayout>
1- Agregar el GridView en el archivo XML
String[] data = {"data1","data2","data3","data4","data5","data6","data7","data8"};
2- Crear el origen de datos (Data Source) para el GridView en la actividad (Activity)
3- Instanciar el GridView XML en un objeto de Java
GridView gridView = (GridView) findViewById(R.id.idGridView);
4- Definir un adaptador (Adapter) para el GridView y asignárselo
ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout_simple_list_item1,data);
gridView.setAdapter(adapter);
<?xml version="1.0" encoding="utf-8" ?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:id="@+id/idLayout">
<WebView android:id="@+id/idWebView"
android:layout_width="fill_parent"
android:layout_height="fill_parent"/>
</LinearLayout>
1- Agregar el elemento <WebView> en el archivo XML
WebView browser = (WebView) findViewById(R.id.idWebView);
2- Instanciar el WebView XML en un objeto de Java
3- Asignar la URL del WebView
browser.loadUrl("https://www.google.com.co");
<manifest>
<uses-permission android:name="android.permission.INTERNET" />
</manifest>
WebView browser = (WebView) findViewById(R.id.idWebView);
WebSettings webSettings = browser.getSettings();
webSettings.setJavaScriptEnabled(true);
Es una vista que proporciona una interfaz de usuario que permite ingresar una búsqueda y enviar la solicitud a un proveedor de búsquedas
<?xml version="1.0" encoding="utf-8" ?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:id="@+id/idLayout">
<SearchView android:id="@+id/idSearchView"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:iconifiedByDefault="false">
<requestFocus />
</SearchView>
</LinearLayout>
1- Agregar el elemento <SearchView> en el archivo XML
SearchView searchView = (SearchView) findViewById(R.id.idSearchView);
2- Instanciar el SearchView XML en un objeto de Java
3- Ejecutar la consulta y agregar el método setOnQueryTextListener() al searchView
searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener(){
@Override
public boolean onQueryTextSubmit(String s){
return false;
}
@Override
public boolean onQueryTextChange(String s){
return false;
}
});
Android proporciona diferentes opciones para manejar la persistencia de los datos de la aplicación
Depende de las necesidades, escogeremos que opción de almacenamiento es más conveniente para los nuestros datos
Preferencias compartidas
Almacena información privada en pares clave-valor
Almacenamiento Interno
Almacena información privada en la memoria del dispositivo
Almacenamiento Externo
Almacena información pública en el almacenamiento externo compartido
Base de datos SQLite
Almacena información estructurada en una base de datos privada. Permite guardar la información en tablas relacionadas
Remoto
Almacena información en tu propio servidor
Almacena información privada en pares clave-valor
Usuario
Contraseña
admin
123
Clave (key)
Valor (value)
data/data/<nombre_paquete>/shared-prefs
La información se almacena en un archivo XML en el directorio
Existen dos métodos para obtener un objeto con las preferencias de usuario
Modos de operación
MODE_PRIVATE
0 - Por defecto. Solo la aplicación puede acceder al archivo
Modo
Uso
MODE_READABLE
MODE_WRITEABLE
MODE_MULTI_PROCESS
Todas las aplicaciones pueden leer el archivo
Todas las aplicaciones pueden escribir el archivo
Múltiples procesos pueden modificar el mismo archivo de preferencias compartidas
getPreferences(int mode);
1- Obtener una referencia al objeto de preferencias compartidas
getSharedPreferences(String name, int mode);
2- Llamar al editor
SharedPreference.Editor editor = sharedpreferences.edit();
editor.putString("nombre","johnattan");
editor.putString("contraseña","ultrasecreta");
3- Usar el editor para agregar información en pares clave-valor
4- Ejecutar los cambios del editor
editor.commit();
getPreferences(int mode);
1- Obtener una referencia al objeto de preferencias compartidas
getSharedPreferences(String name, int mode);
2- Usar la clave (key) proporcionada previamente para obtener el valor (value)
3- Proporcionar un valor por defecto en caso que el valor no se encuentre
String nombre = sharedPreferences.getString("nombre","N/A");
String contraseña = sharedPreferences.getString("contraseña","N/A");
data/data/<nombre_paquete>/files
La información se almacena en un archivo XML en el directorio
1- Llamar al método openFileOutput(String filename, int mode) especificando:
Este retorna un FileOutputStream
Crear y escribir un archivo privado en el almacenamiento interno
Context.MODE_PRIVATE
0 - Por defecto. Solo la aplicación puede acceder al archivo
Modo
Uso
Agregar información al contenido existente
Context.MODE_APPEND
2- Escribir en el archivo usando el método write()
3- Cerrar el flujo de escritura usando el método close()
String FILENAME = "archivo_prueba";
String string = "Hola mundo!";
FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE);
fos.write(string.getBytes());
fos.close();
1- Llamar al método openFileInput(String filename) especificando:
Este retorna un FileInputStream
2- Leer los bytes del archivo usando el método read(). La lectura se ejecuta byte por byte para agregar cada caracter
3- Cerrar el flujo de lectura usando el método close()
FileInputStream fis = openFileInput(FILENAME);
int read = -1;
StringBuffer buffer = new StringBuffer();
read = fis.read();
while( read != -1){
buffer.append((char) read);
}
fis.close();
1- Agregar permisos
WRITE_EXTERNAL_STORAGE
READ_EXTERNAL_STORAGE
WRITE_EXTERNAL_STORAGE
Agregar en el archivo AndroidManifest.xml
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
2- Verificar disponibilidad de acceso al almacenamiento
Llamar al método getExternalStorageState() para verificar si el acceso al almacenamiento está disponible
//Disponible para escritura
public boolean isExternalStorageWritable() {
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {
return true;
}
return false;
}
//Disponible para lectura
public boolean isExternalStorageReadable() {
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state) || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
return true;
}
return false;
}
3- Obtener los archivos del directorio usando los métodos
a- getExternalStorageFilesDir(String type)
Archivos específicos a tu app, son eliminados al desinstalarla
File folder = getExternalStorageFilesDir("MyFolder");
File myfile = new File(folder, "mydata.txt");
3- Obtener los archivos del directorio usando los métodos
b- getExternalStoragePublicDirectory(String type)
Archivos no específicos a tu app, son deberían ser eliminados al desinstalarla
File folder = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
File myfile = new File(folder, "mydata.txt");
4- Usar el FileInputStream y el FileOutputStream para realizar la operación requerida
String string = "Hola mundo!";
FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE);
fos.write(string.getBytes());
fos.close();
1- Obtener los archivos del directorio usando los métodos
a- getExternalStorageFilesDir(String type)
Archivos específicos a tu app, son eliminados al desinstalarla
File folder = getExternalStorageFilesDir("MyFolder");
File myfile = new File(folder, "mydata.txt");
1- Obtener los archivos del directorio usando los métodos
b- getExternalStoragePublicDirectory(String type)
Archivos no específicos a tu app, son deberían ser eliminados al desinstalarla
File folder = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
File myfile = new File(folder, "mydata.txt");
FileInputStream fis = openFileInput(FILENAME);
int read = -1;
StringBuffer buffer = new StringBuffer();
read = fis.read();
while ( read != -1) {
buffer.append((char) read);
}
fis.close();
2- Leer los bytes del archivo usando el método read(). La lectura se ejecuta byte por byte para agregar cada caracter
3- Cerrar el flujo de lectura usando el método close()
data/data/<nombre_paquete>/cache
La información se almacena en un archivo XML en el directorio
1- Usar el método getCacheDir() para abrir un archivo (File) que represente el directorio interno donde tu aplicación debería guardar los archivos (en caché)
2- Usar la clase archivo (File) para crear un archivo dentro de la carpeta cache
3- Llamar al método openFileOutput(String filename) con el nombre del archivo
1- Usar el método getCacheDir() para abrir un archivo (File) que represente el directorio interno donde tu aplicación debería leer los archivos (en caché)
2- Obtener el archivo usando la clase archivo (File) especificando su nombre
3- Usar la clase FileInputStream para leer la información de los archivos
data/data/<nombre_paquete>/databases
La información se almacena en un archivo XML en el directorio
1- Crear una nueva clase de Java llamada DataBaseHelper
2- Extender la clase con SQLiteOpenHelper
public class DataBaseHelper extends SQLiteOpenHelper{
}
public class DataBaseHelper extends SQLiteOpenHelper{
@Override
public void onCreate(SQLiteDatabase db){
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){
}
}
3- Implementar los métodos
4- Crear el contructor por defecto
5- Definir el nombre de la base de datos y la tabla
public static final String DATABASE_NAME = "Empresa.db";
public static final String TABLE_NAME = "tblEmpleado";
public class DataBaseHelper extends SQLiteOpenHelper{
public DataBaseHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version){
super(context, name, factory, version);
}
@Override
public void onCreate(SQLiteDatabase db){
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){
}
}
6- Definir los nombres de las columnas (campos de la tabla)
public static final String COL_1 = "ID";
public static final String COL_2 = "NOMBRE";
public static final String COL_3 = "APELLIDO";
public class DataBaseHelper extends SQLiteOpenHelper{
public static final String DATABASE_NAME = "Empresa.db";
public static final String TABLE_NAME = "tblEmpleado";
public static final String COL_1 = "ID";
public static final String COL_2 = "NOMBRE";
public static final String COL_3 = "APELLIDO";
public DataBaseHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version){
super(context, name, factory, version);
}
@Override
public void onCreate(SQLiteDatabase db){
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){
}
}
El código luce así hasta ahora
7- Modificar el constructor para tomar solo el nombre de la base de datos y la versión para la superclase (Context.Provide)
public DataBaseHelper(Context context){
super(context, DATABASE_NAME, null, 1);
}
8- En el método onCreate escribir la sentencia para crear la tabla
void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE " + DATABASE_NAME + "(ID INTEGER PRIMARY KEY AUTOINCREMENT, NOMBRE TEXT, APELLIDO TEXT)");
}
9- En el método onUpgrade escribir la sentencia para borrar la tabla en caso de que esta exista
void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
}
10- Crear la base de datos usando el método getWritableDatabase() al interior del constructor
public DataBaseHelper(Context context){
super(context, DATABASE_NAME, null, 1);
SQLiteDatabase db = this.getWritableDatabase();
}
public class DataBaseHelper extends SQLiteOpenHelper{
public static final String DATABASE_NAME = "Empresa.db";
public static final String TABLE_NAME = "tblEmpleado";
public static final String COL_1 = "ID";
public static final String COL_2 = "NOMBRE";
public static final String COL_3 = "APELLIDO";
public DataBaseHelper(Context context){
super(context, DATABASE_NAME, null, 1);
SQLiteDatabase db = this.getWritableDatabase();
}
@Override
void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE " + DATABASE_NAME + "(ID INTEGER PRIMARY KEY AUTOINCREMENT, NOMBRE TEXT, APELLIDO TEXT)");
}
@Override
void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
}
}
El código luce así hasta ahora
11- Crear un objeto de la clase DataBaseHelper en MainActivity y pasarle el contexto su constructor
DataBaseHelper myDb = new DataBaseHelper(this);
Al crear este objeto, la llamada a su método constructor permite crear la base de datos y sus tablas
1- Seguir los pasos anteriores para crear la base de datos y sus tablas
public boolean insertData(){
}
2- Crear un método en la clase DatabaseHelper para guardar datos en la tabla
3- Especificar en el método que datos se guardarán en la tabla
public boolean insertData(String nombre, String Apellido){
}
4- Crear una instancia de la clase ContentValues y usar el método put para guardar los datos en el objeto
ContentValues contentValues = new ContentValues():
contentValues.put(COL_2,nombre);
contentValues.put(COL_3,apellido);
5- Guardar la información en la tabla usando el método insert de la instancia de la clase SQLiteDatabase
long insert (String table, String nullColumnHack, ContentValues values)
Parámetro | Uso |
---|---|
table | La tabla en la que se insertará la fila actual |
nullColumnHack | Opcional. Valores por defecto en caso que el parámetro values esté vacío |
values | Mapeo que contiene los datos a insertar (nombres de columna y sus valores) |
public class DataBaseHelper extends SQLiteOpenHelper{
public static final String DATABASE_NAME = "Empresa.db";
public static final String TABLE_NAME = "tblEmpleado";
public static final String COL_1 = "ID";
public static final String COL_2 = "NOMBRE";
public static final String COL_3 = "APELLIDO";
public DataBaseHelper(Context context){
super(context, DATABASE_NAME, null, 1);
}
@Override
void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE " + DATABASE_NAME + "(ID INTEGER PRIMARY KEY AUTOINCREMENT, NOMBRE TEXT, APELLIDO TEXT)");
}
@Override
void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
}
public boolean insertData(String nombre, String Apellido){
SQLiteDatabase db = this.getWritableDatabase();
ContentValues contentValues = new ContentValues():
contentValues.put(COL_2,nombre);
contentValues.put(COL_3,apellido);
long result = db.insert(TABLE_NAME, null, contentValues);
db.close();
//Verificar si la información fue guardada en la base de datos
if(result == -1){
Toast.makeText(this, "No guardado", Toast.LENGTH_SHORT).show();
return false;
}else{
Toast.makeText(this, "Guardado correctamente", Toast.LENGTH_SHORT).show();
return true;
}
}
}
Tenemos entonces
6- Ahora en MainActivity
DataBaseHelper myDb;
myDb.insertData(nombre,apellido);