Comment vérifier si un service est en cours d'exécution sur Android?

J'utilise la suite de l'intérieur d'une activité:

private boolean isMyServiceRunning(Class<?> serviceClass) {
    ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
        if (serviceClass.getName().equals(service.service.getClassName())) {
            return true;
        }
    }
    return false;
}

Et je l'appelle à l'aide:

isMyServiceRunning(MyService.class)

Cela fonctionne de manière fiable, car il est basé sur les informations sur l'exécution des services fournis par le système d'exploitation Android à travers ActivityManager#getRunningServices.

Toutes les approches à l'aide de onDestroy ou onSometing des événements ou des Liants ou des variables statiques ne fonctionnera pas de manière fiable, car en tant que développeur, vous ne savez jamais, quand Android décide de tuer votre processus ou des rappels sont appelés ou non. Veuillez noter que le "tuables" colonne de la événements du cycle de vie de la table dans l'Android documentation.

Un petit complément est:

Mon but est de savoir si un service est en cours d'exécution sans réellement l'exécution si elle n'est pas en cours d'exécution.

Appel bindService ou l'appel d'une intention qui peut être pris par le service n'est pas une bonne idée alors qu'il va commencer le service s'il n'est pas en cours d'exécution.

Donc, comme miracle2k suggéré, le mieux est d'avoir un champ statique dans la classe de service pour savoir si le service a été commencé ou pas.

Pour le rendre encore plus propre, je vous suggère de transformer le service dans un singleton avec un très très chargement différé: c'est, il n'y a pas d'instanciation à tous les singleton exemple par le biais de méthodes statiques. La statique de la méthode getInstance de votre service/singleton retourne l'instance du singleton si elle a été créée. Mais il n'a pas réellement démarrer ou instancier le singleton lui-même. Le service est démarré uniquement par le biais de la normale de démarrage du service méthodes.

Il serait alors encore plus propre à modifier le modèle de conception singleton pour renommer la confusion de la méthode getInstance en quelque chose qui ressemble isInstanceCreated() : boolean méthode.

Le code ressemblera à:

public class MyService extends Service
{
   private static MyService instance = null;

   public static boolean isInstanceCreated() {
      return instance != null;
   }//met

   @Override
   public void onCreate()
   {
      instance = this;
      ....
   }//met

   @Override
   public void onDestroy()
   {
      instance = null;
      ...
   }//met
}//class

Cette solution est élégante, mais elle n'est pertinente que si vous avez accès à la classe de service et uniquement pour les classes de iside l'application/paquet du service. Si vos classes sont en dehors de l'application de service/paquet alors vous pouvez interroger l'ActivityManager avec des limitations souligné par Pieter-Jan Van Robays.

    public boolean checkServiceRunning(){
         ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
        for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) 
                {
                    if ("com.example.yourpackagename.YourServiceName"
                            .equals(service.service.getClassName())) 
                    {
                        return true;
                    }
                }
             return false;
    }

Un extrait de Android docs:

Comme sendBroadcast(Intention), mais s'il y a des récepteurs pour
le but de cette fonction va les bloquer et de les expédier immédiatement
avant de revenir.

Pense de ce hack "pinging" la Service puisque l'on peut diffuser de manière synchrone l'on peut diffuser et d'obtenir un résultat -- de façon synchrone -- sur le thread d'INTERFACE utilisateur.

Service

@Override
public void onCreate() {
   LocalBroadcastManager
     .getInstance(this)
     .registerReceiver(new ServiceEchoReceiver(), new IntentFilter("ping"));
}

private class ServiceEchoReceiver extends BroadcastReceiver {
    public void onReceive (Context context, Intent intent) {
      LocalBroadcastManager
         .getInstance(this)
         .sendBroadcastSync(new Intent("pong"));
    }
}

Activity

    bool serviceRunning = false;

    protected void onCreate (Bundle savedInstanceState){
        LocalBroadcastManager.getInstance(this).registerReceiver(pong, new IntentFilter("pong"));
        LocalBroadcastManager.getInstance(this).sendBroadcastSync(new Intent("ping"));
        if(!serviceRunning){
           //run the service
        }
    }

    private BroadcastReceiver pong = new BroadcastReceiver(){
        public void onReceive (Context context, Intent intent) {
          serviceRunning = true;   
        }
    }

onDestroy n'est pas toujours appelé dans le service, de sorte que c'est inutile!

Par exemple: il suffit de lancer l'application avec un seul changement à partir d'Eclipse. L'application est violemment sorti de l'aide de SIG: 9.

Tout d'abord il ne faut pas tenter de joindre le service à l'aide de la ActivityManager. (Discuté ici)

Services peut s'exécuter sur leur propre, être lié à une Activité ou les deux. Le moyen de vérifier, dans une Activité, si votre Service est en cours d'exécution ou non est de faire une interface (qui s'étend de Liant) où vous déclarer des méthodes à la fois, l'Activité et le Service, de comprendre. Vous pouvez le faire en faisant votre propre Interface où vous déclarez par exemple "isServiceRunning()".
Vous pouvez ensuite lier votre Activité à votre Service, exécutez la méthode isServiceRunning(), le Service permettra de vérifier lui-même si elle fonctionne ou pas et retourne un booléen à votre Activité.

Vous pouvez également utiliser cette méthode pour arrêter de votre Service ou d'interagir avec lui d'une autre manière.

J'ai utilisé ce tutoriel pour savoir comment mettre en Œuvre ce scénario dans ma demande.

Pour les cas d'utilisation donné, là, on peut simplement utiliser la stopService() de retour de la méthode de la valeur. Il retourne true si il existe le service spécifié et il est tué. Sinon, il retourne false. Donc, vous pouvez redémarrer le service si le résultat est false d'autre, il est assuré que le service a été arrêté. 🙂 Il serait mieux si vous avez un coup d'oeil à cette.

Ci-dessous est un élégant hack qui couvre tous les Ifs. C'est pour les services locaux seulement.

    public final class AService extends Service {
private static AService mInstance = null;
public static boolean isServiceCreated() {
try {
//If instance was not cleared but the service was destroyed an Exception will be thrown
return mInstance != null && mInstance.ping();
} catch (NullPointerException e) {
//destroyed/not-started
return false;
}
}
/**
* Simply returns true. If the service is still active, this method will be accessible.
* @return
*/
private boolean ping() {
return true;
}
@Override
public void onCreate() {
mInstance = this;
}
@Override
public void onDestroy() {
mInstance = null;
}
}

Et puis, plus tard:

    if(AService.isServiceCreated()){
...
}else{
startService(...);
}

Il peut y avoir plusieurs services avec le même nom de classe.

Je viens de créer deux applications. Le nom du package de la première application est com.example.mock. J'ai créé un sous-paquetage appelé lorem dans l'application et un service appelé Mock2Service. Donc, son nom complet est com.example.mock.lorem.Mock2Service.

Puis j'ai créé la deuxième application et un service appelé Mock2Service. Le nom du package de la seconde application est com.example.mock.lorem. Le nom pleinement qualifié du service est com.example.mock.lorem.Mock2Service, trop.

Voici mon logcat de sortie.

03-27 12:02:19.985: D/TAG(32155): Mock-01: com.example.mock.lorem.Mock2Service
03-27 12:02:33.755: D/TAG(32277): Mock-02: com.example.mock.lorem.Mock2Service

Une meilleure idée est de comparer ComponentName cas car equals() de ComponentName compare les deux noms de paquets et les noms de classe. Et il ne peut y avoir deux applications avec le même nom du package installé sur un périphérique.

La méthode equals() de ComponentName.

@Override
public boolean equals(Object obj) {
try {
if (obj != null) {
ComponentName other = (ComponentName)obj;
//Note: no null checks, because mPackage and mClass can
//never be null.
return mPackage.equals(other.mPackage)
&& mClass.equals(other.mClass);
}
} catch (ClassCastException e) {
}
return false;
}

Nomcomposant

Si le service appartient à un autre processus ou APK utiliser la solution basée sur le ActivityManager.

Si vous avez accès à sa source, il suffit d'utiliser la solution basée sur un champ statique. Mais au lieu d'utiliser un booléen, je voudrais suggérer à l'aide d'un objet Date. Alors que le service est en cours d'exécution, juste de mettre à jour sa valeur à "maintenant" et quand il finit de le régler à la valeur null. De l'activité, vous pouvez vérifier si sa valeur null ou la date est trop vieux, ce qui signifie qu'il n'est pas en cours d'exécution.

Vous pouvez également envoyer de diffusion de notification de votre service indiquant qui est en cours d'exécution le long de plus d'informations, comme des progrès.

simple d'utilisation lier avec de ne pas créer d'auto - voir ps. et mise à jour...

public abstract class Context {
... 
/*
* @return {true} If you have successfully bound to the service, 
*  {false} is returned if the connection is not made 
*  so you will not receive the service object.
*/
public abstract boolean bindService(@RequiresPermission Intent service,
@NonNull ServiceConnection conn, @BindServiceFlags int flags);

exemple :

    Intent bindIntent = new Intent(context, Class<Service>);
boolean bindResult = context.bindService(bindIntent, ServiceConnection, 0);

pourquoi ne pas l'utiliser? getRunningServices()

List<ActivityManager.RunningServiceInfo> getRunningServices (int maxNum)
Return a list of the services that are currently running.

Remarque: cette méthode est uniquement destiné à des fins de débogage ou de la mise en œuvre de la gestion des services de type interfaces utilisateur.

---

ps. android documentation est trompeur, j'ai ouvert un sujet sur google tracker pour éliminer tous les doutes:

https://issuetracker.google.com/issues/68908332

comme nous pouvons le voir se lier service appelle en fait une transaction via ActivityManager classeur à travers le Service de cache liants - je la force de la piste de laquelle le service est responsable de la liaison, mais comme nous pouvons voir le résultat de bind est:

int res = ActivityManagerNative.getDefault().bindService(...);
return res != 0;

transaction est effectuée par le classeur:

ServiceManager.getService("activity");

suivante:

  public static IBinder getService(String name) {
try {
IBinder service = sCache.get(name);
if (service != null) {
return service;
} else {
return getIServiceManager().getService(name);

il est en ActivityThread via:

 public final void bindApplication(...) {
if (services != null) {
//Setup the service cache in the ServiceManager
ServiceManager.initServiceCache(services);
}

ce qui est appelé en ActivityManagerService dans la méthode:

 private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
...
thread.bindApplication(... , getCommonServicesLocked(),...)

alors:

 private HashMap<String, IBinder> getCommonServicesLocked() {

mais il n'y a pas de "activité" seule fenêtre de paquet et d'alarme..

donc nous avons besoin de revenir à l'appel:

 return getIServiceManager().getService(name);
sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());

cela fait appel à l'aide d':

    mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0);

ce qui conduit à :

BinderInternal.getContextObject()

et c'est la méthode native....

  /**
* Return the global "context object" of the system.  This is usually
* an implementation of IServiceManager, which you can use to find
* other services.
*/
public static final native IBinder getContextObject();

je n'ai pas le temps maintenant d'creusé dans c jusqu'à ce que je disséquer appel reste, je dois suspendre ma réponse.

mais la meilleure façon de vérifier si le service est en cours d'exécution est de créer bind (si bind est pas créé le service n'existe pas) - et d'interroger le service à propos de son état par l'intermédiaire de la liaison (en utilisant stockées internes, le drapeau de l'état).

mise à jour 23.06.2018

j'ai trouvé ces intéressantes:

/**
* Provide a binder to an already-bound service.  This method is synchronous
* and will not start the target service if it is not present, so it is safe
* to call from {@link #onReceive}.
*
* For peekService() to return a non null {@link android.os.IBinder} interface
* the service must have published it before. In other words some component
* must have called {@link android.content.Context#bindService(Intent, ServiceConnection, int)} on it.
*
* @param myContext The Context that had been passed to {@link #onReceive(Context, Intent)}
* @param service Identifies the already-bound service you wish to use. See
* {@link android.content.Context#bindService(Intent, ServiceConnection, int)}
* for more information.
*/
public IBinder peekService(Context myContext, Intent service) {
IActivityManager am = ActivityManager.getService();
IBinder binder = null;
try {
service.prepareToLeaveProcess(myContext);
binder = am.peekService(service, service.resolveTypeIfNeeded(
myContext.getContentResolver()), myContext.getOpPackageName());
} catch (RemoteException e) {
}
return binder;
}

en bref 🙂

"Fournir un classeur déjà lié service. Cette méthode est synchrone et de ne pas commencer la cible de service s'il n'est pas présent."

public IBinder peekService(But de service, Chaîne resolvedType,
Chaîne callingPackage) throws RemoteException;

*

public static IBinder peekService(IBinder remote, Intent service, String resolvedType)
throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken("android.app.IActivityManager");
service.writeToParcel(data, 0);
data.writeString(resolvedType);
remote.transact(android.os.IBinder.FIRST_CALL_TRANSACTION+84, data, reply, 0);
reply.readException();
IBinder binder = reply.readStrongBinder();
reply.recycle();
data.recycle();
return binder;
}

*

Mon kotlin de conversion de la ActivityManager::getRunningServices en fonction des réponses. Mettre cette fonction dans une activité

private fun isMyServiceRunning(serviceClass: Class<out Service>) =
(getSystemService(ACTIVITY_SERVICE) as ActivityManager)
.getRunningServices(Int.MAX_VALUE)
?.map { it.service.className }
?.contains(serviceClass.name) ?: false

De prendre facilement les gars... 🙂

Je pense que la solution la plus adaptée est la tenue d'une paire clé-valeur dans SharedPreferences sur si le service est en cours d'exécution ou non.

Logique est très simple; dans la position souhaitée dans votre classe de service, mettre une valeur booléenne qui va agir comme un drapeau pour vous de savoir si le service est en cours d'exécution ou non. Alors lisez cette valeur où vous le voulez dans votre application.

Un exemple de code que j'utilise dans mon application est ci-dessous:

Dans ma classe de Service (Un service pour les Flux Audio), j'exécute le code suivant lorsque le service est en place;

private void updatePlayerStatus(boolean isRadioPlaying)
{
SharedPreferences sharedPref = this.getSharedPreferences(getString(R.string.str_shared_file_name), Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putBoolean(getString(R.string.str_shared_file_radio_status_key), isRadioPlaying);
editor.commit();
}

Puis dans toute activité de ma demande, je suis à la vérification de l'état du service avec l'aide du code suivant;

private boolean isRadioRunning() {
SharedPreferences sharedPref = this.getSharedPreferences(getString(R.string.str_shared_file_name), Context.MODE_PRIVATE);
return sharedPref.getBoolean(getString(R.string.str_shared_file_radio_status_key), false);
}

Pas d'autorisations spéciales, pas de boucles... moyen Facile, propre solution 🙂

Si vous avez besoin d'informations supplémentaires, veuillez consulter le lien

Espère que cette aide.