Android：如何创建不受资源限制的后台服务？（Root/AOSP场景）

Alright, let's break this down based on your specific scenario—since you're targeting a fully controlled custom AOSP environment (I’ll also cover rooted devices for others who might stumble on this question):

In a custom AOSP setup, the cleanest path to an unrestricted background service is building it as a system service. This places it directly in the system process, completely outside Android's app sandbox restrictions. Here's how to do this while keeping Android Studio in your development workflow:

• Integrate AOSP with Android Studio
  First, sync your full AOSP source code locally. Then, in Android Studio, import the frameworks/base/services/core module (this is where most system services live). You can create your new service class here—extend SystemService or build it as a standalone service tailored to your needs.

• Register your service in the system manifest
  Open frameworks/base/core/res/AndroidManifest.xml and add a <service> entry for your service. Make sure to set it to run in the system process and lock down permissions so only the system can interact with it:

  <service android:name="com.android.server.YourCustomBackgroundService"
           android:process="system"
           android:permission="android.permission.BIND_SYSTEM_SERVICE"
           android:exported="false"/>
  

• Hook your service into SystemServer
  SystemServer is the core process that launches all system services. Open frameworks/base/services/java/com/android/server/SystemServer.java, find the startOtherServices() method, and add a line to start your service:

  mSystemServiceManager.startService(YourCustomBackgroundService.class);
  

• Build and flash your modified AOSP
  Compile the full system with make -j$(nproc) (adjust the thread count based on your CPU cores), then flash the resulting image to your custom device. Your service will now run as a core system component—no battery optimization, memory limits, or background killing will affect it.

• Debug with Android Studio
  You can debug your system service by attaching Android Studio to the system_server process. First, enable debugging for the system process with adb shell am set-debug-app -w com.android.systemserver, then use AS's remote debugging feature to connect and set breakpoints.

For users with rooted standard Android devices (not a custom AOSP build), you can achieve near-unrestricted background execution by elevating your service to root privileges:

• Launch your service with root permissions
  Instead of relying on Android's standard service launch, use the su command to start your service as the root user. This pulls it out of the app sandbox:

  // Kotlin example to start the service with root
  Runtime.getRuntime().exec("su -c am startservice --user 0 -n com.your.package/.UnrestrictedBackgroundService")
  

• Bypass battery optimization
  Use root to add your app to the system's battery optimization whitelist, so the system won't throttle or kill it:

  # Run this via adb or within your app using su
  dumpsys deviceidle whitelist +com.your.package
  

• Ensure persistent execution
  Register a BOOT_COMPLETED broadcast receiver (with root permissions) to restart your service if the device reboots. Since it's running as root, Android's memory killer won't target it like a regular app service.

• Avoid app lifecycle dependencies
  Both system services and root-run services are independent of regular app components. Don't tie your service's lifecycle to an Activity or Fragment—keep it self-contained.
• Leverage Java/Kotlin portability
  You can use most standard Java SE APIs and Android system APIs in both scenarios. For system services, you'll have direct access to low-level system APIs; for root services, use JNI or system commands to access hardware/system resources.
• Keep it minimal
  Since your service has unrestricted access, focus only on the functionality you need—avoid unnecessary resource usage to keep the system stable.

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