Fragmento onKeyDown actividad capturar y utilizar en el fragmento

Question

Tengo la actividad del fragmento con localizador:

List<Fragment> fragments = new Vector<Fragment>(); 
    fragments.add(Fragment.instantiate(this, PastEventListFragment.class.getName(),bundle)); 
    fragments.add(Fragment.instantiate(this, EventListFragment.class.getName(),bundle)); 

    this.mPagerAdapter = new EventPagerAdapter(super.getSupportFragmentManager(), fragments); 
    // 
    ViewPager pager = (ViewPager)super.findViewById(R.id.viewpager1); 

    pager.setAdapter(this.mPagerAdapter); 
    pager.setCurrentItem(1); 

cojo caso onKeyDown:

@Override 
public boolean onKeyDown(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_MENU) { 

    } 
    return super.onKeyDown(keyCode, event); 
} 

La pregunta es: Cómo utilizar el evento en todos los fragmentos i haber creado una instancia en esta actividad. Gracias

Answer 1

Lo que puedes hacer es definir un método personalizado en tu (s) clase (s) de fragmento. Por ejemplo:

public void myOnKeyDown(int key_code){ 
    //do whatever you want here 
} 

y llame a este método cada vez que se produzca un evento de pulsación en su clase de actividad. Por ejemplo:

@Override 
public boolean onKeyDown(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_MENU) { 
     ((PastEventListFragment)fragments.get(0)).myOnKeyDown(keyCode); 
     ((EventListFragment)fragments.get(1)).myOnKeyDown(keyCode); 

     //and so on... 
    } 
    return super.onKeyDown(keyCode, event); 
} 

Answer 2

Si alguien está interessed cómo hacerlo con Boradcast:

En su fragmento en onViewCreated

@Override 
public void onViewCreated(View view, Bundle savedInstanceState) { 
    super.onViewCreated(view, savedInstanceState); 


// Register to receive messages. 
// We are registering an observer (mMessageReceiver) to receive Intents 
// with actions named "custom-event-name". 
LocalBroadcastManager.getInstance(this).registerReceiver(mMessageReceiver, 
new IntentFilter("activity-says-hi")); 

...} 

// Our handler for received Intents. This will be called whenever an Intent 
// with an action named "custom-event-name" is broadcasted. 
private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() { 
@Override 
public void onReceive(Context context, Intent intent) { 
// Get extra data included in the Intent 

doSomethingCauseVolumeKeyPressed(); 

} 
}; 

su KeyEvent - código para poner en actividad

@Override 
public boolean dispatchKeyEvent(KeyEvent event) { 
    int action = event.getAction(); 
    int keyCode = event.getKeyCode(); 
    switch (keyCode) { 
     case KeyEvent.KEYCODE_VOLUME_UP: 
      if (action == KeyEvent.ACTION_DOWN) { 
       sendBroadcast(); 
      } 
      return true; 
     case KeyEvent.KEYCODE_VOLUME_DOWN: 
      if (action == KeyEvent.ACTION_DOWN) { 
       sendBroadcast(); 
      } 
      return true; 
     default: 
      return super.dispatchKeyEvent(event); 
    } 
} 

su emisor de difusión:

private void sendVolumeBroadcast(){ 
    Intent intent = new Intent("activity-says-hi"); 
    LocalBroadcastManager.getInstance(this).sendBroadcast(intent); 
} 

Answer 3

He subclase las clases de Actividad y Fragmento para realizar el paso de KeyEvents. Para mí, parece más claro que enviar transmisiones locales. Pero esta solución puede no ser tan flexible. Elija la forma preferida por usted mismo.

Aquí es la actividad:

public abstract class KeyEventPassingActivity extends Activity { 

    public interface KeyEventListener extends View.OnKeyListener { 
     boolean isVisible(); 
     View getView(); 
    } 

    private final List<KeyEventListener> keyEventHandlerList = new ArrayList<>(); 

    @Override 
    public boolean dispatchKeyEvent(KeyEvent event) { 
     for (KeyEventListener handler : keyEventHandlerList) { 
      if (handleKeyEvent(handler, event)) { 
       return true; 
      } 
     } 
     return super.dispatchKeyEvent(event); 
    } 

    void addKeyEventHandler(@NonNull KeyEventListener handler) { 
     keyEventHandlerList.add(handler); 
    } 

    void removeKeyEventHandler(@NonNull KeyEventListener handler) { 
     keyEventHandlerList.remove(handler); 
    } 

    /** 
    * @return <tt>true</tt> if the event was handled, <tt>false</tt> otherwise 
    */ 
    private boolean handleKeyEvent(@Nullable KeyEventListener listener, KeyEvent event) { 
     return listener != null 
       && listener.isVisible() 
       && listener.onKey(listener.getView(), event.getKeyCode(), event); 
    } 
} 

y el fragmento:

public abstract class KeyEventHandlingFragment extends Fragment 
     implements KeyEventPassingActivity.KeyEventListener { 

    @SuppressWarnings("deprecation") 
    @Override 
    public void onAttach(Activity activity) { 
     super.onAttach(activity); 
     if (activity instanceof KeyEventPassingActivity) { 
      ((KeyEventPassingActivity) activity).addKeyEventHandler(this); 
     } 
    } 

    @Override 
    public void onDetach() { 
     Activity activity = getActivity(); 
     if (activity instanceof KeyEventPassingActivity) { 
      ((KeyEventPassingActivity) activity).removeKeyEventHandler(this); 
     } 
     super.onDetach(); 
    } 
} 

Síntesis: https://gist.github.com/0neel/7d1ed5d26f2148b4168b6616337159ed