En Android podemos usar el motor de Base de DatosSQLite el cual es muy sencillo de usar, el inconveniente es que está limitado en comparación con SQL Server por ejemplo, pero de igual manera sirve y muy bien.
Podemos crear nuestra Base de Datos en el mismo directorio de la Aplicación lejos de la vista del usuario común, o la podemos crear en una carpeta en la memoria interna o externa en la que podemos tener acceso a ella fácilmente para poder consultarla con un programa externo (no recomendable)
Directorio de la Aplicación
SQLiteDatabase db;
db = openOrCreateDatabase("mejor_p", Context.MODE_PRIVATE, null);
Directorio en memoria externa y también declaramos otra variable SQLiteDatabase para usarla aparte de la anterior.
También tenemos la posibilidad de usar más de una Base de Datos en la misma Aplicación, si se requiere y sin ningún problema.
Aquí vemos cómo se ejecutan las querys para tener acceso a la Base de Datos, pudiendo utilizar las instrucciones que queramos (recordar que es una versión limitada y querys muy complejas puede que no las soporte)
Si han utilizado SQL Server, MySQL u otro motor de Base de Datos, las query son casi lo mismo.
Crear una tabla
CREATE TABLE IF NOT EXISTS clientes (Id INTEGER PRIMARY KEY, Nombre NVARCHAR(100), Telefono NVARCHAR(100), Pais NVARCHAR(15), Estado NVARCHAR(15))
Insertar / INSERT
INSERT INTO nombretabla (Campo1, Campo2, Campo3) VALUES (Valor1, Valor2, Valor3)
Consultar / SELECT
SELECT * FROM nombretabla WHERE condiciones
Modificar o actualizar / UPDATE
UPDATE nombretabla SET Campo1 = 'ValorNuevo' WHERE condiciones
Eliminar / DELETE
DELETE FROM nombretabla WHERE condiciones
*No olvidemos que los valores numéricos pueden escribirse tal cual pero los valores de tipo string necesitan estar entre comillas simples.
Tenemos diferentes maneras de informar al usuario algún suceso que afecte a nuestra Aplicación y para ello nos valemos de las notificaciones, en algunos casos es necesaria la intervención del mismo usuario pero en otras es solo para informarle de lo ocurrido.
Para eso a continuación aprenderemos a hacer uso de las notificaciones Toast, Dialog, Push y, Snackbar
5.1 Toast
Existen diferentes formas para mostrarlas en pantalla.
La notificación por medio de un diálogo de alerta la podemos utilizar para pedir una acción al usuario, puede ser una confirmación o la captura de un dato.
Este diálogo es generado por el propio Sistema Operativo, solamente le mandamos los parámetros como Title, Message para que se muestre en el diálogo, además de los botones de acción con su respectiva función con disposición de tres botones, el de respuesta positiva, respuesta negativa y respuesta neutral.
En este dialogo le asignamos Titulo, Mensaje y Botones con sus respectivos ClickListener para ejecutar las acciones antes de mostrarlo.
AlertDialog.Builder builder = new AlertDialog.Builder(registro.this);
builder.setTitle("Titulo del dialogo")
.setMessage("Descripción para el usuario")
.setPositiveButton("OK",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(DialogoActivity.this, "Respuesta Positiva", Toast.LENGTH_SHORT).show();
}
})
.setNegativeButton("CANCELAR",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(DialogoActivity.this, "Respuesta Negativa", Toast.LENGTH_SHORT).show();
}
})
.setNeutralButton("DESPUES",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
Toast.makeText(DialogoActivity.this, "Respuesta Neutral", Toast.LENGTH_SHORT).show();
}
});
builder.show();
Listo, se ejecutará la función del botón que se haya presionado.
También podemos usar diálogos más personalizados creados con un Layout agregando los EditText, TextView, Buttons, etc. Lo que se hace es crear el dialogo asignándole el Layout que creamos con el evento onCreateDialog.
Primero onCreateDialog crea el dialogo con el Layout
Ahora onPrepareDialog Instancia los controles y los Click con sus respectivas funciones.
@Override
protected void onPrepareDialog(int id, Dialog dialog) {
switch (id) {
case DIALOG:
//Instanciamos todos los controles que contiene nuestro dialogo
final AlertDialog alertDialog = (AlertDialog) dialog;
final EditText TxtDescripcion = (EditText) alertDialog.findViewById(R.id.TxtDescripcion);
final Button BtnAceptar = (Button) alertDialog.findViewById(R.id.BtnAceptar);
final Button BtnCancelar = (Button) alertDialog.findViewById(R.id.BtnCancelar);
BtnAceptar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(DialogoActivity.this, TxtDescripcion.getText().toString(), Toast.LENGTH_SHORT).show();
TxtDescripcion.setText("");
alertDialog.dismiss();
}
});
BtnCancelar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
alertDialog.dismiss();
}
});
break;
}
}
Finalmente es llamado con
showDialog(DIALOG);
La variable DIALOG la declaramos al inicio y podemos usar los diálogos que necesitamos, con un Switch podemos configurar los diálogos por separado.
5.3 Push
Las notificaciones Push se usan generalmente en aplicaciones conectadas a un servidor como Firebase, Amazon Web Services, Azure o hasta por medio de PHP para recibir precisamente notificaciones de lo que sucede en esos servidores con nuestra respectiva cuenta, alguna actividad por hacer o un mensaje recibido, etc. Ahora solo veremos cómo mostrarlas.
Podemos elegir el icono que se mostrará en la barra de notificación, el sonido cuando aparezca, si activa vibración, un título, una descripción y una acción para cuando la presionemos.
NotificationCompat.Builder mBuilder;
NotificationManager mNotifyMgr =(NotificationManager) getApplicationContext().getSystemService(NOTIFICATION_SERVICE);
Intent i=new Intent(PushActivity.this, Notificaciones.class);
PendingIntent pendingIntent = PendingIntent.getActivity(PushActivity.this, 0, i, 0);
int Icono = R.drawable.ic_videogame_asset_black_24dp;
Uri NotificacionSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
mBuilder =new NotificationCompat.Builder(getApplicationContext())
.setContentIntent(pendingIntent)
.setSmallIcon(Icono)
.setContentTitle("Mi App")
.setContentText("Abrir la app en Notificaciones")
.setVibrate(new long[] {100, 250, 100, 500})
.setSound(NotificacionSound)
.setAutoCancel(true);
mNotifyMgr.notify(1, mBuilder.build());
Con esto nos aseguramos que aparezca nuestra notificación y que al presionarla nos mande a la sección de notificaciones de nuestra aplicación, en este caso, o a cualquier aplicación que queramos.
5.4 Snackbar
La Snackbar aparece desde abajo y dura unos segundos mostrando un mensaje y además puede requerir una acción con un Botón de texto.
Snackbar.make(Btn, "Snackbar Notificación", Snackbar.LENGTH_LONG)
.setAction("Toast", new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(SnackbarActivity.this, "Toast Ejemplo", Toast.LENGTH_SHORT).show();
}
}).show();
Existen diferentes formas de mostrar una imagen en un Activity.
4.1 Cargar imagen desde carpeta Drawable
Cargar una imagen desde la carpeta Drawable es tan sencillo como llamarla directamente desde la carpeta, lo malo es que la imagen se tiene que guardar dentro del proyecto pero teniendo la seguridad de que siempre estará disponible.
Cargamos la imagen que tenemos en la carpeta Drawable para usarla como botón para abrir la galería y seleccionar una imagen guardada para ponerla en nuestro control ImageView.
El TabActivity nos permite mediante Fragments tener las pestañas que queramos en el mismo Activity mostrando diferentes tipos de contenido en cada uno de ellos.
Se hace un Layout para cada Fragment con los controles que quieran y dentro del Fragment se programan las funciones que hará cada control, pero ya que los dos Fragments se muestran dentro del mismo Activity funciones como el Toast se verán igual sin importar en cual Fragment nos encontremos.
En el evento onCreateView es donde creamos los Fragments
public static class PlaceholderFragment extends Fragment {
/**
* The fragment argument representing the section number for this
* fragment.
*/
private static final String ARG_SECTION_NUMBER = "section_number";
public PlaceholderFragment() {
}
/**
* Returns a new instance of this fragment for the given section
* number.
*/
public static PlaceholderFragment newInstance(int sectionNumber) {
PlaceholderFragment fragment = new PlaceholderFragment();
Bundle args = new Bundle();
args.putInt(ARG_SECTION_NUMBER, sectionNumber);
fragment.setArguments(args);
return fragment;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fragment_tab, container, false);
if (getArguments().getInt(ARG_SECTION_NUMBER) == 1) {
rootView = inflater.inflate(R.layout.fragment_tab, container, false);
} else if (getArguments().getInt(ARG_SECTION_NUMBER) == 2) {
rootView = inflater.inflate(R.layout.fragment_tab2, container, false);
}
return rootView;
}
}
En la Clase SectionsPagerAdapter cargamos el Fragment correspondiente a cada sección
public class SectionsPagerAdapter extends FragmentPagerAdapter {
public SectionsPagerAdapter(FragmentManager fm) {
super(fm);
}
@Override
public Fragment getItem(int position) {
// getItem is called to instantiate the fragment for the given page.
// Return a PlaceholderFragment (defined as a static inner class below).
//return PlaceholderFragment.newInstance(position + 1);
Fragment fragment = null;
switch (position) {
case 0:
fragment = new tab();
break;
case 1:
fragment = new tab2();
break;
}
return fragment;
}
@Override
public int getCount() {
// Show 2 total pages.
return 2;
}
}
Fragment tab
public class tab extends Fragment {
ImageView Imagen;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
View view = inflater.inflate(R.layout.fragment_tab, container, false);
Drawable myDrawable = getResources().getDrawable(R.drawable.youtube_boton);
Imagen = (ImageView) view.findViewById(R.id.Imagen1);
Imagen.setImageDrawable(myDrawable);
return view;
}
}
El RadioButton son una lista de opciones que se agregan mediante un RadioGroup y dentro iran todos los RadioButton que queramos, sabiendo que de este grupo sólo se podrá elegir una sola opción ya que cuando se seleccione otra la que estaba seleccionada se desactivará.
Una vez declarados los RadioButton y el RadioGroup, en este ultimo usamos el evento setOnChekedChangeListener para poder realizar una acción según el RadioButton que se haya seleccionado, en este caso llenamos la variable RadioAcciones con un valor de acuerdo a lo seleccionado.
RadioOpciones.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
public void onCheckedChanged(RadioGroup group, int checkedId) {
switch (checkedId) {
case R.id.RadioCrear:
RadioAcciones = "Crear";
break;
case R.id.RadioConsultar:
RadioAcciones = "Consultar";
break;
case R.id.RadioEliminar:
RadioAcciones = "Eliminar";
break;
}
}
});
El Calendario nos permite elegir tanto la fecha como la hora del dispositivo pero de forma separada, es decir, podemos elegir sólo la fecha o sólo la hora por medio del DatePicker o TimePicker y podemos dejar que se muestren en pantalla o invocarlos desde un botón para ahorrar espacio y lo que podemos hacer es guardar en variables los valores de año, mes, día, hora y minuto para después usarlas como queramos.
En este ejemplo tomaremos la fecha actual al iniciar el Activity y después podremos cambiarla con el DatePicker y TimePicker desde un botón o directamente del que mostramos en pantalla.
Primero creamos un Calendar para tomar la fecha por separado (año, mes, día, hora, minuto, segundo) actual del dispositivo.
Calendar Calendario = Calendar.getInstance();
Dia = Calendario.get(Calendar.DAY_OF_MONTH);
Mes = Calendario.get(Calendar.MONTH);
Año = Calendario.get(Calendar.YEAR);
Hora = Calendario.get(Calendar.HOUR);
Min = Calendario.get(Calendar.MINUTE);
Seg = Calendario.get(Calendar.SECOND);
Lo siguiente es cargar nuestro DatePicker y TimePicker con los valores obtenidos.
DatePicker = (DatePicker) findViewById(R.id.Calendario);
DatePicker.init(Año, Mes, Dia, new DatePicker.OnDateChangedListener() {
@Override
public void onDateChanged(DatePicker datePicker, int year, int month, int day) {
CambiarFecha(year,month+1,day);
}
});
TimePicker = (TimePicker) findViewById(R.id.Horas);
TimePicker.setOnTimeChangedListener(new android.widget.TimePicker.OnTimeChangedListener(){
@Override
public void onTimeChanged(TimePicker view, int hourOfDay, int minute) {
if(hourOfDay>12) Horario = " p.m.";
else Horario = " a.m.";
CambiarHoras(hourOfDay,minute,Seg,Horario);
}});
El DatePicker y TimePicker los podemos abrir con una fecha seleccionada, casi siempre es la fecha actual, que es la que tenemos en las variables Año, Mes, Dia, Hora y Min para no perdernos tanto a la hora de seleccionarla y poder navegar fácilmente hasta la fecha que queramos seleccionar.
Nuestra función ObtenerFecha abre el DatePickerDialog con la fecha actual seleccionada
private void ObtenerFecha(){
DatePickerDialog SeleccionarFecha = new DatePickerDialog(this, new DatePickerDialog.OnDateSetListener() {
@Override
public void onDateSet(DatePicker view, int year, int month, int dayOfMonth) {
CambiarFecha(year,month+1,dayOfMonth);
}
},Año, Mes, Dia);
SeleccionarFecha.show();
}
La funcion ObtenerHora nos abre el TimerPickerDialog con la hora actual seleccionada
private void ObtenerHora(){
TimePickerDialog SeleccionarHora = new TimePickerDialog(this, new TimePickerDialog.OnTimeSetListener() {
@Override
public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
if(hourOfDay>12) Horario = " p.m.";
else Horario = " a.m.";
CambiarHoras(hourOfDay,minute,Seg, Horario);
}
}, Hora, Min, false);
SeleccionarHora.show();
}
Ahora la fecha que seleccionemos necesitamos colocarla en alguna parte ya sea una variable o un EditText o un TextView, en este caso lo pondremos en un TextView con la siguiente función y en el formato que queramos, CambiarFecha y CambiarHora
El ListViewer nos muestra una lista de registros en un orden específico según nuestro propósito, tiene diferentes propiedades que veremos a continuación.
Item o Fila
Cada fila se compone de uno a varios datos informativos por ejemplo un nombre de contacto que sería el valor principal o el que queremos que resalte y un número telefónico o dirección y pueden ser los que quieran, pero se corre el riesgo de sobrecargar la información y perder de vista lo importante.
El diseño de la fila lo hacemos con un XML de Layout diferente que contenga los controles que se necesitan, sólo para una fila y el ListViewer por medio de un Adapter se encarga de tomarlo y llenarlo para cada registro que se va a mostrar en la lista, en este caso creamos el Layout que llamamos “List_item” para nuestro ejemplo.
Llenar la lista
El ListView se llena por medio de un Adapter que ordena los datos con su respectivo control, ya sea EditText, TextView, etc. en el orden que queramos.
Seleccionamos de nuestra base de datos los datos que queramos, nombrando nuestro Id como “_id” para que el Adapter lo integre en el ListView y se seleccione cuando llamemos al evento Click.
Cursor cursor = db.rawQuery("SELECT Id AS _id,Nombre,Telefono,Pais,Estado FROM clientes", null);
String[] from = new String[] { "Nombre", "Telefono", "Pais", "Estado"};
int[] to = new int[] { R.id.TxtNombre, R.id.TxtTelefono, R.id.TxtPais, R.id.TxtEstado};
cursorAdapter = new ListAdapter(this, cursor, from, to);
Listado.setAdapter(cursorAdapter);
Para el Adapter creamos un archivo de tipo Java Class al que solamente le indicamos el Layout que usaremos para cada fila del ListView, al que llamamos “LisAdapter”.
public class ListAdapter extends SimpleCursorAdapter {
private Cursor cursor;
public ListAdapter(Context contexto, Cursor cursor, String[] from, int[] to) {
super(contexto, R.layout.list_item, cursor, from, to);
this.cursor = cursor;
}
}
Click
Puede tener un evento de click para cuando seleccionemos un registro queremos que realice una acción con la información de la fila.
En nuestro ejemplo como utilizamos un Id de una base de datos, es el que nos regresa cuando damos Click y con el hacemos una consulta para obtener los datos para mostrarlos en un Toast.
Listado = (ListView)findViewById(R.id.Listado);
Listado.setOnItemClickListener(new OnItemClickListener() {public void onItemClick(AdapterView<?> parent, View view,int position, long id) {
Cursor Persona = db.rawQuery("SELECT Nombre,Telefono FROM clientes WHERE Id=" + id,null);
Persona.moveToFirst();
String Nombre = Persona.getString(0);
String Telefono = Persona.getString(1);
Toast.makeText(ListViewActivity.this, "Nombre: " + Nombre + ", Teléfono: " + Telefono, Toast.LENGTH_SHORT).show();
}
});
Menú contextual
También podemos agregarle un menú contextual para elegir más acciones, el cual también requiere de un archivo de menú con los items para mostrarlos.
En la carpeta “menu” creamos el archivo “menu” donde colocamos los items o las opciones que aparecerán en el menú contextual.
Para hacer que cuando seleccionemos una opción de nuestro menú contextual se realice una acción utilizamos el evento “OnContexitemSelected”.
Al igual que el evento CLick hacemos uso del Id que le corresponde a cada fila para realizar una acción con él, en este caso borramos de la base de datos los que correspondan al Id seleccionado.
@Override
public boolean onContextItemSelected(android.view.MenuItem item) {
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
switch (item.getItemId()) {
case R.id.opcion_borrar:
db.execSQL("DELETE FROM clientes WHERE Id=" + (int) info.id);
CrearLista();
return true;
default:
return super.onContextItemSelected((android.view.MenuItem) item);
}
}
Los botones en Android son la forma de interacción más fácil en una interfaz, ya que solo presionandolos podemos invocar una función o serie de funciones en cadena de los que él mismo nos dice que hace.
Los botones pueden ser sólo con texto, sólo una imagen o una imagen con texto, también se le pueden agregar diferentes estilo para adecuarlos al diseño de nuestra Aplicación.
Primero tenemos un Botón tan sencillo como nos lo muestra Android. Con sus atributos básicos de altura y anchura y un texto.
Este Botón contiene un estilo predeterminado en el archivo styles.xml el cual podemos agregarlo a cualquier Botón sin tener que duplicar las mismas propiedades a cada uno. y como vemos solamente hemos agregado la propiedad style con el valor del nombre del estilo que queramos agregarle al Botón.
En el archivo styles.xml el estilo que llamamos Button agregamos además de un padding y un textColor, un background al que hacemos referencia a un archivo en la carpeta drawable que se llama botonazul que es el que nos cambia el color de fondo del Botón en su estado normal y cuando lo presionamos.
Este Botón contiene un icono y un texto, el icono lo agregamos con la propiedad drawableLeft que lo pone a la izquierda del texto, pero puede se en cualquier parte, arriba, abajo o a la derecha indicándolo en la propiedad drawableTop, etc.
La propiedad drawablePadding nos pone el espacio alrededor del icono solamente.
La propiedad backgroundTint nos cambia el color del Botón.
Aquí tenemos un ImageButton con la imagen en la propiedad src elegimos una imagen con el logotipo de YouTube y podemos notar que se muestra en tamaño real y el área que indicamos es la parte de la imagen que se muestra que es la parte del centro.
Por último tenemos el FloatingActionButton que utiliza una imagen de vector en la propiedad src y al cual le damos su posición relativa con la propiedad layout_gravity indicando que lo queremos al fondo a la derecha, sea cual sea el tamaño de la pantalla y su orientación vertical u horizontal end|bottom
El TextView no es más que una simple etiqueta de texto a la que podemos adornar con diferentes estilos y propiedades de texto, veremos cómo crearla y modificarla desde Layout y desde código.
Podemos asignarle texto desde el archivo strings (recomendado) o directamente en la propiedad “texto”.
android:text="@string/Texto1"
Archivo Strings
<string name="Texto1">Texto desde archivo string</string>
Texto escrito directamente en la propiedad
android:text="Texto directo"
También podemos agregar o modificar las propiedades desde el código en tiempo de ejecución.
//Primero instanciamos el TextView
TxtCambioTexto = (TextView) findViewById(R.id.TxtCambioTexto);
//Boton para cambiar el texto
BtnCambiarTexto = (Button) findViewById(R.id.BtnCambiarTexto);
BtnCambiarTexto.setOnClickListener(new ClickEvent());
//Con un boton le cambiamos el texto
class ClickEvent implements View.OnClickListener{
public void onClick(View Btn){
if(Btn == BtnCambiarTexto){
TxtCambioTexto.setText("Este texto fue cambiado por código");
TxtCambioTexto.setTextColor(Color.RED);
}
}
}
Resultado
Como se muestra además del texto podemos cambiar cualquier propiedad desde el código en tiempo de ejecución como el color, entre otros.
Los tipos de teclados en el EditText que podemos utilizar para capturar números, decimales, con signo negativo, texto normal, correo electrónico, contraseñas, etc.
InputType Number / Teclado numérico
Este teclado nos permite escribir sólo números enteros y aunque aparezcan el punto y el signo negativo en el teclado, no los podemos utilizar.
IntpuType Decimal|Signed / Teclado numérico decimal y signo
Esta es una combinación de tipos de teclado en el que podemos utilizar el punto decimal y el signo negativo, si solamente dejamos el tipo Decimal no podríamos usar el signo negativo, incluso el tipo Signed podemos usarlo también junto al tipo Number.
InputType EmailAdress / Teclado para dirección de correo
Este tipo agrega el caracter @ en el teclado para tener acceso fácilmente en el caso de que estemos capturando correos electronicos.
InputType Password / Teclado para contraseñas
De los más usados este tipo de teclado nos oculta los caracteres que estamos escribiendo ya que se tratan de contraseñas y no queremos que nadie las vea.
This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.
