Comment vérifier si un service fonctionne sur Android?

Comment puis-je vérifier si un service background (sur Android) fonctionne?

je veux une activité Android qui change l'état du service -- elle me permet de l'allumer si elle est éteinte et éteinte si elle est allumée.

804
demandé sur Peter Mortensen 2009-03-01 21:09:09

23 réponses

j'ai eu le même problème il n'ya pas longtemps. Puisque mon service était local, j'ai fini par utiliser simplement un champ statique dans la classe service pour basculer l'état, comme décrit par hackbod ici

MODIFIER (pour mémoire):

Voici la solution proposée par hackbod:

si votre code client et serveur fait partie du même .apk et vous êtes engagement envers le service avec une intention concrète (qui précise classe de service exacte), alors vous pouvez simplement avoir votre service variable globale lorsqu'il est en cours d'exécution que votre client peut vérifier.

nous n'avons pas d'API pour vérifier si un service est courir parce que, presque sans faute, quand vous voulez faire quelque chose comme ça, vous finissez avec des conditions de course dans votre code.

249
répondu miracle2k 2015-08-17 20:01:04

j'utilise ce qui suit 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 en utilisant:

isMyServiceRunning(MyService.class)

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

toutes les approches utilisant des événements onDestroy ou onSometing ou des liants ou des variables statiques ne fonctionneront pas de manière fiable parce qu'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. S'il vous plaît noter la colonne "killable" dans le tableau des événements du cycle de vie dans la documentation Android.

1542
répondu geekQ 2014-11-05 18:57:14

compris!

Vous DOIT appel startService() pour votre service, pour être correctement enregistré et en passant BIND_AUTO_CREATE ne suffira pas.

Intent bindIntent = new Intent(this,ServiceTask.class);
startService(bindIntent);
bindService(bindIntent,mConnection,0);

et maintenant la classe des outils de service:

public class ServiceTools {
    private static String LOG_TAG = ServiceTools.class.getName();

    public static boolean isServiceRunning(String serviceClassName){
        final ActivityManager activityManager = (ActivityManager)Application.getContext().getSystemService(Context.ACTIVITY_SERVICE);
        final List<RunningServiceInfo> services = activityManager.getRunningServices(Integer.MAX_VALUE);

        for (RunningServiceInfo runningServiceInfo : services) {
            if (runningServiceInfo.service.getClassName().equals(serviceClassName)){
                return true;
            }
        }
        return false;
     }
}
67
répondu Kevin Parker 2015-08-24 06:06:14

un petit complément est:

mon but est de savoir si un service est en cours d'exécution sans l'exécuter réellement s'il n'est pas en cours d'exécution.

appeler bindService ou appeler une intention qui peut être captée par le service n'est pas une bonne idée alors car il va démarrer le service si elle 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 suggère de transformer le service dans un singleton avec une fessée très paresseuse Fessée: c'est-à-dire qu'il n'y a pas d'instanciation du tout de l'instance singleton par des méthodes statiques. La méthode gettinstance statique de votre service/singleton renvoie simplement l'instance du singleton si elle a été créée. Mais il ne démarre pas ou n'instancie pas le singleton lui-même. Le service est seulement commencé par le service normal démarrer méthodes.

il serait alors encore plus propre de modifier le dessin de singleton pour renommer la méthode confuse getInstance en quelque chose comme la méthode isInstanceCreated() : boolean .

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 service et seulement pour les classes iside l'application/paquet du service. Si vos cours sont en dehors du service app / package alors vous pouvez interroger L'ActivityManager avec les limitations soulignées par Pieter-Jan Van Robays.

51
répondu Snicolas 2014-11-05 19:00:24

vous pouvez utiliser ceci (je n'ai pas encore essayé cela, mais j'espère que cela fonctionne):

if(startService(someIntent) != null) {
    Toast.makeText(getBaseContext(), "Service is already running", Toast.LENGTH_SHORT).show();
}
else {
    Toast.makeText(getBaseContext(), "There is no service running, starting service..", Toast.LENGTH_SHORT).show();
}

la méthode startService renvoie un objet ComponentName s'il y a déjà un service en cours d'exécution. Dans la négative, null sera retourné.

See public abstract ComponentName startService (Intent service) .

ce n'est pas comme vérifier je pense, parce que c'est Démarrer le service, donc vous peut ajouter stopService(someIntent); sous le code.

22
répondu Keenan Gebze 2014-11-05 18:54:29
    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;
    }
14
répondu J.R 2017-11-10 05:20:13

j'ai légèrement modifié une des solutions présentées ci-dessus, mais en passant la classe au lieu d'un nom de chaîne générique, afin d'être sûr de comparer les chaînes provenant de la même méthode class.getName()

public class ServiceTools {
    private static String LOG_TAG = ServiceTools.class.getName();

    public static boolean isServiceRunning(Context context,Class<?> serviceClass){
        final ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
        final List<RunningServiceInfo> services = activityManager.getRunningServices(Integer.MAX_VALUE);

        for (RunningServiceInfo runningServiceInfo : services) {
            Log.d(Constants.TAG, String.format("Service:%s", runningServiceInfo.service.getClassName()));
            if (runningServiceInfo.service.getClassName().equals(serviceClass.getName())){
                return true;
            }
        }
        return false;
    }
}

et puis

Boolean isServiceRunning = ServiceTools.isServiceRunning(
                    MainActivity.this.getApplicationContext(),
                    BackgroundIntentService.class);
11
répondu loretoparisi 2016-07-13 14:26:04

je veux juste ajouter une note à la réponse de @Snicolas. Les étapes suivantes peuvent être utilisées pour vérifier le service stop avec/sans appeler onDestroy() .

  1. onDestroy() disant: Allez dans Paramètres -> Applications -> Services en cours d'Exécution -> Sélectionner et d'arrêter votre service.

  2. onDestroy() ne l'Appelle pas: Allez dans Paramètres -> Applications -> Gérer les Applications -> Sélectionner et de "Forcer l'Arrêt" de votre application qui votre service est en cours d'exécution. Cependant, comme votre application est arrêtée ici, donc certainement les instances de service seront également arrêtés.

enfin, je voudrais mentionner que l'approche mentionnée là en utilisant une variable statique dans la classe singleton fonctionne pour moi.

7
répondu Paul 2012-09-22 00:22:39

onDestroy n'est pas toujours appelé dans le service donc c'est inutile!

par exemple: il suffit d'exécuter l'application à nouveau avec un changement de Eclipse. L'application est sortie de force en utilisant SIG: 9.

6
répondu Kevin Parker 2014-06-02 11:06:07

ceci est un extrait de Android docs

Ordonné émissions (envoyé avec Contexte.sendOrderedBroadcast ) sont livré à un récepteur à la fois. Comme chaque récepteur exécute dans tour, il peut propager un résultat au récepteur suivant, ou il peut annuler complètement la diffusion pour qu'elle ne soit pas transmise à d'autres récepteur.

pensez à ceci hack comme "pinging" le Service puisque nous pouvons diffuser synchrone nous pouvons diffuser et obtenir un résultat synchrone sur le fil UI.

Service

BroadcastReceiver .

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

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

Activity

    bool serviceRunning = false;

    protected void onCreate (Bundle savedInstanceState){
        LocalBroadcastManager.getInstance(this).registerReceiver(echo);
        LocalBroadcastManager.getInstance(this).sendBroadcastSync(new Intent("echo"));
        if(!serviceRunning){
           //try and run the service
        }
    }

    private BroadcastReceiver echo = new BroadcastReceiver(){
        public void onReceive (Context context, Intent intent) {
          serviceRunning = true;   
        }
    }
6
répondu peter 2018-06-14 07:57:42

tout d'abord, vous ne devez pas essayer d'atteindre le service en utilisant L'ActivityManager. (Discuté ici )

Services peuvent fonctionner sur leur propre, être liés à une activité ou les deux. La façon de vérifier une activité si votre Service est en cours d'exécution ou non est en faisant une interface (qui étend Binder) où vous déclarez des méthodes que les deux, L'activité et le Service, comprennent. Vous pouvez le faire en faisant votre propre Interface où vous déclarez par exemple "isServiceRunning ()". Vous pouvez alors lier votre activité à votre Service, exécuter la méthode isServiceRunning(), le Service vérifiera par lui-même s'il fonctionne ou non et retournera un booléen à votre activité.

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

j'ai utilisé ce tutoriel pour apprendre comment implémenter ce scénario dans mon application.

5
répondu Pieter-Jan Van Robays 2012-06-06 17:07:28

pour vérifier si un service fonctionne, il suffit de le demander. Mettre en place un récepteur de radiodiffusion dans votre service qui répond aux pings de vos activités. Enregistrez le diffuseur au début du service et désinscrivez-le lorsque le service est détruit. De votre activité (ou de toute composante), envoyer un diffusion locale intention au service et si elle répond, vous savez qu'il est en cours d'exécution. Notez la différence subtile entre ACTION_PING et ACTION_PONG dans le code ci-dessous.

public class PingableService extends Service
{
    public static final String ACTION_PING = PingableService.class.getName() + ".PING";
    public static final String ACTION_PONG = PingableService.class.getName() + ".PONG";

    public int onStartCommand (Intent intent, int flags, int startId)
    {
        LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver, new IntentFilter(ACTION_PING));
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy ()
    {
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver);
        super.onDestroy();
    }

    private BroadcastReceiver mReceiver = new BroadcastReceiver()
    {
        @Override
        public void onReceive (Context context, Intent intent)
        {
            if (intent.getAction().equals(ACTION_PING))
            {
                LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getApplicationContext());
                manager.sendBroadcast(new Intent(ACTION_PONG));
            }
        }
    };
}


public class MyActivity extends Activity
{
    private boolean isSvcRunning = false;

    @Override
    protected void onStart()
    {
        LocalBroadcastManager manager = LocalBroadcastManager.getInstance(getApplicationContext());
        manager.registerReceiver(mReceiver, new IntentFilter(PingableService.ACTION_PONG));
        // the service will respond to this broadcast only if it's running
        manager.sendBroadcast(new Intent(PingableService.ACTION_PING));
        super.onStart();
    }

    @Override
    protected void onStop()
    {
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver);
        super.onStop();
    }

    protected BroadcastReceiver mReceiver = new BroadcastReceiver()
    {
        @Override
        public void onReceive (Context context, Intent intent)
        {
            // here you receive the response from the service
            if (intent.getAction().equals(PingableService.ACTION_PONG))
            {
                isSvcRunning = true;
            }
        }
    };
}
5
répondu Ben H 2016-10-29 21:12:06

Xamarin C# version:

private bool isMyServiceRunning(System.Type cls)
{
    ActivityManager manager = (ActivityManager)GetSystemService(Context.ActivityService);

    foreach (var service in manager.GetRunningServices(int.MaxValue)) {
        if (service.Service.ClassName.Equals(Java.Lang.Class.FromType(cls).CanonicalName)) {
            return true;
        }
    }
    return false;
}
5
répondu Nima 2018-09-04 08:50:01

pour le cas d'utilisation donné ici, nous pouvons simplement utiliser la valeur de retour de la méthode stopService() . Il retourne true s'il existe le service spécifié et qu'il est tué. Sinon, il retourne false . Donc, vous pouvez redémarrer le service si le résultat est false sinon il est assuré que le service a été arrêté. :) Ce serait mieux si vous avez un oeil à ce .

4
répondu Rahul Raveendran 2013-05-28 09:55:23

encore une fois, une autre alternative que les gens pourraient trouver plus propre s'ils utilisent des intentions en attente (par exemple avec le AlarmManager :

public static boolean isRunning(Class<? extends Service> serviceClass) {
    final Intent intent = new Intent(context, serviceClass);
    return (PendingIntent.getService(context, CODE, intent, PendingIntent.FLAG_NO_CREATE) != null);
}

CODE est une constante que vous définissez en privé dans votre classe pour identifier les intentions pendantes associées à votre service.

4
répondu Snicolas 2014-08-06 23:41:37

ci-dessous est un hack élégant qui couvre tous les Ifs . Ce service est réservé aux services locaux.

    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 plus tard:

    if(AService.isServiceCreated()){
        ...
    }else{
        startService(...);
    }
2
répondu TheRealChx101 2018-01-19 14:08:18

il peut y avoir plusieurs services portant le même nom de classe.

je viens de créer deux applications. Le nom du paquet 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 . Son nom complet est donc com.example.mock.lorem.Mock2Service .

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

voici ma sortie logcat.

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 les instances ComponentName parce que equals() de ComponentName compare à la fois les noms de paquets et les noms de classe. Et il ne peut pas y avoir deux applications avec le même nom de paquet 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

1
répondu Maksim Dmitriev 2014-03-27 08:35:23

La réponse de geekQ mais dans Kotlin classe. Merci geekQ

fun isMyServiceRunning(serviceClass : Class<*> ) : Boolean{
    var manager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    for (service in manager.getRunningServices(Integer.MAX_VALUE)) {
        if (serviceClass.name.equals(service.service.className)) {
            return true
        }
    }
    return false
}

L'appel

isMyServiceRunning(NewService::class.java)
1
répondu Luis Eduardo Moreno 2018-03-23 21:43:10

ceci s'applique davantage au débogage de service D'intention puisqu'ils génèrent un thread, mais peuvent fonctionner pour les services réguliers aussi bien. J'ai trouvé ce fil grâce à Binginging

dans mon cas, j'ai joué avec le débogueur et j'ai trouvé la vue thread. Ça ressemble un peu à L'icône de point de puce dans MS Word. De toute façon, vous n'avez pas besoin d'être en mode débogueur pour l'utiliser. Cliquez sur le processus et cliquez sur ce bouton. Tous les services D'intention apparaîtront pendant qu'ils sont en cours d'exécution, à moins sur l'émulateur.

0
répondu Joe Plante 2012-08-03 20:38:00

si le service appartient à un autre processus OU APK utiliser la solution basée sur L'ActivityManager.

si vous avez accès à sa source, utilisez simplement la solution basée sur un champ statique. Mais au lieu d'utiliser un booléen je suggérerais d'utiliser un objet Date. Pendant que le service est en cours d'exécution, il suffit de mettre à jour sa valeur à 'now' et, lorsqu'il est terminé, de la définir à null. De l'activité, vous pouvez vérifier si son null ou la date est trop ancienne, ce qui signifie qu'il ne fonctionne pas.

vous pouvez également envoyer une notification de diffusion de votre service indiquant que est en cours d'autres informations comme progress.

0
répondu FranMowinckel 2013-08-04 11:14:41

dans la classe Serviceclass define:

 public static Boolean serviceRunning = false;

puis dans onStartCommand (...)

 public int onStartCommand(Intent intent, int flags, int startId) {

    serviceRunning = true;
    ...
}

 @Override
public void onDestroy()
{
    serviceRunning = false;

} 

alors, appelez if(TheServiceClass.serviceRunning == true) de n'importe quelle classe.

0
répondu fullMoon 2015-10-23 18:35:09

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 utiliser? getRunningServices ()

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

Note: cette méthode est uniquement destinée au débogage ou à la mise en œuvre d'interfaces utilisateur de type Gestion de service.


ps. la documentation android est trompeuse j'ai ouvert un problème sur Google tracker pour éliminer tous les doutes:

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

comme nous pouvons le voir, le service bind invoque en fait une transaction via ActivityManager binder à travers le service cache binders-I dint track quel service est responsable de la liaison, mais comme nous pouvons le voir le résultat pour bind est:

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

transaction est effectuée par le classeur:

ServiceManager.getService("activity");

suivant:

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

ceci est défini dans ActivityThread via:

 public final void bindApplication(...) {

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

cela s'appelle dans ActivityManagerService dans la méthode:

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

puis:

 private HashMap<String, IBinder> getCommonServicesLocked() {

mais il n'y a pas d '"activité" seulement paquet de fenêtre et 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);

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 de creuser en c donc jusqu'à ce que je dissèque appel de repos je suspends 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 n'est pas créé, le service n'existe pas) - et interroge le service sur son état par le biais de bind (en utilisant un drapeau interne stocké sur cet état).

mise à jour 23.06.2018

j'ai trouvé ces intéressants:

/**
 * 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 ne démarre pas le service cible s'il n'est pas présent."

public IBinder peekService(Intent service, String resolvedType, String callingPackage) lance 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;
}

*

0
répondu ceph3us 2018-06-23 16:05:03

calmez-vous... :)

je pense que la solution la plus appropriée est de tenir une paire de valeur clé dans SharedPreferences si le service est en cours d'exécution ou non.

la logique est très droite; à n'importe quelle position désirée dans votre classe de service; mettez une valeur booléenne qui agira comme un drapeau pour vous si le service est en cours d'exécution ou non. Ensuite, lisez cette valeur où vous voulez dans votre application.

un exemple de code que je suis utiliser dans mon application est ci-dessous:

dans ma classe de Service (un service pour Audio Stream), 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();
}

alors dans n'importe quelle activité de ma demande, je vérifie le statut du service à 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 de permissions spéciales, pas de boucles... Moyen facile, propre solution :)

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

Espérons que cette aide.

-3
répondu Taner 2015-08-04 10:21:27