Introducción de esta sección
Bien, en el capítulo anterior repasamos los cuatro componentes principales de Android: Activity, Service, BroadcastReceiver, ContentProvider, y el vínculo entre ellos: Intent. Y en este capítulo les traemos algo llamado Fragment (fragmento). En esta sección presentaremos algunos conceptos básicos y usos de este Fragment. ¡Documentación oficial:Fragment
1. Conceptos básicos
1) ¿Qué es y para qué sirve?
Respuesta: Fragment es una nueva API introducida después de Android 3.0. Su propósito inicial fue adaptarse a las tabletas de pantalla grande. Por supuesto, ahora sigue siendo el favorito del diseño de UI de aplicaciones para tabletas, y también lo agregaremos en el desarrollo de teléfonos móviles comunes. Podemos verlo como un pequeño Activity, también llamado fragmento de Activity. ¡Piénsalo! Si una interfaz muy grande tiene un solo diseño, cuán problemático sería escribir la interfaz, y si hay muchos componentes, también es problemático administrarlos. Con Fragment podemos dividir la pantalla en varias partes, agruparlas y realizar una gestión modular. De esta manera, es más conveniente actualizar dinámicamente la interfaz de usuario de Activity durante la ejecución. Además, Fragment no se puede usar solo; debe estar anidado en Activity. Aunque tiene su propio ciclo de vida, también se ve afectado por el ciclo de vida del Activity anfitrión. Por ejemplo, si el Activity se destruye, él también será destruido.
La siguiente figura muestra un diagrama de manejo de un Fragment en diferentes situaciones entre teléfono y tableta, dado en la documentación:

PD: Una página simple de navegación de noticias que usa dos Fragments para mostrar la lista de noticias y el contenido de las noticias respectivamente;
2) Diagrama del ciclo de vida de Fragment

3) Puntos clave:
A continuación, algunos puntos clave sobre el uso de Fragment:
- Introducido después de la versión 3.0, es decir, minSdk debe ser mayor que 11
- Fragment debe usarse anidado en Activity; por supuesto, también se puede anidar en otro Fragment, pero este Fragment anidado también debe estar anidado en Activity. Indirectamente, ¡Fragment aún necesita estar anidado en Activity! Está afectado por el ciclo de vida del Activity anfitrión; por supuesto, también tiene su propio ciclo de vida. Además, no se recomienda anidar Fragment dentro de Fragment porque el ciclo de vida del Fragment anidado no es controlable.
- La documentación oficial dice que al crear un Fragment, al menos se deben implementar tres métodos: onCreate(), onCreateView(), onPause(); aunque parece que solo escribir onCreateView() también es posible...
- El ciclo de vida de Fragment es algo similar al de Activity: tres estados:
Resumed: el Fragment en ejecución es visible
Paused: el Activity donde se encuentra es visible, pero no puede obtener el foco
Stoped: ① Al llamar a addToBackStack(), el Fragment se agrega a la pila Back ② El Activity pasa a segundo plano, o el Fragment es reemplazado/eliminado
PD: el fragment en estado detenido sigue vivo (todos los estados e información de miembros son mantenidos por el sistema), sin embargo, ya no es visible para el usuario, y si el activity es eliminado, él también será eliminado.
4) Algunas subclases de Fragment:
PD: Muchas veces simplemente sobrescribimos Fragment, inflate carga el diseño para completar el negocio correspondiente; las subclases no se usan mucho, ¡investigaremos más a fondo cuando sea necesario!
- Diálogo:DialogFragment
- Lista:ListFragment
- Configuración de opciones:PreferenceFragment
- Interfaz WebView:WebViewFragment
5) ¿Usar Fragment del paquete App o del paquete v4:
Resumen del problema:
Creo que muchos amigos encontrarán la siguiente situación al usar Fragment:

Entonces, ¿usamos Fragment en android.app o usamos Fragment en el paquete android.support.v4.app?
Respuesta: En realidad, ambos son posibles. Como se mencionó antes, Fragment se introdujo después de Android 3.0 (API 11). Entonces, ¿qué pasa si la aplicación desarrollada necesita ejecutarse en versiones anteriores a 3.0? Por ejemplo, ¡2.3 que todavía tiene una pequeña cuota de mercado! Así que el paquete v4 nació en respuesta a esta necesidad, y puede ser compatible hasta la versión 1.6. En cuanto a qué paquete usar, depende de tus necesidades. Ahora la cuota de mercado de teléfonos con versiones anteriores a 3.0 ya no es mucha; por todas partes hay teléfonos con 4.0 o superior, y 6.0 ya salió en octubre, ¿no crees? Así que en este momento, puedes usar directamente el Fragment del paquete app y llamar a los métodos correspondientes; normalmente no habrá problemas. Si tu Fragment usa el paquete app, tanto FragmentManager como FragmentTransaction también deben ser del paquete app. O usas todo del paquete app, o todo del paquete v4, de lo contrario habrá errores. Por supuesto, si quieres que tu aplicación también sea compatible con teléfonos de versiones bajas, entonces puedes elegir el paquete v4.
Cosas a tener en cuenta al usar Fragment del paquete v4:
- ① Si usas Fragment del paquete v4, entonces el Activity donde se encuentra debe heredar FragmentActivity. Caso: hoy cargué estáticamente el fragment en un archivo XML y sobrescribí Fragment, pero al cargar el Activity se reportó un error. El mensaje era algo así como error de Fragment o no encontrado; cambié el atributo name varias veces y seguía mal. Finalmente descubrí que era porque usé el paquete v4; solo necesitaba cambiar tu Activity a FragmentActivity.
- ② Anteriormente escribí el siguiente código y luego reportó un error:
Es un poco desconcertante. Fragment, FragmentManager, FragmentTransaction todos usan el paquete v4, y Activity también hereda FragmentActivity. ¿Por qué? Cambiar todo al paquete app funcionaría, pero ¿no entra en conflicto con nuestra premisa de usar el paquete v4? En realidad, hay una solución, ¿verdad?
Respuesta: solo necesitasgetFragmentManagercambiar ( ) agetSupportFragmentManager( ) y listo.
2. Crear un Fragment
1) Cargar Fragment estáticamente
Proceso de implementación:

Código de ejemplo:
Step 1:Definir el diseño de Fragment, es decir, el contenido que muestra el fragment.
Step 2:Personaliza una clase Fragment; debe heredar Fragment o sus subclases, y sobrescribir el método onCreateView(). En ese método, llama al método inflater.inflate() para cargar el archivo de diseño del Fragment y luego devuelve el objeto view cargado.
public class Fragmentone extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment1, container,false);
return view;
}
}
Step 3:En el archivo de diseño correspondiente al Activity que necesita cargar el Fragment, agrega la etiqueta fragment. Recuerda que el atributo name es el nombre de clase totalmente calificado, es decir, debe incluir el nombre del paquete de Fragment, como:
<fragment
android:id="@+id/fragment1"
android:name="com.jay.example.fragmentdemo.Fragmentone"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1" />
Step 4:El Activity solo necesita llamar a setContentView() en el método onCreate() para cargar el archivo de diseño.
2) Cargar Fragment dinámicamente
Proceso de implementación:

Código de ejemplo:Aquí se demuestra cómo cambiar Fragment cuando se rota la pantalla entre horizontal y vertical:

No publicaré el código de Fragment y el diseño; directamente publicaré el código clave de MainActivity:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Display dis = getWindowManager().getDefaultDisplay();
if(dis.getWidth() > dis.getHeight())
{
Fragment1 f1 = new Fragment1();
getFragmentManager().beginTransaction().replace(R.id.LinearLayout1, f1).commit();
}
else
{
Fragment2 f2 = new Fragment2();
getFragmentManager().beginTransaction().replace(R.id.LinearLayout1, f2).commit();
}
}
}
3. Gestión de Fragment y transacciones de Fragment

4. Interacción entre Fragment y Activity

Puede que algunos amigos no les guste ver diagramas; a continuación lo presento en texto:
1) Obtención de componentes
Fragment obtiene los componentes en Activity:getActivity().findViewById(R.id.list);
Activity obtiene los componentes en Fragment (puede ser según id y tag):getFragmentManager.findFragmentByid(R.id.fragment1);
2) Transferencia de datos
① Activity transfiere datos a Fragment:
En la Activity, crea un paquete Bundle, llama al método `setArguments(bundle)` de la instancia del Fragment para pasarle el paquete Bundle al Fragment. Luego, en el Fragment, llama a `getArguments()` para obtener el objeto Bundle y analizarlo.
② El Fragment pasa datos a la Activity
En el Fragment se define una interfaz de devolución de llamada interna, y luego la Activity que contiene a ese Fragment implementa dicha interfaz. Así el Fragment puede pasar datos a través de la interfaz de devolución de llamada. Las devoluciones de llamada, creo que muchos saben qué son, pero no saben escribirlas. Si buscas en Internet "Fragment pasa datos a Activity", todo es el código del profesor Li Gang; la verdad, no tengo palabras. Bueno, aquí escribiré un fragmento de código; creo que con solo verlo los lectores lo entenderán:
Step 1: definir una interfaz de devolución de llamada (en el Fragment):
/*接口*/
public interface CallBack{
/*定义一个获取信息的方法*/
public void getResult(String result);
}
Step 2: devolución de llamada de la interfaz (en el Fragment)
/*接口回调*/
public void getData(CallBack callBack){
/*获取文本框的信息,当然你也可以传其他类型的参数,看需求咯*/
String msg = editText.getText().toString();
callBack.getResult(msg);
}
Step 3: usar el método de devolución de llamada de la interfaz para leer datos (en la Activity)
/* 使用接口回调的方法获取数据 */
leftFragment.getData(new CallBack() {
@Override
public void getResult(String result) { /*打印信息*/
Toast.makeText(MainActivity.this, "-->>" + result, 1).show();
}
});
Resumen del método:
->En el Fragment se define una interfaz, y en la interfaz se define un método abstracto; el tipo de dato que quieras pasar se establece como tipo del parámetro.
->Luego también hay que escribir un método que invoque al método abstracto de la interfaz y le pase los datos que se quieren transmitir.
->Después viene la Activity: se llama al método proporcionado por el Fragment y, al sobrescribir el método abstracto, se leen los datos. ¡¡¡Eso es todo!!!
③ Transmisión de datos entre Fragment y Fragment
En realidad es muy sencillo: encuentra el objeto Fragment que va a recibir los datos y llama directamente a `setArguments()` para pasarle los datos. Normalmente se hace al usar `replace`, es decir, al saltar de un Fragment a otro; solo necesitas, después de inicializar el Fragment al que se va a saltar, llamar a su método `setArguments()` para pasarle los datos.
Si dos Fragment necesitan transmitirse datos en tiempo real, en lugar de mediante un salto, primero hay que obtener en la Activity los datos enviados por f1 y luego pasarlos a f2; es decir, la Activity actúa como intermediario~
El código de ejemplo es el siguiente:
FragmentManager fManager = getSupportFragmentManager( );
FragmentTransaction fTransaction = fManager.beginTransaction();
Fragmentthree t1 = new Fragmentthree();
Fragmenttwo t2 = new Fragmenttwo();
Bundle bundle = new Bundle();
bundle.putString("key",id);
t2.setArguments(bundle);
fTransaction.add(R.id.fragmentRoot, t2, "~~~");
fTransaction.addToBackStack(t1);
fTransaction.commit();
5. Recorrer el diagrama del ciclo de vida:
Después de pensarlo mucho, he decidido llevaros a hacer un breve recorrido por el diagrama del ciclo de vida para profundizar en la comprensión del ciclo de vida del Fragment:
① Cuando la Activity carga el Fragment, se van llamando los siguientes métodos en orden:onAttach -> onCreate -> onCreateView -> onActivityCreated -> onStart ->onResume
② Cuando creamos una Activity de estilo cuadro de diálogo flotante, u otra, es decir, hacemos que la Activity donde se encuentra el Fragment sea visible pero no obtenga el foco:onPause
③ Cuando se cierra el diálogo, la Activity vuelve a obtener el foco:onResume
④ Cuando reemplazamos el Fragment y llamamos a `addToBackStack()` para agregarlo a la pila Back:onPause -> onStop -> onDestoryView !!Nota, ¡¡el Fragment todavía no ha sido destruido en este momento!!
⑤ Cuando pulsamos la tecla de retroceso del teclado, el Fragment se mostrará de nuevo:onCreateView -> onActivityCreated -> onStart -> onResume
⑥ Si después de reemplazar, antes del commit de la transacción,no llamamos a `addToBackStack()`para agregar el Fragment a la pila Back; o si se sale de la Activity, entonces el Fragment se terminará por completo y entrará en estado de destrucción.onPause -> onStop -> onDestoryView -> onDestory -> onDetach
Resumen de esta sección:
En esta sección hemos explicado algunos conceptos básicos y usos sencillos del Fragment. Creo que poco a poco os irá gustando Fragment. Por cuestión de extensión, en esta sección escribimos solo esto; en la siguiente os llevaremos a escribir algunos ejemplos comunes sobre Fragment. ¡Esperadlo con interés, gracias~
Es un poco desconcertante. Fragment, FragmentManager, FragmentTransaction todos usan el paquete v4, y Activity también hereda FragmentActivity. ¿Por qué? Cambiar todo al paquete app funcionaría, pero ¿no entra en conflicto con nuestra premisa de usar el paquete v4? En realidad, hay una solución, ¿verdad?