针对Oreo限制：是否将Service设为前台？仅后台显示通知

Alright, let's tackle your Android notification and background service issues head-on. Here's a step-by-step solution tailored to your requirements:

First, we need a reliable way to detect if the app is running in the background, then configure notifications to be as non-intrusive as possible.

a. Detect App Background State #

Create a lifecycle observer to track active activities—this lets us accurately tell when the app moves to the background:

public class AppLifecycleObserver implements Application.ActivityLifecycleCallbacks {
    private int activityCount = 0;

    public boolean isAppInBackground() {
        return activityCount == 0;
    }

    @Override
    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {}

    @Override
    public void onActivityStarted(@NonNull Activity activity) {
        activityCount++;
    }

    @Override
    public void onActivityResumed(@NonNull Activity activity) {}

    @Override
    public void onActivityPaused(@NonNull Activity activity) {}

    @Override
    public void onActivityStopped(@NonNull Activity activity) {
        activityCount--;
    }

    @Override
    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {}

    @Override
    public void onActivityDestroyed(@NonNull Activity activity) {}
}

Register this observer in your Application class to make it global:

public class MyApp extends Application {
    public static AppLifecycleObserver lifecycleObserver;

    @Override
    public void onCreate() {
        super.onCreate();
        lifecycleObserver = new AppLifecycleObserver();
        registerActivityLifecycleCallbacks(lifecycleObserver);
    }
}

b. Configure Non-Intrusive Notifications #

For Android Oreo (API 26+) and above, you must create a low-priority notification channel to avoid unwanted sounds/vibrations. For older versions, adjust the notification priority directly.

Create a Low-Priority Notification Channel #

private void createNotificationChannel() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationChannel channel = new NotificationChannel(
                "BACKGROUND_NOTIF_CHANNEL",
                "Background Notifications",
                NotificationManager.IMPORTANCE_LOW // No sound, minimal system interference
        );
        channel.setDescription("Notifications only shown when app is in background");
        channel.setVibrationPattern(new long[]{0}); // Disable vibration entirely
        channel.enableVibration(false);

        NotificationManager notificationManager = getSystemService(NotificationManager.class);
        notificationManager.createNotificationChannel(channel);
    }
}

Show Notification Only When App is in Background #

Wrap your notification logic with a background check to ensure it only appears when the app isn't active:

private void showBackgroundNotification(String title, String content) {
    // Skip notification if app is in foreground
    if (!MyApp.lifecycleObserver.isAppInBackground()) {
        return;
    }

    NotificationCompat.Builder builder = new NotificationCompat.Builder(this, "BACKGROUND_NOTIF_CHANNEL")
            .setSmallIcon(R.drawable.ic_notification)
            .setContentTitle(title)
            .setContentText(content)
            .setPriority(NotificationCompat.PRIORITY_LOW)
            .setVibrate(new long[]{0}) // Disable vibration for pre-Oreo devices
            .setSound(null); // Mute notification sound

    NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
    notificationManager.notify(1, builder.build());
}

Android Oreo (API 26+) blocks direct background service starts to reduce battery drain. Instead, use WorkManager—it's Google's recommended tool for background tasks, designed to comply with system restrictions across all Android versions.

a. Create a Worker Class #

This worker will handle the background task and trigger the notification only if the app is in the background:

public class BackgroundNotificationWorker extends Worker {
    public BackgroundNotificationWorker(@NonNull Context context, @NonNull WorkerParameters params) {
        super(context, params);
    }

    @NonNull
    @Override
    public Result doWork() {
        // Check background state before showing notification
        if (MyApp.lifecycleObserver.isAppInBackground()) {
            String title = getInputData().getString("title");
            String content = getInputData().getString("content");
            showNotification(title, content);
        }
        return Result.success();
    }

    private void showNotification(String title, String content) {
        // Reuse the non-intrusive notification builder logic
        NotificationCompat.Builder builder = new NotificationCompat.Builder(getApplicationContext(), "BACKGROUND_NOTIF_CHANNEL")
                .setSmallIcon(R.drawable.ic_notification)
                .setContentTitle(title)
                .setContentText(content)
                .setPriority(NotificationCompat.PRIORITY_LOW)
                .setVibrate(new long[]{0})
                .setSound(null);

        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(getApplicationContext());
        notificationManager.notify(2, builder.build());
    }
}

b. Enqueue the Work Request #

When you need to trigger a background task (and potentially a notification), enqueue the worker instead of starting a service:

private void enqueueBackgroundNotificationTask(String title, String content) {
    Data inputData = new Data.Builder()
            .putString("title", title)
            .putString("content", content)
            .build();

    OneTimeWorkRequest workRequest = new OneTimeWorkRequest.Builder(BackgroundNotificationWorker.class)
            .setInputData(inputData)
            .build();

    WorkManager.getInstance(this).enqueue(workRequest);
}

Key Notes: #

• WorkManager automatically handles task scheduling around system battery optimizations, so your tasks will run without violating Oreo's restrictions.
• For recurring tasks, use PeriodicWorkRequest instead of OneTimeWorkRequest.

内容的提问来源于stack exchange，提问作者Bipin