android - single - overridePendingTransition no funciona cuando se utiliza FLAG_ACTIVITY_REORDER_TO_FRONT

intent flags

Question

Tengo dos actividades en la pila, para mostrarlas utilizo FLAG_ACTIVITY_REORDER_TO_FRONT. Hasta ahora todo bien, el problema viene cuando quiero traer la actividad con una animación 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 transición no se muestra, sin embargo, si el indicador no se agrega al intento (eliminando la línea 2), entonces no hay problema.

¿Es posible llevar una actividad al frente con una animación?

¡Muchas gracias!

Answer 1

¿Qué tal crear animación en onCreate () o onStart () de la segunda actividad?

Answer 2

En realidad, la solución correcta al usar REORDER_TO_FRONT es llamar a overridePendingTransition en el método onNewIntent () de la actividad que va a abrir.

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

reemplace con sus transiciones.

Si necesita reemplazar selectivamente la transición, puede agregar un extra en su intento y verificarlo en onNewIntent () para decidir qué hacer.

Esto no es adecuado si no conoce la transición que se abrirá (si no lo especifica explícitamente, por ejemplo), sino que es la solución correcta.

Answer 3

Hice algo similar e hice lo siguiente:

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 4

Me encontré con este mismo problema. El truco es anular la transición en la devolución de llamada onResume ().

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

Answer 5

Mi colega se encontró con este problema y se las arregló para resolverlo al agregar el atributo de SDK mínimo (5 y más).

ya que esta función estaba disponible desde la API 5, hacer cumplir el uso de un nivel sdk más alto nos convenció.

Answer 6

Tengo el mismo problema. Le sugiero que compruebe su AndroidManifest.xml para asegurarse de que ActivityA y ActivityB no tienen establecido Theme.Translucent.NoTitleBar , este tema contiene "android: windowIsTranslucent" = true causa el problema.

Espero que esto te ayude

Answer 7

Vocación

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

después de terminar(); de la actividad de cierre funcionó para mí.

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

Es mejor que invocar OnResume porque hace que la actividad sea más independiente sobre las animaciones de entrada y salida:

Llamando después del final de la actividad del remitente:

Actividad A --- Ingrese la Transición 1 (en A) ---> Actividad B --- Ingrese la Transición 2 (en B) ---> Actividad C

Actividad A <--- Salida Transición 1 (en B) --- Actividad B <--- Salida Transición 2 (en C) --- Actividad C

Actividad A --- Ingrese la Transición 1 (en A) ---> Actividad C --- Ingrese la Transición 3 (en C) ---> Actividad B

Actividad A <--- Salida Transición 3 (en C) --- Actividad C <--- Salida Transición 2 (en B) --- Actividad B

Llamando onResume de la actividad del receptor:

Actividad A --- Ingrese la Transición 1 (en B) ---> Actividad B --- Ingrese la Transición 2 (en C) ---> Actividad C

Actividad A <--- Ingrese la Transición 1 (en A) --- Actividad B <--- Ingrese la Transición 2 (en B) --- Actividad C

Actividad A --- Ingrese la Transición 3 (en C) ---> Actividad C --- Ingrese la Transición 2 (en B) ---> Actividad B

Actividad A <--- Ingrese la Transición 1 (en A) --- Actividad C <--- Ingrese la Transición 3 (en C) --- Actividad B

Aquí, la animación onResume siempre tiene que ser la misma, sin importar qué actividad del remitente sea, sino el primer enfoque, donde puedes personalizar la animación fácilmente.

Answer 8

para mí, la solución fue asegurarme de que se ejecutara en el hilo de 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();