android - two - fragment set listener

Comunicación entre un fragmento y una actividad: mejores prácticas

Question

Esta pregunta es principalmente para solicitar opiniones sobre la mejor manera de manejar mi aplicación. Tengo tres fragmentos manejados por una actividad. El fragmento A tiene un elemento que se puede hacer clic en la foto y el Fragmento B tiene 4 elementos que se pueden hacer clic en los botones. El otro fragmento solo muestra detalles cuando se hace clic en la foto. Estoy usando ActionBarSherlock.

Los botones de avance y retroceso necesitan cambiar la foto a la posición siguiente o anterior, respectivamente. Podía mantener la foto y los botones en el mismo fragmento, pero quería mantenerlos separados en caso de que quisiera reorganizarlos en una tableta.

Necesito un consejo: ¿debería combinar los Fragmentos A y B? Si no, tendré que descubrir cómo implementar una interfaz para 3 elementos clicables.

Consideré usar Roboguice, pero ya estoy extendiendo el uso de SherlockFragmentActivity, así que eso es un no ir. Vi mencionar a Otto, pero no vi buenos tutoriales sobre cómo incluirlos en un proyecto. ¿Cuál crees que debería ser la mejor práctica de diseño?

También necesito ayuda para descubrir cómo comunicarme entre un fragmento y una actividad. Me gustaría mantener algunos datos "globales" en la aplicación, como la identificación de pose. ¿Hay algún código de ejemplo que pueda ver además de la información del desarrollador android? Eso no es tan útil.

Por cierto, ya estoy almacenando toda la información sobre cada pose en una base de datos SQLite. Esa es la parte fácil.

Answer 1

El método sugerido para comunicarse entre fragmentos es utilizar callbacks / listeners que son administrados por su actividad principal.

Creo que el código en esta página es bastante claro: http://developer.android.com/training/basics/fragments/communicating.html

También puede hacer referencia a la aplicación de programación IO 2012, que está diseñada para ser una aplicación de referencia de facto. Se puede encontrar aquí: http://code.google.com/p/iosched/

Además, aquí hay una pregunta de SO con buena información: cómo pasar datos entre fragmentos

Answer 2

Estoy usando Intents para comunicar acciones a la actividad principal. La actividad principal es escucharlos anulando onNewIntent (intención intencionada). La actividad principal traduce estas acciones a los fragmentos correspondientes, por ejemplo.

Entonces puedes hacer algo como esto:

public class MainActivity extends Activity  {

    public static final String INTENT_ACTION_SHOW_FOO = "show_foo";
    public static final String INTENT_ACTION_SHOW_BAR = "show_bar";


   @Override
   protected void onNewIntent(Intent intent) {
        routeIntent(intent);
   }

  private void routeIntent(Intent intent) {
       String action = intent.getAction();
       if (action != null) {               
            switch (action) {
            case INTENT_ACTION_SHOW_FOO:
                // for example show the corresponding fragment
                loadFragment(FooFragment);
                break;
            case INTENT_ACTION_SHOW_BAR:
                loadFragment(BarFragment);
                break;               
        }
    }
}

Luego dentro de cualquier fragmento para mostrar el fragmento foo:

Intent intent = new Intent(context, MainActivity.class);
intent.setAction(INTENT_ACTION_SHOW_FOO);
// Prevent activity to be re-instantiated if it is already running.
// Instead, the onNewEvent() is triggered
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
getContext().startActivity(intent);

Answer 3

Hay varias maneras de comunicarse entre actividades, fragmentos, servicios, etc. El más obvio es comunicarse usando interfaces. Sin embargo, no es una forma productiva de comunicarse. Tienes que implementar los oyentes, etc.

Mi sugerencia es usar un bus de eventos. El bus de eventos es una implementación de patrón de publicación / suscripción.

Puede suscribirse a eventos en su actividad y luego puede publicar esos eventos en sus fragmentos, etc.

Aquí, en mi publicación de blog , puede encontrar más detalles sobre este patrón y también un proyecto de ejemplo para mostrar el uso.

Answer 4

Hice una biblioteca de anotaciones que puede hacer el reparto por ti. mira esto. https://github.com/zeroarst/callbackfragment/

@CallbackFragment
public class MyFragment extends Fragment {

    @Callback
    interface FragmentCallback {
       void onClickButton(MyFragment fragment);
    }    
    private FragmentCallback mCallback;

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.bt1
                mCallback.onClickButton(this);
                break;
            case R.id.bt2
                // Because we give mandatory = false so this might be null if not implemented by the host.
                if (mCallbackNotForce != null)
                mCallbackNotForce.onClickButton(this);
                break;
        }
    }
}

Luego genera una subclase de tu fragmento. Y solo agrégalo a FragmentManager.

public class MainActivity extends AppCompatActivity implements MyFragment.FragmentCallback {

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

        getSupportFragmentManager().beginTransaction()
            .add(R.id.lo_fragm_container, MyFragmentCallbackable.create(), "MY_FRAGM")
            .commit();
    }

    Toast mToast;

    @Override
    public void onClickButton(MyFragment fragment) {
        if (mToast != null)
            mToast.cancel();
        mToast = Toast.makeText(this, "Callback from " + fragment.getTag(), Toast.LENGTH_SHORT);
        mToast.show();
    }
}

Answer 5

La forma más fácil de comunicarse entre su actividad y fragmentos es usar interfaces. La idea es básicamente definir una interfaz dentro de un fragmento A dado y dejar que la actividad implemente esa interfaz.

Una vez que haya implementado esa interfaz, puede hacer lo que quiera en el método que anula.

La otra parte importante de la interfaz es que debes llamar al método abstracto desde tu fragmento y recordar incluirlo en tu actividad. Debería capturar una ClassCastException si no se hace correctamente.

Hay un buen tutorial sobre Simple Developer Blog sobre cómo hacer exactamente este tipo de cosas.

¡Espero que esto haya sido útil para ti!

Answer 6

No estoy seguro de haber entendido realmente lo que quiere hacer, pero la forma sugerida de comunicarse entre fragmentos es usar devoluciones de llamada con la Actividad, nunca directamente entre fragmentos. Vea aquí http://developer.android.com/training/basics/fragments/communicating.html

Answer 7

Puede crear declarar una interfaz pública con una declaración de función en el fragmento e implementar la interfaz en la actividad. Entonces puedes llamar a la función desde el fragmento.

Answer 8

Se implementa mediante la interfaz de devolución de llamada: en primer lugar, tenemos que crear una interfaz:

public interface UpdateFrag {
     public void updatefrag();
    }

En actividad, haz el siguiente código:

UpdateFrag updatfrag ;
public void updateApi(UpdateFrag listener) {
        updatfrag = listener;
   }

desde el evento desde donde la devolución de llamada tiene que dispararse en la actividad:

updatfrag.updatefrag();

En Fragment, implemente la interfaz en CreateView, haga el siguiente código:

 ((Home)getActivity()).updateApi(new UpdateFrag() {
                @Override
                public void updatefrag() {
                   .....your stuff......
                }
            });