overridePendingTransition non funziona quando si utilizza FLAG_ACTIVITY_REORDER_TO_FRONT

Question

Ho due attività nello stack, per mostrarle utilizzo FLAG_ACTIVITY_REORDER_TO_FRONT. Fin qui tutto bene, il problema arriva quando voglio portare l'attività con un'animazione usando overridePendingTransition.

Intent i = new Intent(ActivityA.this, ActivityB.class); 
i.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); 
ActivityA.this.startActivity(i); 
overridePendingTransition(R.anim.transition_to_right, R.anim.transition_to_left); 

La transizione non è mostrato, tuttavia, se il flag non viene aggiunto all'intento (rimuovendo linea 2), allora non c'è problema.

È possibile portare un'attività in primo piano con un'animazione?

Grazie mille!

Answer 1

Come creare animazioni in onCreate() o onStart() della seconda attività.

Answer 2

Il mio collega si è imbattuto in questo problema ed è riuscito a risolverlo aggiungendo l'attributo SDK minimo (5 e oltre) ad esso.

dal momento che questa funzione era disponibile dal api 5, rafforzando l'uso di un livello di sdk superiore ha fatto il trucco per noi.

Answer 3

Mi sono imbattuto in questo stesso problema. Il trucco è sovrascrivere la transizione nel callback onResume().

@Override 
public void onResume() { 
    super.onResume(); 
    overridePendingTransition(R.anim.transition_to_right, R.anim.transition_to_left); 
} 

Answer 4

In realtà la soluzione giusta quando si utilizza REORDER_TO_FRONT è chiamare overridePendingTransition nel metodo onNewIntent() dell'attività che si sta per aprire.

@Override 
protected void onNewIntent(Intent intent) { 
    super.onNewIntent(intent); 
    overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out); 
} 

sostituire con le transizioni.

Se è necessario sostituire selettivamente la transizione, è possibile aggiungere un extra nell'intenzione e verificarlo in onNewIntent() per decidere cosa fare.

Questo non è adatto se non si conosce la transizione che verrà aperta (se non lo si specifica esplicitamente per esempio), ma in caso contrario è la soluzione giusta.

Answer 5

ho fatto qualcosa di simile e l'ho fatto come segue:

private Stack<String> stack; 
ViewAnimator mViewAnimator; 

@Override 
public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    mViewAnimator = new ViewAnimator(this); 
    if (stack == null) stack = new Stack<String>(); 
    push("FirstStackActivity", new Intent(this, FirstStackActivity.class)); 
} 

@Override 
public void finishFromChild(Activity child) { 
    pop(); 
} 

@Override 
public void onBackPressed() { 
    pop(); 
} 

public void push(String id, Intent intent) { 
    Window window = getLocalActivityManager().startActivity(id, intent); 
    if (window != null) { 
     stack.push(id); 
     View view = window.getDecorView(); 
     mViewAnimator.setInAnimation(AnimationUtils.loadAnimation(this, R.anim.push_left_in)); 
     mViewAnimator.setOutAnimation(AnimationUtils.loadAnimation(this, R.anim.push_left_out));    
     mViewAnimator.addView(view); 
     mViewAnimator.showNext(); 
     setContentView(mViewAnimator); 
    } 
} 

public void pop() { 
    if (stack.size() == 1) finish(); 
    if (stack.size() > 0) { 
     LocalActivityManager manager = getLocalActivityManager(); 
     Intent lastIntent = manager.getActivity(stack.peek()).getIntent(); 
     Window newWindow = manager.startActivity(stack.peek(), lastIntent); 
     View view = newWindow.getDecorView(); 
     mViewAnimator.setInAnimation(AnimationUtils.loadAnimation(this, R.anim.push_right_in)); 
     mViewAnimator.setOutAnimation(AnimationUtils.loadAnimation(this, R.anim.push_right_out)); 
     mViewAnimator.showPrevious(); 
     mViewAnimator.removeView(view); 
    } 
    destroy(stack.pop()); 
} 


/** 
* BugFix official 
* @param id 
* @return 
*/ 
public boolean destroy(String id) { 
    final LocalActivityManager activityManager = getLocalActivityManager(); 
    if (activityManager != null) { 
     activityManager.destroyActivity(id, false); 
     try { 
      final Field mActivitiesField = LocalActivityManager.class.getDeclaredField("mActivities"); 
      if (mActivitiesField != null) { 
       mActivitiesField.setAccessible(true); 
       @SuppressWarnings("unchecked") 
       final Map<String, Object> mActivities = (Map<String, Object>) mActivitiesField.get(activityManager); 
       if (mActivities != null) { 
        mActivities.remove(id); 
       } 
       final Field mActivityArrayField = LocalActivityManager.class.getDeclaredField("mActivityArray"); 
       if (mActivityArrayField != null) { 
        mActivityArrayField.setAccessible(true); 
        @SuppressWarnings("unchecked") 
        final ArrayList<Object> mActivityArray = (ArrayList<Object>) mActivityArrayField.get(activityManager); 
        if (mActivityArray != null) { 
         for (Object record : mActivityArray) { 
          final Field idField = record.getClass().getDeclaredField("id"); 
          if (idField != null) { 
           idField.setAccessible(true); 
           final String _id = (String) idField.get(record); 
           if (id.equals(_id)) { 
            mActivityArray.remove(record); 
            break; 
           } 
          } 
         } 
        } 
       } 
      } 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     return true; 
    } 
    return false; 
} 

Answer 6

Calling

overridePendingTransition(R.anim.transition_to_right, R.anim.transition_to_left); 

dopo rivestimento(); dell'attività di chiusura ha funzionato per me.

finish(); 
overridePendingTransition(R.anim.transition_to_right, R.anim.transition_to_left); 

E 'meglio che chiamare onResume, perché rende l'attività più indipendente sui entrare ed uscire animazioni:

Calling dopo l'arrivo di attività mittente:

Attività A --- Enter Transizione 1 (su A) ---> Attività B --- Invio Transizione 2 (su B) ---> Attività C

Attività A < --- Uscita Transizione 1 (su B) --- Attività B < --- Uscita Transizione 2 (su C) --- Attività C

Attività A --- Immettere Transizione 1 (su A) ---> Attività C --- Immettere Transizione 3 (su C) - -> Attività B

Attività A < --- Exit transizione 3 (su C) --- Attività C < --- Exit Transition 2 (su B) --- attività B

Attivazione in corso del rendimento dell'attività del ricevitore:

Attività A --- Immettere Transizione 1 (su B) ---> Attiva ity B --- Enter Transition 2 (on C) ---> Attività C

Attività A < --- Immettere Transizione 1 (su A) --- Attività B < --- Immettere Transizione 2 (su B) --- Attività C

Attività A --- Inserisci transizione 3 (su C) ---> Attività C --- Inserisci Transition 2 (su B) ---> Attività B

Attività A < --- Inserisci Transizione 1 (su A) --- Attività C < --- Inserisci Transizione 3 (su C) --- Attività B

Qui l'animazione onResume deve sempre essere la stessa, non importa quale attività mittente è, invece, il primo approccio, in cui è possibile personalizzare facilmente l'animazione.

Answer 7

per me, la soluzione era quella di assicurarsi che sia corse nel thread UI

runOnUiThread(new Runnable() { 
      public void run() { 
       startActivity(new Intent(ActivityOne.this, ActivityTwo.class)); 
       overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out); 
      } 
     }); 

     finish(); 

Answer 8

Ho avuto lo stesso problema. Ti suggerisco di controllare AndroidManifest.xml per assicurarti che ActivityA e ActivityB non abbiano alcun set Theme.Translucent.NoTitleBar, questo tema contiene "android: windowIsTranslucent" = true causa il problema.

Spero che questo ti aiuti.