Android 8.0：java.lang.IllegalStateException：不允许启动服务 Intent

Question

在应用程序启动时，应用程序启动应该执行某些网络任务的服务。 以 API 级别 26 为目标后，我的应用程序无法在后台在 Android 8.0 上启动服务。

原因：java.lang.IllegalStateException: 不允许启动 服务意图{ cmp=my.app.tt/com.my.service }：应用处于后台 uid UidRecord{90372b1 u0a136 CEM idle procs:1 seq(0,0,0)}

据我了解，它与： Background execution limits

startService() 方法现在会抛出 IllegalStateException，如果 面向 Android 8.0 的应用程序尝试在以下情况下使用该方法 不允许创建后台服务。

“在不允许的情况下” - 它的实际含义是什么？以及如何解决它。我不想将我的服务设置为“前台”

Answer 1

我得到了解决方案。对于 8.0 之前的设备，您必须使用 startService()，但对于 7.0 之后的设备，您必须使用 startForgroundService()。这是启动服务的代码示例。

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

在服务类中，请添加以下代码以进行通知：

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

其中 O 是 Android 版本 26。

如果您不希望您的服务在前台运行而希望它在后台运行，则发布 Android O 您必须将服务绑定到如下连接：

Intent serviceIntent = new Intent(context, ServedService.class);
context.startService(serviceIntent);
context.bindService(serviceIntent, new ServiceConnection() {
     @Override
     public void onServiceConnected(ComponentName name, IBinder service) {
         //retrieve an instance of the service here from the IBinder returned 
         //from the onBind method to communicate with 
     }

     @Override
     public void onServiceDisconnected(ComponentName name) {
     }
}, Context.BIND_AUTO_CREATE);

Answer 2

允许的情况是临时白名单，后台服务的行为与 Android O 之前的行为相同。

在某些情况下，后台应用会被置于临时白名单中几分钟。当应用在白名单中时，它可以不受限制地启动服务，并且允许其后台服务运行。应用在处理用户可见的任务时会被列入白名单，例如：

• 处理高优先级 Firebase 云消息传递 (FCM) 消息。
• 接收广播，例如 SMS/MMS 消息。
• 从通知中执行 PendingIntent。
• 在 VPN 应用将自身提升到前台之前启动 VpnService。

来源：https://developer.android.com/about/versions/oreo/background.html

也就是说，如果您的后台服务不符合白名单要求，您必须使用新的JobScheduler。它与后台服务基本相同，但它会定期调用，而不是在后台连续运行。

如果您使用的是 IntentService，则可以更改为 JobIntentService。请参阅@kosev 的answer below。

Answer 3

最好的方法是使用 JobIntentService，它使用新的 JobScheduler for Oreo 或旧服务（如果不可用）。

在清单中声明：

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

在您的服务中，您必须将 onHandleIntent 替换为 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
    }

}

然后你开始你的服务：

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

Answer 4

如果服务通过扩展IntentService 在后台线程中运行，您可以将IntentService 替换为作为Android 支持库的一部分提供的JobIntentService

使用JobIntentService 的优点是，它在O 之前的设备和O 及更高版本的设备上表现为IntentService，它将其作为作业进行调度

JobScheduler 也可用于定期/按需作业。但是，请确保处理向后兼容性，因为 JobScheduler API 仅适用于 API 21

Answer 5

是的，那是因为您无法再在 API 26 上在后台启动服务。所以您可以在 API 26 之上启动 ForegroundService。

你必须使用

ContextCompat.startForegroundService(...)

并在处理泄漏时发布通知。

Answer 6

在 Oreo Android 中定义了limits to background services。

为了改善用户体验，Android 8.0（API 级别 26）强加了 限制应用在后台运行时可以执行的操作。

如果您需要始终运行的服务，那么您可以使用前台服务。

后台服务限制：当应用处于空闲状态时，存在限制 对其使用后台服务。这不适用于前台 服务，对用户来说更明显。

所以你可以做一个前台服务。您需要在服务运行时向用户显示通知。 See this answer（还有很多）

一个解决方案如果 -

您不想收到有关服务的通知？

您可以进行周期性任务，1. 它启动您的服务，2. 服务将完成其工作，3. 自行停止。这样，您的应用将不会被视为耗电。

您可以通过Alarm Manager、Job Scheduler、Evernote-Jobs 或Work Manager 使用周期性任务。

• 工作经理是周期性任务的最佳解决方案。这是通过Android Architecture Component 介绍的。
• 与 Job-Scheduler（仅 >21 API）不同，它适用于所有版本。
• 它还在Doze-Standby mode 之后开始工作。
• 创建一个Android Boot Receiver 用于在设备启动后安排服务。

我已经使用 Work-Manager 测试了永久运行的服务。

Answer 7

正如@kosev 在his answer 中所说，您可以使用 JobIntentService。 但是我使用了另一种解决方案 - 我捕获了 IllegalStateException 并将服务作为前台启动。 比如这个函数启动我的服务：

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

当我处理 Intent 时，我会做这样的事情：

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

Answer 8

使用JobScheduler的替代解决方案，它可以定期在后台启动服务。

首先将类命名为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());
   }
  }

然后，将 JobService 类命名为 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;
  }
 }

在名为 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);
 }
}

使用服务和接收器类代码更新 清单文件

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

将main_intent启动器留给默认创建的mainActivity.java文件，MainActivity.java文件的变化是

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

哇哦！！后台服务在没有前台服务的情况下启动

[编辑]：您可以将工作管理器用于 Android 中的任何类型的后台任务。

Answer 9

来自firebase release notes，他们声明对 Android O 的支持是在 10.2.1 中首次发布的（尽管我建议使用最新版本）。

请为 android O 添加新的 firebase 消息传递依赖项

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

如果需要，升级 google play 服务和 google 存储库。

Answer 10

我看到很多建议只使用 ForegroundService 的回复。为了使用 ForegroundService，必须有一个与之关联的通知。用户将看到此通知。根据情况，他们可能会对您的应用感到恼火并卸载它。

最简单的解决方案是使用名为 WorkManager 的新架构组件。您可以在此处查看文档：https://developer.android.com/topic/libraries/architecture/workmanager/

您只需定义扩展 Worker 的工人类。

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

然后你安排你想运行它的时间。

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

简单！有很多方法可以配置工作人员。它支持重复性工作，如果你需要，你甚至可以做一些复杂的事情，比如链接。希望这会有所帮助。

Answer 11

如果应用程序在后台运行时任何 Intent 之前都可以正常工作，那么从 Android 8 及更高版本开始不会再出现这种情况。仅指应用在后台时必须进行一些处理的意图。

必须遵循以下步骤：

1. 上述意图应使用JobIntentService 而不是 IntentService。

2. 扩展JobIntentService 的类应该实现-onHandleWork(@NonNull Intent intent) 方法并且应该具有以下 方法，它将调用onHandleWork 方法：

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

3. 从定义您的意图的类调用enqueueWork(Context, intent)。

   示例代码：

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

下面的类以前是扩展服务类

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. JobIntentService 需要com.android.support:support-compat - 我使用26.1.0 V。

5. 最重要的是确保 Firebase 库版本至少在 10.2.1，我遇到了 10.2.0 的问题 - 如果您有任何问题！

6. 您的清单应具有以下 Service 类权限：

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

希望这会有所帮助。

Answer 12

如果您在 8.0 上运行代码，那么应用程序将会崩溃。所以在前台启动服务。如果低于 8.0 使用这个：

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

如果高于或 8.0 则使用此：

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

Answer 13

由于对此答案的投票存在争议（截至本次编辑为 +4/-4），请先查看其他答案，并将其用作最后的手段。我只为a networking app that runs as root 使用了此一次，我同意一般情况下不应使用此解决方案的普遍意见。

原答案如下：

其他答案都是正确的，但我想指出解决此问题的另一种方法是要求用户为您的应用禁用电池优化（这通常不是一个好主意，除非您的应用是系统有关的）。请参阅this answer，了解如何请求退出电池优化而不让您的应用在 Google Play 中被禁止。

您还应该通过以下方式检查接收器中的电池优化是否已关闭以防止崩溃：

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

Answer 14

如果您已经集成了 firebase 消息推送通知，那么，

由于Background Execution Limits，为 android O (Android 8.0) 添加新的/更新的 firebase 消息传递依赖项。

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

如果需要，升级 google play 服务和 google 存储库。

更新：

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

Answer 15

使用startForegroundService() 而不是startService() 并且不要忘记在启动服务后 5 秒内在您的服务中创建startForeground(1,new Notification());。

Answer 16

我也有这个问题

添加了这个库

implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'

并重新安装应用程序为我解决了这个问题

Answer 17

这实际上是因为手机在屏幕外，或者您在启动服务时按下了电源按钮。对我有用的解决方案是 启动一个活动，当它进入 onResume 然后启动服务。 就我而言，它正在启动并启动服务。