Android: Pause et reprise au niveau de l'application

J'ai essayé d'obtenir le Niveau d'Application de Pause et de Reprendre semblable à une activité onPause et onResume. Je sais il n'y a pas d'API qui dispose de cette fonctionnalité.

J'essaie de suivre ce post: http://curioustechizen.blogspot.com/2012/12/android-application-level-pause-and.html

Mais je n'ai pas eu de chance jusqu'à présent.

Quelqu'un a été en mesure de réaliser cela? Ce paradigme avez-vous utilisé?

Laissez-moi savoir si vous avez besoin de moi pour coller du code dans cette question.
Merci pour l'aide

source d'informationauteur TMacGyver

Une autre solution au problème serait de simplement garder une trace du nombre de onStart() et onStop() appels de toutes les activités. Exemple:

Tout d'abord, créer une classe pour tenir le compte:

public class ActiveActivitiesTracker {
    private static int sActiveActivities = 0;

    public static void activityStarted()
    {
        if( sActiveActivities == 0 )
        {
            //TODO: Here is presumably "application level" resume
        }
        sActiveActivities++;
    }

    public static void activityStopped()
    {
        sActiveActivities--;
        if( sActiveActivities == 0 )
        {
            //TODO: Here is presumably "application level" pause
        }
    }
}

Alors, dans chaque activité, il suffit d'appeler la activityStarted() et activityStopped() méthodes:

@Override
public void onStart() {
    super.onStart();
    ActiveActivitiesTracker.activityStarted();
}

@Override
public void onStop() {
    super.onStop();
    ActiveActivitiesTracker.activityStopped();
}

4

J'ai eu le même problème. Mon but était de verrouillage de l'Application, si l'utilisateur abandonne. Un objectif simple, je crois qu'il serait facile à mettre en œuvre. Mais toutes les solutions que j'ai trouvées étaient complexes. Je suis donc venu pour une solution simple: Une heure en fonction de verrouillage.

Fondamentalement, il fonctionne comme ceci:
- Démarrer le compte à rebours pour le verrouillage de l'application dans onPause
- Arrêter le compte à rebours dans onResume
- Si onResume n'est pas appelée dans le temps, de changer de verrouillage
À cet effet, j'ai créé un petit peu de classe:
```
public class ApplicationLock {

private static final String TAG = ApplicationLock.class.getSimpleName();
private static final int LOCK_TIME = 1000; //lock after a second
private static boolean lock = true; //default is locked
private static Handler handler = new Handler();
private static Runnable runnable = new Runnable() {
    @Override
    public void run() {
        lock = true;
        Log.i("ActivityTracker", "App locked");
    }
};

public static boolean activityStarted()
{
    handler.removeCallbacks(runnable);
    if(lock)
    {
        Log.i(TAG, "App resumed - LOCKED");
        return true;
    }else{
        Log.i(TAG, "App resumed - NOT LOCKED");
        return false;
    }
}

public static void activityStopped()
{
    handler.postDelayed(runnable, LOCK_TIME);
    Log.i(TAG, "App paused - Starting countdown");

}
```
Appelez simplement activityStopped() dans vos activités onPause() et activityStarted() dans onResume(). Vérifier le résultat de activityStarted(). Si elle retourne true, verrouiller votre application. Si l'orientation de l'application est changé, onResume sera appelé très rapidement après onPause, de sorte que l'application ne sera pas de verrouillage.

Cette solution pourrait ne pas être adaptée à chaque scénario, mais dans mon cas, c'était la meilleure solution. En outre, vous pouvez modifier le compte à rebours, pour augmenter l'expérience de l'utilisateur (L'utilisateur a appuyé sur un mauvais bouton et renvoie à l'application en quelques secondes, pas besoin de verrouiller l'application). Espérons que cela est utile à quelqu'un d'autre.

J'ai fait quelque chose de très similaire à cela dans une application qui utilise un service qui a fourni des fonctions GPS par plusieurs activités. L'idée était de n'avoir le service lorsqu'une des activités qu'il est visible, et pas là quand aucun n'est visible. Dans votre cas, chaque activité de crochet dans un service, et vous saurez quand le tout a été mis en pause ou reprise par accrochage dans le service de onCreate() et onDestroy() méthodes.

Ici est un stripped-down exemple:

Composants nécessaires (il pourrait sans doute être placé dans une classe utilitaire si vous souhaitez les réutiliser, ou je viens d'avoir pour chaque classe d'activité):

private boolean mAppActiveServiceBound = false;
private AppActiveService mAppActiveService = null;
private ServiceConnection mAppActiveConnection = new ServiceConnection() {
    public void onServiceConnected( ComponentName className, IBinder service ) {
        mAppActiveService = ( (AppActiveService.AppActiveBinder) service ).getService();
    }
    public void onServiceDisconnected( ComponentName className ) {
        mAppActiveService = null;
    }
};

Puis dans votre onStart() et onStop() les méthodes pour chaque activité:

@Override
public void onStart() {
    super.onStart();
    mAppActiveServiceBound = bindService( new Intent( this, AppActiveService.class ), mAppActiveConnection, Context.BIND_AUTO_CREATE );
}

@Override
public void onStop() {
    super.onStop();
    if( mAppActiveServiceBound ) {
        unbindService( mAppActiveConnection );
        mAppActiveServiceBound = false;
    }
}

Et enfin, le service lui-même:

public class  AppActiveService extends Service {
    //Receives interactions from clients:
    private final IBinder mBinder = new AppActiveBinder();

    /**
     * Provides a handle to the bound service.
     */
    public class  AppActiveBinder extends Binder {
        AppActiveService getService() {
            return AppActiveService.this;
        }
    }

    @Override
    public void onCreate(){
        //TODO: Here is presumably "application level" resume
    }

    @Override
    public void onDestroy(){
        //TODO: Here is presumably "application level" pause
    }
}

Vous devez vous connecter pour publier un commentaire.