Ho una schermata iniziale su un timer. Il mio problema è che prima di iniziare la finish()mia attività devo controllare che l'attività successiva sia iniziata perché si apre una finestra di dialogo di sistema e voglio solo farlo finish(); una volta che l'utente ha selezionato un'opzione dalla finestra di dialogo?

So che ci sono molte domande su come vedere se la tua attività è in primo piano, ma non so se questo consente anche finestre di dialogo sopra l'attività.

Ecco il problema, il rosso è la mia attività che è in secondo piano mentre il dialogo è in primo piano:

EDIT: ho provato a non usare finish()ma poi la mia attività può essere riportata nello stack di applicazioni che sto cercando di evitare.

Questo è ciò che è consigliato come soluzione giusta :

La soluzione giusta (i crediti vanno a Dan, CommonsWare e NeTeInStEiN) Tieni traccia della visibilità della tua applicazione da solo utilizzando i metodi Activity.onPause, Activity.onResume. Memorizza lo stato di "visibilità" in qualche altra classe. Le buone scelte sono la tua implementazione dell'Applicazione o di un Servizio (ci sono anche alcune varianti di questa soluzione se desideri controllare la visibilità dell'attività dal servizio).

Esempio Implementare una classe Application personalizzata (notare il metodo statico isActivityVisible ()):

public class MyApplication extends Application {

  public static boolean isActivityVisible() {
    return activityVisible;
  }  

  public static void activityResumed() {
    activityVisible = true;
  }

  public static void activityPaused() {
    activityVisible = false;
  }

  private static boolean activityVisible;
}

Registra la tua classe dell'applicazione in AndroidManifest.xml:

<application
    android:name="your.app.package.MyApplication"
    android:icon="@drawable/icon"
    android:label="@string/app_name" >

Aggiungi onPause e onResume a ogni attività nel progetto (puoi creare un antenato comune per le tue attività se lo desideri, ma se la tua attività è già estesa da MapActivity / ListActivity ecc. Devi comunque scrivere quanto segue a mano) :

@Override
protected void onResume() {
  super.onResume();
  MyApplication.activityResumed();
}

@Override
protected void onPause() {
  super.onPause();
  MyApplication.activityPaused();
}

Nel tuo finish()metodo, vuoi isActivityVisible()controllare se l'attività è visibile o meno. Lì puoi anche verificare se l'utente ha selezionato un'opzione o meno. Continua quando sono soddisfatte entrambe le condizioni.

La fonte menziona anche due soluzioni sbagliate ... quindi evita di farlo.

Fonte: stackoverflow

Se il targeting è di livello API 14 o superiore, è possibile utilizzare android.app.Application.ActivityLifecycleCallbacks

public class MyApplication extends Application implements ActivityLifecycleCallbacks {
    private static boolean isInterestingActivityVisible;

    @Override
    public void onCreate() {
        super.onCreate();

        // Register to be notified of activity state changes
        registerActivityLifecycleCallbacks(this);
        ....
    }

    public boolean isInterestingActivityVisible() {
        return isInterestingActivityVisible;
    }

    @Override
    public void onActivityResumed(Activity activity) {
        if (activity instanceof MyInterestingActivity) {
             isInterestingActivityVisible = true;
        }
    }

    @Override
    public void onActivityStopped(Activity activity) {
        if (activity instanceof MyInterestingActivity) {
             isInterestingActivityVisible = false;
        }
    }

    // Other state change callback stubs
    ....
}

UPD : aggiornato allo stato Lifecycle.State.RESUMED. Grazie a @htafoya per questo.

Nel 2019 con l'aiuto della nuova libreria di supporto 28+o AndroidX puoi semplicemente usare:

val isActivityInForeground = activity.lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)

Puoi leggere di più nella documenazione per capire cosa è successo sotto il cofano.

Activity :: hasWindowFocus () ti restituisce il booleano di cui hai bisogno.

public class ActivityForegroundChecker extends TimerTask
{
    private static final long FOREGROUND_CHECK_PERIOD = 5000;
    private static final long FIRST_DELAY             = 3000;

    private Activity m_activity;
    private Timer    m_timer;

    public ActivityForegroundChecker (Activity p_activity)
    {
        m_activity = p_activity;
    }

    @Override
    public void run()
    {
        if (m_activity.hasWindowFocus() == true) {
            // Activity is on foreground
            return;
        }
        // Activity is on background.
    }

    public void start ()
    {
        if (m_timer != null) {
            return;
        }
        m_timer = new Timer();
        m_timer.schedule(this, FIRST_DELAY, FOREGROUND_CHECK_PERIOD);
    }

    public void stop ()
    {
        if (m_timer == null) {
            return;
        }
        m_timer.cancel();
        m_timer.purge();
        m_timer = null;
    }
}

Ecco un esempio di classe per controllare la visibilità delle tue attività ovunque ti trovi.

Ricorda che se mostri una finestra di dialogo , il risultato sarà falso poiché la finestra di dialogo avrà il focus principale. Oltre a questo è davvero utile e più affidabile delle soluzioni suggerite.

Questa è esattamente la differenza tra onPausee gli onStopeventi dell'attività come descritto nella documentazione della classe Attività .

Se ti capisco bene, quello che vuoi fare è chiamare finish()dalla tua attività onStopper interromperla. Guarda l'immagine allegata dell'app Activity Lifecycle Demo . Ecco come appare quando l'attività B viene avviata dall'attività A. L'ordine degli eventi è dal basso verso l'alto, quindi puoi vedere che l'attività A onStopviene chiamata dopo che l'attività B onResumeè già stata chiamata.

Nel caso in cui venga visualizzata una finestra di dialogo, la tua attività è oscurata in background e onPauseviene solo chiamata.

Due possibili soluzioni:

1) Richiami del ciclo di vita delle attività

Usa un'applicazione che implementa ActivityLifecycleCallbacks e usala per tenere traccia degli eventi del ciclo di vita delle attività nella tua applicazione. Nota che ActivityLifecycleCallbacks è per Android api> = 14. Per Android precedente api, dovrai implementarlo da solo all'interno di tutte le tue attività ;-)

Utilizzare l' applicazione quando è necessario condividere / archiviare stati tra le attività.

2) Verificare la presenza di informazioni sul processo in esecuzione

È possibile controllare lo stato di un processo in esecuzione con questa classe RunningAppProcessInfo

Recupera l'elenco dei processi in esecuzione con ActivityManager.getRunningAppProcesses () e filtra l'elenco dei risultati per verificare il RunningAppProcessInfo desiderato e verificarne la "importanza"

Ho creato un progetto su GitHub app-foreground-background-listen

che utilizza una logica molto semplice e funziona bene con tutti i livelli di API Android.

Usa l'intervallo di tempo tra la pausa e la ripresa dallo sfondo per determinare se è attivo dallo sfondo

Nell'applicazione personalizzata

private static boolean isInBackground;
private static boolean isAwakeFromBackground;
private static final int backgroundAllowance = 10000;

public static void activityPaused() {
    isInBackground = true;
    final Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            if (isInBackground) {
                isAwakeFromBackground = true;
            }
        }
    }, backgroundAllowance);
    Log.v("activity status", "activityPaused");
}

public static void activityResumed() {
    isInBackground = false;
    if(isAwakeFromBackground){
        // do something when awake from background
        Log.v("activity status", "isAwakeFromBackground");
    }
    isAwakeFromBackground = false;
    Log.v("activity status", "activityResumed");
}

Nella classe BaseActivity

@Override
protected void onResume() {
  super.onResume();
  MyApplication.activityResumed();
}

@Override
protected void onPause() {
  super.onPause();
  MyApplication.activityPaused();
}

Penso di avere una soluzione migliore. Perché puoi compilare semplicemente MyApplication.activityResumed (); a ogni attività di una estensione.

Per prima cosa devi creare (come CyberneticTwerkGuruOrc)

public class MyApplication extends Application {

  public static boolean isActivityVisible() {
    return activityVisible;
  }  

  public static void activityResumed() {
    activityVisible = true;
  }

  public static void activityPaused() {
    activityVisible = false;
  }

  private static boolean activityVisible;
}

Successivamente, devi aggiungere la classe Application ad AndroidManifest.xml

<application
    android:name="your.app.package.MyApplication"
    android:icon="@drawable/icon"
    android:label="@string/app_name" >

Quindi, crea la classe ActivityBase

public class ActivityBase extends Activity {

    @Override
    protected void onPause() {
        super.onPause();
        MyApplication.activityPaused();
    }

    @Override
    protected void onResume() {
        super.onResume();
        MyApplication.activityResumed();
    }
}

Infine, quando crei una nuova attività, puoi semplicemente estenderla per ActivityBase anziché per Activity.

public class Main extends ActivityBase {
    @Override
    protected void onResume() {
        super.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
    }
}

Per me è un metodo migliore perché devi solo ricordarti di estendere per ActivityBase. Inoltre puoi espandere la tua funzione di base in futuro. Nel mio caso ho aggiunto ricevitori per il mio servizio e avvisi sulla rete in una classe.

Se vuoi controllare la visibilità della tua App, puoi semplicemente chiamare

MyApplication.isActivityVisible()

Ciò può ottenere ciò in modo efficiente utilizzando Application.ActivityLifecycleCallbacks

Ad esempio, prendiamo il nome della classe Activity come ProfileActivity e scopriamo se è in primo piano o in background

per prima cosa dobbiamo creare la nostra classe di applicazione estendendo la classe di applicazione

che implementa

Application.ActivityLifecycleCallbacks

Consente di essere la mia classe di applicazione come segue

Classe di applicazione

public class AppController extends Application implements Application.ActivityLifecycleCallbacks {


private boolean activityInForeground;

@Override
public void onCreate() {
    super.onCreate();

//register ActivityLifecycleCallbacks  

    registerActivityLifecycleCallbacks(this);

}



public static boolean isActivityVisible() {
    return activityVisible;
}

public static void activityResumed() {
    activityVisible = true;
}

public static void activityPaused() {
    activityVisible = false;
}

private static boolean activityVisible;

@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {

}

@Override
public void onActivityStarted(Activity activity) {

}

@Override
public void onActivityResumed(Activity activity) {
    //Here you can add all Activity class you need to check whether its on screen or not

    activityInForeground = activity instanceof ProfileActivity;
}

@Override
public void onActivityPaused(Activity activity) {

}

@Override
public void onActivityStopped(Activity activity) {

}

@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {

}

@Override
public void onActivityDestroyed(Activity activity) {

}

public boolean isActivityInForeground() {
    return activityInForeground;
}
}

nella classe sopra c'è un metodo di override onActivityResumed di ActivityLifecycleCallbacks

 @Override
public void onActivityResumed(Activity activity) {
    //Here you can add all Activity class you need to check whether its on screen or not

    activityInForeground = activity instanceof ProfileActivity;
}

dove è possibile trovare tutte le istanze di attività attualmente visualizzate sullo schermo, controlla semplicemente se la tua attività è sullo schermo o meno con il metodo sopra.

Registra la tua classe Application in manifest.xml

<application
    android:name=".AppController" />

Per controllare il tempo L'attività è in primo piano o in background secondo la soluzione sopra, chiama il seguente metodo sui luoghi che devi controllare

AppController applicationControl = (AppController) getApplicationContext();
    if(applicationControl.isActivityInForeground()){
     Log.d("TAG","Activity is in foreground")
    }
    else
    {
      Log.d("TAG","Activity is in background")
    }

Se vuoi sapere se qualsiasi attività della tua app è visibile sullo schermo, puoi fare qualcosa del genere:

public class MyAppActivityCallbacks implements Application.ActivityLifecycleCallbacks {
private Set<Class<Activity>> visibleActivities = new HashSet<>();

@Override
public void onActivityResumed(Activity activity) {
    visibleActivities.add((Class<Activity>) activity.getClass());
}

@Override
public void onActivityStopped(Activity activity) {
     visibleActivities.remove(activity.getClass());
}

public boolean isAnyActivityVisible() {
    return !visibleActivities.isEmpty();
}

@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {}

@Override
public void onActivityStarted(Activity activity) {}

@Override
public void onActivityPaused(Activity activity) {}

@Override
public void onActivityDestroyed(Activity activity) {}

@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}}

Basta creare un singleton di questa classe e impostarlo nell'istanza dell'applicazione come di seguito:

class App extends Application{
     @Override
     public void onCreate() {
         registerActivityLifecycleCallbacks(myAppActivityCallbacks);
     }
}

Quindi puoi utilizzare il metodo isAnyActivityVisible () della tua istanza MyAppActivityCallbacks ovunque!

hai provato a non chiamare finish e a inserire "android: noHistory =" true "nel manifest? questo impedirà all'attività di andare nello stack.

Devo dire che il tuo flusso di lavoro non è in un modo Android standard. In Android, non è necessaria la finish()tua attività se desideri aprire un'altra attività da Intent. Per quanto riguarda la comodità dell'utente, Android consente all'utente di utilizzare il tasto "Indietro" per tornare dall'attività che hai aperto alla tua app.

Quindi lascia che il sistema interrompa la tua attività e salvi tutto ciò che è necessario quando la tua attività viene richiamata.

Salva una bandiera se sei in pausa o ripreso. Se riprendi significa che sei in primo piano

boolean  isResumed = false;

@Override
public void onPause() {
  super.onPause();    
  isResumed = false;
}

@Override
public void onResume() {
  super.onResume();    
  isResumed = true;
}

private void finishIfForeground() {
  if (isResumed) {
    finish();
  }
}

Una possibile soluzione potrebbe essere l'impostazione di un flag mentre si mostra la finestra di dialogo del sistema e quindi nel metodo onStop del ciclo di vita dell'attività, controllare il flag, se vero, terminare l'attività.

Ad esempio, se la finestra di dialogo di sistema viene attivata da un clic del pulsante, l'ascoltatore onclick potrebbe essere simile

private OnClickListener btnClickListener = new OnClickListener() {

    @Override
    public void onClick(View v) {           
        Intent intent = new Intent();
        intent.setAction(Intent.ACTION_SEND);
        intent.setType("text/plain");
        CheckActivity.this.startActivity(Intent.createChooser(intent, "Complete action using"));
        checkFlag = true;  //flag used to check

    }
};

e in interruzione dell'attività:

@Override
protected void onStop() {
    if(checkFlag){
        finish();
    }
    super.onStop();
}

Perché non utilizzare le trasmissioni per questo? la seconda attività (quella che deve essere attiva) può inviare una trasmissione locale come questa:

//put this in onCreate(..) or any other lifecycle method that suits you best
//notice the string sent to the intent, it will be used to register a receiver!
Intent result = new Intent("broadcast identifier");
result.putString("some message");//this is optional
LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(result);

quindi scrivi un semplice ricevitore all'interno dell'attività splash:

//this goes on the class level (like a class/instance variable, not in a method) of your splash activity:
private BroadcastReceiver receiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        //kill activity here!!!
        //mission accomplished!
    }
};

e registra il tuo nuovo ricevitore con LocalBroadcastManager per ascoltare la trasmissione dalla tua seconda attività:

//notice the string sent to the intent filter, this is where you tell the BroadcastManager which broadcasts you want to listen to!
LocalBroadcastManager.getInstance(getApplicationContext()).registerReceiver(receiver, new IntentFilter("broadcast identifier"));

NOTA che potresti usare una costante o una risorsa stringa per la stringa "identificatore di trasmissione".

Se usi finish()solo per evitare che una nuova app venga avviata nello stack (attività) della tua app, puoi usare Intent.FLAG_ACTIVITY_NEW_TASKflag, quando avvii una nuova applicazione e non chiamare finish()affatto. Secondo la documentazione , questo è il flag da utilizzare per implementare un comportamento in stile "launcher".

// just add this line before you start an activity
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

Usa questi metodi all'interno di un file Activity.

isDestroyed()

Aggiunto in Api 17
Restituisce vero se la chiamata finale a onDestroy () è stata effettuata sull'attività, quindi questa istanza è ora morta.

isFinishing()

Aggiunto in Api 1
Controlla se questa attività è in fase di completamento, o perché hai chiamato finish () su di essa o qualcun altro ha richiesto che finisse. Questo viene spesso utilizzato in onPause () per determinare se l'attività è semplicemente in pausa o completamente terminata.

Dalla documentazione sulle perdite di memoria

Un errore comune con AsyncTaskè acquisire un forte riferimento all'host Activity(o Fragment):

class MyActivity extends Activity {
  private AsyncTask<Void, Void, Void> myTask = new AsyncTask<Void, Void, Void>() {
    // Don't do this! Inner classes implicitly keep a pointer to their
    // parent, which in this case is the Activity!
  }
}

Questo è un problema perché AsyncTaskpuò facilmente sopravvivere al genitore Activity, ad esempio se si verifica una modifica alla configurazione mentre l'attività è in esecuzione.

Il modo giusto per farlo è rendere il tuo compito una staticclasse, che non cattura il genitore, e con un debole riferimento all'host Activity:

class MyActivity extends Activity {
  static class MyTask extends AsyncTask<Void, Void, Void> {
    // Weak references will still allow the Activity to be garbage-collected
    private final WeakReference<MyActivity> weakActivity;

    MyTask(MyActivity myActivity) {
      this.weakActivity = new WeakReference<>(myActivity);
    }

    @Override
    public Void doInBackground(Void... params) {
      // do async stuff here
    }

    @Override
    public void onPostExecute(Void result) {
      // Re-acquire a strong reference to the activity, and verify
      // that it still exists and is active.
      MyActivity activity = weakActivity.get();
      if (activity == null
          || activity.isFinishing()
          || activity.isDestroyed()) {
        // activity is no longer valid, don't do anything!
        return;
      }

      // The activity is still valid, do main-thread stuff here
    }
  }
}

Ecco una soluzione che utilizza Applicationclass.

public class AppSingleton extends Application implements Application.ActivityLifecycleCallbacks {

private WeakReference<Context> foregroundActivity;


@Override
public void onActivityResumed(Activity activity) {
    foregroundActivity=new WeakReference<Context>(activity);
}

@Override
public void onActivityPaused(Activity activity) {
    String class_name_activity=activity.getClass().getCanonicalName();
    if (foregroundActivity != null && 
            foregroundActivity.get().getClass().getCanonicalName().equals(class_name_activity)) {
        foregroundActivity = null;
    }
}

//............................

public boolean isOnForeground(@NonNull Context activity_cntxt) {
    return isOnForeground(activity_cntxt.getClass().getCanonicalName());
}

public boolean isOnForeground(@NonNull String activity_canonical_name) {
    if (foregroundActivity != null && foregroundActivity.get() != null) {
        return foregroundActivity.get().getClass().getCanonicalName().equals(activity_canonical_name);
    }
    return false;
}
}

Puoi semplicemente usarlo come segue,

((AppSingleton)context.getApplicationContext()).isOnForeground(context_activity);

Se hai un riferimento all'attività richiesta o utilizzi il nome canonico dell'attività, puoi scoprire se è in primo piano o meno. Questa soluzione potrebbe non essere infallibile. Pertanto i tuoi commenti sono davvero ben accetti.

Non so perché nessuno abbia parlato di sharedPreferences, per l'attività A, impostando un SharedPreference in questo modo (ad esempio in onPause ()):

SharedPreferences pref = context.getSharedPreferences(SHARED_PREF, 0);
SharedPreferences.Editor editor = pref.edit();
editor.putBoolean("is_activity_paused_a", true);
editor.commit();

Penso che questo sia il modo affidabile per monitorare la visibilità delle attività.

Sarebbe Activity.onWindowFocusChanged(boolean hasFocus)utile qui? Questo, oltre a una bandiera a livello di classe, qualcosa di simile isFocusedcheonWindowFocusChanged set, sarebbe un modo semplice per dire in qualsiasi punto della vostra attività, se si è focalizzata o meno. Dalla lettura dei documenti, sembra che impostare correttamente "false" in qualsiasi situazione in cui l'attività non è direttamente in "primo piano" fisico, ad esempio se viene visualizzata una finestra di dialogo o la barra delle notifiche è abbassata.

Esempio:

boolean isFocused;
@Override
void onWindowFocusChanged (boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);
    isFocused = hasFocus;
}

void someMethod() {
    if (isFocused) {
        // The activity is the foremost object on the screen
    } else {
        // The activity is obscured or otherwise not visible
    }
}

Se stai usando EventBus , è un metodo chiamato hasSubscriberForEventche può essere usato per controllare se un Activityè focalizzato.

Mi piaceva

se l'attività non è in primo piano

getIntent ()

restituirà null. : P =