Wie überprüfe ich, ob ein Dienst unter Android ausgeführt wird?

Wie überprüfe ich, ob ein Hintergrunddienst ausgeführt wird?

Ich möchte eine Android-Aktivität, die den Status des Dienstes umschaltet. Mit dieser Funktion kann ich sie aktivieren, wenn sie deaktiviert ist, und deaktivieren, wenn sie aktiviert ist.

Ich hatte vor kurzem das gleiche Problem. Da mein Dienst lokal war, habe ich einfach ein statisches Feld in der Dienstklasse verwendet, um den Status umzuschalten, wie hier von hackbod beschrieben

EDIT (für die Aufzeichnung):

Hier ist die von Hackbod vorgeschlagene Lösung:

Wenn Ihr Client- und Servercode Teil derselben APK-Datei ist und Sie mit einer konkreten Absicht (eine, die die genaue Serviceklasse angibt) an den Service binden, können Sie Ihren Service einfach eine globale Variable festlegen lassen, wenn er diese ausführt Ihr Kunde kann dies überprüfen.

Wir haben absichtlich keine API, um zu überprüfen, ob ein Dienst ausgeführt wird, da Sie fast immer Rennbedingungen in Ihrem Code haben, wenn Sie so etwas tun möchten.

Ich verwende Folgendes innerhalb einer Aktivität:

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;
}

Und ich nenne es mit:

isMyServiceRunning(MyService.class)

Dies funktioniert zuverlässig, da es auf den Informationen zum Ausführen von Diensten basiert, die vom Android-Betriebssystem über ActivityManager # getRunningServices bereitgestellt werden .

Alle Ansätze, die onDestroy- oder onSometing-Ereignisse oder Ordner oder statische Variablen verwenden, funktionieren nicht zuverlässig, da Sie als Entwickler nie wissen, wann Android Ihren Prozess beendet oder welche der genannten Rückrufe aufgerufen werden oder nicht. Bitte beachten Sie die Spalte "killable" in der Lifecycle-Ereignistabelle in der Android-Dokumentation.

Ich habs!

Sie MÜSSEN anrufen, startService()damit Ihr Dienst ordnungsgemäß registriert wird und das Bestehen BIND_AUTO_CREATEnicht ausreicht.

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

Und jetzt die ServiceTools-Klasse:

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;
     }
}

Eine kleine Ergänzung ist:

Mein Ziel ist es zu wissen, ob ein Dienst ausgeführt wird, ohne ihn tatsächlich auszuführen, wenn er nicht ausgeführt wird.

Das Aufrufen von bindService oder das Aufrufen einer Absicht, die vom Dienst abgefangen werden kann, ist dann keine gute Idee, da der Dienst gestartet wird, wenn er nicht ausgeführt wird.

Wie miracle2k vorgeschlagen hat, ist es am besten, ein statisches Feld in der Serviceklasse zu haben, um zu wissen, ob der Service gestartet wurde oder nicht.

Um es noch sauberer zu machen, schlage ich vor, den Dienst in einen Singleton mit einem sehr sehr faulen Abruf umzuwandeln: Das heißt, es gibt überhaupt keine Instanziierung der Singleton- Instanz durch statische Methoden. Die statische getInstance-Methode Ihres Dienstes / Singletons gibt nur die Instanz des Singletons zurück, wenn dieser erstellt wurde. Der Singleton selbst wird jedoch nicht gestartet oder instanziiert. Der Dienst wird nur über normale Dienststartmethoden gestartet.

Es wäre dann noch sauberer, das Singleton-Entwurfsmuster zu ändern, um die verwirrende getInstance-Methode in so etwas wie die isInstanceCreated() : booleanMethode umzubenennen .

Der Code sieht folgendermaßen aus:

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

Diese Lösung ist elegant, aber nur relevant, wenn Sie Zugriff auf die Serviceklasse haben und nur für Klassen neben der App / dem Paket des Service. Wenn sich Ihre Klassen außerhalb der Service-App / des Service-Pakets befinden, können Sie den ActivityManager mit den von Pieter-Jan Van Robays unterstrichenen Einschränkungen abfragen.

Sie können dies verwenden (ich habe es noch nicht versucht, aber ich hoffe, dass es funktioniert):

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();
}

Die startService-Methode gibt ein ComponentName-Objekt zurück, wenn bereits ein Dienst ausgeführt wird. Wenn nicht, wird null zurückgegeben.

Siehe public abstract ComponentName startService (Absichtsdienst) .

Dies ist nicht wie eine Überprüfung, denke ich, weil es den Dienst startet, so dass Sie stopService(someIntent);unter dem Code hinzufügen können .

/**
 * Check if the service is Running 
 * @param serviceClass the class of the Service
 *
 * @return true if the service is running otherwise false
 */
public boolean checkServiceRunning(Class<?> serviceClass){
    ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE))
    {
        if (serviceClass.getName().equals(service.service.getClassName()))
        {
            return true;
        }
    }
    return false;
}

Ein Auszug aus Android- Dokumenten:

Wie sendBroadcast (Intent) , aber wenn es Empfänger für den Intent gibt, blockiert diese Funktion diese und versendet sie sofort, bevor sie zurückkehren.

Stellen Sie sich diesen Hack als "Ping" vorService . Da wir synchron senden können, können wir synchron über den UI-Thread senden und ein Ergebnis erhalten .

Service

@Override
public void onCreate() {
   LocalBroadcastManager
     .getInstance(this)
     .registerReceiver(new ServiceEchoReceiver(), new IntentFilter("ping"));
     //do not forget to deregister the receiver when the service is destroyed to avoid
     //any potential memory leaks 
}

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;   
        }
    }

Der Gewinner in vielen Anwendungen ist natürlich ein statisches boolesches Feld im Dienst, das auf truein Service.onCreate()und auf falsein gesetzt ist, Service.onDestroy()weil es viel einfacher ist.

Ich habe eine der oben vorgestellten Lösungen leicht modifiziert, aber die Klasse anstelle eines generischen Zeichenfolgennamens übergeben, um sicherzugehen, dass Zeichenfolgen verglichen werden, die aus derselben Methode stammen 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;
    }
}

und dann

Boolean isServiceRunning = ServiceTools.isServiceRunning(
                    MainActivity.this.getApplicationContext(),
                    BackgroundIntentService.class);

Der richtige Weg, um zu überprüfen, ob ein Dienst ausgeführt wird, besteht darin, ihn einfach zu fragen. Implementieren Sie einen BroadcastReceiver in Ihrem Dienst, der auf Pings aus Ihren Aktivitäten reagiert. Registrieren Sie den BroadcastReceiver, wenn der Dienst gestartet wird, und heben Sie die Registrierung auf, wenn der Dienst zerstört wird. Senden Sie aus Ihrer Aktivität (oder einer beliebigen Komponente) eine lokale Broadcast- Absicht an den Dienst. Wenn dieser antwortet, wissen Sie, dass er ausgeführt wird. Beachten Sie den subtilen Unterschied zwischen ACTION_PING und ACTION_PONG im folgenden Code.

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;
            }
        }
    };
}

Ich möchte der Antwort von @Snicolas nur eine Notiz hinzufügen. Mit den folgenden Schritten können Sie den Stoppdienst mit / ohne Anruf überprüfen onDestroy().

1. onDestroy() aufgerufen: Gehen Sie zu Einstellungen -> Anwendung -> Ausführen von Diensten -> Wählen Sie Ihren Dienst aus und beenden Sie ihn.

2. onDestroy()nicht aufgerufen: Gehen Sie zu Einstellungen -> Anwendung -> Anwendungen verwalten -> Wählen Sie Ihre Anwendung aus, in der Ihr Dienst ausgeführt wird, und klicken Sie auf "Stopp erzwingen". Da Ihre Anwendung hier jedoch gestoppt wird, werden definitiv auch die Dienstinstanzen gestoppt.

Abschließend möchte ich erwähnen, dass der dort erwähnte Ansatz, bei dem eine statische Variable in der Singleton-Klasse verwendet wird, für mich funktioniert.

onDestroy wird nicht immer im Service angerufen, das ist also nutzlos!

Beispiel: Führen Sie die App mit einer Änderung von Eclipse erneut aus. Die Anwendung wird mit SIG: 9 zwangsweise beendet.

Zunächst sollten Sie nicht versuchen, den Dienst mit dem ActivityManager zu erreichen. (Diskutiert hier )

Dienste können eigenständig ausgeführt werden, an eine Aktivität gebunden sein oder beides. Sie können eine Aktivität einchecken, wenn Ihr Dienst ausgeführt wird oder nicht, indem Sie eine Schnittstelle (die Binder erweitert) erstellen, in der Sie Methoden deklarieren, die sowohl die Aktivität als auch der Dienst verstehen. Sie können dies tun, indem Sie eine eigene Schnittstelle erstellen, in der Sie beispielsweise "isServiceRunning ()" deklarieren. Sie können dann Ihre Aktivität an Ihren Dienst binden, die Methode isServiceRunning () ausführen, der Dienst prüft selbst, ob sie ausgeführt wird oder nicht, und gibt einen Booleschen Wert an Ihre Aktivität zurück.

Sie können diese Methode auch verwenden, um Ihren Dienst zu beenden oder auf andere Weise mit ihm zu interagieren.

In diesem Tutorial habe ich gelernt, wie dieses Szenario in meiner Anwendung implementiert wird.

Wieder eine andere Alternative, die Menschen möglicherweise sauberer finden, wenn sie ausstehende Absichten verwenden (zum Beispiel mit 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);
}

Wo CODEist eine Konstante, die Sie privat in Ihrer Klasse definieren, um die ausstehenden Absichten zu identifizieren, die Ihrem Service zugeordnet sind.

Unten ist ein eleganter Hack, der alle abdeckt Ifs. Dies gilt nur für lokale Dienste.

    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;
        }
    }

Und später:

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

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;
}

Für den hier angegebenen Anwendungsfall können wir einfach stopService()den Rückgabewert der Methode verwenden. Es wird zurückgegeben, truewenn der angegebene Dienst vorhanden ist und beendet wird. Sonst kehrt es zurück false. Sie können den Dienst also neu starten, wenn das Ergebnis falseanders ist. Es wird sichergestellt, dass der aktuelle Dienst gestoppt wurde. :) Es wäre besser, wenn Sie einen Blick auf haben diese .

Ein anderer Ansatz mit Kotlin. Inspiriert von den Antworten anderer Benutzer

fun isMyServiceRunning(serviceClass: Class<*>): Boolean {
    val manager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    return manager.getRunningServices(Integer.MAX_VALUE)
            .any { it.service.className == serviceClass.name }
}

Als Kotlin-Erweiterung

fun Context.isMyServiceRunning(serviceClass: Class<*>): Boolean {
    val manager = this.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    return manager.getRunningServices(Integer.MAX_VALUE)
            .any { it.service.className == serviceClass.name }
}

Verwendungszweck

context.isMyServiceRunning(MyService::class.java)

In kotlin können Sie eine boolesche Variable in das Begleitobjekt einfügen und deren Wert aus einer beliebigen Klasse überprüfen:

companion object{
     var isRuning = false

}

Ändern Sie den Wert, wenn der Dienst erstellt und zerstört wird

 override fun onCreate() {
        super.onCreate()
        isRuning = true
    }

override fun onDestroy() {
    super.onDestroy()
    isRuning = false
    }

Verwenden Sie in Ihrer Service-Unterklasse einen statischen Booleschen Wert, um den Status des Service abzurufen, wie unten gezeigt.

MyService.kt

class MyService : Service() {
    override fun onCreate() {
        super.onCreate()
        isServiceStarted = true
    }
    override fun onDestroy() {
        super.onDestroy()
        isServiceStarted = false
    }
    companion object {
        var isServiceStarted = false
    }
}

MainActivity.kt

class MainActivity : AppCompatActivity(){
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val serviceStarted = FileObserverService.isServiceStarted
        if (!serviceStarted) {
            val startFileObserverService = Intent(this, FileObserverService::class.java)
            ContextCompat.startForegroundService(this, startFileObserverService)
        }
    }
}

Für Kotlin können Sie den folgenden Code verwenden.

fun isMyServiceRunning(calssObj: Class<SERVICE_CALL_NAME>): Boolean {
    val manager = requireActivity().getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    for (service in manager.getRunningServices(Integer.MAX_VALUE)) {
        if (calssObj.getName().equals(service.service.getClassName())) {
            return true
        }
    }
    return false
}

Die Antwort von geekQ aber in der Kotlin-Klasse. Danke 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
}

Der Anruf

isMyServiceRunning(NewService::class.java)

Es kann mehrere Dienste mit demselben Klassennamen geben.

Ich habe gerade zwei Apps erstellt. Der Paketname der ersten App lautet com.example.mock. Ich habe ein Unterpaket erstellt, das loremin der App aufgerufen wurde, und einen Dienst namens Mock2Service. Sein voll qualifizierter Name ist also com.example.mock.lorem.Mock2Service.

Dann habe ich die zweite App und einen Dienst namens erstellt Mock2Service. Der Paketname der zweiten App lautet com.example.mock.lorem. Der vollqualifizierte Name des Dienstes ist com.example.mock.lorem.Mock2Serviceebenfalls.

Hier ist meine Logcat-Ausgabe.

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

Eine bessere Idee ist zu vergleichen ComponentNameFällen wegen equals()der ComponentNamebeiden Paketnamen und Klassennamen vergleicht. Auf einem Gerät können nicht zwei Apps mit demselben Paketnamen installiert sein.

Die Methode equals () von 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;
}

Komponentenname

Bitte benutzen Sie diesen Code.

if (isMyServiceRunning(MainActivity.this, xyzService.class)) { // Service class name
    // Service running
} else {
    // Service Stop
}


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

Dies gilt eher für das Debuggen von Intent-Diensten, da sie einen Thread erzeugen, aber möglicherweise auch für reguläre Dienste funktionieren. Ich habe diesen Thread dank Binging gefunden

In meinem Fall habe ich mit dem Debugger herumgespielt und die Thread-Ansicht gefunden. Es sieht aus wie das Aufzählungszeichen in MS Word. Wie auch immer, Sie müssen sich nicht im Debugger-Modus befinden, um es zu verwenden. Klicken Sie auf den Prozess und dann auf diese Schaltfläche. Alle Intent Services werden angezeigt, während sie ausgeführt werden, zumindest auf dem Emulator.

Wenn der Dienst zu einem anderen Prozess oder APK gehört, verwenden Sie die auf dem ActivityManager basierende Lösung.

Wenn Sie Zugriff auf die Quelle haben, verwenden Sie einfach die Lösung basierend auf einem statischen Feld. Stattdessen würde ich die Verwendung eines Booleschen Werts vorschlagen. Während der Dienst ausgeführt wird, aktualisieren Sie einfach seinen Wert auf "Jetzt" und setzen Sie ihn nach Abschluss auf "Null". Anhand der Aktivität können Sie überprüfen, ob sie null ist oder das Datum zu alt ist, was bedeutet, dass sie nicht ausgeführt wird.

Sie können auch eine Broadcast-Benachrichtigung von Ihrem Dienst senden, die angibt, dass weitere Informationen wie der Fortschritt ausgeführt werden.

In TheServiceClass definieren Sie:

 public static Boolean serviceRunning = false;

Dann In onStartCommand (...)

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

    serviceRunning = true;
    ...
}

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

} 

Rufen Sie dann if(TheServiceClass.serviceRunning == true)aus einer beliebigen Klasse an.

einfache Verwendung binden mit nicht automatisch erstellen - siehe ps. und aktualisieren ...

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);

Beispiel:

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

warum nicht verwenden? getRunningServices ()

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

Hinweis: Diese Methode ist nur zum Debuggen oder Implementieren von Benutzeroberflächen vom Typ Service Management vorgesehen.

ps. Android-Dokumentation ist irreführend Ich habe ein Problem auf Google Tracker geöffnet, um alle Zweifel zu beseitigen:

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

Wie wir sehen können, ruft der Bindedienst tatsächlich eine Transaktion über den ActivityManager-Ordner über die Service-Cache-Ordner auf. Ich verfolge nicht, welcher Dienst für die Bindung verantwortlich ist, aber wie wir sehen können, lautet das Ergebnis für die Bindung:

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

Transaktion erfolgt über Ordner:

ServiceManager.getService("activity");

Nächster:

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

Dies wird in ActivityThread festgelegt über:

 public final void bindApplication(...) {

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

Dies wird in ActivityManagerService in der Methode aufgerufen:

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

dann:

 private HashMap<String, IBinder> getCommonServicesLocked() {

aber es gibt keine "Aktivität" nur Fensterpaket und Alarm ..

Also müssen wir zurückrufen, um anzurufen:

 return getIServiceManager().getService(name);

    sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());

Dies macht Anruf durch:

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

was dazu führt :

BinderInternal.getContextObject()

und das ist native Methode ....

  /**
     * 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();

Ich habe jetzt keine Zeit, mich in c zu vertiefen. Bis ich den Restanruf seziere, setze ich meine Antwort aus.

Der beste Weg, um zu überprüfen, ob der Dienst ausgeführt wird, besteht darin, eine Bindung zu erstellen (wenn die Bindung nicht erstellt wurde, existiert kein Dienst) - und den Dienst über die Bindung nach seinem Status abzufragen (unter Verwendung des gespeicherten internen Flags für den Status).

Update 23.06.2018

Ich fand die interessant:

/**
 * 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;
}

Zusamenfassend :)

"Stellen Sie einen Ordner für einen bereits gebundenen Dienst bereit. Diese Methode ist synchron und startet den Zieldienst nicht, wenn er nicht vorhanden ist."

public IBinder peekService (Intent Service, String ResolutionedType, String Calling Package) löst eine RemoteException aus.

* *

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;
}

* *

Meine Kotlin-Konvertierung der ActivityManager::getRunningServicesbasierten Antworten. Fügen Sie diese Funktion in eine Aktivität ein.

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

Sie können diese Optionen in den Android Developer-Optionen verwenden, um festzustellen, ob Ihr Dienst noch im Hintergrund ausgeführt wird.

1. Open Settings in your Android device.
2. Find Developer Options.
3. Find Running Services option.
4. Find your app icon.
5. You will then see all the service that belongs to your app running in the background.

Nimm es ruhig Jungs ... :)

Ich denke, die am besten geeignete Lösung besteht darin, ein Schlüssel-Wert-Paar SharedPreferenceszu halten, ob der Dienst ausgeführt wird oder nicht.

Die Logik ist sehr klar; an jeder gewünschten Position in Ihrer Serviceklasse; Setzen Sie einen booleschen Wert, der als Flag für Sie dient, ob der Dienst ausgeführt wird oder nicht. Lesen Sie diesen Wert dann an einer beliebigen Stelle in Ihrer Anwendung.

Ein Beispielcode, den ich in meiner App verwende, ist unten:

In meiner Service-Klasse (Ein Service für Audio Stream) führe ich den folgenden Code aus, wenn der Service aktiv ist.

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();
}

In jeder Aktivität meiner Anwendung überprüfe ich dann den Status des Dienstes mithilfe des folgenden Codes.

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);
}

Keine besonderen Berechtigungen, keine Schleifen ... Einfacher Weg, saubere Lösung :)

Wenn Sie zusätzliche Informationen benötigen, klicken Sie bitte auf den Link

Hoffe das hilft.