Jak zkontrolovat, zda je služba běžící na Androidu?

hlasů
774

Jak mohu zjistit, zda je spuštěna služba na pozadí (v systému Android)?

Chci Android činnost, která přepíná stav služby - to mi umožňuje zapnout v případě, že je vypnutý a vypnout, pokud je zapnuta.

Položena 01/03/2009 v 19:09
zdroj uživatelem
V jiných jazycích...                            


29 odpovědí

hlasů
1k

I použít následující zevnitř činnosti:

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

A říkám to pomocí:

isMyServiceRunning(MyService.class)

Tato metoda funguje spolehlivě, protože je založen na informacích o spuštění služby poskytované operačním systémem Android prostřednictvím ActivityManager # getRunningServices .

Všechny přístupy využívající onDestroy nebo onSometing události nebo pojiva nebo statické proměnné nebude fungovat spolehlivě, protože jako vývojář nikdy nevíte, kdy Android rozhodne zabít proces nebo které z uvedených zpětných volání se nazývají nebo ne. Upozorňujeme, že „killable“ sloupec v tabulce životního cyklu událostí v dokumentaci Android.

Odpovězeno 07/05/2011 v 13:54
zdroj uživatelem

hlasů
244

Měl jsem stejný problém, není to tak dávno. Vzhledem k tomu, moje služba byla místní, jsem skončil jednoduše pomocí statické pole ve třídě služeb pro přepínání stavu, jak je popsáno v hackbod zde

EDIT (pro záznam):

Zde je řešení navrhované hackbod:

Pokud váš klient a kódového serveru je součástí stejného .apk a jsou závazné pro službu s betonovou Intent (jeden, který určuje přesné třídu služby), pak můžete jednoduše mít své služby nastavit globální proměnné, když je spuštěn, že váš klient může zkontrolovat.

My záměrně nemají API ověřit, zda je služba spuštěna, protože téměř bez výjimky, pokud chcete udělat něco podobného, ​​že jste skončili s podmínkami závodu v kódu.

Odpovězeno 03/03/2009 v 23:58
zdroj uživatelem

hlasů
67

Mám to!

Vám musí volat startService()za vaše služby, které mají být řádně zaregistrován a absolvování BIND_AUTO_CREATEnebude stačit.

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

A teď třída ServiceTools:

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;
     }
}
Odpovězeno 12/02/2011 v 05:42
zdroj uživatelem

hlasů
50

Malý doplňkem je:

Mým cílem je zjistit, wether služba běží bez Vlastně jeho spuštění, pokud není v provozu.

Volání bindService nebo volání o záměru, které mohou být zachyceny pomocí služby není dobrý nápad, pak jak to bude spustit službu, pokud to není v chodu.

Takže, jak miracle2k navrhl, že nejlepší je mít statickou pole ve třídě služby vědět, zda byla služba spuštěna či nikoliv.

Aby to bylo ještě čistší, navrhuji transformovat služby v ojedinělým s velmi velmi líné načítání: to znamená, že neexistuje žádná instance na všechny ojedinělým například prostřednictvím statických metod. Statické metody getInstance vaší služby / Singleton právě vrací instance Singleton, pokud byl vytvořen. Ale to není Vlastně spustit nebo instanciate ojedinělým sám. Tato služba je spuštěna pouze pomocí běžných spustit službu metodami.

To by pak bylo ještě čistší upravit singleton návrhový vzor pro přejmenování matoucí způsob getInstance do něčeho, jako je isInstanceCreated() : booleanmetoda.

Kód bude vypadat následovně:

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

Toto řešení je elegantní, ale je relevantní pouze v případě, že máte přístup k třídě služeb a pouze pro třídy Iside app / balíček služby. Pokud vaše třídy jsou mimo app služby / balíku pak byste mohli dotazovat ActivityManager s omezeními a podtržený Pieter-Jan van Robays.

Odpovězeno 20/05/2011 v 11:58
zdroj uživatelem

hlasů
22

Můžete použít (Nezkoušel jsem to ještě, ale doufám, že to bude fungovat):

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

Způsob StartService vrací objekt ComponentName pokud je již spuštěna služba. Pokud tomu tak není, bude vrácena null.

Viz veřejnosti abstraktní ComponentName StartService (Intent sluzba) .

To není jako kontrola Myslím si, protože to začíná službu, takže si můžete přidat stopService(someIntent);pod kódem.

Odpovězeno 23/09/2010 v 18:01
zdroj uživatelem

hlasů
13
    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;
    }
Odpovězeno 14/07/2014 v 04:23
zdroj uživatelem

hlasů
10

Trochu jsem změnil jedno z řešení výše uvedených, ale prochází třídu místo rodového jména řetězce, aby se ujistěte se, že srovnávat struny vychází ze stejné metody 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;
    }
}

a pak

Boolean isServiceRunning = ServiceTools.isServiceRunning(
                    MainActivity.this.getApplicationContext(),
                    BackgroundIntentService.class);
Odpovězeno 13/07/2016 v 14:26
zdroj uživatelem

hlasů
7

Jen chci přidat poznámku k odpovědi ze strany @Snicolas. Následující kroky mohou být použity pro kontrolu stop servis s / bez volání onDestroy().

  1. onDestroy() volal: Přejděte na Nastavení -> Aplikace -> Running Services -> Vyberte a zastavte službu.

  2. onDestroy()Není Called: Přejděte na Nastavení -> Aplikace -> Správa aplikací -> Vyberte a „Stop“ Force vaši žádost, ve kterém je spuštěna vaše služba. Nicméně, protože vaše žádost se zde zastavil, takže určitě budou také zastavena instance služby.

Na závěr bych rád uvedl, že tento přístup není zmíněno použití statická proměnná ve ojedinělým třídě pracuje pro mě.

Odpovězeno 16/09/2012 v 17:54
zdroj uživatelem

hlasů
6

onDestroy není vždy jen ve službě, takže to je k ničemu!

Například: Stačí spustit aplikaci znovu s jednou změnou od Eclipse. Aplikace je násilně ukončen pomocí SIG: 9.

Odpovězeno 12/02/2011 v 05:26
zdroj uživatelem

hlasů
5

Správný způsob, jak zjistit, zda je spuštěna služba, je to prostě zeptat. Implementovat BroadcastReceiver ve své službě, který reaguje na ping z vašich aktivit. Zaregistrujte BroadcastReceiver při spuštění služby, a rušit, když je služba zničen. Z vaší aktivity (nebo jakoukoliv složku), poslat místního vysílání záměr ke službě a pokud to odpovídá, víte, je to běh. Všimněte si jemné rozdíly mezi ACTION_PING a ACTION_PONG v kódu níže.

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;
            }
        }
    };
}
Odpovězeno 29/10/2016 v 20:15
zdroj uživatelem

hlasů
5

Toto je výňatek z Android dokumenty

Objednané vysílání (odeslané Context.sendOrderedBroadcast ) jsou dodávány do jednoho přijímače najednou. Jako každý přijímač spustí zase může šířit na výsledek dalšího přijímače, nebo jej lze zcela přerušit vysílání, takže nebudou předány do jiných přijímačů.

To je trochu hack, ale myslet na to, jak „pinging jen“Service protože můžeme vysílat syncronously můžeme vysílat a získat výsledek synchronně na UI závitu.

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;   
        }
    }
Odpovězeno 19/09/2016 v 17:48
zdroj uživatelem

hlasů
5

V první řadě byste nesmím pokusit se dosáhnout službu pomocí ActivityManager. (Diskutovaná zde )

Služby mohou fungovat samy o sobě, být vázán na určitou činnost nebo obojí. Způsob, jak zjistit v činnosti, pokud počítač běží služba, nebo ne, je tím, že rozhraní (který rozšiřuje Binder), kde deklarovat metody, které obě činnosti a služby, rozumět. Můžete to udělat tím, že své vlastní rozhraní, kde si prohlásit, například „isServiceRunning ()“. Potom se může vázat vaši aktivitu na vaší službě, spusťte metodu isServiceRunning (), služba bude kontrolovat sama, pokud je spuštěn, nebo ne a vrací boolean k vaší činnosti.

Můžete také použít tuto metodu k ukončení služby nebo komunikovat s ním jiným způsobem.

Použil jsem tento návod, se dozvíte, jak implementovat tento scénář v mé žádosti.

Odpovězeno 30/03/2011 v 15:56
zdroj uživatelem

hlasů
4

Xamarin C # verison.

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;
        }
Odpovězeno 13/06/2016 v 19:00
zdroj uživatelem

hlasů
4

Opět platí, že další alternativou, že lidé mohli najít čistší, pokud používají čekající záměry (například s 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);
}

Tam, kde CODEje konstanta, která definujete soukromě ve své třídě k identifikaci nevyřízené záměry spojené s vašim službám.

Odpovězeno 07/08/2014 v 00:41
zdroj uživatelem

hlasů
4

Pro use-case zde dané můžeme jednoduše využívat stopService()návratové hodnoty metody. Vrátí true, pokud existuje zadanou službu a je zabit. V opačném případě vrátí false. Takže můžete restartovat službu v případě, že výsledek je falsejiný je zajištěno, že současná služba byla zastavena. :) Bylo by lepší, kdyby jste se podívat na to .

Odpovězeno 28/05/2013 v 10:55
zdroj uživatelem

hlasů
1

Reakce geekQ ale ve třídě Kotlin. Díky 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
}

Volání

isMyServiceRunning(NewService::class.java)
Odpovězeno 23/03/2018 v 21:43
zdroj uživatelem

hlasů
1

Níže je elegantní hack, který se vztahuje na všechny Ifs. To je pouze pro místní služby.

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

A pak o něco později:

    if(AService.isServiceCreated()){
        ...
    }else{
        startService(...);
    }
Odpovězeno 19/01/2018 v 14:08
zdroj uživatelem

hlasů
1

Uvnitř TheServiceClass definovat:

 public static Boolean serviceRunning = false;

Potom V onStartCommand (...)

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

    serviceRunning = true;
    ...
}

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

} 

Potom volat if(TheServiceClass.serviceRunning == true)z libovolné třídy.

Odpovězeno 23/10/2015 v 18:35
zdroj uživatelem

hlasů
1

Tam může být několik služeb se stejným názvem třídy.

Právě jsem vytvořil dvě aplikace. Název balíčku první aplikace je com.example.mock. Vytvořil jsem dílčího balíčku s názvem loremv aplikaci a službu s názvem Mock2Service. Takže jeho plně kvalifikovaný název je com.example.mock.lorem.Mock2Service.

Pak jsem vytvořil druhou aplikaci a službu s názvem Mock2Service. Název balíčku druhého app je com.example.mock.lorem. Plně kvalifikovaný název služby je com.example.mock.lorem.Mock2Servicetaky.

Tady je můj logcat výstup.

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

Lepší nápad je porovnat ComponentNameinstance, protože equals()z ComponentNamesrovnává oba názvy balíků a názvy tříd. A nemohou existovat dvě aplikace se stejným názvem balíčku nainstalované v zařízení.

Rovná se () metoda 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;
}

ComponentName

Odpovězeno 27/03/2014 v 09:11
zdroj uživatelem

hlasů
0

V Kotlin můžete přidat boolean proměnné v doprovodném objektu a zkontrolujte jeho hodnotu z jakékoliv třídy, které chcete:

companion object{
     var isRuning = false

}

Změňte to ocení, když je služba vytvořena a zničena

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

override fun onDestroy() {
    super.onDestroy()
    isRuning = false
    }
Odpovězeno 04/08/2019 v 07:47
zdroj uživatelem

hlasů
0

Pro Kotlin, můžete použít následující kód.

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;
}
Odpovězeno 24/07/2019 v 09:29
zdroj uživatelem

hlasů
0

Použijte tento kód.

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;
    }
Odpovězeno 09/04/2019 v 08:46
zdroj uživatelem

hlasů
0

Můj Kotlin přepočet ActivityManager::getRunningServicesodpovědí na bázi. Dát tuto funkci v activity-

private fun isMyServiceRunning(serviceClass: Class<out Service>) =
    (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
        .getRunningServices(Int.MAX_VALUE)
        ?.map { it.service.className }
        ?.contains(serviceClass.name) ?: false
Odpovězeno 15/03/2019 v 16:58
zdroj uživatelem

hlasů
0

Ve vaší službě Sub-Class Pomocí statické logickou získat stav služby jak je ukázáno níže.

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)
        }
    }
}
Odpovězeno 08/02/2019 v 13:05
zdroj uživatelem

hlasů
0

jednoduchá obsluha vážou se nevytvářejí auto - viz ps.

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

příklad:

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

proč ne používat? getRunningServices ()

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

Poznámka: Tato metoda je určena pouze pro ladění nebo provádění servisu Typ řízení uživatelských rozhraní.


ps. android dokumentace je zavádějící jsem otevřel problém na Googlu stopaře, aby odstranila veškeré pochybnosti:

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

jak můžeme vidět bind službu skutečně vyvolá transakci pomocí ActivityManager pojiva prostřednictvím služby vyrovnávací pojiva - i dint stopu, která je zodpovědná za vazbu službu, ale jak můžeme vidět výsledek pro bind je:

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

transakce se provádí přes pojivo:

ServiceManager.getService("activity");

další:

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

to je zasazen do ActivityThread via:

 public final void bindApplication(...) {

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

to se nazývá v ActivityManagerService v metodě:

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

pak:

 private HashMap<String, IBinder> getCommonServicesLocked() {

ale není tam žádný „aktivita“ pouze toto okno balíček a alarm ..

takže se musíme vrátit k volání:

 return getIServiceManager().getService(name);

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

toto dělá volání přes:

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

což vede k :

BinderInternal.getContextObject()

a to je nativní metoda ....

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

nemám čas teď kopal v c tak, dokud jsem pitvat zbytek hovoru i pozastavit svou odpověď.

ale nejlepší způsob, jak zkontrolovat, zda je spuštěna služba je vytvořit bind (není-li vytvořen bind služba neexistuje) - a dotaz na servis o jeho stavu přes bind (pomocí uložené interní vlajku na něm stát).

Odpovězeno 11/03/2017 v 17:11
zdroj uživatelem

hlasů
0
public static boolean isServiceRunning;

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
isServiceRunning = true;
return START_NOT_STICKY;
}

@Override
    public void onDestroy() {
        super.onDestroy();
        isServiceRunning = false;
    }

NEBO

v případě, že nechcete používat statické potom účastníku SharedPreferences

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    PrefManager.getPref().saveBoolean(AppConstants.Pref.IS_SERVICE_RUNNING, true);
    return START_NOT_STICKY;
}

@Override
public void onDestroy() {
    super.onDestroy();
    PrefManager.getPref().saveBoolean(AppConstants.Pref.IS_SERVICE_RUNNING, false);
}

PrefManager je můj Singleton třída pro správu všech předvoleb.

Odpovězeno 19/01/2017 v 12:33
zdroj uživatelem

hlasů
0

Pokud je služba patří k jinému procesu nebo APK použít řešení založené na ActivityManager.

Pokud máte přístup k jeho zdroji, stačí použít řešení založené na statickém poli. Ale místo toho používá boolean Navrhoval bych pomocí objektu Date. I když je spuštěna služba, stačí aktualizovat její hodnotu na ‚nyní‘, a když se dokončí nastavit na null. Z činnosti můžete zkontrolovat, zda jeho null nebo datum je příliš starý, což bude znamenat, že není spuštěna.

Můžete také posílat oznámení vysílání z provozu znamená, že běží podél bližší informace jako pokrok.

Odpovězeno 04/08/2013 v 12:14
zdroj uživatelem

hlasů
0

To platí více k záměru Service ladění, protože plodit vlákno, ale může pracovat pro linkovou dopravu stejně. Zjistil jsem toto vlákno díky binging

V mém případě jsem hrál asi s ladicí program a zjistil, že pohled niti. Je to trochu vypadá jako ikona kulka bodu ve formátu MS Word. Tak jako tak, nemusíte být v režimu ladicí ji používat. Klikněte na proces a klikněte na toto tlačítko. Jakékoli Intent Services se zobrazí, když jsou spuštěny, alespoň v emulátoru.

Odpovězeno 03/08/2012 v 21:32
zdroj uživatelem

hlasů
-3

Take it easy lidi ... :)

Myslím, že nejvhodnějším řešením je drží dvojice klíč-hodnota v SharedPreferenceso to, zda je služba spuštěna nebo ne.

Logika je velmi snadná; v libovolné poloze ve své třídě služeb; položil logickou hodnotu, která bude sloužit jako příznak pro vás o tom, zda je služba spuštěna nebo ne. Pak si přečtěte tuto hodnotu Kdekoli chcete ve své aplikaci.

Vzorek kód, který já používám v mé aplikaci je níže:

V mé třídě Service (Služba pro audio stream), já provést následující kód, když je vzhůru;

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

Pak v jakékoli aktivitě mé žádosti, já kontrola stavu služby pomocí následujícího kódu;

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

Žádná zvláštní oprávnění, žádné smyčky ... Snadný způsob, čisté řešení :)

Pokud budete potřebovat další informace naleznete na odkazu

Snad to pomůže.

Odpovězeno 02/07/2013 v 21:46
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more