INSTITUTO TECNOLOGICO DE OCOTLAN

INGENIERIA EN SISTEMAS COMPUTACIONALES

Nombre de la Materia: TÓPICOS AVANZADOS DE PROGRAMACIÓN CON

DISPOSITIVOS android

Nombre del trabajo: Fragments y Navigation Component

alumno: Castellanos Arrañaga Alan Braulio

Número de Control: 18630328
Maestro: Razo Reinoso Julio Cesar
 Fragments

Como crear un fragmento

Para crear un fragmento, extiende la clase Fragment, y sobreescribe los métodos

del ciclo de vida claves para insertar la lógica de tu app, de forma similar a como lo
harías con la clase Activity.
La diferencia es que al crear un Fragment tu debes utilizar la llamada
onCreateView() para definir el layout. De hecho, esta es la única llamada que
necesitas para conseguir que se ejecute el fragmento. Por ejemplo, aquí puedes
ver un fragmento simple que especifica su propio layout:

ArticleFragment.javaJava
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.ViewGroup;

public class ArticleFragment extends Fragment {

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

Como si se tratase de una actividad, un fragmento debería implementar los

métodos del ciclo de vida que te permiten gestionar su estado en función de si es
añadido o eliminado de la actividad en la que se encuentre, además de las
transiciones de la actividad entre los diferentes estados del ciclo de vida. Por
ejemplo, cuando el método onPause() de la actividad es llamado, cualquier
fragmento en la actividad también llama a onPause().

Como agregar un fragmento a una actividad?

Añadir un Fragment a una Actividad utilizando XML

Mientras que los fragmentos son reutilizables, componentes de la UI modulares,
cada instancia de una clase Fragment debe asociarse con un padre
FraggmentActivity. Puedes hacer esta asociación definiendo cada fragmento
dentro del archivo XML que es el layout de tu actividad.

Nota: FragmentActivity es una actividad especial proporcionada en la Support

Library para manipular los fragmentos en versiones del sistema inferiores a un
nivel API 11. Si no utilizas la Support Library puedes utilizar una Activity normal.

Aquí puedes ver un ejemplo de un archivo layout que incluye dos fragmentos para
que en una actividad que se utilice en una pantalla considerada “grande (large)”
(especificada mediante el calificador large en el nombre del directorio).

res/layout-large/news_articles.xmlXHTML

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="fill_parent"
android:layout_height="fill_parent">

<fragment android:name="com.example.android.fragments.HeadlinesFragment"
 android:id="@+id/headlines_fragment"
android:layout_weight="1"
android:layout_width="0dp"
android:layout_height="match_parent" />

<fragment android:name="com.example.android.fragments.ArticleFragment"
android:id="@+id/article_fragment"
android:layout_weight="2"
android:layout_width="0dp"
android:layout_height="match_parent" />

</LinearLayout>

Consejo: Para más información sobre crear layouts para diferentes tamaños de
pantalla, visita Soporte de Diferentes Tamaños de Pantalla.

Ahora aplica el layout a tu actividad:

MainActivity.javaJava

import android.os.Bundle;
import android.support.v4.app.FragmentActivity;

public class MainActivity extends FragmentActivity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.news_articles);
}
}

Si estás utilizando la v7 appcompat library, tu actividad debería en su lugar

extender AppCompatActivity, la cual es una subclase de FragmentActivity (para
más información, visita Añadir la Action Bar).

Nota: Cuando añades un fragmento a un layout de una actividad definiendo el

fragmento en el archivo XML del layout, no puedes eliminar el fragmento en
tiempo de ejecución. Si planeas intercambiar entre tus fragmentos durante la
interacción del usuario, debes añadir el fragmento a la actividad cuando esta se
inicia por primera vez, como se muestra en la próxima lección.
Como pasar datos entre fragmentos
Estas operaciones son las siguientes:
Primero agregue el oyente en el botón enviar y este botón enviará los datos. …
Ahora cree la variable de tipo String para almacenar el valor de EditText que
ingresa el usuario. …
Ahora cree el objeto Intent First_activity. …
Ponga el valor en el método putExtra en el par clave-valor y luego inicie la
actividad.
Ciclo de vida de los fragmentos.
ara navegar por las transiciones entre las etapas del ciclo de vida de una
actividad, la clase Activity proporciona un conjunto básico de seis devoluciones de
llamadas: onCreate(), onStart(), onResume(), onPause(), onStop() y onDestroy().
El sistema invoca cada una de estas devoluciones de llamada cuando una
operación entra en un nuevo estado.
Cuando el usuario comienza a abandonar la actividad, el sistema llama a métodos
para desmantelarla. En algunos casos, este desmantelamiento es solo parcial; la
actividad todavía reside en la memoria (por ejemplo, cuando el usuario cambia a
otra app) y aún puede volver al primer plano. Si el usuario regresa a esa actividad,
se reanuda desde donde la dejó. Con algunas excepciones, se restringen las apps
para que no inicien actividades cuando se ejecutan en segundo plano.
 Navigation component

Descripcion
Se refiere a las interacciones que permiten a los usuarios navegar a través, dentro
y fuera de las diferentes piezas de contenido de tu app. El componente Navigation
de Android Jetpack te permite implementar la navegación, desde simples clics de
botones hasta patrones más complejos, como las barras de apps y los paneles
laterales de navegación.

Principios de la navegación
Destino de inicio fijo
Cada app que compilas tiene un destino de inicio fijo. Esta es la primera pantalla
que ve el usuario cuando inicia la app desde el selector. Este destino también es
la última pantalla que ve el usuario cuando regresa al selector después de
presionar el botón Atrás.

El estado de navegación se representa como una pila de destinos.

Cuando se inicia tu app por primera vez, se crea una nueva tarea para el usuario,
y la app muestra su destino de inicio. Esto se convierte en el destino base de lo
que se conoce como la pila de actividades y es la base del estado de navegación
de tu app. La parte superior de la pila es la pantalla actual, y los destinos
anteriores de la pila representan el historial de dónde has estado.
El botón Arriba nunca sale de tu app
Si un usuario se encuentra en el destino de inicio de la app, el botón Arriba no
aparece, ya que nunca sale de la app. Sin embargo, se muestra el botón Atrás y
sale de la app.

Los vínculos directos simulan la navegación manual

Cuando usas un vínculo directo a un destino dentro de la tarea de tu app, se quita

cualquier pila de actividades existente de la tarea de tu app y se reemplaza con la
pila de actividades con vínculo directo.
Con la app de Sunflower de ejemplo, supongamos que el usuario inició la app
anteriormente desde la pantalla del selector y que navegó hasta la pantalla de
detalles de una manzana.

Cómo crear un gráfico de navegación

La navegación ocurre entre los destinos de tu app, es decir, en cualquier lugar de
tu app en el que los usuarios puedan navegar. Estos destinos están conectados a
través de acciones.
Un gráfico de navegación es un archivo de recursos que contiene todos tus
destinos y acciones. El gráfico representa todas las rutas de navegación de tu app.

Para agregar un gráfico de navegación a tu proyecto, haz lo siguiente:

En la ventana Project, haz clic con el botón derecho en el directorio de res y
selecciona New > Android Resource File. Se muestra el diálogo New Resource
File.
Escribe un nombre como "nav_graph" en el campo File name.
Selecciona Navigation en la lista desplegable Resource type y, luego, haz clic en
OK.

Editor de Navigation
Después de agregar un gráfico, Android Studio abre el gráfico en el Editor de
Navigation. En el Editor de Navigation, puedes editar a nivel visual los gráficos de
navegación o editar directamente el XML subyacente.

Panel de destinos: muestra una lista de tu host de navegación y todos los destinos
que se encuentran actualmente en el Graph Editor.
Graph Editor: incluye una representación visual de tu gráfico de navegación.
Puedes cambiar entre la vista Design y la representación del XML subyacente en
la vista Text.
Atributos: muestra atributos del elemento seleccionado actualmente en el gráfico
de navegación.
Haz clic en la pestaña Text para ver el XML correspondiente, que debería ser
similar al siguiente fragmento:

<?xml version="1.0" encoding="utf-8"?>

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:id="@+id/nav_graph">

</navigation>
Anatomía de un destino
El campo Type indica si un destino se implementa como un fragmento, una
actividad o cualquier otra clase personalizada en tu código fuente.
El campo Label contiene el nombre del destino legible para el usuario. Esto podría
aparecer en la IU, por ejemplo, si conectas el NavGraph a la Toolbar
usandosetupWithNavController(). Por este motivo, se recomienda que uses strings
de recursos para este valor.
El campo ID contiene el ID del destino que se utiliza para hacer referencia al
destino en el código.
En el menú desplegable Class, se muestra el nombre de la clase que está
asociada con el destino. Puedes hacer clic en este menú desplegable para
cambiar la clase asociada por otro tipo de destino.
<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
xmlns:android="http://schemas.android.com/apk/res/android"
app:startDestination="@id/blankFragment">
<fragment
android:id="@+id/blankFragment"
android:name="com.example.cashdog.cashdog.BlankFragment"
android:label="@string/label_blank"
tools:layout="@layout/fragment_blank" />
</navigation>

Cómo navegar a un destino

La navegación a un destino se realiza con un NavController, un objeto que
administra la navegación de una app dentro de un elemento NavHost. Cada
NavHost tiene su propio NavController correspondiente. Para recuperar un
NavController, puedes usar uno de los siguientes métodos:

Kotlin:

Fragment.findNavController()
View.findNavController()
Activity.findNavController(viewId: Int)

Cómo garantizar la seguridad de tipo mediante Safe Args

Para navegar entre destinos, te recomendamos que uses el complemento de
Gradle Safe Args, Este complemento genera clases de objetos y compiladores
simples que permiten navegar con seguridad de tipo y pasar argumentos entre
destinos.
buildscript {
repositories {
google()
}
dependencies {
def nav_version = "2.3.5"
classpath "androidx.navigation:navigation-safe-args-gradle-
plugin:$nav_version"
}
}

Como crear destinos

Cómo crear un destino de fragmento nuevo

Para agregar un tipo de destino nuevo mediante el Editor de Navigation, haz lo
siguiente:
En el Editor de Navigation, haz clic en el ícono New Destination y, luego, en
Create new destination.
Crea tu fragmento en el diálogo New Android Component que se muestra. Si
deseas obtener más información sobre los fragmentos, consulta la documentación
correspondiente.

Cómo crear un destino a partir de un DialogFragment

Si tienes un DialogFragment existente, puedes usar el elemento <dialog> para
agregar el diálogo a tu gráfico de navegación, como se muestra en el siguiente
ejemplo:

<?xml version="1.0" encoding="utf-8"?>

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
 android:id="@+id/nav_graph">

...

<dialog
android:id="@+id/my_dialog_fragment"
android:name="androidx.navigation.myapp.MyDialogFragment">
<argument android:name="myarg" android:defaultValue="@null" />
<action
android:id="@+id/myaction"
app:destination="@+id/another_destination"/>
</dialog>

...

</navigation>
Cómo crear un destino de actividad nuevo
Crear un destino Activity es similar a crear un destino Fragment. Sin embargo, la
naturaleza de un destino Activity resulta bastante diferente.

De forma predeterminada, la biblioteca de Navigation adjunta el NavController a

un diseño de Activity, y el gráfico de navegación activo se define en la Activity
activa. Si un usuario navega a una Activity diferente, el gráfico de navegación
actual ya no estará dentro del alcance. Esto significa que un destino Activity debe
considerarse un extremo dentro de un gráfico de navegación.

Para agregar un destino Activity, especifica el destino Activity con su nombre de

clase completamente calificado:
<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:id="@+id/navigation_graph"
app:startDestination="@id/simpleFragment">

<activity
android:id="@+id/sampleActivityDestination"
android:name="com.example.android.navigation.activity.DestinationActivity"
android:label="@string/sampleActivityTitle" />
</navigation>

El intent-filter en la entrada del manifiesto de la Activity de destino determina cómo

debes estructurar el destino Activity.

Por ejemplo, considera el siguiente archivo de manifiesto:

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.navigation.activity">
<application>
<activity android:name=".DestinationActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<data
android:host="example.com"
android:scheme="https" />
<category android:name="android.intent.category.BROWSABLE" />
 <category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
</application>
</manifest>
El destino Activity correspondiente debe configurarse con los atributos action y
data que coincidan con aquellos en la entrada del manifiesto:

<?xml version="1.0" encoding="utf-8"?>

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:id="@+id/navigation_graph"
app:startDestination="@id/simpleFragment">
<activity
android:id="@+id/localDestinationActivity"
android:label="@string/localActivityTitle"
app:action="android.intent.action.VIEW"
app:data="https://example.com"
app:targetPackage="${applicationId}" />
</navigation>

rgumentos dinámicos
En los ejemplos anteriores, se usaron URL fijas a fin de navegar a destinos. Es
posible que también debas admitir URL dinámicas en las que se envíe información
adicional como parte de la URL. Por ejemplo, puedes enviar un ID del usuario en
una URL con un formato similar a https://example.com?userId=<actual user ID>.
En este caso, en lugar del atributo data, usa dataPattern. Luego, puedes
proporcionar argumentos que se reemplacen por marcadores de posición con
nombre dentro del valor de dataPattern:

<?xml version="1.0" encoding="utf-8"?>

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:id="@+id/navigation_graph"
app:startDestination="@id/simpleFragment">
<activity
android:id="@+id/localDestinationActivity"
android:label="@string/localActivityTitle"
app:action="android.intent.action.VIEW"
app:dataPattern="https://example.com?userId={userId}"
app:targetPackage="com.example.android.another.app">
<argument
android:name="userId"
app:argType="string" />
</activity>
</navigation>