Fragments con Navigation Components

1. Crear la App, con la Actividad en Blanco

2. Modificar el archivo de Dependencias del archivo Build Gradle (app), agregando el
siguiente registro de líneas dentro del marco de dependencias:
def nav_version = "2.5.3"

  //Java language implementation

  implementation "androidx.navigation:navigation-fragment:$nav_version"
  implementation "androidx.navigation:navigation-ui:$nav_version"

3. Se puede eliminar la línea de “def nav version = “2.5.3”, reemplazando el

$nav_version por 2.5.3 y las comillas dobles por simples.
4. En la carpeta res se agrega un nuevo archivo de recursos llamado “nav_graph” y
en el Resource Type se selecciona “Navigation”. El sistema crea el archivo xml con
el nombre seleccionado.
5. Se agrega en el activity_main.xml el archivo de hosts llamado
“NavHostFragment”, dentro del Constraint Layout, seleccionando el host
nav_graph.
6. Adicionar en las líneas de <fragment/> del archivo activity_main.xml las líneas de
Constraint Layout sobre los límites superior, inferior, izquierda y derecha con
respecto al parent:

<androidx.fragment.app.FragmentContainerView
android:id="@+id/fragmentContainerView2"
android:name="androidx.navigation.fragment.NavHostFragment"
android:layout_width="match_parent"
android:layout_height=" match_parent""
app:defaultNavHost="true"
app:navGraph="@navigation/nav_graph"
tools:layout_editor_absoluteX="1dp"
tools:layout_editor_absoluteY="1dp"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintBottom_toBottomOf="parent" />

7. Se crea dentro del nav_graph.xml un “Create new destination”, que es un

fragment cuyo nombre se utilizará para contener los botones del menú inicial. El
sistema crea el archivo xml y el archivo Java correspondiente a ese fragment.
8. Se crean los botones del menú para poder llamar a los otros Fragments.
9. Luego se crean los otros fragments que se requieran en la aplicación, dentro del
nav_graph, repitiendo el paso 7 para cada uno de estos fragments.
10. Luego se desarrolla el contenido de cada uno de estos nuevos fragments,
colocando los elementos gráficos necesarios en cada uno de ellos.
11. Se ingresa al nav_graph y se genera la asociación entre el inicio_fragment y los
demás fragmentos, seleccionando el punto centro del inicio y llevándolo a la
pantalla de cada uno de los fragments (Figura 1):

Figura 1. Asociación entre los Fragments

12. Aparecen en el código del nav_graph todas las reglas de navegación entre los
fragments. En los actions de los fragment se modifica el @+id de cada uno de ellos
con los nombres que se asocien a cada uno de los fragments:

<fragment
android:id="@+id/inicioFragment"
android:name="com.example.pruebanavigation.InicioFragment"
android:label="fragment_inicio"
tools:layout="@layout/fragment_inicio" >
<action
android:id="@+id/action_inicioFragment_to_pantalla1Fragment"
app:destination="@id/pantalla1Fragment" />
<action
android:id="@+id/action_inicioFragment_to_pantalla2Fragment"
app:destination="@id/pantalla2Fragment" />
</fragment>

POR
<fragment
android:id="@+id/inicioFragment"
android:name="com.example.pruebanavigation.InicioFragment"
android:label="fragment_inicio"
tools:layout="@layout/fragment_inicio" >
<action
android:id="@+id/idPantalla1"
app:destination="@id/pantalla1Fragment" />
<action
android:id="@+id/idPantalla2"
app:destination="@id/pantalla2Fragment" />
</fragment>
13. Se crea la lógica de los botones en el MainActivity, destinando OnCLickListener
para cada uno de los botones, generando el salto a cada uno de los fragments
asosciados a los botones:

public class InicioFragment extends Fragment {

public InicioFragment() {
// Required empty public constructor
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup
container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
View vista = inflater.inflate(R.layout.fragment_inicio,
container, false);

Button btn1 = vista.findViewById(R.id.btn1);

Button btn2 = vista.findViewById(R.id.btn2);

btn1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
findNavController(v).navigate(R.id.idPantalla1);
}
});

btn2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
findNavController(v).navigate(R.id.idPantalla2);
}
});

return vista;
}
}

14. Se ejecuta la app.

 Fragments con Navigation Components
Método 2

1. Crear la App, con la Actividad en Blanco

2. Modificar el archivo de Dependencias del archivo Build Gradle (app), agregando el
siguiente registro de líneas dentro del marco de dependencias:

def nav_version = "2.5.3"

  //Java language implementation

  implementation "androidx.navigation:navigation-fragment:$nav_version"
  implementation "androidx.navigation:navigation-ui:$nav_version"

3. Se puede eliminar la línea de “def nav version = “2.5.3”, reemplazando el

$nav_version por 2.5.3 y las comillas dobles por simples.
4. En la carpeta res se agrega un nuevo archivo de recursos llamado “nav_graph” y
en el Resource Type se selecciona “Navigation”. El sistema crea el archivo xml con
el nombre seleccionado.
5. Se agrega en el activity_main.xml el archivo de hosts llamado
“NavHostFragment”, dentro del Constraint Layout, seleccionando el host
nav_graph.
6. Adicionar en las líneas de <fragment/> del archivo activity_main.xml las líneas de
Constraint Layout sobre los límites superior, inferior, izquierda y derecha con
respecto al parent:

<androidx.fragment.app.FragmentContainerView
android:id="@+id/fragmentContainerView2"
android:name="androidx.navigation.fragment.NavHostFragment"
android:layout_width="match_parent"
android:layout_height=" match_parent""
app:defaultNavHost="true"
app:navGraph="@navigation/nav_graph"
tools:layout_editor_absoluteX="1dp"
tools:layout_editor_absoluteY="1dp"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintBottom_toBottomOf="parent" />

7. Se crea dentro del nav_graph.xml un “Create new destination”, que es un

fragment cuyo nombre se utilizará para contener los botones del menú inicial. El
sistema crea el archivo xml y el archivo Java correspondiente a ese fragment.
8. Se crean los botones del menú para poder llamar a los otros Fragments.
9. Luego se crean los otros fragments que se requieran en la aplicación, dentro del
nav_graph, repitiendo el paso 7 para cada uno de estos fragments.
10. Luego se desarrolla el contenido de cada uno de estos nuevos fragments,
colocando los elementos gráficos necesarios en cada uno de ellos.
11. Se ingresa al nav_graph y se genera la asociación entre el inicio_fragment y los
demás fragmentos, seleccionando el punto centro del inicio y llevándolo a la
pantalla de cada uno de los fragments (Figura 2):

Figura 2. Asociación de Acciones entre los Fragments

12. Una vez terminado el proceso anterior, el sistema genera las acciones dentro de
nav_graph para cada uno de los fragments asociados:

<fragment
android:id="@+id/inicioFragment"
android:name="com.example.navigationapplication.InicioFragment"
android:label="fragment_inicio"
tools:layout="@layout/fragment_inicio" >
<action
android:id="@+id/action_inicioFragment_to_primerFragment"
app:destination="@id/primerFragment"
app:enterAnim="@android:anim/accelerate_interpolator"
app:popEnterAnim="@android:anim/bounce_interpolator"
app:popUpToInclusive="true" />
<action
android:id="@+id/action_inicioFragment_to_segundoFragment"
app:destination="@id/segundoFragment" />
</fragment>
 <fragment
android:id="@+id/primerFragment"
android:name="com.example.navigationapplication.PrimerFragment"
android:label="fragment_primer"
tools:layout="@layout/fragment_primer" >
<action
android:id="@+id/action_primerFragment_to_inicioFragment"
app:destination="@id/inicioFragment" />
</fragment>
<fragment
android:id="@+id/segundoFragment"
android:name="com.example.navigationapplication.SegundoFragment"
android:label="fragment_segundo"
tools:layout="@layout/fragment_segundo" >
<action
android:id="@+id/action_segundoFragment_to_tercerFragment"
app:destination="@id/tercerFragment" />
<action
android:id="@+id/action_segundoFragment_to_inicioFragment"
app:destination="@id/inicioFragment" />
</fragment>
<fragment
android:id="@+id/tercerFragment"
android:name="com.example.navigationapplication.TercerFragment"
android:label="fragment_tercer"
tools:layout="@layout/fragment_tercer" >
<action
android:id="@+id/action_tercerFragment_to_segundoFragment"
app:destination="@id/segundoFragment" />
<action
android:id="@+id/action_tercerFragment_to_inicioFragment"
app:destination="@id/inicioFragment" />
</fragment>

13. Luego se definen los procedimientos dentro de cada uno de los Fragments en su
sección Java, primero generando el @Override de onViewCreated, así:

InicioFragment

@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);

Button btn1 = view.findViewById(R.id.btn1);

Button btn2 = view.findViewById(R.id.btn2);

//Forma 2
final NavController navController = Navigation.findNavController(view);

btn1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Navigation.findNavController(v).navigate(R.id.primerFragment);
}
});

//Forma 2
btn2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
navController.navigate(R.id.segundoFragment);
}
});
}

PrimerFragment
 @Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
Button btnAtras = view.findViewById(R.id.btnAtras);

//Forma 2
final NavController navController = Navigation.findNavController(view);

btnAtras.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Navigation.findNavController(v).navigate(R.id.inicioFragment);
}
});
}

SegundoFragment

@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);

Button btnAtras = view.findViewById(R.id.btnAtras);

//Forma 2
final NavController navController = Navigation.findNavController(view);

btnAtras.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Navigation.findNavController(v).navigate(R.id.inicioFragment);
}
});
}

TercerFragment

@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);

Button btnAtras = view.findViewById(R.id.btnAtras);

Button btnInicio = view.findViewById(R.id.btnInicio);

//Forma 2
final NavController navController = Navigation.findNavController(view);

btnAtras.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Navigation.findNavController(v).navigate(R.id.segundoFragment);
}
});

//Forma 2
btnInicio.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
navController.navigate(R.id.inicioFragment);
}
});
}

14. Se ejecuta la App.

 Navigation Drawer con Fragments

1. Se crea un Nuevo Proyecto, seleccionando una plantilla de Navigation Drawer

Activity (Figura 3).

Figura 3. Selección de Navigation Drawer Activity

2. El sistema genera todos los Layout en formato XML correspondientes a la pantalla de

Navigation Drawer (Figura 4):

Figura 4. Contenido de Navigation Drawer.

3. Adicionalmente se crea una carpeta en Java llamada “ui”, la cual contiene subcarpetas
por cada uno de los ítems que estén en el menú de la Main Activity. El nav_graph
ahora se encuentra ubicado en la carpeta res, subcarpeta navigation, y el archivo se
llama mobile_navigation.xml.
4. Dentro del activity_main_drawer.xml aparece cada uno de los grupos que se desean
dentro de la aplicación, los cuales permiten cambiar los nombres de los fragments
asociados a los elementos del menú, incluir el icono y el texto que se presenta dentro
del menú. Si se modifica algún nombre de los @id, se debe proceder a buscar dentro
de la aplicación dicho id para reemplazarlo por el nuevo id:

<group android:checkableBehavior="single">
<item
android:id="@+id/nav_home"
android:icon="@drawable/ic_menu_camera"
android:title="@string/menu_home" />
<item
android:id="@+id/nav_gallery"
android:icon="@drawable/ic_menu_gallery"
android:title="@string/menu_gallery" />
<item
android:id="@+id/nav_slideshow"
android:icon="@drawable/ic_menu_slideshow"
android:title="@string/menu_slideshow" />

<item
android:id="@+id/greenFragment"
android:icon="@drawable/share2"
android:title="Green Fragment" />
</group>

5. Cuando se ha agregado un item en el menú, éste crea en la tool_bar una flecha de

retorno. Si no se desea permitir esta navegación, es decir, sólo se puede cambiar de
fragment al oprimir una opción de menú. Para ello se debe agregar el nombre R.id del
fragment que se desea bloquearle dicha opción de navegación dentro del Main
Activity en la línea correspondiente al mAppBarConfiguration:

mAppBarConfiguration = new AppBarConfiguration.Builder(

R.id.nav_home, R.id.nav_gallery, R.id.nav_slideshow, R.id.greenFragment)
.setOpenableLayout(drawer)
.build();

6. Para cambiar el fragment inicial del sistema, dentro del mobile_navigation.xml se

oprime el icono de la casita o home y luego, se hace click sobre el diseño del XML
que se desea de inicial.
7. Si se cambia el icono de los elementos de menú, este aparecerá con el color del Tinte
de la plantilla, rellenando su contorno. Para poder cambiar los iconos con los colores
originales, dentro del Main Activity y al final de la función public void onCreate, se
debe agregar la siguiente línea:

navigationView.setItemIconTintList(null);

8. Ejecutar la App.
 Recycler View

Es la presentación de datos de una manera ordenada, utilizando para ello un layout

modelo, el cual contendrá el contenido general, y por medio de funciones y
procedimientos se utilizará dicho modelo para la presentación de una lista de registros
(Figura 5). El desarrollador tiene la responsabilidad de definir la estructura de datos, y la
biblioteca RecyclerView creará los elementos de la lista cuando se los necesite.

Figura 5. Ejemplo de un RecyclerView

La librería RecyclerView es la encargada de presentar los datos y viene asociado a ella el

Scroll de los elementos Visuales en la pantalla. Las clases que trabajan en conjunto para el
funcionamiento del RecyclerView son:
 Clase RecyclerView: Esta clase es el contenedor que se define en la Main_Activity
y es el que define la posición y el contenido de cada Frame.
 Clase RecyclerView.Adapter: Crea cada una de las vistas predefinidas por la
estructura del programa y se comunica con RecyclerView.ViewHolder para que los
muestre en pantalla.
 Clase RecyclerView.ViewHolder: Representa cada uno de los elementos
individuales en la pantalla.

Para poder lograr el desarrollo de una aplicación con RecyclerView, se debe proceder con
los siguientes pasos:

1. Se crea la aplicación con un Activity Blank. Luego se define el Layout que más
convenga con la aplicación.
2. Se agrega un contenedor RecyclerView dentro del archivo XML.
3. Luego, se definen los elementos que contendrá el RecyclerView. En el caso de este
ejemplo, se definen en el MainActivity.Java las estructuras de los arrays que
contendrán los datos:

String[] nombres = {"Banano", "Cereza", "Fresa", "Guanábana", "Kiwi", "Manzana",

"Naranja", "Pera", "Sandía", "Uva"};

int[] fotos = {R.drawable.banano, R.drawable.cereza, R.drawable.fresa,

R.drawable.guanabana, R.drawable.kiwi, R.drawable.manzana, R.drawable.naranja,
R.drawable.pera, R.drawable.sandia, R.drawable.uva};

float[] precios = {2500, 3500, 1850, 1200, 3000, 4500, 4300, 3400, 2100, 3670} ;

4. Definir los controles visuales que van a emplearse para mostrar cada elemento de
la estructura de datos. Se hace creando dentro de la carpeta layout en resources,
un archivo XML que contendrá el layout modelo (Figura 6):

Figura 5. Layaout modelo.

5. Crear un LinearLayoutManager para mostrar los ítems en forma vertical.

6. Crear una clase que herede de RecyclerView.Adapter e implemente los métodos
onCreateViewHolder, onBindViewHolder y getItemCount:
7. Plantear una clase que herede de la clase RecyclerView.ViewHolder e
implementar el constructor, recuperar la referencia de los controles visuales del
layout creado en el punto 3 y proceder a actualizar la pantalla para cada item de la
lista:

public class MainActivity extends AppCompatActivity {

String[] nombres = {"Banano", "Cereza", "Fresa", "Guanábana", "Kiwi", "Manzana",

"Naranja", "Pera", "Sandía", "Uva"};

int[] fotos = {R.drawable.banano, R.drawable.cereza, R.drawable.fresa,

R.drawable.guanabana,
R.drawable.kiwi, R.drawable.manzana, R.drawable.naranja, R.drawable.pera,
R.drawable.sandia, R.drawable.uva};

float[] precios = {2500, 3500, 1850, 1200, 3000, 4500, 4300, 3400, 2100, 3670} ;

RecyclerView rv1;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

rv1 = findViewById(R.id.recyclerView);

LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);

rv1.setLayoutManager(linearLayoutManager);
rv1.setAdapter(new AdaptadorFrutas());
 }

private class AdaptadorFrutas extends RecyclerView.Adapter

<AdaptadorFrutas.AdaptadorFrutasHolder> {

@NonNull
@Override
public AdaptadorFrutasHolder onCreateViewHolder(@NonNull ViewGroup parent, int
viewType) {
return new
AdaptadorFrutasHolder(getLayoutInflater() .inflate(R.layout.itemfruta, parent, false));
}

@Override
public void onBindViewHolder(@NonNull AdaptadorFrutasHolder holder, int
position) {
holder.imprimir(position);
}

@Override
public int getItemCount() {
return nombres.length;
}

private class AdaptadorFrutasHolder extends RecyclerView.ViewHolder implements

View.OnClickListener{

TextView tv1, tv2;

ImageView iv1;

public AdaptadorFrutasHolder(@NonNull View itemView) {

super(itemView);

iv1 = itemView.findViewById(R.id.imageView);
tv1 = itemView.findViewById(R.id.tvNombre);
tv2 = itemView.findViewById(R.id.tvPrecio);

itemView.setOnClickListener(this);

public void imprimir(int position) {

iv1.setImageResource(fotos[position]);
tv1.setText(" " + nombres[position]);
tv2.setText(String.valueOf(precios[position]));

@Override
public void onClick(View v) {
Toast.makeText(MainActivity.this, nombres[getLayoutPosition()] + "\n" +
precios[getLayoutPosition()], Toast.LENGTH_LONG).show();
}
}

}
}
 RecyclerView – Agregar y Eliminar Items

1. Crear la Activity y agregar un RecyclerView dentro del Layout seleccionado para la

Activity.
2. Agregar una Clase Java que contenga los parámetros del archivo requerido. En este
caso, agregar el nombre y teléfono, así como el constructor y los getter de dichos
parámetros:

public class Persona {

private String nombre;
private String telefono;

public Persona(){
}

public Persona(String nombre, String telefono) {

this.nombre = nombre;
this.telefono = telefono;
}

public String getNombre() {

return nombre;
}

public String getTelefono() {

return telefono;
}
}

3. Luego se debe definir el ArrayList de la clase creada que contenga los datos
iniciales de dicho Array.
4. Crear un LinearLayoutManager para mostrar los ítems en forma vertical.
5. Crear una clase que herede de RecyclerView.Adapter e implemente los métodos
onCreateViewHolder, onBindViewHolder y getItemCount:
6. Plantear una clase que herede de la clase RecyclerView.ViewHolder e
implementar el constructor, recuperar la referencia de los controles visuales del
layout creado en el punto 3 y proceder a actualizar la pantalla para cada item de la
lista:

public class MainActivity extends AppCompatActivity {

ArrayList<Persona> personas;
RecyclerView rv1;
EditText et1, et2;
AdaptadorPersona ap;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

rv1 = findViewById(R.id.rv1);
et1 = findViewById(R.id.et1);
et2 = findViewById(R.id.et2);

personas = new ArrayList<Persona>();

personas.add(new Persona("Juan Rodriguez", "2345434234"));
 personas.add(new Persona("Pedro Alcazar", "343434232"));
personas.add(new Persona("María de los Palotes", "349802083"));
personas.add(new Persona("Roberto de Niro", "2329070273"));
personas.add(new Persona("Chavo del Ocho", "30343034923"));
personas.add(new Persona("Chilindrina Valdéz", "1291289028"));
personas.add(new Persona("Popis Meza", "654479333"));
personas.add(new Persona("Ñoño Barriga", "232930238028"));

LinearLayoutManager uno = new LinearLayoutManager(this);

rv1.setLayoutManager(uno);
ap = new AdaptadorPersona();
rv1.setAdapter(ap);
}

public void agregar(View view) {

Persona persona1 = new Persona(et1.getText().toString(),

et2.getText().toString());
personas.add(persona1);

et1.setText("");
et2.setText("");

//Actualiza la pantalla
ap.notifyDataSetChanged();
rv1.scrollToPosition(personas.size() - 1);
}

public void eliminar(View view) {

int pos = -1;
for (int f = 0; f<personas.size(); f++){
if(personas.get(f).getNombre().equals(et1.getText().toString())){
pos = f;
}

if (pos != -1){
personas.remove(pos);
ap.notifyDataSetChanged();
if (personas.size()>=0){
rv1.scrollToPosition(0);
}
}
}
}

private class AdaptadorPersona extends

RecyclerView.Adapter<AdaptadorPersonaHolder> {

@NonNull
@Override
public AdaptadorPersonaHolder onCreateViewHolder(@NonNull ViewGroup parent,
int viewType) {
return new
AdaptadorPersonaHolder(getLayoutInflater().inflate(R.layout.itempersona, parent,
false));
}

@Override
public void onBindViewHolder(@NonNull AdaptadorPersonaHolder holder, int
position) {
holder.imprimir(position);
}

@Override
public int getItemCount() {
return personas.size();
}
}

private class AdaptadorPersonaHolder extends RecyclerView.ViewHolder implements

 View.OnClickListener {
TextView tv1, tv2;
public AdaptadorPersonaHolder(@NonNull View itemView) {
super(itemView);

tv1 = itemView.findViewById(R.id.tvnombre);
tv2 = itemView.findViewById(R.id.tvtelefono);
itemView.setOnClickListener(this);

@Override
public void onClick(View v) {
mostrar(getLayoutPosition());

public void imprimir(int position) {

tv1.setText("Nombre: " + personas.get(position).getNombre());
tv2.setText("Teléfono: " + personas.get(position).getTelefono());
}
}

private void mostrar(int layoutPosition) {

et1.setText(personas.get(layoutPosition).getNombre());
et2.setText(personas.get(layoutPosition).getTelefono());
}
}

7. Crear los controles de botones de Agregar y Eliminar, que generan sus respectivos
onClick. En el caso de agregar, es simplemente la función add, y en el caso de
eliminar, se debe proceder a definir la posición del registro a borrar y luego,
proceder a la función remove.
8. Ejecutar la aplicación.
 Procedimientos con Activity

Lanzar una Segunda Actividad

1. Crear un Nuevo Proyecto
2. Crear el componente gráfico (ej. Botón) con el cual se va a activar la entrada a la
segunda Activity.
3. Crear una nueva Activity en app de la sección Proyecto.
4. Crear los componente gráficos que se van a utilizar dentro de la segunda Activity, y
los que se relacionan ya sea con la continuidad a otra Activity o regresar a la
anterior.
5. Se incorpora en el OnCLick del componente gráfico la definición de la intención o
intent para generar el movimiento de pantalla y luego, se produce el inicio de la
actividad:

public void acercaDe(View view) {

Intent intent = new Intent(MainActivity.this, DosActivity.class);
startActivity(intent);
}

Pasar Datos cuando se lanza una Activity

1. Se crea la MainActivity con los componentes gráficos que recibirán la información
y se define el intent.
2. Seguido a esto se definen los extras o variables de datos que se van a enviar la la
Activity receptora:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

et1 = findViewById(R.id.txtNumero1);
et2 = findViewById(R.id.txtNumero2);
sp1 = findViewById(R.id.spOperaciones);

String[] operaciones = {"Sumar", "Restar", "Multiplicar", "Dividir"};

ArrayAdapter<String> adaptador = new ArrayAdapter<>(this,

androidx.appcompat.R.layout.support_simple_spinner_dropdown_item, operaciones);
sp1.setAdapter(adaptador); }

public void resultado(View view) {

Intent intent = new Intent(MainActivity.this, ResultadoActivity.class);

double valor1 = Double.parseDouble(et1.getText().toString());

double valor2 = Double.parseDouble(et2.getText().toString());
String operacion = sp1.getSelectedItem().toString();

intent.putExtra("valor1", valor1);
intent.putExtra("valor2", valor2);
intent.putExtra("operacion", operacion);

et1.setText("");
et2.setText("");
sp1.setSelection(0);

startActivity(intent); }
 3. Luego, dentro de la Activity receptora de los datos, se define el Bundle o montón
que va a recibir los valores parametrizados, y los coloca en variables que se
requieran definir para recibirlos:

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);
setContentView(R.layout.activity_resultado);

tv1 = findViewById(R.id.tv1);

Bundle datos = getIntent().getExtras();

double valor1 = datos.getDouble("valor1");

double valor2 = datos.getDouble("valor2");
String op = datos.getString("operacion");

double resultado = 0;
switch (op) {
case "Sumar":
resultado = valor1 + valor2;
tv1.setText(valor1 + " + " + valor2 + " = " + resultado);
break;
case "Restar":
resultado = valor1 - valor2;
tv1.setText(valor1 + " - " + valor2 + " = " + resultado);
break;
case "Multiplicar":
resultado = valor1 * valor2;
tv1.setText(valor1 + " x " + valor2 + " = " + resultado);
break;
case "Dividir":
resultado = valor1 / valor2;
tv1.setText(valor1 + " ÷ " + valor2 + " = " + resultado);
break;
}
}

Recuperar Datos cuando se Cierra un Activity

1. Crear la MainActivity y la Secundaria. En la principal se define el componente que

posee el onClick (botón).
2. Dentro del onCLick se define parámetro Intent, para establecer de qué pantalla a
cual pantalla se va a dirigir, pero con la diferencia que no sólo se establece el
startActivity, sino el Resultado de la misma (startActivityResult), determinando el
código de respuesta:
Intent intent = new Intent(MainActivity.this, LoginActivity.class);
startActivityForResult(intent, 100);

3. Se genera el método onActivityResult y se define qué sucede cuando el código de

respuesta es utilizado, y dependiendo del tipo de Respuesta del Intent
(RESULT_OK ó RESULT_CANCELLED):

protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent

data) {
super.onActivityResult(requestCode, resultCode, data);
 if(requestCode == 100){
if(resultCode == Activity.RESULT_OK){
Bundle datos = data.getExtras();
tv1.setText(datos.getString("usuario"));
}

if(resultCode == Activity.RESULT_CANCELED){
tv1.setText("Datos Usuario");
Toast.makeText(this, "Se presionó el botón CANCELAR",
Toast.LENGTH_SHORT).show();
}
}
}

4. En la Activity Secundaria se definen los componentes (botones) que contienen el

confirmar (que pasa los datos) y cancelar (que no pasa datos):

public void cancelar(View view) {

Intent intent = new Intent();
setResult(Activity.RESULT_CANCELED, intent);
finish();
}

public void confirmar(View view) {

Intent intent = new Intent();
intent.putExtra("usuario", et1.getText().toString());
setResult(Activity.RESULT_OK, intent);
finish();

}
 Creación y lectura de archivos de texto en la memoria
interna

Se utiliza para la creación de archivos de texto y almacenar datos dentro del mismo, como
efecto del desarrollo mismo de la aplicación. Hay que tener en cuenta dos puntos:

 El almacenamiento de archivos de texto en la memoria interna del dispositivo solo

son accesibles desde la aplicación que los creó.
 Los archivos son eliminados de la memoria interna en el momento que se
desinstala la aplicación del dispositivo.

Ejemplo: Desarrollar una interfaz visual que permita ingresar el nombre de un archivo de
texto y su contenido, al presionar un botón, almacenar los datos en un archivo de texto e
implementar el algoritmo para la lectura de archivos de texto.

1. Crear la aplicación y colocar en el MainActivity los componentes de EditText para

el nombre del archivo y el texto multilínea que llevará el contenido del archivo de
texto.

EditText et1, et2;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

et1 = findViewById(R.id.txtNombreAtchivo);
et2 = findViewById(R.id.txtMultiLine);

2. El botón grabar debe permitir crear el archivo definido en el EditText y dentro de

él colocar el contenido del texto multilínea, todo ello dentro de un try…catch para
poder controlar los errores de archivo:

public void grabar(View view) {

String nombrearchivo = et1.getText().toString();

String contenido = et2.getText().toString();

try{
OutputStreamWriter archivo = new
OutputStreamWriter(openFileOutput(nombrearchivo, Context.MODE_PRIVATE));
archivo.write(contenido);
archivo.flush();
archivo.close();

et1.setText("");
et2.setText("");

Toast.makeText(this, "El Archivo " + nombrearchivo + "\nfue creado

correctamente.", Toast.LENGTH_SHORT).show();
 }catch(Exception e){
Toast.makeText(this, "No se Pudo Crear el Archivo",
Toast.LENGTH_SHORT).show();
}
}

3. El botón recuperar debe permitir localizar el archivo creado por la aplicación y

cuyo nombre está definido en el EditText del nombre del archivo. El sistema
buscará el archivo y colocará el contenido en el texto multilínea. Todo lo anterior
colocado dentro de un try…catch para controlar las excepciones de archivo:

public void recuperar(View view) {

String nombrearchivo = et1.getText().toString();
try{
InputStreamReader archivo = new
InputStreamReader(openFileInput(nombrearchivo));
BufferedReader br = new BufferedReader(archivo);
String linea = br.readLine();
String contenido = "";
while (linea != null){
contenido = contenido + linea + "\n";
linea = br.readLine();
}
br.close();
archivo.close();
et2.setText(contenido);

}catch (IOException e){

Toast.makeText(this, "No se Pudo Abrir el Archivo",
Toast.LENGTH_SHORT).show();
}
}
 Almacenar datos mediante la clase SharedPreferences

Es el almacenamiento de archivos con formato XML dentro de la memoria, generados por

el programa que los creó, y sirven para guardar información de longitud baja, es decir,
archivos como los de configuración que guardan poca información.

Ejemplo: Se desarrolla una Agenda de Actividades Diarias, donde se registra en una fecha
dada, la hora y la Actividad a realizar. El sistema permite cargar al texto multilínea todo lo
referente a todas las actividades diarias a registrar y luego, grabarlas en la memoria.
También permite la búsqueda de la Agenda por fecha.

1. Crear el MainActivity y colocar los EditText de la Fecha, Hora y Actividad. También

el EditText multilínea y los botones Cargar, Grabar, Buscar y Limpiar.
2. Se crea el onClick para el botón cargar(), donde se pasan los datos de pantalla a
variables resumen, que van cargando la información en el texto multilínea:
public void cargar(View view) {
fecha = et1.getText().toString();
hora = et2.getText().toString();
actividad = et3.getText().toString();
actividades += hora + " " + actividad + "\n";
etagenda.setText(actividades);
Toast.makeText(this, "Actividad Cargada", Toast.LENGTH_SHORT).show();
et2.setText("");
et3.setText("");
}

3. Se crea el onClick para el botón grabar(), donde se especifica que existe una clase
creada de SharedPreference, en la cual se especifica el nombre del archivo XML
que contendrá la información y se coloca en modo Privado, con el fin de que el
sistema permita la grabación de datos. Luego se define el Editor de
SharedPreferences y se colocan dentro de este las variables (fecha y actividades).

public void grabar(View view) {

SharedPreferences sp = getSharedPreferences("agenda2", Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
String fechafin = et1.getText().toString();
String actividades = etagenda.getText().toString();
editor.putString(fechafin, actividades);
editor.commit();
Toast.makeText(this, "Han sido grabadas las \nActividades del día " + fechafin,
Toast.LENGTH_LONG).show();
et1.setText("");
et2.setText("");
et3.setText("");
etagenda.setText("");
actividades = "";
}

4. Se crea el onClick para el botón buscar(), que permite colocar la fecha que se
desea buscar y coloca el valor en SharedPreferences. Luego, se colocan los datos
en cada uno de los EditText y el texto multilínea:
 public void buscar(View view) {
SharedPreferences sp = getSharedPreferences("agenda2", Context.MODE_PRIVATE);
String dato = sp.getString(et1.getText().toString(), "");
if (dato.equals("")){
Toast.makeText(this, "No hay Actividad Registrada \nen la Fecha " +
et1.getText().toString(), Toast.LENGTH_LONG).show();
}else{
etagenda.setText(dato);
actividades = etagenda.getText().toString();
}
}

5. Finalmente, se crea el onClick para el botón limpiar(), que permite que en

cualquier momento se limpie la pantalla para volver a ejecutar cualquiera de los
procesos de cargar(), grabar() y buscar():

public void limpiar(View view) {

et1.setText("");
et2.setText("");
et3.setText("");
etagenda.setText("");
actividades = "";
}
 Almacenamiento usando base de datos SQLite

El la forma utilizada para la creación, consulta, eliminación o modificación de registros en

bases de datos de 6ª generación como lo es SQLite. Su estructura es muy similar al SQL
tradicional. Para ello se siguen estos pasos:

1. Se crea la aplicación con su MainActivity.

2. Se crea un Package que contenga una clase para la manipulación de los textos de
base de datos (ej: Package  Utilidades, archivo Java utilidades, con el siguiente
contenido:

package com.example.appsqlite2.utilidades;

public class Utilidades {

public static final String TABLA_VEHICULO = "vehiculos";

public static final String CAMPO_PLACA = "placa";
public static final String CAMPO_MARCA = "marca";
public static final String CAMPO_MODELO = "modelo";
public static final String CAMPO_PRECIO = "precio";

public static final String CREAR_TABLA_VEHICULO = "CREATE TABLE " +

TABLA_VEHICULO +
" (" + CAMPO_PLACA + " TEXT, " +
CAMPO_MARCA + " TEXT, " +
CAMPO_MODELO + " INTEGER, " +
CAMPO_PRECIO + ")";
}

3. Se crea a nivel del MainActivity una clase Java (ej: ConexionSQLiteHelper)

agregando el extends SQLiteOpenHelper que contiene los elementos asociados a
la creación de la Tabla y la Base de Datos. Luego se hace la importación de las
clases e implementando los métodos onCreate y onUpgrade:

public class ConexionSQLiteHelper extends SQLiteOpenHelper {

public ConexionSQLiteHelper(@Nullable Context context, @Nullable String name,
@Nullable SQLiteDatabase.CursorFactory factory, int version) {
super(context, name, factory, version);
}

@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(Utilidades.CREAR_TABLA_VEHICULO);
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS vehiculos" + Utilidades.TABLA_VEHICULO);
onCreate(db);
}
}

4. Se crean los componentes de la pantalla del Main Activity que contienen los datos
del registro. Se agrega el botón “Registrar” el cual lleva asociado el onClick
registrar.
5. Se procede a abrir una conexión SQLite y abriendo la base de datos en formato de
escritura. Luego se establece una variable de la clase ContentValues, y se colocan
los valores determinando primero la variable y luego el valor. Finalmente se utiliza
el comando db.insert() para grabar un registro nuevo:

public void registrar(View view) {

ConexionSQLiteHelper conn = new ConexionSQLiteHelper(this, "bd_simit", null, 1);
SQLiteDatabase db = conn.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(Utilidades.CAMPO_PLACA, txtplaca.getText().toString());
values.put(Utilidades.CAMPO_MARCA, txtmarca.getText().toString());
values.put(Utilidades.CAMPO_MODELO, txtmodelo.getText().toString());
values.put(Utilidades.CAMPO_PRECIO, txtprecio.getText().toString());

Long idresultante = db.insert(Utilidades.TABLA_VEHICULO, Utilidades.CAMPO_PLACA,

values);
Toast.makeText(getApplicationContext(),"Id Registro: " + idresultante,
Toast.LENGTH_SHORT).show();
db.close();

txtplaca.setText("");
txtmarca.setText("");
txtmodelo.setText("");
txtprecio.setText("");

6. Se desarrolla la rutina de consultar(), en la cual se toma el valor de búsqueda

colocándolo en la variable de parámetros y se ejecuta la consulta Query. El sistema
presenta los datos obtenidos:

public void consultar(View view) {

SQLiteDatabase db = conn.getReadableDatabase();
String placax = txtplaca.getText().toString();
String[] parametros = {placax};
String[] campos = {Utilidades.CAMPO_MARCA, Utilidades.CAMPO_MODELO,
Utilidades.CAMPO_PRECIO};

try {
Cursor cursor = db.query(Utilidades.TABLA_VEHICULO, campos,
Utilidades.CAMPO_PLACA + "=?", parametros, null, null, null);
cursor.moveToFirst();
txtmarca.setText(cursor.getString(0));
txtmodelo.setText(cursor.getString(1));
txtprecio.setText(cursor.getString(2));
cursor.close();

}catch (Exception e){

Toast.makeText(getApplicationContext(),"No existe Vehículo de Placa Nº " +
placax, Toast.LENGTH_LONG).show();
limpiar();
}
db.close();

7. La otra sección del CRUD es borrar(), que utiliza los mismos conceptos para la
búsqueda, pero adicionalmente al query, se ejecuta la acción de borrado:

public void borrar(View view) {

SQLiteDatabase db = conn.getWritableDatabase();
String placax = txtplaca.getText().toString();
String[] parametros = {placax};
int cant = db.delete(Utilidades.TABLA_VEHICULO, Utilidades.CAMPO_PLACA + "=?",
 parametros);
if (cant ==1) {
Toast.makeText(getApplicationContext(), "La Placa Nº" +
txtplaca.getText().toString() + "\nFue Eliminada", Toast.LENGTH_LONG).show();
}else {
Toast.makeText(getApplicationContext(), "No se pudo Eliminar la Placa Nº" +
txtplaca.getText().toString(), Toast.LENGTH_LONG).show();
}
limpiar();
db.close();
}

8. Y la última seción del CRUS es actualizar(), que permite modificar los datos
mediante un procedimiento similar al insert(), como lo es ContentValues:

public void actualizar(View view) {

SQLiteDatabase db = conn.getWritableDatabase();
String placax = txtplaca.getText().toString();
String[] parametros = {placax};
ContentValues values = new ContentValues();
values.put(Utilidades.CAMPO_MARCA, txtmarca.getText().toString());
values.put(Utilidades.CAMPO_MODELO, txtmodelo.getText().toString());
values.put(Utilidades.CAMPO_PRECIO, txtprecio.getText().toString());
int cant = db.update(Utilidades.TABLA_VEHICULO, values, Utilidades.CAMPO_PLACA +
"=?", parametros);
if (cant ==1) {
Toast.makeText(getApplicationContext(), "La Placa Nº" +
txtplaca.getText().toString() + "\nFue Actualizada", Toast.LENGTH_LONG).show();
}else {
Toast.makeText(getApplicationContext(), "No se pudo Actualizar la Placa Nº"
+ txtplaca.getText().toString(), Toast.LENGTH_LONG).show();
}
limpiar();
db.close();
}

Todos los procedimientos anteriores se pueden realizar en SQL mediante el rawquery() o

por medio del excecSQL():

INSERTAR:
private void registrarUsuariosSQL() {
ConexionSQLiteHelper conn = new ConexionSQLiteHelper(this, "bd_clientes.db",
null,1);
try {
db = conn.getWritableDatabase();
//INSERT INTO usuarios (id, nombre, telefono) VALUES (1234,'PEDRO',
'34554433')
String insertar = "INSERT INTO " + Utilidades.TABLA_USUARIO + " (" +
Utilidades.CAMPO_ID +
", " + Utilidades.CAMPO_NOMBRE + ", " + Utilidades.CAMPO_TELEFONO +
") VALUES (" +
campoId.getText().toString() + ", '" +
campoNombre.getText().toString() + "','" +
campoTelefono.getText().toString() + ")";
db.execSQL(insertar);
db.close();
}catch (Exception e){
if(db.isOpen()){
db.close();
}
}
}
BUSCAR:
private void consultarSQL() {
SQLiteDatabase db = conn.getReadableDatabase();
String[] param = {campoId.getText().toString()};
try {
//SELECT nombre, telefono FROM usuarios WHERE codigo = ?
Cursor cursor = db.rawQuery("SELECT " + Utilidades.CAMPO_NOMBRE + ", " +
Utilidades.CAMPO_TELEFONO + " FROM " + Utilidades.TABLA_USUARIO + " WHERE " +
Utilidades.CAMPO_ID + "=?", param);
cursor.moveToFirst();
campoNombre.setText(cursor.getString(0));
campoTelefono.setText(cursor.getString(1));
cursor.close();
db.close();

}catch (Exception e){

Toast.makeText(getApplicationContext(),"No existe Documento",
Toast.LENGTH_LONG).show();
limpiar();
db.close();
}
}

NOTA:

Para mostrar una variable en un formato numérico se utiliza la siguiente rutina para
Android:

DecimalFormat formato_numero = new DecimalFormat("#,###,###,###,###");

String salida =formato_numero.format(Integer.parseInt(tuEditText.getText().
toString().replaceAll("[$,.]", "")));
tuEditText.setText("$"+salida);
 Control ViewPager2

Muchas aplicaciones en Android utilizan un patrón de deslizamiento entre pantallas o

parte de las pantallas de derecha a izquierda o de izquierda a derecha (a veces en forma
vertical) para facilitar el acceso a las distintas secciones de una aplicación. El control
ViewPager2 utiliza la librería RecyclerView, pero no precisamente el control visual del
RecyclerView sino las clases Adapter y ViewHolder que provee dicha librería.

Ejemplo: implementar una aplicación que contenga diferentes layouts que muestren al
desplazar horizontalmente de derecha a izquierda o viceversa, las diferentes banderas
suramericanas:

1. Se crea la MainActivity. Dentro de ella se crea un ViewPager2 que va a contener los

layouts de los países.
2. En res (recursos), dentro de la carpeta layouts, se crea la plantilla o layout que es
que se va a modificar con el cambio de posición. Dentro de este, se crean el
TextView y el ImageView que contendrán el nombre del país y la imagen de la
bandera.
3. Se define en el MainActivity el ViewPager (vp) y se le define un adaptador que
contendrá una clase de AdaptadorPaises (con el layout creado), y las matrices de
nombres e imágenes:

public class MainActivity extends AppCompatActivity {

String[] paises =
{"Argentina","Bolivia","Brasil","Chile","Colombia","Ecuador","Paraguay","Perú","Urug
uay","Venezuela"};
int [] fotos = {R.drawable.argentina, R.drawable.bolivia, R.drawable.brasil,
R.drawable.chile, R.drawable.colombia,
R.drawable.ecuador, R.drawable.paraguay, R.drawable.peru,
R.drawable.uruguay, R.drawable.venezuela};

ViewPager2 vp;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

vp = findViewById(R.id.vp);
vp.setAdapter(new AdaptadorPaises());

4. Se crea una inner class con el nombre asignado en el Adaptador, haciendo extends
a un Adaptador del RecyclerView que contendrá los Paises
(AdaptadorPaisesHolder) y se implementan sus tres métodos obligatorios.
5. Dentro de esta clase Adaptador Paises se crea otra subclase
AdaptadorPaisesHolder con extends a RecyclerView.ViewHolder. Luego se define
 el método constructor super. Dentro de este se definen las partes del layout que
contienen el nombre del país y la imagen de la bandera:
private class AdaptadorPaises extends
RecyclerView.Adapter<AdaptadorPaises.AdaptadorPaisHolder> {

@NonNull
@Override
public AdaptadorPaisHolder onCreateViewHolder(@NonNull ViewGroup parent, int
viewType) {
return new AdaptadorPaisHolder(getLayoutInflater().inflate
(R.layout.layoutpais, parent, false));
}

@Override
public void onBindViewHolder(@NonNull AdaptadorPaisHolder holder, int position)
{
holder.imprimir(position);
}

@Override
public int getItemCount() {
return paises.length;
}

class AdaptadorPaisHolder extends RecyclerView.ViewHolder{

ImageView iv1;
TextView tv1;

public AdaptadorPaisHolder(@NonNull View itemView) {

super(itemView);

iv1 = itemView.findViewById(R.id.ivPais);
tv1 = itemView.findViewById(R.id.tvPais);
}

public void imprimir(int position){

iv1.setImageResource(fotos[position]);
tv1.setText(paises[position]);
}
}
}

6. Si se quiere que el movimiento sea de arriba hacia abajo o viceversa, dentro de la

clase MainActivity se configura la orientación del ViewPager2:

vp.setOrientation(ViewPager2.ORIENTATION_VERTICAL);
 Controles TabLayout y ViewPager2

El control TabLayout muestra una serie de pestañas que al vincularlo con el ViewPager2
permite desplazarse entre las vistas del ViewPager2 sin tener que deslizar los dedos de
izquierda a derecha. Disponer de un TabLayout en la parte superior de la pantalla permite
crear un aplicación más ordenada y accesible.

Ejercicio: Mostrar un TableLayout con los días de la semana y mediante un ViewPager2

hacer un contenedor que lleve un TextView para ingresar las actividades del día.

1. Crear el MainActivity y el layout interno se coloca en LinearLayout, pues va a

contener los tabs del TabLayout y el ViewPager2.
2. Insertar un TabLayout en el LinearLayout, y se deben eliminar todos sus
TabItems, que van a ser generados dinámicamente.
3. Insertar un ViewPager2, que será el contenedor del layout interno creado en el
numeral 1.
4. Se definen todos los componentes que van en el MainActivity (el tablayout y el
viewpager).
5. Se crea el AdaptadorAgenda que extiende el RecyclerView.Adapter de la clase
AdaptadorAgenda.AdaptadorAgendaHolder y dentro de ella se ubica la sub-clase
AdaptadorAgendaHolder que se extiende de la clase RecyclerViewHolder. A esta
sub-clase se le crea el constructor.
6. Se crea el componente TextView dentro del constructor. Y a la private class
AdaptadorAgenda se le implementan los 3 métodos que vienen intrínsecos. En el
onCreateViewHolder se hace el retorno para que sea abierto el layout de recursos
creado en el numeral 1. Se enlaza el onBindViewHolder con una función interna
que se encarga de leer cada una de las posiciones de la matriz de actividades, y la
coloca dentro de cada uno de los layouts de cada uno de los días. En el
getItemCount se coloca la longitud de la matriz de días.
public class MainActivity extends AppCompatActivity {

String [] dias =
{"Lunes","Martes","Miércoles","_Jueves","Viernes","Sábado","Domingo"};
String [] actividades = {"","","","","","",""};

ViewPager2 vp2;
TabLayout tablayout1;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

vp2 = findViewById(R.id.viewpager2);
tablayout1 = findViewById(R.id.tablayout1);

vp2.setAdapter(new AdaptadorAgenda());

TabLayoutMediator tlm = new TabLayoutMediator(tablayout1, vp2, new

TabLayoutMediator.TabConfigurationStrategy() {
 @Override
public void onConfigureTab(@NonNull TabLayout.Tab tab, int position) {
tab.setText(dias[position]);
}
});
tlm.attach();
}

private class AdaptadorAgenda extends RecyclerView.Adapter

<AdaptadorAgenda.AdaptadorAgendaHolder> {

@NonNull
@Override
public AdaptadorAgendaHolder onCreateViewHolder(@NonNull ViewGroup parent,
int viewType) {

return new
AdaptadorAgendaHolder(getLayoutInflater().inflate(R.layout.layoutdia, parent,
false));
}

@Override
public void onBindViewHolder(@NonNull AdaptadorAgendaHolder holder, int
position) {

holder.imprimir(position);
}

@Override
public int getItemCount() {
return dias.length;
}

class AdaptadorAgendaHolder extends RecyclerView.ViewHolder{

EditText et1;

public AdaptadorAgendaHolder(@NonNull View itemView) {

super(itemView);

et1 = itemView.findViewById(R.id.etActividades);
et1.setOnKeyListener(new View.OnKeyListener() {
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
actividades[getLayoutPosition()] = et1.getText().toString();
return false;
}
});
}

public void imprimir(int position) {

et1.setText(actividades[position]);
}
}
}
}

7. Luego, hay que tener en cuenta actualizar constantemente, cada vez que se
modifique el EditText Multiline, tome la posición del día y en esa posición grabe la
actividad en la matriz de actividades.
et1 = itemView.findViewById(R.id.etActividades);
et1.setOnKeyListener(new View.OnKeyListener() {
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
actividades[getLayoutPosition()] = et1.getText().toString();
return false;
8. Para que los días no queden amontonados en la pantalla, se va al XML del
MainActivity, se selecciona el TabLayout y se va al atributo tabMode y se modifica
de fixed a scrollable.
9. Para guardar las actividades, se debe implementar el método onPause, el cual
permite que cada vez que se salga de la aplicación, salga de la actividad o se
ingrese a otra, el sistema permitirá grabar los contenidos de las actividades en un
archivo SharedPreferences, el cual mediante la posición del día y la actividad
registra el contenido. A su vez cuando se ingresa a la aplicación o actividad, el
sistema revisa en el onCreate si existe el archivo con formato SharedPreferences y
coloca en cada día la actividad de cada uno.

Dentro de onPause()
@Override
protected void onPause() {
super.onPause();
SharedPreferences preferencias = getSharedPreferences("agenda",
Context.MODE_PRIVATE);
SharedPreferences.Editor editor1 = preferencias.edit();
for (int f=0; f<dias.length; f++){
editor1.putString(dias[f], actividades[f]);
}
editor1.commit();
}

Dentro de onCreate()
SharedPreferences preferencias = getSharedPreferences("agenda",
Context.MODE_PRIVATE);
for (int f=0; f<dias.length; f++){
String acti = preferencias.getString(dias[f], "");
actividades[f] = acti;
}
 Menú de Opciones en la Barra del Titulo

En el Menú de Opciones de la barra del Título se deben ubicar las acciones globales de la
aplicación, como pueden ser: configuración de la aplicación, búsquedas, cerrar la
aplicación, etc.

Figura 6. Menú de la Barra Título.

También forman parte del menú de opciones los íconos que aparecen a la izquierda de los
tres puntos verticales encargados de mostrar el menú desplegable.

1. Crear la App con su respectiva MainActivity

2. En la carpeta res crear un Android Resource Directory, seleccionando el Resource
Type en Menú.
3. En la carpeta nueva de menú, se debe crear Un Nuevo Archivo de Recursos (New
 Menu Resource File) donde quedarán guardadas las opciones del menú.
4. La Paleta de Componentes cambia a componentes de Menú, y la sección de
Component Tree presenta el Layout menú. Dentro de este árbol se van agregando
los diferentes ítems de menú, agregando al menos el id y el texto de cada uno de
ellos, hasta completar las opciones del menú.
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item
android:id="@+id/agrandarfuente"
android:title="Agrandar Fuente" />
<item
android:id="@+id/reducirfuente"
android:title="Reducir Fuente" />
<item
android:id="@+id/salir"
android:title="Salir" />
</menu>
5. Ahora se debe enlazar el menú con el MainActivity agregando un @Override
Method llamado onCreateOptionsMenu, agregando un getMenuInflater, para que
abra las opciones del menú, con el R.menu.menudeopciones:
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menudeopciones, menu);
return true;
}

6. Posterior a esto, se debe capturar el click de cada uno de los ítems del menú, para
poder ejecutar la actividad. Para ello se declaran los componentes en el
MainActivity que va a utilizar la aplicación y luego se agrega el @Override Method
onOptionsItemSelected.
7. Dentro de este método se declara un entero que contiene el número del ítem
seleccionado. Dependiendo de este número se establece la acción a seguir. Se
debe tener en cuenta que cuando existe un return no se coloca break dentro del
case, y debe existir la opción default que lo devuelve al método padre
onOptionsItemSelected dirigido al item original:

@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
int nro = item.getItemId();
float valor;

switch (nro){
case (R.id.agrandarfuente):
valor = tv1.getTextSize();
valor += 20;
tv1.setTextSize(TypedValue.COMPLEX_UNIT_PX, valor);
return true;
case (R.id.reducirfuente):
valor = tv1.getTextSize();
valor -= 20;
tv1.setTextSize(TypedValue.COMPLEX_UNIT_PX, valor);
return true;
case (R.id.salir):
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}

8. Si se desea que la opción del menú aparezca permanentemente en la barra de

título, se debe colocar el atributo showAsAction en always (aparecerá el texto del
título), y para que sólo aparezca un ícono, se debe colocar un archivo gráfico en el
atributo icon.
9. Para crear sub-menús, en el árbol de componentes al ítem que se le desee hacer
un sub-menú, se le agrega un menú de la Paleta de Componentes y dentro de este
menú se agregan los nuevos ítems:
<item
android:id="@+id/color"
android:title="Color"
>
<menu >
<item
android:id="@+id/rojo"
 android:title="Rojo" />
<item
android:id="@+id/verde"
android:title="Verde" />
<item
android:id="@+id/azul"
android:title="Azul" />
</menu>
</item>