Android 8.0: java.lang.IllegalStateException: Nie można uruchomić usługi Intent

Po uruchomieniu aplikacji aplikacja uruchamia usługę, która powinna wykonać jakieś zadanie sieciowe. Po wybraniu interfejsu API na poziomie 26 moja aplikacja nie uruchamia się w systemie Android 8.0 w tle.

Przyczyna: java.lang.IllegalStateException: Niedozwolony do uruchomienia usługi Zamiar {cmp = my.app.tt / com.my.service}: aplikacja jest w tle UidRecord {90372b1 u0a136 Bezczynność CEM: 1 seq (0,0 , 0)}

jak rozumiem, dotyczy to: limitów wykonania w tle

Metoda startService () generuje teraz wyjątek IllegalStateException, jeśli aplikacja atakująca system Android 8.0 próbuje użyć tej metody w sytuacji, gdy nie można tworzyć usług w tle.

„ w sytuacji, gdy nie jest to dozwolone ” - co to właściwie znaczy? I jak to naprawić. Nie chcę ustawiać mojej usługi jako „pierwszego planu”

Dozwolone sytuacje to tymczasowa biała lista, w której usługa w tle zachowuje się tak samo jak przed Androidem O.

W pewnych okolicznościach aplikacja w tle jest umieszczana na tymczasowej białej liście na kilka minut. Gdy aplikacja znajduje się na białej liście, może uruchamiać usługi bez ograniczeń, a jej usługi w tle mogą być uruchamiane. Aplikacja jest umieszczana na białej liście, gdy obsługuje zadanie widoczne dla użytkownika, takie jak:

• Obsługa komunikatu Firebase Cloud Messaging (FCM) o wysokim priorytecie.
• Odbieranie transmisji, takiej jak wiadomość SMS / MMS.
• Wykonanie PendingIntent z powiadomienia.
• Uruchomienie usługi VpnService, zanim aplikacja VPN awansuje na pierwszy plan.

Źródło: https://developer.android.com/about/versions/oreo/background.html

Innymi słowy, jeśli twoja usługa w tle nie spełnia wymagań białej listy, musisz użyć nowego JobScheduler . Zasadniczo działa tak samo jak usługa w tle, ale jest okresowo wywoływana zamiast ciągłego działania w tle.

Jeśli korzystasz z usługi IntentService, możesz zmienić ją na JobIntentService. Zobacz odpowiedź @ kosev poniżej .

Mam rozwiązanie. W przypadku urządzeń w wersji wcześniejszej niż 8.0 wystarczy użyć startService(), ale w przypadku urządzeń w wersji późniejszej niż 7.0 należy użyć startForgroundService(). Oto przykład kodu, aby uruchomić usługę.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        context.startForegroundService(new Intent(context, ServedService.class));
    } else {
        context.startService(new Intent(context, ServedService.class));
    }

W klasie usług dodaj poniższy kod w celu powiadomienia:

@Override
public void onCreate() {
    super.onCreate();
    startForeground(1,new Notification());
}

Gdzie O to wersja Androida 26.

Najlepszym sposobem jest użycie JobIntentService który korzysta z nowego JobScheduler dla Oreo lub starych usług, jeśli nie są dostępne.

Oświadcz w swoim manifeście:

<service android:name=".YourService"
         android:permission="android.permission.BIND_JOB_SERVICE"/>

A w twoich usługach musisz wymienić onHandleIntent na onHandleWork:

public class YourService extends JobIntentService {

    public static final int JOB_ID = 1;

    public static void enqueueWork(Context context, Intent work) {
        enqueueWork(context, YourService.class, JOB_ID, work);
    }

    @Override
    protected void onHandleWork(@NonNull Intent intent) {
        // your code
    }

}

Następnie zaczynasz swoją usługę od:

YourService.enqueueWork(context, new Intent());

Jeśli usługa jest uruchomiona w wątku tła poprzez rozszerzenie IntentService, można zastąpić IntentServicezJobIntentService którego jest wykonane jako część biblioteki Android Wsparcia

Zaletą używania JobIntentServicejest to, że zachowuje się jak IntentServicena urządzeniach sprzed O, a na O i wyżej, wysyła to jako zadanie

JobSchedulermoże być również stosowany do zadań okresowych / na żądanie. Pamiętaj jednak, aby obsługiwać zgodność wsteczną, ponieważ JobSchedulerinterfejs API jest dostępny tylko w interfejsie API 21

W Oreo Android zdefiniowano ograniczenia usług w tle .

Aby poprawić wrażenia użytkownika, system Android 8.0 (poziom API 26) nakłada ograniczenia na to, co aplikacje mogą robić, gdy działają w tle.

Jeśli jednak zawsze potrzebujesz usługi, możesz skorzystać z usługi pierwszego planu.

Ograniczenia usługi w tle: gdy aplikacja jest bezczynna, istnieją ograniczenia w korzystaniu z usług w tle. Nie dotyczy to usług nowej wiedzy, które są bardziej zauważalne dla użytkownika.

Możesz więc zrobić usługę pierwszego planu . Będziesz musiał pokazać użytkownikowi powiadomienie, gdy usługa jest uruchomiona. Zobacz tę odpowiedź (Jest wiele innych)

Rozwiązanie, jeśli -

nie chcesz otrzymywać powiadomienia o swojej usłudze?

Możesz wykonać zadanie okresowe, 1. uruchamia usługę, 2. usługa wykona swoją pracę, 3. zatrzymuje się. Dzięki temu Twoja aplikacja nie będzie uważana za rozładowanie baterii.

Możesz używać zadań okresowych z Menedżerem alarmów , Harmonogramem zadań , Evernote-Jobs lub Work Manager .

• Menedżer pracy jest najlepszym rozwiązaniem dla zadań okresowych. Który został wprowadzony z Android Architecture Component .
• W przeciwieństwie do Job-Scheduler (tylko> 21 API) będzie działał dla wszystkich wersji.
• Również zaczyna działać po trybie drzemki w trybie gotowości .
• Stwórz odbiornik rozruchowy Android dla usługi planowania po uruchomieniu urządzenia.

Testowałem zawsze działającą usługę z Work-Managerem.

Tak, to dlatego, że nie możesz już uruchamiać usług w tle na API 26. Możesz więc uruchomić ForegroundService powyżej API 26.

Musisz użyć

ContextCompat.startForegroundService(...)

i opublikuj powiadomienie podczas przetwarzania wycieku.

Jak powiedział @kosev w swojej odpowiedzi , możesz użyć JobIntentService. Ale używam alternatywnego rozwiązania - wychwytuję IllegalStateException i uruchamiam usługę na pierwszym planie. Na przykład ta funkcja uruchamia moją usługę:

@JvmStatic
protected fun startService(intentAction: String, serviceType: Class<*>, intentExtraSetup: (Intent) -> Unit) {
    val context = App.context
    val intent = Intent(context, serviceType)
    intent.action = intentAction
    intentExtraSetup(intent)
    intent.putExtra(NEED_FOREGROUND_KEY, false)

    try {
        context.startService(intent)
    }
    catch (ex: IllegalStateException) {
        intent.putExtra(NEED_FOREGROUND_KEY, true)
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            context.startForegroundService(intent)
        }
        else {
            context.startService(intent)
        }
    }
}

a kiedy przetwarzam Intent, robię takie rzeczy:

override fun onHandleIntent(intent: Intent?) {
    val needToMoveToForeground = intent?.getBooleanExtra(NEED_FOREGROUND_KEY, false) ?: false
    if(needToMoveToForeground) {
        val notification = notificationService.createSyncServiceNotification()
        startForeground(notification.second, notification.first)

        isInForeground = true
    }

    intent?.let {
        getTask(it)?.process()
    }
}

Z informacji o wydaniu bazy ogniowej wynika, że ​​obsługa Androida O została wydana po raz pierwszy w wersji 10.2.1 (chociaż zalecałbym używanie najnowszej wersji).

dodaj nowe zależności komunikatów firebase dla Androida O

compile 'com.google.firebase:firebase-messaging:11.6.2'

w razie potrzeby zaktualizuj usługi Google Play i repozytoria Google.

Jeśli jakakolwiek intencja wcześniej działała dobrze, gdy aplikacja jest w tle, nie będzie już tak w przypadku Androida 8 i nowszych. Dotyczy tylko zamiaru, który musi wykonać pewne przetwarzanie, gdy aplikacja jest w tle.

Należy postępować zgodnie z poniższymi krokami:

1. Wyżej wymienione zamiary powinny być używane JobIntentServicezamiast IntentService.

2. Rozszerzająca się klasa JobIntentServicepowinna implementować onHandleWork(@NonNull Intent intent)metodę - i powinna mieć poniżej metody, która wywoła onHandleWorkmetodę:

   public static void enqueueWork(Context context, Intent work) {
       enqueueWork(context, xyz.class, 123, work);
   }

3. Zadzwoń enqueueWork(Context, intent)z klasy, w której określono twoje zamiary.

   Przykładowy kod:

   Public class A {
   ...
   ...
       Intent intent = new Intent(Context, B.class);
       //startService(intent); 
       B.enqueueWork(Context, intent);
   }

Poniższa klasa poprzednio rozszerzała klasę Service

Public Class B extends JobIntentService{
...

    public static void enqueueWork(Context context, Intent work) {
        enqueueWork(context, B.class, JobId, work);
    }

    protected void onHandleWork(@NonNull Intent intent) {
        ...
        ...
    }
}

4. com.android.support:support-compatjest potrzebny do JobIntentService- używam 26.1.0 V.

5. Najważniejsze jest, aby upewnić się, że wersja bibliotek Firebase jest przynajmniej włączona 10.2.1, miałem problemy z 10.2.0- jeśli masz!

6. Twój manifest powinien mieć poniższe uprawnienia dla klasy usługi:

   service android:name=".B"
   android:exported="false"
   android:permission="android.permission.BIND_JOB_SERVICE"

Mam nadzieję że to pomoże.

Widzę wiele odpowiedzi, które zalecają użycie usługi ForegroundService. Aby korzystać z usługi ForegroundService, musi być z nią powiązane powiadomienie. Użytkownicy zobaczą to powiadomienie. W zależności od sytuacji mogą się denerwować aplikacją i odinstalować ją.

Najłatwiejszym rozwiązaniem jest użycie nowego komponentu architektury o nazwie WorkManager. Możesz sprawdzić dokumentację tutaj: https://developer.android.com/topic/libraries/architecture/workmanager/

Wystarczy zdefiniować klasę pracownika, która rozszerza pracownika.

public class CompressWorker extends Worker {

    public CompressWorker(
        @NonNull Context context,
        @NonNull WorkerParameters params) {
        super(context, params);
    }

    @Override
    public Worker.Result doWork() {

        // Do the work here--in this case, compress the stored images.
        // In this example no parameters are passed; the task is
        // assumed to be "compress the whole library."
        myCompress();

        // Indicate success or failure with your return value:
        return Result.SUCCESS;

        // (Returning RETRY tells WorkManager to try this task again
        // later; FAILURE says not to try again.)
    }
}

Następnie planujesz, kiedy chcesz go uruchomić.

    OneTimeWorkRequest compressionWork = 
        new OneTimeWorkRequest.Builder(CompressWorker.class)
            .build();
    WorkManager.getInstance().enqueue(compressionWork);

Łatwy! Istnieje wiele sposobów konfigurowania pracowników. Obsługuje powtarzające się zadania, a nawet możesz wykonywać skomplikowane czynności, takie jak tworzenie łańcuchów, jeśli jest to potrzebne. Mam nadzieję że to pomoże.

Alternatywne rozwiązanie przy użyciu JobScheduler, może uruchomić usługę w tle w regularnych odstępach czasu.

Najpierw ułóż klasę o nazwie Util.java

import android.app.job.JobInfo;
import android.app.job.JobScheduler;
import android.content.ComponentName;
import android.content.Context;

public class Util {
// schedule the start of the service every 10 - 30 seconds
public static void schedulerJob(Context context) {
    ComponentName serviceComponent = new ComponentName(context,TestJobService.class);
    JobInfo.Builder builder = new JobInfo.Builder(0,serviceComponent);
    builder.setMinimumLatency(1*1000);    // wait at least
    builder.setOverrideDeadline(3*1000);  //delay time
    builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED);  // require unmetered network
    builder.setRequiresCharging(false);  // we don't care if the device is charging or not
    builder.setRequiresDeviceIdle(true); // device should be idle
    System.out.println("(scheduler Job");

    JobScheduler jobScheduler = null;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
        jobScheduler = context.getSystemService(JobScheduler.class);
    }
    jobScheduler.schedule(builder.build());
   }
  }

Następnie utwórz klasę JobService o nazwie TestJobService.java

import android.app.job.JobParameters;
import android.app.job.JobService;
import android.widget.Toast;

  /**
   * JobService to be scheduled by the JobScheduler.
   * start another service
   */ 
public class TestJobService extends JobService {
@Override
public boolean onStartJob(JobParameters params) {
    Util.schedulerJob(getApplicationContext()); // reschedule the job
    Toast.makeText(this, "Bg Service", Toast.LENGTH_SHORT).show();
    return true;
}

@Override
public boolean onStopJob(JobParameters params) {
    return true;
  }
 }

Po tej klasie BroadCast Receiver o nazwie ServiceReceiver.java

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

 public class ServiceReceiver extends BroadcastReceiver {
 @Override
public void onReceive(Context context, Intent intent) {
    Util.schedulerJob(context);
 }
}

Zaktualizuj plik manifestu za pomocą kodu klasy usługi i odbiornika

<receiver android:name=".ServiceReceiver" >
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED" />
        </intent-filter>
    </receiver>
    <service
        android:name=".TestJobService"
        android:label="Word service"
        android:permission="android.permission.BIND_JOB_SERVICE" >

    </service>

Pozostawiłem program uruchamiający main_intent do pliku mainActivity.java, który jest tworzony domyślnie, a zmiany w pliku MainActivity.java zostały

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Util.schedulerJob(getApplicationContext());
  }
 }

WOOAAH !! Usługa w tle uruchamia się bez usługi pierwszego planu

Jeśli korzystasz z kodu w wersji 8.0, aplikacja ulegnie awarii. Więc uruchom usługę na pierwszym planie. Jeśli poniżej 8.0, użyj tego:

Intent serviceIntent = new Intent(context, RingtonePlayingService.class);
context.startService(serviceIntent);

Jeśli powyżej lub 8.0, użyj tego:

Intent serviceIntent = new Intent(context, RingtonePlayingService.class);
ContextCompat.startForegroundService(context, serviceIntent );

jeśli masz zintegrowane powiadomienie push z bazy ogniowej,

Dodaj nowe / zaktualizuj zależności komunikatów firebase dla Androida O (Android 8.0), ze względu na limity wykonywania w tle .

compile 'com.google.firebase:firebase-messaging:11.4.0'

w razie potrzeby zaktualizuj usługi Google Play i repozytoria Google.

Aktualizacja:

 compile 'com.google.firebase:firebase-messaging:11.4.2'

Użyj startForegroundService()zamiast startService() i nie zapomnij utworzyć startForeground(1,new Notification());w swoim serwisie w ciągu 5 sekund od uruchomienia usługi.

Z powodu kontrowersyjnych głosów na tę odpowiedź (+ 4 / -4 od tej edycji) PROSIMY PATRZEĆ NA INNE ODPOWIEDZI PIERWSZE I WYKORZYSTAĆ TEN WYŁĄCZNIE OSTATNI OŚRODEK . Użyłem tego tylko raz dla aplikacji sieciowej działającej jako root i zgadzam się z ogólną opinią, że tego rozwiązania nie należy używać w normalnych okolicznościach.

Oryginalna odpowiedź poniżej:

Wszystkie pozostałe odpowiedzi są poprawne, ale chciałbym zauważyć, że innym sposobem na obejście tego jest poproszenie użytkownika o wyłączenie optymalizacji baterii dla Twojej aplikacji (zazwyczaj nie jest to dobry pomysł, chyba że aplikacja jest związana z systemem). Zobacz tę odpowiedź, aby dowiedzieć się, jak zrezygnować z optymalizacji baterii bez blokowania aplikacji w Google Play.

Należy również sprawdzić, czy optymalizacje baterii są wyłączone w odbiorniku, aby zapobiec awariom poprzez:

if (Build.VERSION.SDK_INT < 26 || getSystemService<PowerManager>()
        ?.isIgnoringBatteryOptimizations(packageName) != false) {
    startService(Intent(context, MyService::class.java))
} // else calling startService will result in crash

nie używaj w onStartCommand:

return START_NOT_STICKY

po prostu zmień na:

return START_STICKY

i będzie działać