Introducción a esta sección
Bueno, en el último capítulo, revisamos los cuatro componentes principales de Android: Actividad, Servicio, BroadCastReceiver, ContentProvider y el enlace entre ellos: Intención, y este capítulo le trae un Fragmento (fragmento). En esta sección, presentaremos algunos conceptos básicos. conceptos y uso de este Fragmento! Documentación oficial: Fragmento
1. Conceptos básicos
1) ¿Qué diablos es y para qué sirve?
Respuesta: Fragment es una nueva API introducida después de Android 3.0. Su intención original es adaptarse a las tabletas de pantalla grande. Por supuesto, sigue siendo el favorito del diseño de la interfaz de usuario de la aplicación de la tableta, y también agregaremos este Fragmento a los teléfonos móviles comunes. desarrollo. , ¡Podemos considerarlo como una pequeña actividad, también conocida como fragmento de actividad! Piénselo, si tenemos una interfaz grande, solo tenemos un diseño, qué problemático será escribir la interfaz, y si hay muchos componentes, ¡será muy problemático administrarlo! ¡Y usando Fragment, podemos dividir la pantalla en varias partes y luego agruparlas para una administración modular! ¡De esta manera, es más conveniente actualizar dinámicamente la interfaz de usuario de la Actividad durante el proceso en ejecución! Además, Fragmento no se puede usar solo. Debe estar anidado en Actividad. Aunque tiene su propio ciclo de vida, aún se verá afectado por el ciclo de vida de la Actividad anfitriona. Por ejemplo, si la Actividad es destruida por destrucción, ¡también será destruido!
La siguiente figura es un Fragmento dado en el documento correspondiente a diferentes situaciones entre teléfonos móviles y tabletas:
PD: una página de navegación de noticias simple, que utiliza dos fragmentos para mostrar la lista de noticias y el contenido de noticias, respectivamente;
2) Diagrama del ciclo de vida del Fragmento
3) Puntos centrales:
Estos son algunos puntos clave del uso de Fragment:
- Introducido después de la versión 3.0, es decir, minSdk debe ser mayor que 11
- El fragmento debe anidarse en Actividad y, por supuesto, puede anidarse en otro Fragmento, pero este Fragmento anidado también debe anidarse en Actividad. Hablando indirectamente, ¡Fragmento aún debe anidarse en Actividad! Afectado por el ciclo de vida de la Actividad anfitriona, ¡por supuesto que también tiene su propio ciclo de vida! Además, no se recomienda anidar Fragmento dentro de Fragmento porque el ciclo de vida del Fragmento anidado dentro es incontrolable.
- El documento oficial dice que se deben implementar al menos tres métodos al crear un Fragmento: onCreate(), onCreateView(), OnPause( ); pero parece que es posible escribir solo uno onCreateView...
- El ciclo de vida del Fragmento es similar al de la Actividad: tres estados:
Reanudado: el Fragmento en el permiso está visible
En pausa: La Actividad está visible, pero no puede obtener el foco
Detenido: ①Llamar a addToBackStack(), el Fragmento se agrega al Bcak pila ②La actividad pasa a segundo plano, o el fragmento se reemplaza/elimina
. si se mata la actividad, también se matará.
4) Varias subclases de Fragmento:
pd: Muchas veces reescribimos Fragmento directamente, inflamos cargas el diseño para completar el negocio correspondiente, las subclases no se usan mucho, ¡y estudiaremos en profundidad cuando sea necesario!
- Diálogo: Fragmento de diálogo
- Lista: Fragmento de lista
- Configuración de opciones: PreferenceFragment
- Interfaz WebView: WebViewFragment
5) Si usar el Fragmento en el paquete de la aplicación o en el paquete v4:
Resumen del problema:
Creo que muchos amigos se encontrarán con la siguiente situación al usar Fragmento:
Entonces, ¿utilizamos el Fragmento en android.app o el Fragmento en el paquete android.support.v4.app?
Respuesta: En realidad, está bien. Como dije anteriormente, Fragment se introdujo después de Android 3.0 (API 11), entonces, ¿qué pasa si la aplicación desarrollada necesita ejecutarse en una versión inferior a 3.0? Por ejemplo, 2.3, que todavía tiene un poco de mercado Entonces, el paquete v4 Así es como surgió, ¡y puede ser compatible con la versión 1.6 al menos! En cuanto a qué paquete utilizar, depende de sus necesidades. Ahora, la cuota de mercado de los teléfonos móviles por debajo de 3.0 en realidad no es mucha. La calle está por encima de 4.0, y 6.0 se lanzará en octubre. ¿Qué piensas... Así que en este momento, puede Usar el Fragmento directamente en el paquete de la aplicación y luego llamar a los métodos relevantes, generalmente no hay problema; si su Fragmento usa el paquete de la aplicación, tanto FragmentManager como FragmentTransaction deben estar en el paquete de la aplicación. ¡Use todas las aplicaciones, o todas usen v4, de lo contrario informará un error!Por supuesto, si desea que su propia aplicación sea compatible con teléfonos móviles de versión baja, ¡entonces puede elegir usar el paquete v4!
Puntos a tener en cuenta al usar Fragment en el paquete v4:
- ①Si usa el Fragmento en el paquete v4, entonces la Actividad en la que se encuentra debe heredar FragmentActivity Caso: Hoy, cargué el fragmento estáticamente en el archivo xml y luego reescribí el Fragmento, pero se informó un error al cargar la Actividad, La sugerencia general es que el Fragmento es incorrecto o no se puede encontrar nada. ¡El atributo de nombre se ha cambiado varias veces y sigue siendo incorrecto! Finalmente, descubrí que se debe al paquete v4. ¡Simplemente cambie su Actividad a FragmentActivity!
- ② Escribí el siguiente código antes y luego informé un error:
Es un poco desconcertante. Fragment, FragmentManager y FragmentTransaction usan el paquete v4. ¿La actividad también hereda FragmentActivity? Está bien cambiarlo a un paquete de aplicación, pero ¿no entra esto en conflicto con nuestra premisa de usar el paquete v4? De hecho, ¿Existe la solución?
Respuesta: Simplemente cambie getFragmentManager ( ) a getSupportFragmentManager ( )
2. Crea un Fragmento
1) Fragmento de carga estática
Proceso de implementación:
Código de muestra:
Paso 1: Defina el diseño del Fragmento, que es el contenido de visualización del Fragmento.Paso
2: Personalice una clase de Fragmento, necesita heredar Fragmento o sus subclases, reescribir el método onCreateView() y llamar a este método: inflater. método inflate () cargando el archivo de diseño de Fragment, y luego devuelve el objeto de vista cargado
clase pública Fragmentone extiende Fragmento {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle SavedInstanceState) {
View view = inflater.inflate(R.layout.fragment1, container,false);
volver a ver;
}
}
Paso 3: Agregue una etiqueta de fragmento al archivo de diseño correspondiente a la Actividad que necesita cargar el Fragmento. Recuerde, el atributo de nombre es un nombre de clase completamente calificado, que debe incluir el nombre del paquete del Fragmento, como:
<fragmento
android:id="@+id/fragment1"
android:name="com.jay.example.fragmentdemo.Fragmentone"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1" / >
Paso 4: La actividad llama a setContentView() en el método onCreate() para cargar el archivo de diseño.
2) Fragmento de carga dinámica
Proceso de implementación:
Código de muestra: aquí hay una demostración de cómo cambiar fragmentos cuando se cambian las pantallas horizontal y vertical:
El fragmento y el código de diseño no se publicarán, y el código clave de MainActivity se pegará directamente:
MainActivity de clase pública extiende la actividad {
@Override
protected void onCreate (Paquete de estado de instancia guardado) {
super.onCreate (Estado de instancia guardado);
setContentView(R.diseño.actividad_principal);
Pantalla dis = getWindowManager().getDefaultDisplay();
if(dis.getWidth() > dis.getHeight())
{
Fragmento1 f1 = new Fragmento1();
getFragmentManager().beginTransaction().replace(R.id.LinearLayout1, f1).commit();
}
else
{
Fragmento2 f2 = nuevo Fragmento2();
getFragmentManager().beginTransaction().replace(R.id.LinearLayout1, f2).commit();
}
}
}
3. Gestión de fragmentos y asuntos de fragmentos
4. Interacción entre Fragmento y Actividad
Tal vez a algunos amigos no les guste mirar imágenes, así que presentémoslos con palabras:
1) Adquisición de componentes
Fragmento obtiene componentes en Actividad: getActivity().findViewById(R.id.list),
Actividad obtiene componentes en Fragmento (según id y etiqueta): getFragmentManager.findFragmentByid(R.id.fragment1);
2) Transferencia de datos
①Activit transfiere datos a Fragmento:
Cree un paquete Bundle en la Actividad, llame a setArguments(bundle) de la instancia de Fragment para pasar el paquete Bundle al Fragment, luego llame a getArguments en el Fragment para obtener el objeto Bundle y luego analícelo.
②Fragmento transfiere datos a Actividad
Defina una interfaz de devolución de llamada interna en el Fragmento, y luego deje que la Actividad que contiene el Fragmento implemente la interfaz de devolución de llamada, y el Fragmento puede pasar datos a través de la interfaz de devolución de llamada. Devolución de llamada, creo que muchas personas saben lo que es, pero no pueden escribir El "fragmento transfiere datos a la actividad" de Baidu en línea es todo el código del Sr. Li Gang. Estoy realmente sin palabras. Escribamos un código aquí. Creo que los lectores pueden entenderlo de un vistazo:
Paso 1: Definir una interfaz de devolución de llamada: (en Fragmento)
/*Interfaz*/
interfaz pública CallBack{
/*Definir un método para obtener información*/
public void getResult(String result);
}
Paso 2: Devolución de llamada de interfaz (en Fragmento)
/*Devolución de llamada de interfaz*/
public void getData(CallBack callBack){
/*Obtenga la información del cuadro de texto, por supuesto, también puede pasar otros tipos de parámetros, según sus necesidades */
String msg = editText.getText(). toString();
callBack. getResult(mensaje);
}
Paso 3: use el método de devolución de llamada de la interfaz para leer datos (en Actividad)
/* Usar el método de devolución de llamada de la interfaz para obtener datos*/
leftFragment.getData(new CallBack() {
@Override
public void getResult(String result) { /*Imprimir información*/
Toast.makeText(MainActivity.this, "-->>" + resultado, 1).mostrar();
}
});
Resuma el método: -> Defina una interfaz en Fragment, defina un método abstracto en la interfaz y establezca el tipo de parámetro de datos que desea pasar; ->
Luego escriba un método abstracto en la interfaz para llamar a los datos que se pasarán Pass it
-> Entonces es Actividad, llame al método provisto por Fragmento, y luego lea los datos al reescribir el método abstracto.
③Transferencia de datos entre Fragmento y Fragmento
De hecho, esto es muy simple. Encuentre el objeto de fragmento que necesita aceptar datos y llame directamente a setArguments para pasar los datos. para llamar después de inicializar el Fragmento para
saltar ¡Su método setArguments puede pasar datos! usar Actividad como medio~
El código de ejemplo es el siguiente:
FragmentManager fManager = getSupportFragmentManager( );
FragmentTransaction fTransaction = fManager.beginTransaction();
Fragmentotres t1 = new Fragmentotres();
Fragmento dos t2 = new Fragmento dos ();
Paquete paquete = nuevo paquete ();
paquete.putString("clave",id);
t2.setArguments(paquete);
fTransaction.add(R.id.fragmentRoot, t2, "~~~");
fTransacción.addToBackStack(t1);
fTransacción.commit();
5. Tome un diagrama de ciclo de vida:
Después de pensarlo, decidí guiarlo a través del diagrama del ciclo de vida para profundizar su comprensión del ciclo de vida del Fragmento:
①Cuando la Actividad cargue el Fragmento, llame a los siguientes métodos a su vez: onAttach -> onCreate -> onCreateView -> onActivityCreated -> onStart -> onResume
②Cuando creamos una Actividad de estilo de diálogo suspendida, u otras, es para hacer la Actividad donde se encuentra el Fragmento, pero no para poner el foco en Pausa
③Cuando se cierra el cuadro de diálogo, la Actividad gana el foco de nuevo: onResume
④ Cuando reemplazamos Fragment y llamamos a addToBackStack() para agregarlo a la pila Back onPause -> onStop -> onDestoryView ! ! ¡ Tenga en cuenta que el Fragmento no ha sido destruido en este momento!
⑤ Cuando presionamos el botón Atrás en el teclado, Fragmento se mostrará nuevamente: onCreateView -> onActivityCreated -> onStart -> onResume
⑥Si después de reemplazar, no se llama al método addToBackStack() para agregar el Fragmento a la pila posterior antes de la confirmación de la transacción ; o si se sale de la Actividad, el Fragmento finalizará por completo y el Fragmento entrará en estado de destrucción en Pausa - > onStop -> onDestoryView -> onDestory -> onDetach