/**
  * Obtain the list of enrolled fingerprints templates.
  * @return list of current fingerprint items
  *
  * @hide
  */
 @RequiresPermission(USE_FINGERPRINT)
 public List<Fingerprint> getEnrolledFingerprints(int userId) {
  if (mService != null) try {
   return mService.getEnrolledFingerprints(userId,mContext.getopPackageName());
  } catch (remoteexception e) {
   throw e.rethrowFromSystemServer();
  }
  return null;
 }
 /**
  * @hide
  */
 @RequiresPermission(allOf = {
   USE_FINGERPRINT,INteraCT_ACROSS_USERS})
 public boolean hasEnrolledFingerprints(int userId) {
  if (mService != null) try {
   return mService.hasEnrolledFingerprints(userId,mContext.getopPackageName());
  } catch (remoteexception e) {
   throw e.rethrowFromSystemServer();
  }
  return false;
 }
 /**
  * Determine if fingerprint hardware is present and functional.
  *
  * @return true if hardware is present and functional,false otherwise.
  */
 @RequiresPermission(USE_FINGERPRINT)
 public boolean isHardwareDetected() {
  if (mService != null) {
   try {
    long deviceid = 0; /* Todo: plumb hardware id to FPMS */
    return mService.isHardwareDetected(deviceid,mContext.getopPackageName());
   } catch (remoteexception e) {
    throw e.rethrowFromSystemServer();
   }
  } else {
   Log.w(TAG,"isFingerprintHardwareDetected(): Service not connected!");
  }
  return false;
 }

...
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
  mSystemServiceManager.startService(FingerprintService.class);
 }
...

public void onStart() {
  publishBinderService(Context.FINGERPRINT_SERVICE,new FingerprintServiceWrapper());
  IFingerprintDaemon daemon = getFingerprintDaemon();
  listenForUserSwitches();
 }
public IFingerprintDaemon getFingerprintDaemon() {
  if (mDaemon == null) {
   mDaemon = IFingerprintDaemon.Stub.asInterface(ServiceManager.getService(FINGERPRINTD));
   if (mDaemon != null) {
    try {
     mDaemon.asBinder().linkToDeath(this,0);
     mDaemon.init(mDaemonCallback);
     mHaldeviceid = mDaemon.openHal();
     if (mHaldeviceid != 0) {
      updateActiveGroup(ActivityManager.getCurrentUser(),null);
     } else {
      Slog.w(TAG,"Failed to open Fingerprint HAL!");
      Metricslogger.count(mContext,"fingerprintd_openhal_error",1);
      mDaemon = null;
     }
    } catch (remoteexception e) {
     Slog.e(TAG,"Failed to open fingeprintd HAL",e);
     mDaemon = null; // try again later!
    }
   } else {
    Slog.w(TAG,"fingerprint service not available");
   }
  }
  return mDaemon;
 }

public void authenticate(@Nullable CryptoObject crypto,@Nullable CancellationSignal cancel,int flags,@NonNull AuthenticationCallback callback,Handler handler,int userId) {
  if (callback == null) {
   throw new IllegalArgumentException("Must supply an authentication callback");
  }
  if (cancel != null) {
   if (cancel.isCanceled()) {
    Log.w(TAG,"authentication already canceled");
    return;
   } else {
    cancel.setonCancelListener(new OnAuthenticationCancelListener(crypto));
   }
  }
  if (mService != null) try {
   useHandler(handler);
   mAuthenticationCallback = callback;
   mCryptoObject = crypto;
   long sessionId = crypto != null ? crypto.getopId() : 0;
   mService.authenticate(mToken,sessionId,userId,mServiceReceiver,flags,mContext.getopPackageName());
  } catch (remoteexception e) {
   Log.w(TAG,"Remote exception while authenticating: ",e);
   if (callback != null) {
    // Though this may not be a hardware issue,it will cause apps to give up or try
    // again later.
    callback.onAuthenticationError(FINGERPRINT_ERROR_HW_UNAVAILABLE,getErrorString(FINGERPRINT_ERROR_HW_UNAVAILABLE));
   }
  }
 }

public static abstract class AuthenticationCallback {
  public void onAuthenticationError(int errorCode,CharSequence errString) { }
  public void onAuthenticationHelp(int helpCode,CharSequence helpString) { }
  public void onAuthenticationSucceeded(AuthenticationResult result) { }
  public void onAuthenticationFailed() { }
  public void onAuthenticationAcquired(int acquireInfo) {}
 };

public void authenticate(final IBinder token,final long opId,final int groupId,final IFingerprintServiceReceiver receiver,final int flags,final String opPackageName) {
   final int callingUid = Binder.getCallingUid();
   final int callingUserId = UserHandle.getCallingUserId();
   final int pid = Binder.getCallingPid();
   final boolean restricted = isRestricted();
   mHandler.post(new Runnable() {
    @Override
    public void run() {
     if (!canUseFingerprint(opPackageName,true /* foregroundOnly */,callingUid,pid)) {
      if (DEBUG) Slog.v(TAG,"authenticate(): reject " + opPackageName);
      return;
     }
     Metricslogger.histogram(mContext,"fingerprint_token",opId != 0L ? 1 : 0);
     // Get performance stats object for this user.
     HashMap<Integer,PerformanceStats> pmap
       = (opId == 0) ? mPerformanceMap : mCryptoPerformanceMap;
     PerformanceStats stats = pmap.get(mCurrentUserId);
     if (stats == null) {
      stats = new PerformanceStats();
      pmap.put(mCurrentUserId,stats);
     }
     mPerformanceStats = stats;
     startAuthentication(token,opId,callingUserId,groupId,receiver,restricted,opPackageName);
    }
   });
  }

private void startAuthentication(IBinder token,long opId,int callingUserId,int groupId,IFingerprintServiceReceiver receiver,boolean restricted,String opPackageName) {
  updateActiveGroup(groupId,opPackageName);
  if (DEBUG) Slog.v(TAG,"startAuthentication(" + opPackageName + ")");
  AuthenticationClient client = new AuthenticationClient(getContext(),mHaldeviceid,token,mCurrentUserId,opPackageName) {
   @Override
   public boolean handleFailedAttempt() {
    mFailedAttempts++;
    if (mFailedAttempts == MAX_Failed_ATTEMPTS) {
     mPerformanceStats.lockout++;
    }
    if (inLockoutMode()) {
     // Failing multiple times will continue to push out the lockout time.
     scheduleLockoutReset();
     return true;
    }
    return false;
   }
   @Override
   public void resetFailedAttempts() {
    FingerprintService.this.resetFailedAttempts();
   }
   @Override
   public void notifyUserActivity() {
    FingerprintService.this.userActivity();
   }
   @Override
   public IFingerprintDaemon getFingerprintDaemon() {
    return FingerprintService.this.getFingerprintDaemon();
   }
  };
  if (inLockoutMode()) {
   Slog.v(TAG,"In lockout mode; disallowing authentication");
   // Don't bother starting the client. Just send the error message.
   if (!client.onError(FingerprintManager.FINGERPRINT_ERROR_LOCKOUT)) {
    Slog.w(TAG,"Cannot send timeout message to client");
   }
   return;
  }
  startClient(client,true /* initiatedByClient */);
 }

private void startClient(ClientMonitor newClient,boolean initiatedByClient) {
  ClientMonitor currentClient = mCurrentClient;
  if (currentClient != null) {
   if (DEBUG) Slog.v(TAG,"request stop current client " + currentClient.getownerString());
   currentClient.stop(initiatedByClient);
   mPendingClient = newClient;
   mHandler.removeCallbacks(mResetClientState);
   mHandler.postDelayed(mResetClientState,CANCEL_TIMEOUT_LIMIT);
  } else if (newClient != null) {
   mCurrentClient = newClient;
   if (DEBUG) Slog.v(TAG,"starting client "
     + newClient.getClass().getSuperclass().getSimpleName()
     + "(" + newClient.getownerString() + ")"
     + ",initiatedByClient = " + initiatedByClient + ")");
   newClient.start();
  }
 }
public int start() {
  IFingerprintDaemon daemon = getFingerprintDaemon();
  if (daemon == null) {
   Slog.w(TAG,"start authentication: no fingeprintd!");
   return ERROR_ESRCH;
  }
  try {
   final int result = daemon.authenticate(mOpId,getGroupId());
   if (result != 0) {
    Slog.w(TAG,"startAuthentication Failed,result=" + result);
    Metricslogger.histogram(getContext(),"fingeprintd_auth_start_error",result);
    onError(FingerprintManager.FINGERPRINT_ERROR_HW_UNAVAILABLE);
    return result;
   }
   if (DEBUG) Slog.w(TAG,"client " + getownerString() + " is authenticating...");
  } catch (remoteexception e) {
   Slog.e(TAG,"startAuthentication Failed",e);
   return ERROR_ESRCH;
  }
  return 0; // success
 }

mDaemon.init(mDaemonCallback);

private static final int MAX_Failed_ATTEMPTS_LOCKOUT_TIMED = 5;
private static final int MAX_Failed_ATTEMPTS_LOCKOUT_PERMANENT = 20;
private int getLockoutMode() {
  if (mFailedAttempts >= MAX_Failed_ATTEMPTS_LOCKOUT_PERMANENT) {
   return AuthenticationClient.LOCKOUT_PERMANENT;
  } else if (mFailedAttempts > 0 && mTimedLockoutCleared == false &&
    (mFailedAttempts % MAX_Failed_ATTEMPTS_LOCKOUT_TIMED == 0)) {
   return AuthenticationClient.LOCKOUT_TIMED;
  }
  return AuthenticationClient.LOCKOUT_NONE;
 }

由于Android8.0以后不能使用后台服务，使用Service需要使用ContextCompat.startForegroundService启动前台服务，而且通知栏有Notification显示该Service正在运行，这可能会带来不好的用户体验。
如果还是希望使用服务在后台默默工作，通过使用服务开启子进程等等，可以使用JobIntentService。下面的具体的代码：

public class TestService extends JobIntentService {

  private static final int JOB_ID = 1000;

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

  @Override
  protected void onHandleWork(@NonNull Intent intent) {
    // TODO:
  }
}

<service
  android:name=".service.TestService"
  android:exported="true"
  android:permission="android.permission.BIND_JOB_SERVICE"　　//重要1
  />

<uses-permission android:name="android.permission.WAKE_LOCK"/>　//重要2

//@Override
//public IBinder onBind(@NonNull Intent intent) {　//重要3，大坑，不能重写onBind方法，重写的话要返回super.onBind(),否则onHandleWork不会回调。
//    return null;
//}

//重要4，重写onStartCommand方法时要返回super.onStartCommand()

Intent intent = new Intent(MainActivity.this,TestService.class);
intent.putExtra("key","value");
TestService.enqueueWork(MainActivity.this,intent);

/**

   * @hide  文档注释

   */ 
  public FingerprintManager(Context context, IFingerprintService service) { 
        mContext = context; 
        mService = service; 
        if (mService == null) { 
          Slog.v(TAG, "FingerprintManagerService was null"); 
        } 
        mHandler = new MyHandler(context); 
   } //既然在构造函数中初始化这个字段，那我们找到FingerprintManager被new的地方也即是该构造函数被调用的地方： 
 //frameworks/base/core/java/android/app/SystemServiceRegistry.java 
 registerService(Context.FINGERPRINT_SERVICE, FingerprintManager.class, 
   new CachedServiceFetcher<FingerprintManager>()
    { 
     @Override 
     public FingerprintManager createService(ContextImpl ctx) throws ServiceNotFoundException 
     { 
        final IBinder binder; 
     if (ctx.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.O) 
     { 
        binder = ServiceManager.getServiceOrThrow(Context.FINGERPRINT_SERVICE); 
      }
      else { 
          binder = ServiceManager.getService(Context.FINGERPRINT_SERVICE); 
      } 
      IFingerprintService service = IFingerprintService.Stub.asInterface(binder); 
     return new FingerprintManager(ctx.getOuterContext(), service); 
     }
    }
   ); 

在这里我们看到 ServiceManager这个类，这个类是专门来管理系统服务的，通过它我们可以获得特定服务的实现类对象：
IBinder binder = ServiceManager.getService(Context.FINGERPRINT_SERVICE); 
接着将其转换成服务的代理： IFingerprintService service = IfingerprintService.Stub.asInterface(binder);
存放在FingerprintManager中： new FingerprintManager(ctx.getOuterContext(), service); 
至此完成了客户端FingerprintManager到服务端 FINGERPRINT_SERVICE 的连接。 

这里的 FINGERPRINT_SERVICE与FingerprintService之间又有什么关联吗？ 

public class FingerprintService extends SystemService implements IHwBinder.DeathRecipient {
// FingerprintService是系统服务中的一员，

//SystemService： import com.android.server.SystemService; 

   frameworks/base/services/core/java/com/android/server/SystemService.java
  /** 
   * Called when the dependencies listed in the @Service class-annotation are available 
   * and after the chosen start phase. 
   * When this method returns, the service should be published. 
   */
   public abstract void onStart(); 
    

    //frameworks/base/services/core/java/com/android/server/fingerprint/FingerprintService.java
    /**
     * A service to manage multiple clients that want to access the fingerprint HAL API.
     * The service is responsible for maintaining a list of clients and dispatching all
     * fingerprint -related events.
     *
     * @hide
     */
    public class FingerprintService extends SystemService implements IHwBinder.DeathRecipient {
     ......

    @Override
    public void onStart() {
        publishBinderService(Context.FINGERPRINT_SERVICE, new FingerprintServiceWrapper());
        SystemServerInitThreadPool.get().submit(this::getFingerprintDaemon, TAG + ".onStart");
        listenForUserSwitches();
    }
     ......

     /frameworks/base/services/java/com/android/server/SystemServer.java
    /**
     * Starts a miscellaneous grab bag of stuff that has yet to be refactored
     * and organized.
     */
    private void startOtherServices() {
      …..
             if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
                    traceBeginAndSlog("StartFingerprintSensor");
                    mSystemServiceManager.startService(FingerprintService.class);
                    traceEnd();
                }
     …...
FingerprintService在 SystemServer中创建并初始化，当检测到手机支持指纹功能的时候，就会启动这个服务
frameworks/base/services/core/java/com/android/server/SystemServiceManager.java  : mSystemServiceManager

public class MainActivity extends Activity {  
  
  @Override  
  protected void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState);  
    setContentView(R.layout.activity_main);  
  }  
  
  public void startService(View source) {  
    // 创建所需要启动的Service的Intent  
    Intent intent = new Intent(this,MyService.class);  
    startService(intent);  
  }  
  
  public void startIntentService(View source) {  
    // 创建需要启动的IntentService的Intent  
    Intent intent = new Intent(this,MyIntentService.class);  
    startService(intent);  
  }  
}  

public class MyIntentService extends IntentService {  
  
  public MyIntentService() {  
    super("MyIntentService");  
  }  
  
  @Override  
  protected void onHandleIntent(Intent intent) {  
    // IntentService会使用单独的线程来执行该方法的代码  
    // 该方法内执行耗时任务，比如下载文件，此处只是让线程等待20秒  
    long endTime = System.currentTimeMillis() + 20 * 1000;  
    System.out.println("onStart");  
    while (System.currentTimeMillis() < endTime) {  
      synchronized (this) {  
        try {  
          wait(endTime - System.currentTimeMillis());  
        } catch (InterruptedException e) {  
          e.printstacktrace();  
        }  
      }  
    }  
    System.out.println("----耗时任务执行完成---");  
  }  
}  
 

public class MyService extends Service {  
  
  @Override  
  public IBinder onBind(Intent arg0) {  
    return null;  
  }  
  
  @Override  
  public int onStartCommand(Intent intent,int flags,int startId) {  
    // 该方法内执行耗时任务可能导致ANR(Application Not Responding)异常  
    long endTime = System.currentTimeMillis() + 20 * 1000;  
    System.out.println("onStart");  
    while (System.currentTimeMillis() < endTime) {  
      synchronized (this) {  
        try {  
          wait(endTime - System.currentTimeMillis());  
        } catch (InterruptedException e) {  
          e.printstacktrace();  
        }  
      }  
    }  
    System.out.println("----耗时任务执行完成---");  
    return START_STICKY;  
  }  
}  

<em> 复制代码</em><em> 隐藏代码<br></em><span>struct</span> <span>binder_write_read</span> {<br>    <span>binder_size_t</span> write_size; <span>/* 写内容的数据总大小 */</span><br>    <span>binder_size_t</span> write_consumed; <span>/* 记录了从缓冲区读取写内容的大小 */</span><br>    <span>binder_uintptr_t</span> write_buffer; <span>/* 写内容的数据的虚拟地址 */</span><br>    <span>binder_size_t</span> read_size; <span>/* 读内容的数据总大小 */</span><br>    <span>binder_size_t</span> read_consumed; <span>/* 记录了从缓冲区读取读内容的大小 */</span><br>    <span>binder_uintptr_t</span> read_buffer; <span>/* 读内容的数据的虚拟地址 */</span><br>};

<em> 复制代码</em><em> 隐藏代码<br></em><span>struct</span> <span>binder_transaction_data</span> {<br>    <span>union</span> {<br>        __u32 handle;<br>        <span>binder_uintptr_t</span> ptr;<br>    } target; <span>/* 该事务的目标对象 */</span><br>    <span>binder_uintptr_t</span> cookie; <span>/* 只有当事务是由Binder驱动传递给用户空间时，cookie才有意思，它的值是处理该事务的Server位于C++层的本地Binder对象 */</span><br>    __u32 code; <span>/* 方法编号 */</span><br>    __u32 flags;<br>    <span>pid_t</span> sender_pid;<br>    <span>uid_t</span> sender_euid;<br>    <span>binder_size_t</span> data_size; <span>/* 数据长度 */</span><br>    <span>binder_size_t</span> offsets_size; <span>/* 若包含对象，对象的数据大小 */</span><br>    <span>union</span> {<br>        <span>struct</span> {<br>            <span>binder_uintptr_t</span> buffer; <span>/* 参数地址 */</span><br>            <span>binder_uintptr_t</span> offsets; <span>/* 参数对象地址 */</span><br>        } ptr;<br>        __u8 buf[<span>8</span>];<br>    } data; <span>/* 数据 */</span><br>};