Android App, aktywność państwa (bieganie, bieganie, nie planie/tło)

Question

mam natknąć wymogu, ale nie jestem w stanie uzyskać prawidłowy sposób realizacji i stąd potrzebują twojej pomocy.

Co chcę zrobić? - Chcę, aby wykonać działanie w zależności od zgłoszenia uzyskać w następujący sposób:

1. Gdy aplikacja jest otwarta, a na pierwszym planie tj widoczny dla użytkownika i dostaję powiadomienie po prostu pokazać się okienko do rozpoczęcia mojej działalności B
2. Kiedy Aplikacja jest zamknięty tzn ani w tle, ani w planie i dostaję powiadomienie będę pierwszym uruchomieniu mojej aplikacji, a następnie rozpocząć działalność B
3. Gdy aplikacja jest uruchomiona, ale w tle czyli w Niedawnych ale nie jest widoczna dla użytkownika, a następnie chcę zacząć moja aktywność B bez ponownego uruchamiania aplikacji. Ponadto w tym przypadku, gdy użytkownik naciśnie ponownie na Aktywność B, powinien zobaczyć ekran, który przerwali, przed wysłaniem go do tła.

Co mam zrobić? Osiągnąłem punkt # 1 i # 2. Chcę osiągnąć punkt # 3. Próbowałem poniżej

public static boolean isApplicationBroughtToBackground(final Activity activity) { 
    ActivityManager activityManager = (ActivityManager) activity.getSystemService(Context.ACTIVITY_SERVICE); 
    List<ActivityManager.RunningTaskInfo> tasks = activityManager.getRunningTasks(1); 

    // Check the top Activity against the list of Activities contained in the Application's package. 
    if (!tasks.isEmpty()) { 
    ComponentName topActivity = tasks.get(0).topActivity; 
    try { 
     PackageInfo pi = activity.getPackageManager().getPackageInfo(activity.getPackageName(), PackageManager.GET_ACTIVITIES); 
     for (ActivityInfo activityInfo : pi.activities) { 
     if(topActivity.getClassName().equals(activityInfo.name)) { 
      return false; 
     } 
     } 
    } catch(PackageManager.NameNotFoundException e) { 
     return false; // Never happens. 
    } 
    } 
    return true; 
} 

Jednak ta zwraca wartość true w obu przypadkach punkt # 2 i # 3, więc nie jestem w stanie odróżnić tylko # 3.

także Próbowałem poniżej w każdej działalności mam,

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

@Override 
protected void onResume() { 
    super.onResume(); 
    saveIsPausedInPref(false); 
} 

Ale to też nie daje pożądanego rezultatu coz jeśli aplikacja jest wysyłana do tła, naciskając przycisk HOME moje preferencje będą miały isPaused = true, a jeśli użytkownik usunie aplikację z najnowszej wersji, pozostanie ona prawdziwa i ponownie nie będę w stanie odróżnić punktu 2 i 3 po nadejściu powiadomienia.

Przeprosiny dla całej historii, ale mam nadzieję, że jestem w stanie wyjaśnić moje wymagania.

Z góry dziękuję. :)

Edit:

 <activity 
      android:name=".HomeActivity" 
      android:screenOrientation="portrait" > 
     </activity> 
     <activity 
      android:name=".ChatProfileActivity" 
      android:screenOrientation="portrait" > 
     </activity> 

Answer 1

Aby odróżnić przypadek # 2 i # 3 sprawy, można wykonać następujące czynności:

Uruchom ActivityB, jeśli nie jest to przypadek # 1. W ActivityB.onCreate() to zrobić:

super.onCreate(...); 
if (isTaskRoot()) { 
    // ActivityB has been started when the app is not running, 
    // start the app from the beginning 
    Intent restartIntent = new Intent(this, MyRootActivity.class); 
    startActivity(restartIntent); 
    finish(); 
    return; 
} 
... rest of onCreate() code here... 

Answer 2

wiem, że u zorientowali się 1 & 2, ale źle prawy moje własne toughts w przypadku u nie coś innego i u chcą spojrzeć.

1. Jak sprawdzić, czy Twoja aplikacja jest na pierwszym planie?

   this powinien być poprawny sposób, jeśli jej w planie następnie dodać zdarzenie poprzez eventbus, eventbus jest mój Preferowany sposób.

2. Uruchom aplikację o określonej aktywności ze stosem? spójrz na TaskStackBuilder z tym answer, to dostarczy informacji, jak to poprawnie.
3. Wznów aplikację z określoną aktywnością, zachowując bieżący stos? Sprawdź stan aplikacji za pomocą wywołań zwrotnych, a po otrzymaniu powiadomienia otwórz działanie bez FLAG_ACTIVITY_NEW_TASK. To powinno zrobić trik.

Answer 3

Jeśli zmienisz tak, aby nie wyświetlał się żaden pop-up, wystarczy przejść do działania B zawsze (zniszczone, tło lub pierwszy plan), nie potrzebujesz żadnej z tych kontroli. Tylko do pracy z flagami FLAG_ACTIVITY_X na powiadomieniu (to GCM to powiadomienie?).

LaunchMode on Manifest

Intent Flags

Można użyć metody onNewIntent sprawdzić intencje jeśli pochodzi od notyfikacji i rozpocząć działalność B.

Notification Proper BackStack

Answer 4

Poniżej kod działa dla mnie

In AndroidManifes t.xml

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

MyApplication.java

public class MyApplication extends Application { 
private ActivityLifecycleCallbacks myLifecycleHandler; 

@Override 
    public void onCreate() { 
     super.onCreate(); 
     myLifecycleHandler=new MyLifecycleHandler(); 
     registerActivityLifecycleCallbacks(myLifecycleHandler); 
    } 
} 

MyLifecycleHandler.java

public class MyLifecycleHandler implements Application.ActivityLifecycleCallbacks { 
    private static final String TAG = MyLifecycleHandler.class.getSimpleName(); 

private static int resumed; 
private static int paused; 
private static int started; 
private static int stopped; 

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

@Override 
public void onActivityDestroyed(Activity activity) { 
} 

@Override 
public void onActivityResumed(Activity activity) { 
    ++resumed; 
} 

@Override 
public void onActivityPaused(Activity activity) { 
    ++paused; 
    Log.d(TAG, "application is in foreground: " + (resumed > paused)); 
} 

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

@Override 
public void onActivityStarted(Activity activity) { 
    ++started; 
} 

@Override 
public void onActivityStopped(Activity activity) { 
    ++stopped; 
    Log.d(TAG, "application is visible: " + (started > stopped)); 
} 

public static boolean isApplicationVisible() { 
    return started > stopped; 
} 

public static boolean isApplicationInForeground() { 
    return resumed > paused; 
} 
} 

Teraz używając myLifecycleHandler metod można uzyskać wszystkie stwierdza trzeba.

isApplicationInForeground oznacza -> Co najmniej jedna aktywność jest w widocznym stanie.

isApplicationVisible środki -> Conajmniej jedna działalność jest tam, co się zaczęło, ale nie zatrzymał się, oznacza aplikacja jest uruchomiona stan

jeśli isApplicationInForeground prawda isApplicationVisible będzie zawsze prawdziwe, ale odwrotnie nie jest prawda