Modificación de la configuración del sistema para el desarrollo todo en uno de Android --- brillo de la pantalla

Modificación de la configuración del sistema para el desarrollo todo en uno de Android --- brillo de la pantalla

Modificación de la configuración del sistema para el desarrollo todo en uno de Android———sonido

Modifique la configuración del sistema para el desarrollo de máquinas todo en uno con Android --- bloqueo de pantalla automático

prefacio

Recientemente, he estado un poco inactivo en el trabajo, así que me tomé el tiempo de resumirlo: Recientemente, he estado trabajando en el desarrollo de una aplicación todo en uno, que es adecuada para los canales médicos.

La máquina todo en uno fue a la fábrica para personalizar la placa y el sistema. Después de buscarlos, la aplicación se empaquetará en el sistema en forma de apk después de fw. Por supuesto, también se empaquetará el logotipo de arranque.

En esta versión de la máquina todo en uno, hay una sección de funciones que puede cambiar la configuración del sistema.Recuerdo que antes he resumido la configuración del sistema de llamadas de Android.Si te interesa, puedes echarle un vistazo;este artículo explicará algunas funciones 细分化.

Pero al llamar a la configuración del sistema, algunas funciones del sistema permiten a los usuarios ver las mismas funciones que los teléfonos móviles, y algunas funciones no son necesarias para nosotros. Aquí debemos implementar la función de modificar los permisos del sistema por nosotros mismos .

A continuación, publicaré una serie de artículos sobre la modificación de la configuración del sistema para el desarrollo de máquinas todo en uno . ¡Bienvenidos a aprender y progresar juntos!

brillo de la pantalla

La operación de modificar el sistema 屏幕亮度es bastante común, y 多媒体generalmente está involucrada en el desarrollo hasta cierto punto.

Aunque es difícil ver la visualización del efecto en la imagen de arriba, probablemente puedas adivinar la implementación específica de la función, que es controlar el porcentaje de brillo a través de seekBar.

Si desea implementar la función de modificar el brillo de la pantalla, aquí se requiere un 高级permiso de privacidad y el usuario debe estar en la página de configuración de la aplicación 手动授权.

Ideas de diseño

1. Permisos de configuración de AndroidManifest;

2. Obtenga el brillo de la pantalla del sistema;

3. Modificar el brillo de la pantalla en la Configuración del sistema (registrarse para monitorear los cambios de brillo de la pantalla), afectando todas las páginas y aplicaciones;

   3.1 Autoridad de juicio

   3.2 Modifica el brillo de la pantalla si es necesario

   3.3 Guiar al usuario para que autorice si no lo hay

Implementación

Permisos de configuración de AndroidManifest

	<!-- 修改系统设置 -->
    <uses-permission android:name="android.permission.WRITE_SETTINGS" />
    <uses-permission android:name="android.permission.READ_CONTACTS" />
    <uses-permission android:name="com.android.launcher.permission.READ_SETTINGS" />
    <uses-permission android:name="android.permission.HARDWARE_TEST" />

Obtener el brillo de la pantalla del sistema

• Java

	/**
     * 获取app屏幕亮度
     *
     * @param activity
     * @return
     */
    public static int getScreenBrightness(Activity activity) {
    
    
        try {
    
    
            return Settings.System.getInt(activity.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS);
        } catch (Settings.SettingNotFoundException e) {
    
    
            e.printStackTrace();
        }

        return 0;
    }

• kotlin

	/**
     * 获取系统屏幕亮度(0-255)
     */
    private fun getScreenBrightness(): Int {
    
    
        try {
    
    
            return Settings.System.getInt(this.contentResolver, Settings.System.SCREEN_BRIGHTNESS)
        } catch (e: SettingNotFoundException) {
    
    
            e.printStackTrace()
        }
        return 0
    }

Modificar el brillo de la pantalla en los Ajustes del sistema, afectando a todas las páginas y aplicaciones

Registre los cambios de brillo de la pantalla del sistema de monitoreo

• Java

	private void registerContentObserver() {
    
    
        ContentResolver contentResolver = getContentResolver();
        if (contentResolver != null) {
    
    
            contentResolver.registerContentObserver(Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS),
                    true,
                    mBrightnessObserver);
        }
    }

• kotlin

	private fun registerContentObserver() {
    
    
        this.contentResolver?.registerContentObserver(
            Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS),
            true,
            mBrightnessObserver
        )
    }

---

Supervisar los cambios de brillo del sistema

• Java

	private ContentObserver mBrightnessObserver = new ContentObserver(new Handler()) {
    
    
        @Override
        public void onChange(boolean selfChange) {
    
    
            super.onChange(selfChange);

            ContentResolver contentResolver = getContentResolver();
            if (contentResolver != null) {
    
    
                mScreenBrightness = getScreenBrightness(BrightActivity.this);
                Log.e("监听亮度 >>>", "init: " + mScreenBrightness);
                updateNum(mScreenBrightness);
                setWindowBrightness(mScreenBrightness);
            }
        }
    };

• kotlin

	private val mBrightnessObserver = object : ContentObserver(Handler(Looper.getMainLooper())) {
    
    
        override fun onChange(selfChange: Boolean) {
    
    
            super.onChange(selfChange)
            try {
    
    
                this@BrightnessActivity.contentResolver?.let {
    
    
                    mScreenBrightness = Settings.System.getInt(it, Settings.System.SCREEN_BRIGHTNESS)
                    updateNum(mScreenBrightness)
                    setWindowBrightness(mScreenBrightness)
                }
            } catch (e: SettingNotFoundException) {
    
    
                e.printStackTrace()
            }
        }
    }

---

cerrar sesión oyente

• Java

	@Override
    protected void onDestroy() {
    
    
        super.onDestroy();
        ContentResolver contentResolver = getContentResolver();
        if (contentResolver != null) {
    
    
            contentResolver.unregisterContentObserver((ContentObserver) mBrightnessObserver);
        }
    }

• kotlin

	override fun onDestroy() {
    
    
        super.onDestroy()
        //注销监听
        this.contentResolver?.unregisterContentObserver(mBrightnessObserver)
    }

---

Modifique el brillo de la pantalla en la configuración del sistema a través de seekBar

• Java

	brightBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
    
    
            @RequiresApi(api = Build.VERSION_CODES.M)
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
    
    
                Log.e("动态屏幕亮度 >>>", "onProgressChanged: " + progress);
                mScreenBrightness = progress * ratio;
                if (Settings.System.canWrite(BrightActivity.this)) {
    
    
                    setScreenBrightness(mScreenBrightness);
                    updateNum(mScreenBrightness);
                } else {
    
    
                    Toast.makeText(BrightActivity.this, "没有修改权限", Toast.LENGTH_SHORT).show();

                    // 打开允许修改Setting 权限的界面
                    Intent intent = new Intent(
                            Settings.ACTION_MANAGE_WRITE_SETTINGS, Uri
                            .parse("package:"
                                    + getPackageName()));
                    startActivityForResult(intent,
                            mRequestCode);
                }
            }

            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {
    
    

            }

            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {
    
    

            }
        });

• kotlin

	seekBar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
    
    
            override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
    
    
                Log.i("onProgressChanged----", "" + progress)
                mScreenBrightness = progress * ratio
                //判断是否有修改系统设置权限
                if (Settings.System.canWrite(this@BrightnessActivity)) {
    
    
                    setScreenBrightness(mScreenBrightness)
                    updateNum(mScreenBrightness)
                } else {
    
    
                    Toast.makeText(this@BrightnessActivity, "没有修改权限", Toast.LENGTH_SHORT).show()
                    // 打开允许修改系统设置权限的页面
                    val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS, Uri.parse("package:$packageName"))
                    startActivityForResult(intent, mRequestCode)
                }
            }

            override fun onStartTrackingTouch(seekBar: SeekBar?) {
    
    
            }

            override fun onStopTrackingTouch(seekBar: SeekBar?) {
    
    
            }
        })

---

Usuario autorizado, ajuste el brillo de la pantalla

• Java

 	/**
     * 设置系统屏幕亮度，影响所有页面和app
     * 注意：这种方式是需要手动权限的（android.permission.WRITE_SETTINGS）
     */
    private final void setScreenBrightness(int brightness) {
    
    
        //先检测调节模式
        setScreenManualMode();
        //再设置
        Settings.System.putInt(getContentResolver(), Settings.System.SCREEN_BRIGHTNESS, brightness);
    }

    private final void setScreenManualMode() {
    
    
        try {
    
    
            //获取当前系统亮度调节模式
            int mode = Settings.System.getInt(getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE);
            //如果是自动，则改为手动
            if (mode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
    
    
                Settings.System.putInt(getContentResolver(),
                        Settings.System.SCREEN_BRIGHTNESS_MODE,
                        Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
            }
        } catch (Settings.SettingNotFoundException var2) {
    
    
            var2.printStackTrace();
        }
    }

• kotlin

 	/**
     * 设置系统屏幕亮度，影响所有页面和app
     * 注意：这种方式是需要手动权限的（android.permission.WRITE_SETTINGS）
     */
    private fun setScreenBrightness(brightness: Int) {
    
    
        try {
    
    
            //先检测调节模式
            setScreenManualMode()
            //再设置
            Settings.System.putInt(this.contentResolver, Settings.System.SCREEN_BRIGHTNESS, brightness)
        } catch (e: SettingNotFoundException) {
    
    
            e.printStackTrace()
        }
    }

 	/**
     * 设置系统亮度调节模式(SCREEN_BRIGHTNESS_MODE)
     * SCREEN_BRIGHTNESS_MODE_MANUAL 手动调节
     * SCREEN_BRIGHTNESS_MODE_AUTOMATIC 自动调节
     */
    private fun setScreenManualMode() {
    
    
        try {
    
    
            //获取当前系统亮度调节模式
            val mode = Settings.System.getInt(this.contentResolver, Settings.System.SCREEN_BRIGHTNESS_MODE)
            //如果是自动，则改为手动
            if (mode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
    
    
                Settings.System.putInt(
                    this.contentResolver,
                    Settings.System.SCREEN_BRIGHTNESS_MODE,
                    Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL
                )
            }
        } catch (e: SettingNotFoundException) {
    
    
            e.printStackTrace()
        }
    }

---

botón del sistema de monitoreo

	//监听系统按键
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
    
    
        switch (keyCode) {
    
    
            case KeyEvent.KEYCODE_VOLUME_DOWN:
                if (mScreenBrightness > ratio) {
    
    
                    mScreenBrightness -= ratio;
                } else {
    
    
                    mScreenBrightness = 1;
                }
                Log.e("Down >>>", "onKeyDown: " + mScreenBrightness);
                setWindowBrightness(mScreenBrightness);
                updateNum(mScreenBrightness);
                return true;
            case KeyEvent.KEYCODE_VOLUME_UP:
                if (mScreenBrightness < (255 - ratio)) {
    
    
                    mScreenBrightness += ratio;
                } else {
    
    
                    mScreenBrightness = 255;
                }
                Log.e("Up >>>", "onKeyDown: " + mScreenBrightness);
                setWindowBrightness(mScreenBrightness);
                updateNum(mScreenBrightness);
                return true;
           /* case KeyEvent.KEYCODE_VOLUME_MUTE:

                return true;*/
        }
        return super.onKeyDown(keyCode, event);
    }

---

operación completa

• Java

/**
 * @author 拉莫帅
 * @date 2023/2/8
 * @address
 * @Desc 修改系统亮度
 */
public class BrightActivity extends Activity {
    
    

    /**
     * 非系统签名应用，引导用户手动授权修改Settings 权限
     **/
    private int mRequestCode = 1;

    private SeekBar brightBar;

    //当前屏幕亮度
    private int mScreenBrightness = 0;

    //每次加减的比例
    private int ratio = 25;

    private ContentObserver mBrightnessObserver = new ContentObserver(new Handler()) {
    
    
        @Override
        public void onChange(boolean selfChange) {
    
    
            super.onChange(selfChange);

            ContentResolver contentResolver = getContentResolver();
            if (contentResolver != null) {
    
    
                mScreenBrightness = getScreenBrightness(BrightActivity.this);
                Log.e("监听亮度 >>>", "init: " + mScreenBrightness);
                updateNum(mScreenBrightness);
                setWindowBrightness(mScreenBrightness);
            }
        }
    };

    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_bright);

        init();
        registerContentObserver();
        setListener();
    }

    private void init() {
    
    
        brightBar = findViewById(R.id.brightBar);
        ImageView back = findViewById(R.id.back);
        TextView title = findViewById(R.id.title);
        title.setText("亮度");

        //获取当前亮度
        mScreenBrightness = getScreenBrightness(BrightActivity.this);
        Log.e("当前亮度 >>>", "init: " + mScreenBrightness);
        updateNum(mScreenBrightness);

        back.setOnClickListener(new View.OnClickListener() {
    
    
            @Override
            public void onClick(View v) {
    
    
                finish();
            }
        });
    }

    private void registerContentObserver() {
    
    
        ContentResolver contentResolver = getContentResolver();
        if (contentResolver != null) {
    
    
            contentResolver.registerContentObserver(Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS),
                    true,
                    mBrightnessObserver);
        }
    }

    @Override
    protected void onDestroy() {
    
    
        super.onDestroy();
        ContentResolver contentResolver = getContentResolver();
        if (contentResolver != null) {
    
    
            contentResolver.unregisterContentObserver((ContentObserver) mBrightnessObserver);
        }
    }

    private void setListener() {
    
    
        brightBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
    
    
            @RequiresApi(api = Build.VERSION_CODES.M)
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
    
    
                Log.e("动态屏幕亮度 >>>", "onProgressChanged: " + progress);
                mScreenBrightness = progress * ratio;
                if (Settings.System.canWrite(BrightActivity.this)) {
    
    
                    setScreenBrightness(mScreenBrightness);
                    updateNum(mScreenBrightness);
                } else {
    
    
                    Toast.makeText(BrightActivity.this, "没有修改权限", Toast.LENGTH_SHORT).show();

                    // 打开允许修改Setting 权限的界面
                    Intent intent = new Intent(
                            Settings.ACTION_MANAGE_WRITE_SETTINGS, Uri
                            .parse("package:"
                                    + getPackageName()));
                    startActivityForResult(intent,
                            mRequestCode);
                }
            }

            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {
    
    

            }

            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {
    
    

            }
        });
    }

    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    
    
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == mRequestCode) {
    
    
            if (Settings.System.canWrite((Context) BrightActivity.this)) {
    
    
                setScreenBrightness(mScreenBrightness);
                updateNum(mScreenBrightness);
            } else {
    
    
                Toast.makeText((Context) this, "您已拒绝修系统Setting的屏幕亮度权限", Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 获取app屏幕亮度
     *
     * @param activity
     * @return
     */
    public static int getScreenBrightness(Activity activity) {
    
    
        try {
    
    
            return Settings.System.getInt(activity.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS);
        } catch (Settings.SettingNotFoundException e) {
    
    
            e.printStackTrace();
        }

        return 0;
    }

    /**
     * 更新页面显示
     *
     * @param mScreenBrightness
     */
    private final void updateNum(int mScreenBrightness) {
    
    
        //四舍五入
        int i = (int) Math.floor(mScreenBrightness / ratio);
        brightBar.setProgress(i);
    }

    /**
     * 设置系统屏幕亮度，影响所有页面和app
     * 注意：这种方式是需要手动权限的（android.permission.WRITE_SETTINGS）
     */
    private final void setScreenBrightness(int brightness) {
    
    
        //先检测调节模式
        setScreenManualMode();
        //再设置
        Settings.System.putInt(getContentResolver(), Settings.System.SCREEN_BRIGHTNESS, brightness);
    }

    private final void setScreenManualMode() {
    
    
        try {
    
    
            //获取当前系统亮度调节模式
            int mode = Settings.System.getInt(getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE);
            //如果是自动，则改为手动
            if (mode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
    
    
                Settings.System.putInt(getContentResolver(),
                        Settings.System.SCREEN_BRIGHTNESS_MODE,
                        Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
            }
        } catch (Settings.SettingNotFoundException var2) {
    
    
            var2.printStackTrace();
        }

    }

    /**
     * 设置当前应用屏幕亮度，只当前有效
     */
    private final void setWindowBrightness(int brightness) {
    
    
        Window window = this.getWindow();
        WindowManager.LayoutParams lp = window.getAttributes();
        lp.screenBrightness = (float) brightness / 255.0F;
        window.setAttributes(lp);
    }

    //监听系统按键
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
    
    
        switch (keyCode) {
    
    
            case KeyEvent.KEYCODE_VOLUME_DOWN:
                if (mScreenBrightness > ratio) {
    
    
                    mScreenBrightness -= ratio;
                } else {
    
    
                    mScreenBrightness = 1;
                }
                Log.e("Down >>>", "onKeyDown: " + mScreenBrightness);
                setWindowBrightness(mScreenBrightness);
                updateNum(mScreenBrightness);
                return true;
            case KeyEvent.KEYCODE_VOLUME_UP:
                if (mScreenBrightness < (255 - ratio)) {
    
    
                    mScreenBrightness += ratio;
                } else {
    
    
                    mScreenBrightness = 255;
                }
                Log.e("Up >>>", "onKeyDown: " + mScreenBrightness);
                setWindowBrightness(mScreenBrightness);
                updateNum(mScreenBrightness);
                return true;
           /* case KeyEvent.KEYCODE_VOLUME_MUTE:

                return true;*/
        }
        return super.onKeyDown(keyCode, event);
    }
}

• kotlin

class BrightnessActivity : AppCompatActivity() {
    
    

    //当前屏幕亮度
    private var mScreenBrightness: Int = 0

    //每次加减的比例
    private var ratio: Int = 25

    private var mRequestCode = 1

    override fun onCreate(savedInstanceState: Bundle?) {
    
    
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_brightness)

        init()

        registerContentObserver()

        setListener()
    }

    private fun init() {
    
    
        mScreenBrightness = getScreenBrightness()
        updateNum(mScreenBrightness)
    }

    /**
     * 注册监听 系统屏幕亮度变化
     */
    private fun registerContentObserver() {
    
    
        this.contentResolver?.registerContentObserver(
            Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS),
            true,
            mBrightnessObserver
        )
    }

    /**
     * 监听系统亮度变化
     */
    private val mBrightnessObserver = object : ContentObserver(Handler(Looper.getMainLooper())) {
    
    
        override fun onChange(selfChange: Boolean) {
    
    
            super.onChange(selfChange)
            try {
    
    
                this@BrightnessActivity.contentResolver?.let {
    
    
                    mScreenBrightness = Settings.System.getInt(it, Settings.System.SCREEN_BRIGHTNESS)
                    updateNum(mScreenBrightness)
                    setWindowBrightness(mScreenBrightness)
                }
            } catch (e: SettingNotFoundException) {
    
    
                e.printStackTrace()
            }
        }
    }

    override fun onDestroy() {
    
    
        super.onDestroy()
        //注销监听
        this.contentResolver?.unregisterContentObserver(mBrightnessObserver)
    }

    private fun setListener() {
    
    
    	seekBar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
    
    
            override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
    
    
                Log.i("onProgressChanged----", "" + progress)
                mScreenBrightness = progress * ratio
                //判断是否有修改系统设置权限
                if (Settings.System.canWrite(this@BrightnessActivity)) {
    
    
                    setScreenBrightness(mScreenBrightness)
                    updateNum(mScreenBrightness)
                } else {
    
    
                    Toast.makeText(this@BrightnessActivity, "没有修改权限", Toast.LENGTH_SHORT).show()
                    // 打开允许修改系统设置权限的页面
                    val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS, Uri.parse("package:$packageName"))
                    startActivityForResult(intent, mRequestCode)
                }
            }

            override fun onStartTrackingTouch(seekBar: SeekBar?) {
    
    
            }

            override fun onStopTrackingTouch(seekBar: SeekBar?) {
    
    
            }
        })

    }

    /**
     * 处理返回结果
     */
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    
    
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == mRequestCode) {
    
    
            if (Settings.System.canWrite(this@BrightnessActivity)) {
    
    
                setScreenBrightness(mScreenBrightness)
                updateNum(mScreenBrightness)
            } else {
    
    
                Toast.makeText(this@BrightnessActivity, "拒绝了权限", Toast.LENGTH_SHORT).show()
            }
        }
    }

    /**
     * 更新页面显示
     */
    private fun updateNum(mScreenBrightness: Int) {
    
    
        //转float 取四舍五入
        val i: Int = (mScreenBrightness / (ratio.toFloat())).roundToInt()
        tv_brightness.text = i.toString()
        seekBar.progress = i
    }

    /**
     * 获取系统屏幕亮度(0-255)
     */
    private fun getScreenBrightness(): Int {
    
    
        try {
    
    
            return Settings.System.getInt(this.contentResolver, Settings.System.SCREEN_BRIGHTNESS)
        } catch (e: SettingNotFoundException) {
    
    
            e.printStackTrace()
        }
        return 0
    }

    /**
     * 设置系统屏幕亮度，影响所有页面和app
     * 注意：这种方式是需要手动权限的（android.permission.WRITE_SETTINGS）
     */
    private fun setScreenBrightness(brightness: Int) {
    
    
        try {
    
    
            //先检测调节模式
            setScreenManualMode()
            //再设置
            Settings.System.putInt(this.contentResolver, Settings.System.SCREEN_BRIGHTNESS, brightness)
        } catch (e: SettingNotFoundException) {
    
    
            e.printStackTrace()
        }
    }

    /**
     * 设置系统亮度调节模式(SCREEN_BRIGHTNESS_MODE)
     * SCREEN_BRIGHTNESS_MODE_MANUAL 手动调节
     * SCREEN_BRIGHTNESS_MODE_AUTOMATIC 自动调节
     */
    private fun setScreenManualMode() {
    
    
        try {
    
    
            //获取当前系统亮度调节模式
            val mode = Settings.System.getInt(this.contentResolver, Settings.System.SCREEN_BRIGHTNESS_MODE)
            //如果是自动，则改为手动
            if (mode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
    
    
                Settings.System.putInt(
                    this.contentResolver,
                    Settings.System.SCREEN_BRIGHTNESS_MODE,
                    Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL
                )
            }
        } catch (e: SettingNotFoundException) {
    
    
            e.printStackTrace()
        }
    }

    /**
     * 设置当前应用屏幕亮度，只当前有效
     */
    private fun setWindowBrightness(brightness: Int) {
    
    
        val window = window
        val lp = window.attributes
        lp.screenBrightness = brightness / 255.0f
        window.attributes = lp
    }
}

---

Recientemente, me tomé un descanso de mi apretada agenda, ↓↓↓↓[¿Quién es De Code Farmer, el Sr. Chen?]↓↓↓↓, ¡compartiré publicaciones de blog técnicas y contenido de información de alta energía con ustedes regularmente! ¡Bienvenidos a todos los jefes a que les gusten y sigan, son mi fuente de motivación!