Android 系统服务与Binder应用服务

            //
             Start services.
            try
             {
            t.traceBegin("StartServices");
            startBootstrapServices(t);
            startCoreServices(t);
            startOtherServices(t);
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            t.traceEnd(); // StartServices
        }

                @UnsupportedAppUsage
    
            private
            void
             handleCreateService(CreateServiceData data) {
        
            //
             If we are getting ready to gc after going to the background, well
        
            //
             we are back active so skip it.
                    unscheduleGcIdler();

        LoadedApk packageInfo = getPackageInfoNoCheck(
                data.info.applicationInfo, data.compatInfo);
        Service service = null;
        try {
            if (localLOGV) Slog.v(TAG, "Creating service " + data.info.name);

            ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
            Application app = packageInfo.makeApplication(false, mInstrumentation);
            java.lang.ClassLoader cl = packageInfo.getClassLoader();
            service = packageInfo.getAppFactory()
                    .instantiateService(cl, data.info.name, data.intent);
            // Service resources must be initialized with the same loaders as the application
            // context.            context.getResources().addLoaders(
                    app.getResources().getLoaders().toArray(new ResourcesLoader[0]));

            context.setOuterContext(service);
            service.attach(context, this, data.info.name, data.token, app,
                    ActivityManager.getService());
            service.onCreate();
            mServices.put(data.token, service);
            try {
                ActivityManager.getService().serviceDoneExecuting(
                        data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(service, e)) {
                thrownew RuntimeException(
                    "Unable to create service " + data.info.name
                    + ": " + e.toString(), e);
            }
        }
    }

registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
                new CachedServiceFetcher<ActivityManager>() {
            @Override
            public ActivityManager createService(ContextImpl ctx) {
                returnnew ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
            }});

Intent(this, MyService::class.java).also { intent ->
    bindService(intent, object : ServiceConnection{
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            TODO("Not yet implemented")
        }

        override fun onServiceDisconnected(name: ComponentName?) {
            TODO("Not yet implemented")
        }

    }, Context.BIND_AUTO_CREATE)
}

val service = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager

            public
            interface
             ServiceConnection {
    
            /**
            
     * Called when a connection to the Service has been established, with
     * the {
            @link
             android.os.IBinder} of the communication channel to the
     * Service.
     *
     * <p class="note"><b>Note:</b> If the system has started to bind your
     * client app to a service, it‘s possible that your app will never receive
     * this callback. Your app won‘t receive a callback if there‘s an issue with
     * the service, such as the service crashing while being created.
     *
     * 
            @param
             name The concrete component name of the service that has
     * been connected.
     *
     * 
            @param
             service The IBinder of the Service‘s communication channel,
     * which you can now make calls on.
     
            */
            void
             onServiceConnected(ComponentName name, IBinder service);

    
            /**
            
     * Called when a connection to the Service has been lost.  This typically
     * happens when the process hosting the service has crashed or been killed.
     * This does <em>not</em> remove the ServiceConnection itself -- this
     * binding to the service will remain active, and you will receive a call
     * to {
            @link
             #onServiceConnected} when the Service is next running.
     *
     * 
            @param
             name The concrete component name of the service whose
     * connection has been lost.
     
            */
            void
             onServiceDisconnected(ComponentName name);

    
            /**
            
     * Called when the binding to this connection is dead.  This means the
     * interface will never receive another connection.  The application will
     * need to unbind and rebind the connection to activate it again.  This may
     * happen, for example, if the application hosting the service it is bound to
     * has been updated.
     *
     * 
            @param
             name The concrete component name of the service whose
     * connection is dead.
     
            */
            default
            void
             onBindingDied(ComponentName name) {
    }

    
            /**
            
     * Called when the service being bound has returned {
            @code
             null} from its
     * {
            @link
             android.app.Service#onBind(Intent) onBind()} method.  This indicates
     * that the attempting service binding represented by this ServiceConnection
     * will never become usable.
     *
     * <p class="note">The app which requested the binding must still call
     * {
            @link
             Context#unbindService(ServiceConnection)} to release the tracking
     * resources associated with this ServiceConnection even if this callback was
     * invoked following {
            @link
             Context#bindService Context.bindService() bindService()}.
     *
     * 
            @param
             name The concrete component name of the service whose binding
     *     has been rejected by the Service implementation.
     
            */
            default
            void
             onNullBinding(ComponentName name) {
    }
}