<service
    android:name=".DemoService"
    android:exported="true"
    android:process=":demo"
    android:isolatedProcess="false"
    android:enabled="true"
    >
    <intent-filter>
        <action android:name="service.DemoService"/>
    </intent-filter>
</service>

Intent intent = new Intent(context, DemoService.class);
startService(intent);
stopService(intent);

public class DemoService extends Service {
    /**
     * 只有当 Service 第一次被启动的时候才回调。
     *
     * Service 生命周期中，不论如何 onCreate() 都只会回调一次。
     */
    @Override
    public void onCreate() {
        super.onCreate();
    }

    /**
     * Service 被调用 Start 时回调。
     * Service 运行过程中，被多次 Start 时会多次回调。
     * <p/>
     * @param intent 正常 Start 启动 Service 时，Intent 即为 Start 时传入的 Intent。
     *               当 Service 被系统杀死后，如果重新启动，则传入的 intent 与该方法的返回值有关。
     * @param flags 该 Service 启动时的参数，通常用于判断该 Service 被 Start 的原因。
     *              - 0: 表示 Service 是正常启动；
     *              - START_FLAG_REDELIVERY: 表示 Service 是由于被系统杀死，并在内存充足后被系统重新启动。
     *                仅当该方法返回值为 START_REDELIVER_INTENT 时生效。
     *              - START_FLAG_RETRY: 表示 Service 是由于该方法没有正常返回，系统重试。
     * @param startId 表明一个启动 ID，通常与 stopSelfResult(int startId) 搭配使用，
                      在 Service 重启或重试后，避免早前的 stopSelfResult() 请求将后来启动的 Service 停止。
     *                例如：onStartCommand(intent, flags, 5) 启动的 Service，将无法被 stopSelfResult(4) 停止。
     * <p/>
     * @return 有三种典型取值，代表了 Service 被 Start 后，如果被系统杀死，后续的行为。
     *         - START_STICKY: 表示内存充足后需要重新启动，但传入的 intent == null，除非有 Intent 队列，例如 PendingIntent。
     *         - START_NOT_STICKY: 表示内存充足后也不重新启动。
     *         - START_REDELIVER_INTENT: 表示内存充足后需要重新启动，并且把上一次 Start 时使用的 Intent 再重新传入。
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * Service 被首次 Bind 时回调，被 Start 启动时不会回调。
     *
     * Service 生命周期中，不论如何 onBind() 都只会回调一次。
     *
     * Service 在被销毁前，生命周期中只会在第一次被 Client 绑定时回调 onBind()，
     * 之后不论 Client 如何解绑并重新绑定，只要 Service 没有被销毁重启，都不会再次回调 onBind()。
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * Service 被重新 Bind 时回调，仅当 onUnbind() 返回 true 时生效。
     *
     * 仅当：
     * - Service 从 Bound 的状态下被所有 Client Unbind，
     * - 并且 onUnbind() 返回 true，
     * - 并且 Service 未被销毁（即同时处于 Started 状态），
     * 则下一次被 Bind 时才会回调 onRebind()。
     */
    @Override
    public void onRebind(Intent intent) {
        super.onRebind(intent);
    }

    /**
     * Service 被所有 Client Unbind，或者被最后一个 Context.BIND_AUTO_CREATE 模式的 Client Unbind 后回调。
     *
     * 需要注意：
     * - 如果 Service 被多个 Client Bind，只要所有 Context.BIND_AUTO_CREATE 模式的 Client Unbind 就会回调 onUnbind()，
     *   此时其他模式的 Client 就会收到 ServiceConnection#onServiceDisconnected() 回调。
     * - 否则当所有 Client Unbind 后才会触发该回调，且都不会收到 ServiceConnection#onServiceDisconnected() 回调。
     *
     * 当首次从 Bound 状态下被所有以 Context.BIND_AUTO_CREATE 模式 Bind 的 Client Unbind 时会回调，
     * 之后被重新 Bind 和 Unbind，是否回调依赖上一次 onUnbind() 的返回值：
     * - 如果上一次返回 false，则下一次被 Client Bind 时不会回调 onRebind()，且被所有 Client Unbind 后也不会回调 onUnbind()。
     * - 如果上一次返回 true，则下一次被 Client Bind 时会回调 onRebind()，且被所有 Clinet Unbind 后会也回调 onUnbind()。
     */
    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }

    /**
     * Service 真正被销毁时回调。
     *
     * Service 生命周期中，不论如何 onDestroy() 都只会回调一次。
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

/**
 * 直接操作 Binder 对象的方式。
 */
public class DemoService extends Service {
    
    public class DemoBinder extends Binder {
        // 通过 Binder 返回 Service 实例，使得外部可以持有该 Service 对象并与之通信
        public DemoService getService() {
            return DemoService.this;
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) { return new DemoBinder(); }

    // 可以由外部调用的方法
    public void work() { }
}

public class DemoActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        bindService(new Intent(this, DemoService.class), new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                DemoBinder demoBinder = (DemoBinder) service;
                // 持有 DemoService 的实例对象，并调用 Service 的公有方法。
                demoBinder.getService().work(); 
            }
            @Override
            public void onServiceDisconnected(ComponentName name) { /* 仅当异常 Unbind 时才回调 */ }
        }, Context.BIND_AUTO_CREATE);
    }
}

/**
 * 通过 Messenger 发送消息。
 */
public class DemoService extends Service {
    public static final int MSG_ON_BIND = 0;

    // Service 自己的 Handler，用于处理来自 Client 的消息。
    private final Handler serviceHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MSG_ON_BIND: {
                    // 通过接收 Client 发送过来的消息，从消息中获取 Client 的 Messenger。
                    clientMessenger = msg.replyTo;
                    break;
                }
                default: break;
            }
        }
    };
    // Client 的 Messenger，用于向 Client 发送消息。
    private Messenger clientMessenger;
    // Service 自己的 Messenger，用于接收来自 Client 的消息。
    private final Messenger serviceMessenger = new Messenger(serviceHandler);

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        // 返回 Service 的 Messenger，持有方就能向 Service 发送消息。
        return serviceMessenger.getBinder();
    }

    /**
     * Service 通过 Client 的 Messenger 向 Client 发送消息通信。
     */
    private void sendToClient() throws RemoteException {
        if (clientMessenger != null) {
            clientMessenger.send(Message.obtain());
        }
    }
}

public class DemoActivity extends AppCompatActivity {
    // Client 自己的 Handler，用于处理来自 Service 的消息。
    private final Handler clientHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            // 处理来自 Service 发送的消息
        }
    };
    // Client 自己的 Messenger，用于接收来自 Service 的消息。
    private final Messenger clientMessenger = new Messenger(clientHandler);
    // Service 的 Messenger，用于向 Service 发送消息。
    private Messenger serviceMessenger;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        bindService(new Intent(this, DemoService.class), new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                // 通过 Service 的 Binder 来构造 Service 的 Messenger。
                serviceMessenger = new Messenger(service);
                // 先向 Service 发送一条消息，通过 Msg.replyTo 把 Client 自己的 Messenger 传过去，
                // 这样 Service 才能拿到 Client 的 Messenger，才能向 Client 发送消息。
                Message onBindMsg = Message.obtain();
                onBindMsg.what = DemoService.MSG_ON_BIND;
                onBindMsg.replyTo = clientMessenger;
                serviceMessenger.send(onBindMsg);
            }
            @Override
            public void onServiceDisconnected(ComponentName name) { /* 仅当异常 Unbind 时才回调 */ }
        }, Context.BIND_AUTO_CREATE);
    }

    /**
     * Client 通过 Service 的 Messenger 向 Service 发送消息通信。
     */
    private void sendOnBindToService() throws RemoteException {
        if (serviceMessenger != null) {
            serviceMessenger.send(Message.obtain());
        }
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    Window activityWindow = getWindow();
    // 设置 Window 不可点击：
    activityWindow.addFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
    // 设置 Window 不关心外界触摸事件：
    activityWindow.addFlags(WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH);
    // 设置 DecorView 为全屏状态
    View decorView = activityWindow.getDecorView();
    decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    // 设置状态栏透明不可见：
    activityWindow.setStatusBarColor(Color.TRANSPARENT);
    // 设置 Window 位于左上角：
    activityWindow.setGravity(Gravity.START | Gravity.TOP);
    WindowManager.LayoutParams params = activityWindow.getAttributes();
    // 设置 Window 相对 Gravity 横纵坐标偏移均为 0：
    params.x = 0;
    params.y = 0;
    // 设置 Window 的宽和高均为 1 像素：
    params.height = 1;
    params.width = 1;
    activityWindow.setAttributes(params);
}