Modify system settings for Android all-in-one research and development——screen brightness
Modification of system settings for Android all-in-one development———sound
Modification of system settings for Android all-in-one development——automatically lock the screen
foreword
Recently, I have been a little idle at work, so I took the time to summarize for you: Recently, I have been working on the development of an all-in-one app, which is suitable for medical channels.
The all-in-one machine went to the factory to customize the board and system. After looking for them, the app will be packaged into the system in the form of apk, and of course the boot logo will also be packaged.
In this version of the all-in-one machine, there is a function section that can change the system settings. I remember that I have summarized the Android call system settings before . If you are interested, you can take a look; this article will explain some functions 细分化.
But when calling the system settings, some system functions allow users to see the same functions as mobile phones, and some functions are not needed by us. Here we need to realize the function of modifying system permissions by ourselves .
Next, I will publish a series of articles about modifying system settings for all-in-one machine development . Welcome to learn and progress together!
screen brightness
The operation of modifying the system 屏幕亮度is quite common, and it 多媒体is generally involved in development to some extent.
Although it is difficult to see the effect display from the above picture, you can probably guess the specific implementation of the function, which is to control the percentage of brightness through seekBar.
高级If you want to implement the function of modifying the screen brightness, a privacy permission is involved here , and the user needs to be on the app settings page 手动授权.
Design ideas
-
AndroidManifest setting permissions;
-
Get system screen brightness;
-
Modify the screen brightness in the system Settings (register to monitor screen brightness changes), affecting all pages and apps;
3.1 Judgment authority
3.2 Modify the screen brightness if necessary
3.3 Guide the user to authorize if there is none
Implementation
AndroidManifest setting permissions
<!-- 修改系统设置 -->
<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" />
Get system screen brightness
- 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
}
Modify the screen brightness in the system Settings, affecting all pages and apps
Register monitoring system screen brightness changes
- 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
)
}
Monitor system brightness changes
- Java
private ContentObserver mBrightnessObserver = new ContentObserver(new Handler()) {
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.contentResolver?.let {
mScreenBrightness = Settings.System.getInt(it, Settings.System.SCREEN_BRIGHTNESS)
updateNum(mScreenBrightness)
setWindowBrightness(mScreenBrightness)
}
} catch (e: SettingNotFoundException) {
e.printStackTrace()
}
}
}
logout listener
- Java
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)
}
Modify the screen brightness in the system Settings through seekBar
- Java
brightBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
(api = Build.VERSION_CODES.M)
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);
}
}
public void onStartTrackingTouch(SeekBar seekBar) {
}
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)) {
setScreenBrightness(mScreenBrightness)
updateNum(mScreenBrightness)
} else {
Toast.makeText(this, "没有修改权限", 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?) {
}
})
User authorized, set screen brightness
- 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()
}
}
monitor system button
//监听系统按键
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);
}
complete operation
- 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()) {
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);
}
}
};
(api = Build.VERSION_CODES.M)
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() {
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);
}
}
protected void onDestroy() {
super.onDestroy();
ContentResolver contentResolver = getContentResolver();
if (contentResolver != null) {
contentResolver.unregisterContentObserver((ContentObserver) mBrightnessObserver);
}
}
private void setListener() {
brightBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
(api = Build.VERSION_CODES.M)
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);
}
}
public void onStartTrackingTouch(SeekBar seekBar) {
}
public void onStopTrackingTouch(SeekBar seekBar) {
}
});
}
(api = Build.VERSION_CODES.M)
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);
}
//监听系统按键
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.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)) {
setScreenBrightness(mScreenBrightness)
updateNum(mScreenBrightness)
} else {
Toast.makeText(this, "没有修改权限", 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)) {
setScreenBrightness(mScreenBrightness)
updateNum(mScreenBrightness)
} else {
Toast.makeText(this, "拒绝了权限", 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
}
}
Recently, I took a break from my busy schedule, ↓↓↓↓[Who’s De Code Farmer Mr. Chen]↓↓↓↓, I will share technical blog posts and high-energy information content with you regularly! Welcome all bosses to like and follow, you are my source of motivation!