3.定时关机

BaseActivity代码：
(利用反射，调用系统方法关机)

import android.content.Context;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.View;
import android.view.WindowManager;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Timer;
import java.util.TimerTask;

public abstract class BaseActivity extends AppCompatActivity {
    private static final String TAG = BaseActivity.class.getSimpleName();
    private static final String SERVICE_MANAGER = "android.os.ServiceManager";
    private static final String GET_SERVICE = "getService";
    private static final String IPOWER_MANAGER_STUB = "android.os.IPowerManager$Stub";
    private static final String AS_INTERFACE = "asInterface";
    private static final String SHUTDOWN = "shutdown";
    private static final String USER_REQUESTED = "userrequested";
    private static final int KEYSTROKES_ONE_SECOND = 14;
    private static Timer mTimer;
    private static TimerTask mTask;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(this.getLayoutId());
        initView();
        ActivityStackManager.getManagerInstance().pushActivity(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        hideSystemBar();
        startTimer();
        Logger.d(TAG, "onResume, start timer");
    }

    @Override
    protected void onPause() {
        super.onPause();
        stopTimer();
        Logger.d(TAG, "onPause, stop timer");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityStackManager.getManagerInstance().popActivity(this);
    }

    private void hideSystemBar() {
        getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                | View.SYSTEM_UI_FLAG_FULLSCREEN
                | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);

        getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN
                | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
                // Add the FLAG_KEEP_SCREEN_ON flag for keeping on screen.
                | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        event.startTracking();
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_POWER:
                if (event.getRepeatCount() == KEYSTROKES_ONE_SECOND) {
                    // TODO
                    Logger.d(TAG, "onKeyDown -> KEYCODE_POWER -> keycode = " + event.getKeyCode());
                    return true;
                }
                break;
            case KeyEvent.KEYCODE_FUNCTION:
                if (event.getRepeatCount() == 0) {
                    // do some preparations
                    Logger.d(TAG, "onKeyDown -> KEYCODE_FUNCTION -> keycode = " + event.getKeyCode());
                    return true;
                }
                break;
            case KeyEvent.KEYCODE_MEDIA_RECORD:
                if (event.getRepeatCount() == 0) {
                    // do some preparations
                    Logger.d(TAG, "onKeyDown -> KEYCODE_MEDIA_RECORD -> keycode = " + event.getKeyCode());
                    return true;
                }
                break;
            default:
                break;
        }
        return super.onKeyDown(keyCode, event);
    }

    @Override
    public boolean onKeyLongPress(int keyCode, KeyEvent event) {
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_FUNCTION:
                // TODO
                Logger.d(TAG, "onKeyLongPress -> KEYCODE_FUNCTION -> keycode = " + event.getKeyCode());
                break;
            case KeyEvent.KEYCODE_MEDIA_RECORD:
                // TODO
                Logger.d(TAG, "onKeyLongPress -> KEYCODE_MEDIA_RECORD -> keycode = " + event.getKeyCode());
                break;
            default:
                break;
        }
        return super.onKeyLongPress(keyCode, event);
    }

    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_POWER:
                // TODO
                Logger.d(TAG, "onKeyUp -> KEYCODE_POWER -> keycode = " + event.getKeyCode());
                break;
            case KeyEvent.KEYCODE_FUNCTION:
                // TODO
                Logger.d(TAG, "onKeyUp -> KEYCODE_FUNCTION -> keycode = " + event.getKeyCode());
                break;
            case KeyEvent.KEYCODE_MEDIA_RECORD:
                // TODO
                Logger.d(TAG, "onKeyUp -> KEYCODE_MEDIA_RECORD -> keycode = " + event.getKeyCode());
                break;
            default:
                break;
        }
        return super.onKeyUp(keyCode, event);
    }

    @Override
    public void onUserInteraction() {
        super.onUserInteraction();
        PowerOffTimerUtil.stopTimer();
        PowerOffTimerUtil.startTimer();
        Logger.d(TAG, "onUserInteraction, reStart timer");
    }

    private void initTimer() {
        if (mTask == null) {
            mTask = new MyTask();
        }
        if (mTimer == null) {
           mTimer = new Timer();
        }
    }

    class MyTask extends TimerTask {
        @Override
        public void run() {
            try {
                Class serviceManager = null;
                serviceManager = Class.forName(SERVICE_MANAGER);
                Method getService = serviceManager
                        .getMethod(GET_SERVICE, java.lang.String.class);
                Object remoteService = getService.invoke(null, Context.POWER_SERVICE);
                Class stub = Class.forName(IPOWER_MANAGER_STUB);
                Method asInterface = stub.getMethod(AS_INTERFACE, android.os.IBinder.class);
                Object powerManager = asInterface.invoke(null, remoteService);
                Method shutdown = powerManager.getClass()
                       .getMethod(SHUTDOWN, boolean.class, String.class, boolean.class);
                shutdown.invoke(powerManager, false, USER_REQUESTED, true);
           } catch (ClassNotFoundException exception) {
                Logger.d(TAG, exception.getMessage());
            } catch (NoSuchMethodException exception) {
                Logger.d(TAG, exception.getMessage());
            } catch (IllegalAccessException exception) {
                Logger.d(TAG, exception.getMessage());
            } catch (InvocationTargetException exception) {
                Logger.d(TAG, exception.getMessage());
            }
        }
    }

    /**
     * startTimer.
     */
    private void startTimer() {
        initTimer();
        try {
            mTimer.schedule(mTask, 100000);
        } catch (IllegalStateException exception) {
            Logger.d(TAG, exception.getMessage());
        }
    }

    /**
     * stopTimer.
     */
    private void stopTimer() {
        if (mTimer != null) {
            mTimer.cancel();
            mTimer = null;
        }
        if (mTask != null) {
            mTask.cancel();
            mTask = null;
        }
    }

    /**
     * get layout id (R.layout.xx).
     *
     * @return int.
     */
    protected abstract int getLayoutId();

    /**
     * init UI component.
     *
     * @return void.
     */
    protected abstract void initView();
}