android - update - ¿La mejor práctica para actualizar argumentos de un fragmento?

singleton fragment android

Question

Sé sobre la "nueva instancia" -Pattern ( mejor práctica para crear instancias de un nuevo fragmento de Android ). Pero, ¿cómo puedo actualizar estos argumentos de un fragmento, por ejemplo, si otro fragmento cambia los datos?

Sé sobre callback-methods entre Fragments / Activitys, pero estas devoluciones de llamada no actualizarán los argumentos?

Por ejemplo: en la creación del fragmento, paso un URI al mismo con el paquete. Luego, otro fragmento cambia este URI a través de la devolución de llamada del método changeUri (Uri uri) en el primer fragmento. Si luego el fragmento se vuelve a crear (por ejemplo, debido a la rotación de la pantalla) usará el primer URI del paquete de argumentos en lugar del uri actualizado más tarde, ¿correcto?

¿Cuál es la mejor práctica para resolver esto? ¿Debo almacenarlo manualmente en savedInstanceState y en el uso decidir si usar el instanceState o arguments-bundle?

Estoy buscando una forma estándar de manejar los argumentos de mis fragmentos, así que creo que voy con un enfoque así (pseudo-código):

private Uri arg1;

public static Fragment newInstance(Uri arg1) {
  create bundle
  create fragment instance
  set bundle to fragment
  return fragment
}

private void onCreate(Bundle savedInstance) {
  if(savedInstance != null) {
    arg1 = savedInstance.uri
  }
}

private Uri getUri() {
  if(arg1 == null) {
    arg1 = getArguments.uri
  }
  if(arg1 == null) {
    arg1 = defaultValue
  }
}

Así que tengo una forma sencilla y unificada para acceder a mi argumento. Y no tiene que usar el if-else-hassle, cada vez que necesito ese argumento.

¿Qué piensa usted al respecto?

Answer 1

Dependiendo de la forma en que use sus fragmentos, puede determinar cuán efectiva será esa estrategia.

Por ejemplo, si tiene muchos fragmentos en el patrón común de paginación / vista y los está administrando con un FragmentStatePagerAdapter, es posible que su actividad u otros fragmentos hagan referencia a una instancia de fragmento que ya no exista y que cause una excepción de puntero nulo.

Una forma de evitar esto, si no desea escribir devoluciones de llamada, es utilizar Intents y BroadcastReceivers (que puede ser un poco exagerado y difícil de administrar, pero si se hace correctamente puede ahorrar muchos dolores de cabeza en mi experiencia) para enviar y recibir transmisiones hacia y desde la actividad principal.

Lo mejor de los intentos es que se pueden sintonizar para que funcionen en momentos específicos y aceptar una amplia gama de extras de datos, incluidos paquetes y objetos aptos para paquetería.

Answer 2

En caso de que desee reutilizar un fragmento pero necesite actualizar los argumentos, debe usar fragment.getArguments (). PutAll (bundle);

    private static void setInspireByDoArguments(DoOptionsFragment fragment, long doId) {
    Bundle bundle = new Bundle();
    bundle.putLong(Constants.EXTRA_DO_ID, doId);
    bundle.putInt(Constants.EXTRA_DO_OPTIONS_DIALOG_MODE, MODE_GET_INSPIRE_BY_DO);
    if (fragment.getArguments() != null) {
        fragment.getArguments().putAll(bundle);
    } else
        fragment.setArguments(bundle);
}

 //This is how I managed to Check if the fragment exist and update the arguments.

 public static void showDoInspireDialog(FragmentManager fragmentManager, long doId, DoOptionsFragment.DoOptionCallBack callBack) {
    DoOptionsFragment doOptionsFragment = (DoOptionsFragment) fragmentManager.findFragmentByTag("do_options_fragment");
    if (doOptionsFragment == null) {
        doOptionsFragment = DoOptionsFragment.getInspiredByDoInstance(doId, callBack);
        fragmentManager.beginTransaction()
                .add(doOptionsFragment, "do_options_fragment")
                .commit();
    } else {
        doOptionsFragment.setCallBack(callBack);
        setInspireByDoArguments(doOptionsFragment, doId);
        doOptionsFragment.showInspireByDoDialog(doId);
    }
}

  public static DoOptionsFragment getInspiredByDoInstance(long doId, DoOptionsFragment.DoOptionCallBack callBack) {
    DoOptionsFragment doOptionsFragment = new DoOptionsFragment();
    setInspireByDoArguments(doOptionsFragment, doId);
    doOptionsFragment.setCallBack(callBack);
    return doOptionsFragment;
}

Answer 3

Guarda el estado de la misma manera que lo haría con Actividades en la devolución de llamada onSaveInstanceState del Fragmento. Si ha actualizado el URI desde el último onCreate() , almacenará el URI actualizado en el Bundle , y lo recibirá de nuevo en onCreate() . El estado de guardado es exactamente para lo que está diseñado, y al cambiar el URI, todo lo que ha hecho es cambiar de estado.

Answer 4

No puede cambiar los argumentos una vez que su conjunto y Fragment se agregan a la Activity , utilicé un enfoque similar que usted mismo definió. Primero revisé el Bundle pasado a onCreate() si no es nulo, lo uso pero si es nulo, entonces uso argumentos. Y onSaveInstanceState() lo que sea que sea la información más reciente en onSaveInstanceState() . Para obtener más detalles: ¿es posible pasar argumentos a un fragmento después de que se haya agregado a una actividad?

Answer 5

Solo cambio valor en paquete Ejemplo:

synchronized (fragment.getArguments()) {
        fragment.getArguments().putInt(KEY, new Value);
    }

Y actualiza el contenido con un nuevo argumento

Answer 6

Best practice for updating arguments of a fragment : ¿Por qué necesitamos agregar un argumento mediante el método NewInstance() y por qué son las mejores prácticas para el fragmento?

Fragmento se puede pensar como una sección modular de una actividad. Esto significa que cuando creamos un fragmento necesitamos hacerlo modular e independiente.

Supongamos que necesita un fragmento que necesita un argumento para operar. También podemos escribirlo

MyFragmentClass mFrag = new MyFragmentClass();
Bundle bundle = new Bundle();
bundle.putString("key", value);
mFrag.setArguments(bundle);

También funciona bien y puedes obtener un argumento en el método onCreate . Aquí está la diferencia de que también puedes hacer una instancia de fragmento sin argumentos y agregarlo al administrador de fragmentos, pero tu fragmento necesita un argumento para operar. Al newInstance método newInstance en fragmentos, el desarrollador debe agregar argumentos durante la creación. Es por eso que se dice mejores prácticas.

En su problema, puede usar setRetainInstance(boolean retain) que evita que su fragmento se destruya cuando se destruye la actividad.