Intro to Service

Zac:tivi Zac$ adb shell ps | grep com.tencent.mobileqq
# curr_user   pid                                                 process name
u0_a163       6779   669 1638852  27152 0                   0 S com.tencent.mobileqq:MSF
u0_a163      22001   669 1915536 224004 0                   0 S com.tencent.mobileqq
u0_a163      27829   669 1670960 236668 0                   0 S com.tencent.mobileqq:qzone

# root permission need
adb shell cat /sys/module/lowmemorykiller/parameters/minfree

# App 处于前台时
adb shell cat /proc/4061/oom_adj
0
# App 处于后台时
Zac:tivi Zac$ adb shell cat /proc/4061/oom_adj
11

// These are the various interesting memory levels that we will give to
// the OOM killer.  Note that the OOM killer only supports 6 slots, so we
// can't give it a different value for every possible kind of process.
private final int[] mOomAdj = new int[] {
    FOREGROUND_APP_ADJ, VISIBLE_APP_ADJ, PERCEPTIBLE_APP_ADJ,
    BACKUP_APP_ADJ, CACHED_APP_MIN_ADJ, CACHED_APP_MAX_ADJ
};

import android.app.Notification
import android.app.PendingIntent
import android.app.Service
import android.content.Intent
import android.os.Build.VERSION_CODES
import android.os.IBinder
import androidx.annotation.RequiresApi

/**
 * Service code sample.
 *
 * @author: Zac
 * @date: 2022/3/16
 */
class SampleService : Service() {

  companion object {
    private const val NOTIFICATION_ID = 0x1001;
    private const val CHANNEL_NAME = "default";
  }

  // Indicates how to behave if the service is killed
  private var startMode: Int = START_STICKY
  // Interface for clients that bind
  private var binder: IBinder? = null
  // Indiacates whether onRebind should be used
  private var allowRebind: Boolean = false

  private val pendingIntent: PendingIntent =
    Intent(this, MainActivity::class.java).let { notificationIntent ->
      PendingIntent.getActivity(this, 0, notificationIntent, 0)
    }

  /**
   * Create foreground service
   */
  @RequiresApi(VERSION_CODES.O)
  private val notification: Notification = Notification.Builder(this, CHANNEL_NAME)
    .setContentTitle(getText(R.string.notification_title))
    .setContentText(getText(R.string.notification_message))
    .setSmallIcon(R.drawable.icon)
    .setContentIntent(pendingIntent)
    .setTicker(getText(R.string.ticker_text))
    .build()

  override fun onCreate() {
    // The service is being created
    startForeground(NOTIFICATION_ID, notification)
  }

  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
    // The service is starting, due to call startService()
    return startMode
  }

  override fun onUnbind(intent: Intent?): Boolean {
    // All clients have unbound with unbindService()
    return allowRebind
  }

  override fun onRebind(intent: Intent?) {
    // A client is binding to the service with bindService,
    // after onUnbind() has already been called
  }

  override fun onBind(intent: Intent?): IBinder? {
    // A client is binding to the service with bindService()
    return binder
  }
}

import android.app.Notification
import android.app.PendingIntent
import android.app.Service
import android.content.Intent
import android.os.Build.VERSION_CODES
import android.os.Handler
import android.os.HandlerThread
import android.os.IBinder
import android.os.Looper
import android.os.Message
import android.os.Process.THREAD_PRIORITY_BACKGROUND
import androidx.annotation.RequiresApi

/**
 * Service code sample.
 *
 * @author: Zac
 * @date: 2022/3/16
 */
class SampleIntentService : Service() {

  companion object {
    private const val NOTIFICATION_ID = 0x1001;
    private const val CHANNEL_NAME = "default";
  }

  private var serviceLooper: Looper? = null
  private var serviceHandler: ServiceHandler? = null

  private inner class ServiceHandler(looper: Looper): Handler(looper) {
    override fun handleMessage(msg: Message) {
      // to do some work here

      // Stop the service using the startId, so that we don't stop the
      // service in the middle of handling another job
      stopSelf(msg.arg1)
    }
  }

  private val pendingIntent: PendingIntent =
    Intent(this, MainActivity::class.java).let { notificationIntent ->
      PendingIntent.getActivity(this, 0, notificationIntent, 0)
    }

  /**
   * Create foreground notification
   */
  @RequiresApi(VERSION_CODES.O)
  private val notification: Notification = Notification.Builder(this, CHANNEL_NAME)
    .setContentTitle(getText(R.string.notification_title))
    .setContentText(getText(R.string.notification_message))
    .setSmallIcon(R.drawable.icon)
    .setContentIntent(pendingIntent)
    .setTicker(getText(R.string.ticker_text))
    .build()

  override fun onCreate() {
    // Start up the thread running the service.
    // We create a separate thread because the service normally runs in
    // the process's main thread, which we don't want block. We also make
    // it background priority so CPU-intensive work will not disrupt the UI.
    HandlerThread("SampleIntentService", THREAD_PRIORITY_BACKGROUND).apply {
      start()

      // Get the HandlerThread's Looper
      serviceLooper = looper
      serviceHandler = ServiceHandler(looper)
    }
  }

  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
    startForeground(NOTIFICATION_ID, notification)

    // For each start request, send a message to start a job and deliver the
    // start ID so we know which request we're stopping when we finish the job
    serviceHandler?.obtainMessage()?.also { msg->
      msg.arg1 = startId
      serviceHandler?.sendMessage(msg)
    }

    // If service get killed, after returning from here, restart
    return START_STICKY
  }

  override fun onBind(intent: Intent?): IBinder? {
    // No binder provide here
    return null
  }
}

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