Fragment di Android maneggia la pressione sul button di riproduzione

Ho alcuni frammenti nella mia attività

[1], [2], [3], [4], [5], [6] 

E sul button Indietro premere devo tornare da [2] a [1] se il frammento attivo corrente è [2] o non fare altrimenti.

  • È "ANR" un'exception o un errore o cosa?
  • Samsung My Files explorer: scegli il file dalla cartella specificata
  • C'è un codice per leggere MS Office PPT su Android?
  • Android Studio non funziona mentre crea l'applicazione utilizzando AppCompat v23 e API21
  • Android: Disegnare un button come spinner
  • Problema di Lollipop di Android - Imansible caricare l'image dalla camera a ImageView
  • Qual è la pratica migliore per farlo?

    EDIT : l'applicazione non deve ritornare a [2] da [3] … [6]

  • Servizio di localizzazione del servizio di unità
  • Utilizza file dll in applicazioni Android
  • MediaPlayer setDataSource, meglio utilizzare il path o FileDescriptor?
  • Dipendenze Gradle: compilare il progetto per path relativo
  • Unire il menu TabActivity con i menu delle attività contenute
  • Come condividere text e image in Google Plus (G +) da Android senza utilizzare Intent?
  • 25 Solutions collect form web for “Fragment di Android maneggia la pressione sul button di riproduzione”

    Quando si sta passando tra i frammenti, call addToBackStack() come parte della tua addToBackStack() di FragmentTransaction :

     FragmentTransaction tx = fragmentManager.beginTransation(); tx.replace( R.id.fragment, new MyFragment() ).addToBackStack( "tag" ).commit(); 

    Se hai bisogno di un controllo più dettagliato (ad esempio, quando alcuni frammenti sono visibili, vuoi sopprimere il tasto indietro) puoi impostare un OnKeyListener nella vista principale del tuo frammento:

     //You need to add the following line for this solution to work; thanks skayred fragment.getView().setFocusableInTouchMode(true); fragment.getView().requestFocus(); fragment.getView().setOnKeyListener( new OnKeyListener() { @Override public boolean onKey( View v, int keyCode, KeyEvent event ) { if( keyCode == KeyEvent.KEYCODE_BACK ) { return true; } return false; } } ); 

    Preferirei fare qualcosa di simile:

     private final static String TAG_FRAGMENT = "TAG_FRAGMENT"; private void showFragment() { final Myfragment fragment = new MyFragment(); final FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); transaction.replace(R.id.fragment, fragment, TAG_FRAGMENT); transaction.addToBackStack(null); transaction.commit(); } @Override public void onBackPressed() { final Myfragment fragment = (Myfragment) getSupportFragmentManager().findFragmentByTag(TAG_FRAGMENT); if (fragment.allowBackPressed()) { // and then you define a method allowBackPressed with the logic to allow back pressed or not super.onBackPressed(); } } 

    se si supera il metodo onKey per la vista di frammento hai bisogno di:

      view.setFocusableInTouchMode(true); view.requestFocus(); view.setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { Log.i(tag, "keyCode: " + keyCode); if( keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_UP) { Log.i(tag, "onKey Back listener is working!!!"); getFragmentManager().popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE); return true; } return false; } }); 

    Utilizzare il metodo addToBackStack quando si sostituisce un frammento da un altro:

     getFragmentManager().beginTransaction().replace(R.id.content_frame, fragment).addToBackStack("my_fragment").commit(); 

    Quindi nella tua attività, utilizza il seguente codice per tornare da un frammento a un altro (quello precedente).

     @Override public void onBackPressed() { if (getFragmentManager().getBackStackEntryCount() > 0) { getFragmentManager().popBackStack(); } else { super.onBackPressed(); } } 

    Se si desidera gestire l'evento hardware Back key di quello che è necessario eseguire il seguente codice nel metodo onActivityCreated () di Fragment.

    È inoltre necessario controllare l'evento Action_Down o Action_UP. Se non verifichi, allora il metodo OnKey () chiamerà 2 volte.

    Inoltre, se la tua radice di vista (getView ()) non contiene focus, allora non funziona. Se hai fatto clic su qualsiasi controllo, allora devi dare attenzione a rootview utilizzando getView (). RequestFocus (); Dopo questo solo CallKeydown () chiamerà.

     getView().setFocusableInTouchMode(true); getView().requestFocus(); getView().setOnKeyListener(new OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_DOWN) { if (keyCode == KeyEvent.KEYCODE_BACK) { Toast.makeText(getActivity(), "Back Pressed", Toast.LENGTH_SHORT).show(); return true; } } return false; } }); 

    Lavorando molto bene per me.

    Il modo più ideale per farlo è qui: Frammento: quale richiamo è richiamato quando si preme il tasto di printing e personalizza

     public class MyActivity extends Activity { //... //Defined in Activity class, so override @Override public void onBackPressed() { super.onBackPressed(); myFragment.onBackPressed(); } } public class MyFragment extends Fragment { //Your created method public static void onBackPressed() { //Pop Fragments off backstack and do your other checks } } 

    Crea interfacce:

    BackButtonHandlerInterface

     public interface BackButtonHandlerInterface { void addBackClickListener (OnBackClickListener onBackClickListener); void removeBackClickListener (OnBackClickListener onBackClickListener); } 

    OnBackClickListener

     public interface OnBackClickListener { boolean onBackClick(); } 

    In attività:

     public class MainActivity extends AppCompatActivity implements BackButtonHandlerInterface { private ArrayList<WeakReference<OnBackClickListener>> backClickListenersList = new ArrayList<>(); @Override public void addBackClickListener(OnBackClickListener onBackClickListener) { backClickListenersList.add(new WeakReference<>(onBackClickListener)); } @Override public void removeBackClickListener(OnBackClickListener onBackClickListener) { for (Iterator<WeakReference<OnBackClickListener>> iterator = backClickListenersList.iterator(); iterator.hasNext();){ WeakReference<OnBackClickListener> weakRef = iterator.next(); if (weakRef.get() == onBackClickListener){ iterator.remove(); } } } @Override public void onBackPressed() { if(!fragmentsBackKeyIntercept()){ super.onBackPressed(); } } private boolean fragmentsBackKeyIntercept() { boolean isIntercept = false; for (WeakReference<OnBackClickListener> weakRef : backClickListenersList) { OnBackClickListener onBackClickListener = weakRef.get(); if (onBackClickListener != null) { boolean isFragmIntercept = onBackClickListener.onBackClick(); if (!isIntercept) isIntercept = isFragmIntercept; } } return isIntercept; } } 

    Nel frammento :

     public class MyFragment extends Fragment implements OnBackClickListener{ private BackButtonHandlerInterface backButtonHandler; @Override public void onAttach(Activity activity) { super.onAttach(activity); backButtonHandler = (BackButtonHandlerInterface) activity; backButtonHandler.addBackClickListener(this); } @Override public void onDetach() { super.onDetach(); backButtonHandler.removeBackClickListener(this); backButtonHandler = null; } @Override public boolean onBackClick() { //This method handle onBackPressed()! return true or false return false; } } 

      @Override public void onResume() { super.onResume(); getView().setFocusableInTouchMode(true); getView().requestFocus(); getView().setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK){ if (mDrawerLayout.isDrawerOpen(GravityCompat.START)){ mDrawerLayout.closeDrawer(GravityCompat.START); } return true; } return false; } }); } 

    Oppure si potrebbe utilizzare getSupportFragmentManager().getBackStackEntryCount() per controllare cosa fare:

     @Override public void onBackPressed() { logger.d("@@@@@@ back stack entry count : " + getSupportFragmentManager().getBackStackEntryCount()); if (getSupportFragmentManager().getBackStackEntryCount() != 0) { // only show dialog while there's back stack entry dialog.show(getSupportFragmentManager(), "ConfirmDialogFragment"); } else if (getSupportFragmentManager().getBackStackEntryCount() == 0) { // or just go back to main activity super.onBackPressed(); } } 

    Se gestisci il stream di aggiunta a ripristino di each transazione, allora puoi fare qualcosa di simile per mostrare il frammento precedente quando l'utente premere il button di ripristino (puoi anche mappare il button Home).

     @Override public void onBackPressed() { if (getFragmentManager().getBackStackEntryCount() > 0) getFragmentManager().popBackStack(); else super.onBackPressed(); } 

    Sto lavorando con SlidingMenu e Frammento, presento il mio caso qui e spero di aiutare qualcuno.

    Logica quando si preme il tasto [Back]:

    1. Quando SlidingMenu mostra, chiudere, non c'è più cose da fare.
    2. Oppure, quando mostrerà il frammento di secondo (o più), scorri al frammento precedente e non è più da fare.
    3. SlidingMenu non viene visualizzato, il frammento corrente è # 0, fa il tasto originale [Back].

       public class Main extends SherlockFragmentActivity { private SlidingMenu menu=null; Constants.VP=new ViewPager(this); //Some stuff... @Override public void onBackPressed() { if(menu.isMenuShowing()) { menu.showContent(true); //Close SlidingMenu when menu showing return; } else { int page=Constants.VP.getCurrentItem(); if(page>0) { Constants.VP.setCurrentItem(page-1, true); //Show previous fragment until Fragment#0 return; } else {super.onBackPressed();} //If SlidingMenu is not showing and current Fragment is #0, do the original [Back] key does. In my case is exit from APP } } } 

    Questa è una soluzione molto buona e affidabile: http://vinsol.com/blog/2014/10/01/handling-back-button-press-inside-fragments/

    Il ragazzo ha fatto un frammento astratto che gestisce il comportmento backPress e sta passando tra i frammenti attivi usando il model di strategia.

    Per alcuni di voi c'è forse un piccolo inconveniente nella class astratta …

    Poco tempo, la soluzione dal link è così:

     // Abstract Fragment handling the back presses public abstract class BackHandledFragment extends Fragment { protected BackHandlerInterface backHandlerInterface; public abstract String getTagText(); public abstract boolean onBackPressed(); @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); if(!(getActivity() instanceof BackHandlerInterface)) { throw new ClassCastException("Hosting activity must implement BackHandlerInterface"); } else { backHandlerInterface = (BackHandlerInterface) getActivity(); } } @Override public void onStart() { super.onStart(); // Mark this fragment as the selected Fragment. backHandlerInterface.setSelectedFragment(this); } public interface BackHandlerInterface { public void setSelectedFragment(BackHandledFragment backHandledFragment); } } 

    E l'utilizzo nell'attività:

     // BASIC ACTIVITY CODE THAT LETS ITS FRAGMENT UTILIZE onBackPress EVENTS // IN AN ADAPTIVE AND ORGANIZED PATTERN USING BackHandledFragment public class TheActivity extends FragmentActivity implements BackHandlerInterface { private BackHandledFragment selectedFragment; @Override public void onBackPressed() { if(selectedFragment == null || !selectedFragment.onBackPressed()) { // Selected fragment did not consume the back press event. super.onBackPressed(); } } @Override public void setSelectedFragment(BackHandledFragment selectedFragment) { this.selectedFragment = selectedFragment; } } 

    Codice di lavoro:

     package com.example.keralapolice; import android.app.Fragment; import android.app.FragmentManager; import android.app.FragmentManager.OnBackStackChangedListener; import android.content.Intent; import android.os.Bundle; import android.util.Log; import android.view.Gravity; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.Toast; public class ChiefFragment extends Fragment { View view; // public OnBackPressedListener onBackPressedListener; @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle args) { view = inflater.inflate(R.layout.activity_chief, container, false); getActivity().getActionBar().hide(); view.setFocusableInTouchMode(true); view.requestFocus(); view.setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { Log.i(getTag(), "keyCode: " + keyCode); if (keyCode == KeyEvent.KEYCODE_BACK) { getActivity().getActionBar().show(); Log.i(getTag(), "onKey Back listener is working!!!"); getFragmentManager().popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE); // String cameback="CameBack"; Intent i = new Intent(getActivity(), home.class); // i.putExtra("Comingback", cameback); startActivity(i); return true; } else { return false; } } }); return view; } } 

    Penso che il modo più semplice sia quello di creare un'interface e nell'attività controllare se il frammento è del tipo di interface e, in caso affermativo, call il suo metodo per gestire il pop. Ecco l'interface da implementare nel frammento.

     public interface BackPressedFragment { // Note for this to work, name AND tag must be set anytime the fragment is added to back stack, eg // getActivity().getSupportFragmentManager().beginTransaction() // .replace(R.id.fragment_container, MyFragment.newInstance(), "MY_FRAG_TAG") // .addToBackStack("MY_FRAG_TAG") // .commit(); // This is really an override. Should call popBackStack itself. void onPopBackStack(); } 

    Ecco come implementarlo.

     public class MyFragment extends Fragment implements BackPressedFragment @Override public void onPopBackStack() { /* Your code goes here, do anything you want. */ getActivity().getSupportFragmentManager().popBackStack(); } 

    E nella tua attività, quando gestisci il pop (probabilmente in entrambi onBackPressed e onOptionsItemSelected), pop il backstack utilizzando questo metodo:

     public void popBackStack() { FragmentManager fm = getSupportFragmentManager(); // Call current fragment's onPopBackStack if it has one. String fragmentTag = fm.getBackStackEntryAt(fm.getBackStackEntryCount() - 1).getName(); Fragment currentFragment = getSupportFragmentManager().findFragmentByTag(fragmentTag); if (currentFragment instanceof BackPressedFragment) ((BackPressedFragment)currentFragment).onPopBackStack(); else fm.popBackStack(); } 

    È ansible utilizzare da getActionBar().setDisplayHomeAsUpEnabled() :

     @Override public void onBackStackChanged() { int backStackEntryCount = getFragmentManager().getBackStackEntryCount(); if(backStackEntryCount > 0){ getActionBar().setDisplayHomeAsUpEnabled(true); }else{ getActionBar().setDisplayHomeAsUpEnabled(false); } } 
      rootView.setFocusableInTouchMode(true); rootView.requestFocus(); rootView.setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK) { Fragment NameofFragment = new NameofFragment; FragmentTransaction transaction=getFragmentManager().beginTransaction(); transaction.replace(R.id.frame_container,NameofFragment); transaction.commit(); return true; } return false; } }); return rootView; 

    Abbiamo creato una piccola libreria per gestire la schiena attraverso diversi frammenti e / o in attività. L'utilizzo è semplice come l'aggiunta di dipendenza nel file gradle:

     compile 'net.skoumal.fragmentback:fragment-back:0.1.0' 

    Lasciate che il tuo frammento implementa BackFragment interface BackFragment :

     public abstract class MyFragment extends Fragment implements BackFragment { public boolean onBackPressed() { // -- your code -- // return true if you want to consume back-pressed event return false; } public int getBackPriority() { return NORMAL_BACK_PRIORITY; } } 

    Notificare i tuoi frammenti di printing:

     public class MainActivity extends AppCompatActivity { @Override public void onBackPressed() { // first ask your fragments to handle back-pressed event if(!BackFragmentHelper.fireOnBackPressedEvent(this)) { // lets do the default back action if fragments don't consume it super.onBackPressed(); } } } 

    Per ulteriori dettagli e altri casi di utilizzo visitare la pagina GitHub:

    https://github.com/skoumalcz/fragment-back

    Aggiungere addToBackStack () alla transazione di frammento e quindi utilizzare il codice sottostante per implementare la navigazione indietro per i frammenti

     getSupportFragmentManager().addOnBackStackChangedListener( new FragmentManager.OnBackStackChangedListener() { public void onBackStackChanged() { // Update your UI here. } }); 

    se si utilizza FragmentActivity. allora fare questo

    prima chiamata Questo all'interno del frammento.

     public void callParentMethod(){ getActivity().onBackPressed(); } 

    e quindi call il metodo onBackPressed a lato della class FragmentActivity padre.

     @Override public void onBackPressed() { //super.onBackPressed(); //create a dialog to ask yes no question whether or not the user wants to exit ... } 

    Aggiungi questo codice nella tua attività

    @Override

     public void onBackPressed() { if (getFragmentManager().getBackStackEntryCount() == 0) { super.onBackPressed(); } else { getFragmentManager().popBackStack(); } } 

    E aggiungi questa row nel frammento prima di commit ()

    ft.addToBackStack ("qualsiasi nome");

    Per coloro che utilizzano frammento statico

    In un caso se si dispone di un frammento statico, allora sarebbe preferibile. Crea un object di istanza del tuo frammento

     private static MyFragment instance=null; 

    in onCreate () di MyFragment inizializza tale istanza

      instance=this; 

    anche fare una function per get l'istanza

      public static MyFragment getInstance(){ return instance; } 

    anche fare funzioni

     public boolean allowBackPressed(){ if(allowBack==true){ return true; } return false; } //allowBack is a boolean variable that will be set to true at the action //where you want that your backButton should not close activity. In my case I open //Navigation Drawer then I set it to true. so when I press backbutton my //drawer should be get closed public void performSomeAction(){ //.. Your code ///Here I have closed my drawer } 

    Nella tua attività puoi fare

     @Override public void onBackPressed() { if (MyFragment.getInstance().allowBackPressed()) { MyFragment.getInstance().performSomeAction(); } else{ super.onBackPressed(); } } 

    in class di frammento mettere questo codice per l'evento di back:

      rootView.setFocusableInTouchMode(true); rootView.requestFocus(); rootView.setOnKeyListener( new OnKeyListener() { @Override public boolean onKey( View v, int keyCode, KeyEvent event ) { if( keyCode == KeyEvent.KEYCODE_BACK ) { FragmentManager fragmentManager = getFragmentManager(); fragmentManager.beginTransaction() .replace(R.id.frame_container, new Book_service_provider()).commit(); return true; } return false; } } ); 

    Dopo aver esaminato tutte le soluzioni, ho capito che c'è una soluzione molto più semplice.

    Nell'attività di onBackPressed () che ospita tutti i tuoi frammenti, trova il frammento che si desidera impedire la printing indietro. Poi, se trovato, basta tornare. Quindi popBackStack non succederà mai per questo frammento.

      @Override public void onBackPressed() { Fragment1 fragment1 = (Fragment1) getFragmentManager().findFragmentByTag(“Fragment1”); if (fragment1 != null) return; if (getFragmentManager().getBackStackEntryCount() > 0){ getFragmentManager().popBackStack(); } } 

    Il controllo dello backstack funziona perfettamente


     @Override public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK) { if (getFragmentManager().getBackStackEntryCount() == 1) { // DO something here since there is only one fragment left // Popping a dialog asking to quit the application return false; } } return super.onKeyDown(keyCode, event); } 

    Nel tuo metodo oncreateView () è necessario scrivere questo codice e in condizione KEYCODE_BACk è ansible scrivere qualunque funzionalità che desideri

     View v = inflater.inflate(R.layout.xyz, container, false); //Back pressed Logic for fragment v.setFocusableInTouchMode(true); v.requestFocus(); v.setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_DOWN) { if (keyCode == KeyEvent.KEYCODE_BACK) { getActivity().finish(); Intent intent = new Intent(getActivity(), MainActivity.class); startActivity(intent); return true; } } return false; } }); 
    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.