diff --git a/misc/dsg-configs/org.deepin.dde.daemon.power.json b/misc/dsg-configs/org.deepin.dde.daemon.power.json index 6a7a103fa..bbdce7b50 100644 --- a/misc/dsg-configs/org.deepin.dde.daemon.power.json +++ b/misc/dsg-configs/org.deepin.dde.daemon.power.json @@ -250,6 +250,398 @@ "description": "延时调用HandleIdleOff时间间隔，单位ms", "permissions": "readwrite", "visibility": "public" + }, + "linePowerScreensaverDelay": { + "value": 0, + "serial": 0, + "flags": [ + "global" + ], + "name": "linePowerScreensaverDelay", + "name[zh_CN]": "插电时显示屏保的超时时间", + "description": "line power screen saver delay", + "permissions": "readwrite", + "visibility": "public" + }, + "batteryScreensaverDelay": { + "value": 0, + "serial": 0, + "flags": [ + "global" + ], + "name": "batteryScreensaverDelay", + "name[zh_CN]": "使用电池时显示屏保的超时时间", + "description": "battery screen saver delay", + "permissions": "readwrite", + "visibility": "public" + }, + "batteryScreenBlackDelay": { + "value": 300, + "serial": 0, + "flags": [ + "global" + ], + "name": "batteryScreenBlackDelay", + "name[zh_CN]": "使用电池时的屏幕黑屏延时", + "description": "battery screen black delay", + "permissions": "readwrite", + "visibility": "public" + }, + "batterySleepDelay": { + "value": 900, + "serial": 0, + "flags": [ + "global" + ], + "name": "batterySleepDelay", + "name[zh_CN]": "使用电池时的休眠延时", + "description": "battery sleep delay", + "permissions": "readwrite", + "visibility": "public" + }, + "linePowerScreenBlackDelay": { + "value": 900, + "serial": 0, + "flags": [ + "global" + ], + "name": "linePowerScreenBlackDelay", + "name[zh_CN]": "插电时屏幕黑屏延时", + "description": "line power screen black delay", + "permissions": "readwrite", + "visibility": "public" + }, + "linePowerSleepDelay": { + "value": 1800, + "serial": 0, + "flags": [ + "global" + ], + "name": "linePowerSleepDelay", + "name[zh_CN]": "插电时休眠延时", + "description": "line power sleep delay", + "permissions": "readwrite", + "visibility": "public" + }, + "linePowerLockDelay": { + "value": 900, + "serial": 0, + "flags": [ + "global" + ], + "name": "linePowerLockDelay", + "name[zh_CN]": "插电时锁屏延时", + "description": "line power lock delay", + "permissions": "readwrite", + "visibility": "public" + }, + "batteryLockDelay": { + "value": 300, + "serial": 0, + "flags": [ + "global" + ], + "name": "batteryLockDelay", + "name[zh_CN]": "使用电池时锁屏延时", + "description": "battery lock delay", + "permissions": "readwrite", + "visibility": "public" + }, + "adjustBrightnessEnabled": { + "value": false, + "serial": 0, + "flags": [ + "global" + ], + "name": "adjustBrightnessEnabled", + "name[zh_CN]": "启用自动调节亮度", + "description": "adjust display brigtness enabled", + "permissions": "readwrite", + "visibility": "public" + }, + "ambientLightAdjustBrightness": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "ambientLightAdjustBrightness", + "name[zh_CN]": "通过环境光自动调节亮度", + "description": "auto adjust backlight brightness according to ambient light intensity", + "permissions": "readwrite", + "visibility": "public" + }, + "screenBlackLock": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "screenBlackLock", + "name[zh_CN]": "关闭屏幕前锁定", + "description": "screen black lock", + "permissions": "readwrite", + "visibility": "public" + }, + "sleepLock": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "sleep lock", + "name[zh_CN]": "睡眠前锁定", + "description": "sleep lock", + "permissions": "readwrite", + "visibility": "public" + }, + "lidClosedSleep": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "lidClosedSleep", + "name[zh_CN]": "插电时合盖休眠", + "description": "Sleep when close the lid if use line power", + "permissions": "readwrite", + "visibility": "public" + }, + "batteryLidClosedSleep": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "batteryLidClosedSleep", + "name[zh_CN]": "使用电池时合盖休眠", + "description": "Sleep when close the lid if use battery", + "permissions": "readwrite", + "visibility": "public" + }, + "powerButtonPressedExec": { + "value": "dde-shutdown", + "serial": 0, + "flags": [ + "global" + ], + "name": "powerButtonPressedExec", + "name[zh_CN]": "电源键按下执行的命令", + "description": "power button pressed exec", + "permissions": "readwrite", + "visibility": "public" + }, + "fullscreenWorkaroundAppList": { + "value": ["libflash", "chrome", "firefox","mplayer", "operaplugin", "soffice", "wpp", "evince", "vlc", "totem"], + "serial": 0, + "flags": [ + "global" + ], + "name": "fullscreenWorkaroundAppList", + "name[zh_CN]": "全屏工作模式应用列表", + "description": "app in list fullscreen inhbit screensaver", + "permissions": "readwrite", + "visibility": "public" + }, + "usePercentageForPolicy": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "usePercentageForPolicy", + "name[zh_CN]": "使用基于电池百分比的策略", + "description": "Whether battery percentage based policy should be used. It should work around broken firmwares. It is also more reliable than the time left.", + "permissions": "readwrite", + "visibility": "public" + }, + "powerModuleInitialized": { + "value": false, + "serial": 0, + "flags": [ + "global" + ], + "name": "powerModuleInitialized", + "name[zh_CN]": "电源模块是否初始化", + "description": "power module initialized", + "permissions": "readwrite", + "visibility": "public" + }, + "lowPowerNotifyThreshold": { + "value": 20, + "serial": 0, + "flags": [ + "global" + ], + "name": "lowPowerNotifyThreshold", + "name[zh_CN]": "低电量通知阈值", + "description": "low power notify threshold", + "permissions": "readwrite" + }, + "lowPowerAction": { + "value": 1, + "serial": 0, + "flags": [ + "global" + ], + "name": "lowPowerAction", + "name[zh_CN]": "低电量时系统动作", + "description": "0: suspend, 1: hibernate", + "permissions": "readwrite" + }, + "percentageAction": { + "value": 5, + "serial": 0, + "flags": [ + "global" + ], + "name": "percentageAction", + "name[zh_CN]": "执行动作的百分比", + "description": "system action when battery low", + "permissions": "readwrite" + }, + "timeToEmptyLow": { + "value": 1200, + "serial": 0, + "flags": [ + "global" + ], + "name": "timeToEmptyLow", + "name[zh_CN]": "time to empty low", + "description": "time to empty low", + "permissions": "readwrite" + }, + "timeToEmptyDanger": { + "value": 900, + "serial": 0, + "flags": [ + "global" + ], + "name": "timeToEmptyDanger", + "name[zh_CN]": "time to empty low", + "description": "time to empty low", + "permissions": "readwrite" + }, + "timeToEmptyCritical": { + "value": 600, + "serial": 0, + "flags": [ + "global" + ], + "name": "timeToEmptyCritical", + "name[zh_CN]": "time to empty low", + "description": "time to empty low", + "permissions": "readwrite" + }, + "timeToEmptyAction": { + "value": 300, + "serial": 0, + "flags": [ + "global" + ], + "name": "timeToEmptyAction", + "name[zh_CN]": "system action when battery low", + "description": "system action when battery low", + "permissions": "readwrite" + }, + "linePowerLidClosedAction": { + "value": 1, + "serial": 0, + "flags": [ + "global" + ], + "name": "linePowerLidClosedAction", + "name[zh_CN]": "插电状态下合盖执行的动作", + "description": "0:shutdown, 1:suspend, 2:hibernate, 3:turnOffScreen, 4:showSessionUI, 5:doNothing", + "permissions": "readwrite" + }, + "linePowerPressPowerButton": { + "value": 4, + "serial": 0, + "flags": [ + "global" + ], + "name": "linePowerPressPowerButton", + "name[zh_CN]": "插电状态下按电源键的动作", + "description": "0:shutdown, 1:suspend, 2:hibernate, 3:turnOffScreen, 4:showSessionUI, 5:doNothing", + "permissions": "readwrite" + }, + "batteryLidClosedAction": { + "value": 1, + "serial": 0, + "flags": [ + "global" + ], + "name": "batteryLidClosedAction", + "name[zh_CN]": "使用电池时合盖执行的动作", + "description": "0:shutdown, 1:suspend, 2:hibernate, 3:turnOffScreen, 4:showSessionUI, 5:doNothing", + "permissions": "readwrite" + }, + "batteryPressPowerButton": { + "value": 4, + "serial": 0, + "flags": [ + "global" + ], + "name": "batteryPressPowerButton", + "name[zh_CN]": "使用电池时按电源键执行的动作", + "description": "0:shutdown, 1:suspend, 2:hibernate, 3:turnOffScreen, 4:showSessionUI, 5:doNothing", + "permissions": "readwrite" + }, + "lowPowerNotifyEnable": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "lowPowerNotifyEnable", + "name[zh_CN]": "低电量时打开系统通知", + "description": "enable system notify when low power", + "permissions": "readwrite" + }, + "saveBrightnessWhilePsm": { + "value": "", + "serial": 0, + "flags": [ + "global" + ], + "name": "saveBrightnessWhilePsm", + "name[zh_CN]": "省电模式时自动降低亮度", + "description": "brightness saved while power saving mode enabled", + "permissions": "readwrite" + }, + "lightSensorEnabled": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "lightSensorEnabled", + "name[zh_CN]": "光感应器开关", + "description": "light sensor enabled", + "permissions": "readwrite" + }, + "lowPowerPercentInUpdatingNotify": { + "value": 50, + "serial": 0, + "flags":[ + "global" + ], + "name": "lowPowerPercentInUpdatingNotify", + "name[zh_CN]": "更新系统时触发警告的电量", + "description": "low power percent in updating notify", + "permissions": "readwrite" + }, + "highPerformanceEnabled": { + "value": true, + "serial": 0, + "flags": [ + "global" + ], + "name": "highPerformanceEnabled", + "name[zh_CN]": "高性能模式开关", + "description": "high performance enabled", + "permissions": "readwrite" } } -} \ No newline at end of file +} diff --git a/session/power1/constant.go b/session/power1/constant.go index 96fa93212..3fcea1f0f 100644 --- a/session/power1/constant.go +++ b/session/power1/constant.go @@ -6,62 +6,64 @@ package power // nolint const ( - gsSchemaPower = "com.deepin.dde.power" - // settingKeys - settingKeyBatteryScreensaverDelay = "battery-screensaver-delay" - settingKeyBatteryScreenBlackDelay = "battery-screen-black-delay" - settingKeyBatterySleepDelay = "battery-sleep-delay" - settingKeyBatteryLockDelay = "battery-lock-delay" - - settingKeyLinePowerScreensaverDelay = "line-power-screensaver-delay" - settingKeyLinePowerScreenBlackDelay = "line-power-screen-black-delay" - settingKeyLinePowerSleepDelay = "line-power-sleep-delay" - settingKeyLinePowerLockDelay = "line-power-lock-delay" - - settingKeyAdjustBrightnessEnabled = "adjust-brightness-enabled" - settingKeyAmbientLightAdjuestBrightness = "ambient-light-adjust-brightness" - settingKeyScreenBlackLock = "screen-black-lock" - settingKeySleepLock = "sleep-lock" - - settingKeyLinePowerLidClosedAction = "line-power-lid-closed-action" - settingKeyLinePowerPressPowerBtnAction = "line-power-press-power-button" - settingKeyBatteryLidClosedAction = "battery-lid-closed-action" - settingKeyBatteryPressPowerBtnAction = "battery-press-power-button" - settingKeyLowPowerNotifyEnable = "low-power-notify-enable" - settingKeyLowPowerNotifyThreshold = "low-power-notify-threshold" - settingKeyLowPowerAutoSleepThreshold = "percentage-action" - settingKeyLowPowerAction = "low-power-action" - settingKeyBrightnessDropPercent = "brightness-drop-percent" - settingKeyPowerSavingEnabled = "power-saving-mode-enabled" - - settingKeyPowerButtonPressedExec = "power-button-pressed-exec" - - settingKeyFullScreenWorkaroundEnabled = "fullscreen-workaround-enabled" - settingKeyUsePercentageForPolicy = "use-percentage-for-policy" - - settingKeyLowPercentage = "percentage-low" - settingKeyDangerlPercentage = "percentage-danger" - settingKeyCriticalPercentage = "percentage-critical" - settingKeyActionPercentage = "percentage-action" - - settingKeyLowTime = "time-to-empty-low" - settingKeyDangerTime = "time-to-empty-danger" - settingKeyCriticalTime = "time-to-empty-critical" - settingKeyActionTime = "time-to-empty-action" - - settingKeySaveBrightnessWhilePsm = "save-brightness-while-psm" - - settingLightSensorEnabled = "light-sensor-enabled" - settingKeyMode = "mode" - - settingKeyHighPerformanceEnabled = "high-performance-enabled" - // cmd cmdDDELowPower = "/usr/lib/deepin-daemon/dde-lowpower" batteryDisplay = "Display" ) +// dconfig keys +const ( + dsettingLinePowerScreensaverDelay = "linePowerScreensaverDelay" + dsettingBatteryScreensaverDelay = "batteryScreensaverDelay" + dsettingPowerSavingModeBrightnessDropPercent = "powerSavingModeBrightnessDropPercent" + dsettingBatteryScreenBlackDelay = "batteryScreenBlackDelay" + dsettingBatterySleepDelay = "batterySleepDelay" + dsettingLinePowerScreenBlackDelay = "linePowerScreenBlackDelay" + dsettingLinePowerSleepDelay = "linePowerSleepDelay" + dsettingLinePowerLockDelay = "linePowerLockDelay" + dsettingBatteryLockDelay = "batteryLockDelay" + dsettingAdjustBrightnessEnabled = "adjustBrightnessEnabled" + dsettingAmbientLightAdjustBrightness = "ambientLightAdjustBrightness" + dsettingScreenBlackLock = "screenBlackLock" + dsettingSleepLock = "sleepLock" + dsettingLidClosedSleep = "lidClosedSleep" + dsettingBatteryLidClosedSleep = "batteryLidClosedSleep" + dsettingPowerButtonPressedExec = "powerButtonPressedExec" + dsettingFullscreenWorkaroundAppList = "fullscreenWorkaroundAppList" + dsettingUsePercentageForPolicy = "usePercentageForPolicy" + dsettingPowerModuleInitialized = "powerModuleInitialized" + dsettingLowPowerNotifyThreshold = "lowPowerNotifyThreshold" + dsettingLowPowerAction = "lowPowerAction" + dsettingPercentageAction = "percentageAction" + dsettingTimeToEmptyLow = "timeToEmptyLow" + dsettingTimeToEmptyDanger = "timeToEmptyDanger" + dsettingTimeToEmptyCritical = "timeToEmptyCritical" + dsettingTimeToEmptyAction = "timeToEmptyAction" + dsettingLinePowerLidClosedAction = "linePowerLidClosedAction" + dsettingLinePowerPressPowerButton = "linePowerPressPowerButton" + dsettingBatteryLidClosedAction = "batteryLidClosedAction" + dsettingBatteryPressPowerButton = "batteryPressPowerButton" + dsettingLowPowerNotifyEnable = "lowPowerNotifyEnable" + dsettingSaveBrightnessWhilePsm = "saveBrightnessWhilePsm" + dsettingLightSensorEnabled = "lightSensorEnabled" + dsettingLowPowerPercentInUpdatingNotify = "lowPowerPercentInUpdatingNotify" + dsettingHighPerformanceEnabled = "highPerformanceEnabled" + dsettingsPowerSavingModeEnabled = "powerSavingModeEnabled" + dsettingScheduledShutdownState = "scheduledShutdownState" + dsettingShutdownTime = "shutdownTime" + dsettingShutdownRepetition = "shutdownRepetition" + dsettingCustomShutdownWeekDays = "customShutdownWeekDays" + dsettingShutdownCountdown = "shutdownCountdown" + dsettingNextShutdownTime = "nextShutdownTime" +) + +const ( + DSettingsAppID = "org.deepin.dde.daemon" + DSettingsDisplayName = "org.deepin.Display" + DSettingsAutoChangeWm = "auto-change-deepin-wm" +) + const ( powerActionShutdown int32 = iota powerActionSuspend diff --git a/session/power1/daemon.go b/session/power1/daemon.go index 2ead2ecd2..10bccfe39 100644 --- a/session/power1/daemon.go +++ b/session/power1/daemon.go @@ -5,9 +5,10 @@ package power import ( + "os" + "github.com/linuxdeepin/dde-daemon/loader" "github.com/linuxdeepin/go-lib/log" - "os" ) var logger = log.NewLogger("daemon/session/power") diff --git a/session/power1/lid_switch.go b/session/power1/lid_switch.go index 1150aa542..07819a679 100644 --- a/session/power1/lid_switch.go +++ b/session/power1/lid_switch.go @@ -94,9 +94,9 @@ func (h *LidSwitchHandler) doLidStateChanged(state bool) { onBattery = h.manager.OnBattery var lidCloseAction int32 if onBattery { - lidCloseAction = m.BatteryLidClosedAction.Get() // 获取合盖操作 + lidCloseAction = m.BatteryLidClosedAction // 获取合盖操作 } else { - lidCloseAction = m.LinePowerLidClosedAction.Get() // 获取合盖操作 + lidCloseAction = m.LinePowerLidClosedAction // 获取合盖操作 } switch lidCloseAction { case powerActionShutdown: diff --git a/session/power1/manager.go b/session/power1/manager.go index 1e917f271..ae0b27351 100644 --- a/session/power1/manager.go +++ b/session/power1/manager.go @@ -8,6 +8,7 @@ import ( "encoding/json" "errors" "fmt" + dutils "github.com/linuxdeepin/go-lib/utils" "os" @@ -31,29 +32,13 @@ import ( DisplayManager "github.com/linuxdeepin/go-dbus-factory/system/org.freedesktop.DisplayManager" login1 "github.com/linuxdeepin/go-dbus-factory/system/org.freedesktop.login1" timedate "github.com/linuxdeepin/go-dbus-factory/system/org.freedesktop.timedate1" - gio "github.com/linuxdeepin/go-gir/gio-2.0" "github.com/linuxdeepin/go-lib/dbusutil" - "github.com/linuxdeepin/go-lib/dbusutil/gsprop" "github.com/linuxdeepin/go-lib/gettext" ) //go:generate dbusutil-gen -type Manager manager.go //go:generate dbusutil-gen em -type Manager,WarnLevelConfigManager -const ( - DSettingsAppID = "org.deepin.dde.daemon" - DSettingsDisplayName = "org.deepin.Display" - DSettingsAutoChangeWm = "auto-change-deepin-wm" - - // 定时关机 - dsettingScheduledShutdownState = "scheduledShutdownState" - dsettingShutdownTime = "shutdownTime" - dsettingShutdownRepetition = "shutdownRepetition" - dsettingCustomShutdownWeekDays = "customShutdownWeekDays" - dsettingShutdownCountdown = "shutdownCountdown" - dsettingNextShutdownTime = "nextShutdownTime" -) - const ( Once int = iota Everyday @@ -81,7 +66,6 @@ type Manager struct { systemSigLoop *dbusutil.SignalLoop syncConfig *dsync.Config helper *Helper - settings *gio.Settings warnLevelCountTicker *countTicker warnLevelConfig *WarnLevelConfigManager submodules map[string]submodule @@ -130,69 +114,74 @@ type Manager struct { // 是否有环境光传感器 HasAmbientLightSensor bool - // dbusutil-gen: ignore-below // 电池是否可用，是否存在 + + // dbusutil-gen: ignore BatteryIsPresent map[string]bool + // 电池电量百分比 + + // dbusutil-gen: ignore BatteryPercentage map[string]float64 + // 电池状态 + + // dbusutil-gen: ignore BatteryState map[string]uint32 // 接通电源时，不做任何操作，到显示屏保的时间 - LinePowerScreensaverDelay gsprop.Int `prop:"access:rw"` + LinePowerScreensaverDelay int `prop:"access:rw"` // 接通电源时，不做任何操作，到关闭屏幕的时间 - LinePowerScreenBlackDelay gsprop.Int `prop:"access:rw"` + LinePowerScreenBlackDelay int `prop:"access:rw"` // 接通电源时，不做任何操作，到睡眠的时间 - LinePowerSleepDelay gsprop.Int `prop:"access:rw"` + LinePowerSleepDelay int `prop:"access:rw"` // 使用电池时，不做任何操作，到显示屏保的时间 - BatteryScreensaverDelay gsprop.Int `prop:"access:rw"` + BatteryScreensaverDelay int `prop:"access:rw"` // 使用电池时，不做任何操作，到关闭屏幕的时间 - BatteryScreenBlackDelay gsprop.Int `prop:"access:rw"` + BatteryScreenBlackDelay int `prop:"access:rw"` // 使用电池时，不做任何操作，到睡眠的时间 - BatterySleepDelay gsprop.Int `prop:"access:rw"` + BatterySleepDelay int `prop:"access:rw"` // 关闭屏幕前是否锁定 - ScreenBlackLock gsprop.Bool `prop:"access:rw"` + ScreenBlackLock bool `prop:"access:rw"` // 睡眠前是否锁定 - SleepLock gsprop.Bool `prop:"access:rw"` - - // 废弃 - LidClosedSleep gsprop.Bool `prop:"access:rw"` + SleepLock bool `prop:"access:rw"` // 接通电源时，笔记本电脑盖上盖子 待机（默认选择）、睡眠、关闭显示器、无任何操作 - LinePowerLidClosedAction gsprop.Enum `prop:"access:rw"` + LinePowerLidClosedAction int32 `prop:"access:rw"` // 接通电源时，按下电源按钮 关机（默认选择）、待机、睡眠、关闭显示器、无任何操作 - LinePowerPressPowerBtnAction gsprop.Enum `prop:"access:rw"` // keybinding中监听power按键事件,获取gsettings的值 + LinePowerPressPowerBtnAction int32 `prop:"access:rw"` // keybinding中监听power按键事件,获取gsettings的值 // 使用电池时，笔记本电脑盖上盖子 待机（默认选择）、睡眠、关闭显示器、无任何操作 - BatteryLidClosedAction gsprop.Enum `prop:"access:rw"` + BatteryLidClosedAction int32 `prop:"access:rw"` // 使用电池时，按下电源按钮 关机（默认选择）、待机、睡眠、关闭显示器、无任何操作 - BatteryPressPowerBtnAction gsprop.Enum `prop:"access:rw"` // keybinding中监听power按键事件,获取gsettings的值 + BatteryPressPowerBtnAction int32 `prop:"access:rw"` // keybinding中监听power按键事件,获取gsettings的值 // 接通电源时，不做任何操作，到自动锁屏的时间 - LinePowerLockDelay gsprop.Int `prop:"access:rw"` + LinePowerLockDelay int `prop:"access:rw"` // 使用电池时，不做任何操作，到自动锁屏的时间 - BatteryLockDelay gsprop.Int `prop:"access:rw"` + BatteryLockDelay int `prop:"access:rw"` // 打开电量通知 - LowPowerNotifyEnable gsprop.Bool `prop:"access:rw"` // 开启后默认当电池仅剩余达到电量水平低时（默认15%）发出系统通知“电池电量低，请连接电源”； + LowPowerNotifyEnable bool `prop:"access:rw"` // 开启后默认当电池仅剩余达到电量水平低时（默认15%）发出系统通知“电池电量低，请连接电源”； // 当电池仅剩余为设置低电量时（默认5%），发出系统通知“电池电量耗尽”，进入待机模式； // 电池低电量通知百分比 - LowPowerNotifyThreshold gsprop.Int `prop:"access:rw"` // 设置电量低提醒的阈值，可设置范围10%-25%，默认为20% + LowPowerNotifyThreshold int32 `prop:"access:rw"` // 设置电量低提醒的阈值，可设置范围10%-25%，默认为20% // 自动待机电量百分比 - LowPowerAutoSleepThreshold gsprop.Int `prop:"access:rw"` // 设置电池电量进入待机模式（s3）的阈值，可设置范围为1%-9%，默认为5%（范围待确定） + LowPowerAutoSleepThreshold int32 `prop:"access:rw"` // 设置电池电量进入待机模式（s3）的阈值，可设置范围为1%-9%，默认为5%（范围待确定） // 低电量操作 - LowPowerAction gsprop.Enum `prop:"access:rw"` + LowPowerAction int32 `prop:"access:rw"` - savingModeBrightnessDropPercent gsprop.Int // 用来接收和保存来自system power中降低的屏幕亮度值 + savingModeBrightnessDropPercent int32 // 用来接收和保存来自system power中降低的屏幕亮度值 - AmbientLightAdjustBrightness gsprop.Bool `prop:"access:rw"` + AmbientLightAdjustBrightness bool `prop:"access:rw"` + // dbusutil-gen: ignore-below ambientLightClaimed bool lightLevelUnit string @@ -259,34 +248,8 @@ func newManager(service *dbusutil.Service) (*Manager, error) { return nil, err } - m.settings = gio.NewSettings(gsSchemaPower) - m.warnLevelConfig = NewWarnLevelConfigManager(m.settings) - - m.LinePowerScreensaverDelay.Bind(m.settings, settingKeyLinePowerScreensaverDelay) - m.LinePowerScreenBlackDelay.Bind(m.settings, settingKeyLinePowerScreenBlackDelay) - m.LinePowerSleepDelay.Bind(m.settings, settingKeyLinePowerSleepDelay) - m.LinePowerLockDelay.Bind(m.settings, settingKeyLinePowerLockDelay) - m.BatteryScreensaverDelay.Bind(m.settings, settingKeyBatteryScreensaverDelay) - m.BatteryScreenBlackDelay.Bind(m.settings, settingKeyBatteryScreenBlackDelay) - m.BatterySleepDelay.Bind(m.settings, settingKeyBatterySleepDelay) - m.BatteryLockDelay.Bind(m.settings, settingKeyBatteryLockDelay) - m.ScreenBlackLock.Bind(m.settings, settingKeyScreenBlackLock) - m.SleepLock.Bind(m.settings, settingKeySleepLock) - - m.LinePowerLidClosedAction.Bind(m.settings, settingKeyLinePowerLidClosedAction) - m.LinePowerPressPowerBtnAction.Bind(m.settings, settingKeyLinePowerPressPowerBtnAction) - m.BatteryLidClosedAction.Bind(m.settings, settingKeyBatteryLidClosedAction) - m.BatteryPressPowerBtnAction.Bind(m.settings, settingKeyBatteryPressPowerBtnAction) - m.LowPowerNotifyEnable.Bind(m.settings, settingKeyLowPowerNotifyEnable) - m.LowPowerNotifyThreshold.Bind(m.settings, settingKeyLowPowerNotifyThreshold) - m.LowPowerAutoSleepThreshold.Bind(m.settings, settingKeyLowPowerAutoSleepThreshold) - m.LowPowerAction.Bind(m.settings, settingKeyLowPowerAction) - m.savingModeBrightnessDropPercent.Bind(m.settings, settingKeyBrightnessDropPercent) - m.initGSettingsConnectChanged() - m.AmbientLightAdjustBrightness.Bind(m.settings, - settingKeyAmbientLightAdjuestBrightness) - m.lightSensorEnabled = m.settings.GetBoolean(settingLightSensorEnabled) - m.gsHighPerformanceEnabled = m.settings.GetBoolean(settingKeyHighPerformanceEnabled) + m.warnLevelConfig = NewWarnLevelConfigManager(m) + m.warnLevelConfig.setChangeCallback(m.handleBatteryDisplayUpdate) power := m.helper.Power err = common.ActivateSysDaemonService(power.ServiceName_()) @@ -323,15 +286,6 @@ func newManager(service *dbusutil.Service) (*Manager, error) { // 初始化电源模式 m.systemPower = systemPower.NewPower(systemBus) - isHighPerformanceSupported, err := m.systemPower.IsHighPerformanceSupported().Get(0) - if err != nil { - logger.Warning("Get systemPower.IsHighPerformanceSupported err :", err) - } - m.setPropIsHighPerformanceSupported(isHighPerformanceSupported && m.settings.GetBoolean(settingKeyHighPerformanceEnabled)) - m.isPowerSaveSupported, err = m.systemPower.IsPowerSaveSupported().Get(0) - if err != nil { - logger.Warning("Get systemPower.IsPowerSaveSupported err :", err) - } // 绑定org.deepin.dde.Display1的DBus m.display = display.NewDisplay(sessionBus) @@ -480,17 +434,67 @@ func (m *Manager) init() { logger.Warning(err) } - m.warnLevelConfig.setChangeCallback(m.handleBatteryDisplayUpdate) - + m.initDsg() + m.initDConfigConnectChanged() m.initOnBatteryChangedHandler() m.initSubmodules() m.startSubmodules() m.inhibitLogind() - m.initDsg() + m.initDBusPropCallback() + + m.warnLevelConfig.initDsg() + m.warnLevelConfig.connectSettingsChanged() + + isHighPerformanceSupported, err := m.systemPower.IsHighPerformanceSupported().Get(0) + if err != nil { + logger.Warning("Get systemPower.IsHighPerformanceSupported err :", err) + } + + hignPerformanceEnabled, err := m.dsPowerConfigManager.Value(0, dsettingHighPerformanceEnabled) + if err != nil { + logger.Warning("Get systemPower.IsHighPerformanceEnabled err :", err) + } else { + m.setPropIsHighPerformanceSupported(isHighPerformanceSupported && hignPerformanceEnabled.Value().(bool)) + } + + m.isPowerSaveSupported, err = m.systemPower.IsPowerSaveSupported().Get(0) + if err != nil { + logger.Warning("Get systemPower.IsPowerSaveSupported err :", err) + } + // TODO: treeland 上idle暂未实现 + //if m.UseWayland { + // m.kwinHanleIdleOffCh = make(chan bool, 10) + // go m.listenEventToHandleIdleOff() + // + // go func() { + // for ch := range m.kwinHanleIdleOffCh { + // if ch { + // m.prepareSuspendLocker.Lock() + // // 如果系统处于suspend状态，不需要在上层通过鼠标键盘事件唤醒系统 + // if m.prepareSuspend >= suspendStatePrepare { + // m.prepareSuspendLocker.Unlock() + // continue + // } + // m.prepareSuspendLocker.Unlock() + // + // logger.Info("kwin handle idle off") + // + // if v := m.submodules[submodulePSP]; v != nil { + // if psp := v.(*powerSavePlan); psp != nil { + // psp.HandleIdleOff() + // } + // } + // } + // } + // }() + //} +} + +func (m *Manager) initDBusPropCallback() { so := m.service.GetServerObject(m) if so != nil { - err = so.SetWriteCallback(m, "ScheduledShutdownState", func(write *dbusutil.PropertyWrite) *dbus.Error { + err := so.SetWriteCallback(m, "ScheduledShutdownState", func(write *dbusutil.PropertyWrite) *dbus.Error { value, ok := write.Value.(bool) if !ok { logger.Warning("Type is not bool") @@ -498,7 +502,7 @@ func (m *Manager) init() { logger.Info("ScheduledShutdownState change to", value) } m.setPropScheduledShutdownState(value) - err = m.savePowerDsgConfig(dsettingScheduledShutdownState) + err := m.savePowerDsgConfig(dsettingScheduledShutdownState) return dbusutil.ToError(err) }) err = so.SetWriteCallback(m, "ShutdownTime", func(write *dbusutil.PropertyWrite) *dbus.Error { @@ -532,35 +536,236 @@ func (m *Manager) init() { err = m.savePowerDsgConfig(dsettingCustomShutdownWeekDays) return dbusutil.ToError(err) }) - } + err = so.SetWriteCallback(m, "LinePowerScreensaverDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("ShutdownRepetition change to", value) + } + m.setPropLinePowerScreensaverDelay(int(value)) + err = m.savePowerDsgConfig(dsettingLinePowerScreensaverDelay) + return dbusutil.ToError(err) + }) - // TODO: treeland 上idle暂未实现 - //if m.UseWayland { - // m.kwinHanleIdleOffCh = make(chan bool, 10) - // go m.listenEventToHandleIdleOff() - // - // go func() { - // for ch := range m.kwinHanleIdleOffCh { - // if ch { - // m.prepareSuspendLocker.Lock() - // // 如果系统处于suspend状态，不需要在上层通过鼠标键盘事件唤醒系统 - // if m.prepareSuspend >= suspendStatePrepare { - // m.prepareSuspendLocker.Unlock() - // continue - // } - // m.prepareSuspendLocker.Unlock() - // - // logger.Info("kwin handle idle off") - // - // if v := m.submodules[submodulePSP]; v != nil { - // if psp := v.(*powerSavePlan); psp != nil { - // psp.HandleIdleOff() - // } - // } - // } - // } - // }() - //} + err = so.SetWriteCallback(m, "BatteryScreensaverDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("ShutdownRepetition change to", value) + } + m.setPropBatteryScreensaverDelay(int(value)) + err = m.savePowerDsgConfig(dsettingBatteryScreensaverDelay) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LinePowerScreenBlackDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("LinePowerScreenBlackDelay change to", value) + } + m.setPropLinePowerScreenBlackDelay(int(value)) + err = m.savePowerDsgConfig(dsettingLinePowerScreenBlackDelay) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LinePowerSleepDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("LinePowerSleepDelay change to", value) + } + m.setPropLinePowerSleepDelay(int(value)) + err = m.savePowerDsgConfig(dsettingLinePowerSleepDelay) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LinePowerLockDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("LinePowerLockDelay change to", value) + } + m.setPropLinePowerLockDelay(int(value)) + err = m.savePowerDsgConfig(dsettingLinePowerLockDelay) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "BatteryScreenBlackDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("BatteryScreenBlackDelay change to", value) + } + m.setPropBatteryScreenBlackDelay(int(value)) + err = m.savePowerDsgConfig(dsettingBatteryScreenBlackDelay) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "BatterySleepDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("BatterySleepDelay change to", value) + } + m.setPropBatterySleepDelay(int(value)) + err = m.savePowerDsgConfig(dsettingBatterySleepDelay) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "BatteryLockDelay", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("BatteryLockDelay change to", value) + } + m.setPropBatteryLockDelay(int(value)) + err = m.savePowerDsgConfig(dsettingBatteryLockDelay) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "ScreenBlackLock", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(bool) + if !ok { + logger.Warning("Type is not bool") + } else { + logger.Info("ScreenBlackLock change to", value) + } + m.setPropScreenBlackLock(value) + err = m.savePowerDsgConfig(dsettingScreenBlackLock) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "SleepLock", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(bool) + if !ok { + logger.Warning("Type is not bool") + } else { + logger.Info("SleepLock change to", value) + } + m.setPropSleepLock(value) + err = m.savePowerDsgConfig(dsettingSleepLock) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LinePowerLidClosedAction", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("LinePowerLidClosedAction change to", value) + } + m.setPropLinePowerLidClosedAction(value) + err = m.savePowerDsgConfig(dsettingLinePowerLidClosedAction) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LinePowerPressPowerBtnAction", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("LinePowerPressPowerBtnAction change to", value) + } + m.setPropLinePowerPressPowerBtnAction(value) + m.LinePowerPressPowerBtnAction = value + err = m.savePowerDsgConfig(dsettingLinePowerPressPowerButton) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "BatteryLidClosedAction", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("BatteryLidClosedAction change to", value) + } + m.setPropBatteryLidClosedAction(value) + err = m.savePowerDsgConfig(dsettingBatteryLidClosedAction) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "BatteryPressPowerBtnAction", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("BatteryPressPowerBtnAction change to", value) + } + m.setPropBatteryPressPowerBtnAction(value) + err = m.savePowerDsgConfig(dsettingBatteryPressPowerButton) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LowPowerNotifyEnable", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(bool) + if !ok { + logger.Warning("Type is not bool") + } else { + logger.Info("LowPowerNotifyEnable change to", value) + } + m.setPropLowPowerNotifyEnable(value) + err = m.savePowerDsgConfig(dsettingLowPowerNotifyEnable) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LowPowerAction", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int") + } else { + logger.Info("LowPowerAction change to", value) + } + m.setPropLowPowerAction(value) + err = m.savePowerDsgConfig(dsettingLowPowerAction) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "AmbientLightAdjustBrightness", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(bool) + if !ok { + logger.Warning("Type is not bool") + } else { + logger.Info("AmbientLightAdjustBrightness change to", value) + } + m.setPropAmbientLightAdjustBrightness(value) + err = m.savePowerDsgConfig(dsettingAmbientLightAdjustBrightness) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LowPowerAutoSleepThreshold", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int32") + } else { + logger.Info("LowPowerAutoSleepThreshold change to", value) + } + m.setPropLowPowerAutoSleepThreshold(value) + err = m.savePowerDsgConfig(dsettingPercentageAction) + return dbusutil.ToError(err) + }) + + err = so.SetWriteCallback(m, "LowPowerNotifyThreshold", func(write *dbusutil.PropertyWrite) *dbus.Error { + value, ok := write.Value.(int32) + if !ok { + logger.Warning("Type is not int32") + } else { + logger.Info("LowPowerNotifyThreshold change to", value) + } + m.setPropLowPowerNotifyThreshold(value) + err = m.savePowerDsgConfig(dsettingLowPowerNotifyThreshold) + return dbusutil.ToError(err) + }) + + } } func (m *Manager) destroy() { @@ -594,30 +799,30 @@ func (m *Manager) Reset() *dbus.Error { logger.Debug("Reset settings") var settingKeys = []string{ - settingKeyLinePowerScreenBlackDelay, - settingKeyLinePowerSleepDelay, - settingKeyLinePowerLockDelay, - settingKeyLinePowerLidClosedAction, - settingKeyLinePowerPressPowerBtnAction, - - settingKeyBatteryScreenBlackDelay, - settingKeyBatterySleepDelay, - settingKeyBatteryLockDelay, - settingKeyBatteryLidClosedAction, - settingKeyBatteryPressPowerBtnAction, - - settingKeyScreenBlackLock, - settingKeySleepLock, - settingKeyPowerButtonPressedExec, - - settingKeyLowPowerNotifyEnable, - settingKeyLowPowerNotifyThreshold, - settingKeyLowPowerAutoSleepThreshold, - settingKeyBrightnessDropPercent, + dsettingLinePowerScreenBlackDelay, + dsettingLinePowerSleepDelay, + dsettingLinePowerLockDelay, + dsettingLinePowerLidClosedAction, + dsettingLinePowerPressPowerButton, + + dsettingBatteryScreenBlackDelay, + dsettingBatterySleepDelay, + dsettingBatteryLockDelay, + dsettingBatteryLidClosedAction, + dsettingBatteryPressPowerButton, + + dsettingScreenBlackLock, + dsettingSleepLock, + dsettingPowerButtonPressedExec, + + dsettingLowPowerNotifyEnable, + dsettingLowPowerNotifyThreshold, + dsettingPercentageAction, + dsettingPowerSavingModeBrightnessDropPercent, } for _, key := range settingKeys { logger.Debug("reset setting", key) - m.settings.Reset(key) + m.dsPowerConfigManager.Reset(0, key) } return nil } @@ -713,18 +918,86 @@ func (m *Manager) initDsg() { logger.Info("Set ScheduledShutdownState property", m.ScheduledShutdownState) } } + case dsettingPowerSavingModeBrightnessDropPercent: + m.savingModeBrightnessDropPercent = int32(transTypeToInt(data.Value(), 0)) + case dsettingLinePowerScreensaverDelay: + m.LinePowerScreensaverDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingBatteryScreensaverDelay: + m.BatteryScreensaverDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingBatteryScreenBlackDelay: + m.BatteryScreenBlackDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingBatterySleepDelay: + m.BatterySleepDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingLinePowerScreenBlackDelay: + m.LinePowerScreenBlackDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingLinePowerSleepDelay: + m.LinePowerSleepDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingLinePowerLockDelay: + m.LinePowerLockDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingBatteryLockDelay: + m.BatteryLockDelay = int(transTypeToInt(data.Value(), 0)) + case dsettingAmbientLightAdjustBrightness: + m.AmbientLightAdjustBrightness = data.Value().(bool) + case dsettingScreenBlackLock: + m.ScreenBlackLock = data.Value().(bool) + case dsettingSleepLock: + m.SleepLock = data.Value().(bool) + case dsettingLowPowerAction: + m.LowPowerAction = int32(transTypeToInt(data.Value(), 0)) + case dsettingLinePowerLidClosedAction: + m.LinePowerLidClosedAction = int32(transTypeToInt(data.Value(), 0)) + case dsettingLinePowerPressPowerButton: + m.LinePowerPressPowerBtnAction = int32(transTypeToInt(data.Value(), 0)) + case dsettingBatteryLidClosedAction: + m.BatteryLidClosedAction = int32(transTypeToInt(data.Value(), 0)) + case dsettingBatteryPressPowerButton: + m.BatteryPressPowerBtnAction = int32(transTypeToInt(data.Value(), 0)) + case dsettingLowPowerNotifyEnable: + m.LowPowerNotifyEnable = data.Value().(bool) + case dsettingLightSensorEnabled: + m.lightSensorEnabled = data.Value().(bool) + case dsettingHighPerformanceEnabled: + m.gsHighPerformanceEnabled = data.Value().(bool) + case dsettingLowPowerNotifyThreshold: + m.LowPowerNotifyThreshold = int32(transTypeToInt(data.Value(), 0)) + case dsettingPercentageAction: + m.LowPowerAutoSleepThreshold = int32(transTypeToInt(data.Value(), 0)) } + // m.scheduledShutdownSwitch(false, false) // m.scheduledShutdownSwitch(m.ScheduledShutdownState, false) } + getDsPowerConfig(dsettingPowerSavingModeBrightnessDropPercent, true) getDsPowerConfig(dsettingCustomShutdownWeekDays, true) getDsPowerConfig(dsettingShutdownCountdown, true) getDsPowerConfig(dsettingShutdownRepetition, true) getDsPowerConfig(dsettingShutdownTime, true) getDsPowerConfig(dsettingScheduledShutdownState, true) getDsPowerConfig(dsettingNextShutdownTime, true) + getDsPowerConfig(dsettingLinePowerScreensaverDelay, true) + getDsPowerConfig(dsettingBatteryScreensaverDelay, true) + getDsPowerConfig(dsettingBatteryScreenBlackDelay, true) + getDsPowerConfig(dsettingBatterySleepDelay, true) + getDsPowerConfig(dsettingLinePowerScreenBlackDelay, true) + getDsPowerConfig(dsettingLinePowerSleepDelay, true) + getDsPowerConfig(dsettingLinePowerLockDelay, true) + getDsPowerConfig(dsettingBatteryLockDelay, true) + getDsPowerConfig(dsettingAmbientLightAdjustBrightness, true) + getDsPowerConfig(dsettingScreenBlackLock, true) + getDsPowerConfig(dsettingSleepLock, true) + getDsPowerConfig(dsettingLowPowerAction, true) + getDsPowerConfig(dsettingLinePowerLidClosedAction, true) + getDsPowerConfig(dsettingLinePowerPressPowerButton, true) + getDsPowerConfig(dsettingBatteryLidClosedAction, true) + getDsPowerConfig(dsettingBatteryPressPowerButton, true) + getDsPowerConfig(dsettingLowPowerNotifyEnable, true) + getDsPowerConfig(dsettingLightSensorEnabled, true) + getDsPowerConfig(dsettingHighPerformanceEnabled, true) + getDsPowerConfig(dsettingLowPowerNotifyThreshold, true) + getDsPowerConfig(dsettingPercentageAction, true) + m.dsPowerConfigManager.InitSignalExt(m.systemSigLoop, true) m.dsPowerConfigManager.ConnectValueChanged(func(key string) { if key == dsettingNextShutdownTime { @@ -769,6 +1042,50 @@ func (m *Manager) savePowerDsgConfig(key string) (err error) { value = m.ShutdownTime case dsettingScheduledShutdownState: value = m.ScheduledShutdownState + case dsettingPowerSavingModeBrightnessDropPercent: + value = m.savingModeBrightnessDropPercent + case dsettingLinePowerScreensaverDelay: + value = m.LinePowerScreensaverDelay + case dsettingBatteryScreensaverDelay: + value = m.BatteryScreensaverDelay + case dsettingBatteryScreenBlackDelay: + value = m.BatteryScreenBlackDelay + case dsettingBatterySleepDelay: + value = m.BatterySleepDelay + case dsettingLinePowerScreenBlackDelay: + value = m.LinePowerScreenBlackDelay + case dsettingLinePowerSleepDelay: + value = m.LinePowerSleepDelay + case dsettingLinePowerLockDelay: + value = m.LinePowerLockDelay + case dsettingBatteryLockDelay: + value = m.BatteryLockDelay + case dsettingAmbientLightAdjustBrightness: + value = m.AmbientLightAdjustBrightness + case dsettingScreenBlackLock: + value = m.ScreenBlackLock + case dsettingSleepLock: + value = m.SleepLock + case dsettingLowPowerAction: + value = m.LowPowerAction + case dsettingLinePowerLidClosedAction: + value = m.LinePowerLidClosedAction + case dsettingLinePowerPressPowerButton: + value = m.LinePowerPressPowerBtnAction + case dsettingBatteryLidClosedAction: + value = m.BatteryLidClosedAction + case dsettingBatteryPressPowerButton: + value = m.BatteryPressPowerBtnAction + case dsettingLowPowerNotifyEnable: + value = m.LowPowerNotifyEnable + case dsettingLightSensorEnabled: + value = m.lightSensorEnabled + case dsettingHighPerformanceEnabled: + value = m.gsHighPerformanceEnabled + case dsettingLowPowerNotifyThreshold: + value = m.LowPowerNotifyThreshold + case dsettingPercentageAction: + value = m.LowPowerAutoSleepThreshold } err = m.setDsgData(key, value, m.dsPowerConfigManager) if err != nil { @@ -782,6 +1099,9 @@ func (m *Manager) setDsgData(key string, value interface{}, dsg configManager.Ma if dsg == nil { return errors.New("setDsgData dsg is nil") } + if value == nil { + return errors.New("setDsgData value is nil") + } err := dsg.SetValue(0, key, dbus.MakeVariant(value)) if err != nil { logger.Warningf("setDsgData key : %s. err : %v", key, err) diff --git a/session/power1/manager_ambient_light.go b/session/power1/manager_ambient_light.go index 26605a5ce..b6fe35903 100644 --- a/session/power1/manager_ambient_light.go +++ b/session/power1/manager_ambient_light.go @@ -16,7 +16,7 @@ func (m *Manager) claimOrReleaseAmbientLight() { logger.Debug("call claimOrReleaseAmbientLight") var shouldClaim bool - autoAdjustEnabled := m.AmbientLightAdjustBrightness.Get() + autoAdjustEnabled := m.AmbientLightAdjustBrightness m.PropsMu.RLock() if m.HasAmbientLightSensor && @@ -84,7 +84,7 @@ func (m *Manager) releaseAmbientLight() { } func (m *Manager) handleLightLevelChanged(lightLevel float64) { - if !m.AmbientLightAdjustBrightness.Get() { + if !m.AmbientLightAdjustBrightness { return } diff --git a/session/power1/manager_events.go b/session/power1/manager_events.go index b60537b46..0ae7de692 100644 --- a/session/power1/manager_events.go +++ b/session/power1/manager_events.go @@ -74,7 +74,7 @@ func (m *Manager) handleBeforeSuspend() { m.setDDEBlackScreenActive(true) if m.UseWayland { // 如果是treeland，并且待机休眠唤醒是需要解锁，则将session 给lock - if m.SleepLock.Get() { + if m.SleepLock { err := m.currentSession.Lock(0) if err != nil { logger.Warning("set session lock failed:", err) @@ -172,9 +172,9 @@ func (m *Manager) handleWakeupDDELowPowerCheck() { } m.setPropBatteryPercentage(percentage) - logger.Info(" PrepareForSleep(False) : wakeup, Battery percentage : ", percentage, m.BatteryPercentage[batteryDisplay], m.warnLevelConfig.ActionPercentage.Get()) + logger.Info(" PrepareForSleep(False) : wakeup, Battery percentage : ", percentage, m.BatteryPercentage[batteryDisplay], m.warnLevelConfig.ActionPercentage) - if percentage <= float64(m.warnLevelConfig.ActionPercentage.Get()) { + if percentage <= float64(m.warnLevelConfig.ActionPercentage) { return } } @@ -268,7 +268,7 @@ func (m *Manager) handleWarnLevelChanged(level WarnLevel) { m.warnLevelCountTicker = newCountTicker(time.Second, func(count int) { if count == 3 { // after 3 seconds, lock and then show dde low power - if m.SleepLock.Get() { + if m.SleepLock { m.lockWaitShow(5*time.Second, false) } } else if count == 4 { @@ -277,7 +277,7 @@ func (m *Manager) handleWarnLevelChanged(level WarnLevel) { // after 5 seconds, force suspend m.disableWarnLevelCountTicker() - if m.LowPowerAction.Get() == lowPowerActionSuspend { + if m.LowPowerAction == lowPowerActionSuspend { m.doSuspend() } else { m.doHibernate() diff --git a/session/power1/power_dbusutil.go b/session/power1/power_dbusutil.go index 596e3c447..c07adecac 100644 --- a/session/power1/power_dbusutil.go +++ b/session/power1/power_dbusutil.go @@ -119,6 +119,253 @@ func (v *Manager) emitPropChangedHasAmbientLightSensor(value bool) error { return v.service.EmitPropertyChanged(v, "HasAmbientLightSensor", value) } +func (v *Manager) setPropLinePowerScreensaverDelay(value int) (changed bool) { + if v.LinePowerScreensaverDelay != value { + v.LinePowerScreensaverDelay = value + v.emitPropChangedLinePowerScreensaverDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLinePowerScreensaverDelay(value int) error { + return v.service.EmitPropertyChanged(v, "LinePowerScreensaverDelay", value) +} + +func (v *Manager) setPropLinePowerScreenBlackDelay(value int) (changed bool) { + if v.LinePowerScreenBlackDelay != value { + v.LinePowerScreenBlackDelay = value + v.emitPropChangedLinePowerScreenBlackDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLinePowerScreenBlackDelay(value int) error { + return v.service.EmitPropertyChanged(v, "LinePowerScreenBlackDelay", value) +} + +func (v *Manager) setPropLinePowerSleepDelay(value int) (changed bool) { + if v.LinePowerSleepDelay != value { + v.LinePowerSleepDelay = value + v.emitPropChangedLinePowerSleepDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLinePowerSleepDelay(value int) error { + return v.service.EmitPropertyChanged(v, "LinePowerSleepDelay", value) +} + +func (v *Manager) setPropBatteryScreensaverDelay(value int) (changed bool) { + if v.BatteryScreensaverDelay != value { + v.BatteryScreensaverDelay = value + v.emitPropChangedBatteryScreensaverDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedBatteryScreensaverDelay(value int) error { + return v.service.EmitPropertyChanged(v, "BatteryScreensaverDelay", value) +} + +func (v *Manager) setPropBatteryScreenBlackDelay(value int) (changed bool) { + if v.BatteryScreenBlackDelay != value { + v.BatteryScreenBlackDelay = value + v.emitPropChangedBatteryScreenBlackDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedBatteryScreenBlackDelay(value int) error { + return v.service.EmitPropertyChanged(v, "BatteryScreenBlackDelay", value) +} + +func (v *Manager) setPropBatterySleepDelay(value int) (changed bool) { + if v.BatterySleepDelay != value { + v.BatterySleepDelay = value + v.emitPropChangedBatterySleepDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedBatterySleepDelay(value int) error { + return v.service.EmitPropertyChanged(v, "BatterySleepDelay", value) +} + +func (v *Manager) setPropScreenBlackLock(value bool) (changed bool) { + if v.ScreenBlackLock != value { + v.ScreenBlackLock = value + v.emitPropChangedScreenBlackLock(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedScreenBlackLock(value bool) error { + return v.service.EmitPropertyChanged(v, "ScreenBlackLock", value) +} + +func (v *Manager) setPropSleepLock(value bool) (changed bool) { + if v.SleepLock != value { + v.SleepLock = value + v.emitPropChangedSleepLock(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedSleepLock(value bool) error { + return v.service.EmitPropertyChanged(v, "SleepLock", value) +} + +func (v *Manager) setPropLinePowerLidClosedAction(value int32) (changed bool) { + if v.LinePowerLidClosedAction != value { + v.LinePowerLidClosedAction = value + v.emitPropChangedLinePowerLidClosedAction(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLinePowerLidClosedAction(value int32) error { + return v.service.EmitPropertyChanged(v, "LinePowerLidClosedAction", value) +} + +func (v *Manager) setPropLinePowerPressPowerBtnAction(value int32) (changed bool) { + if v.LinePowerPressPowerBtnAction != value { + v.LinePowerPressPowerBtnAction = value + v.emitPropChangedLinePowerPressPowerBtnAction(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLinePowerPressPowerBtnAction(value int32) error { + return v.service.EmitPropertyChanged(v, "LinePowerPressPowerBtnAction", value) +} + +func (v *Manager) setPropBatteryLidClosedAction(value int32) (changed bool) { + if v.BatteryLidClosedAction != value { + v.BatteryLidClosedAction = value + v.emitPropChangedBatteryLidClosedAction(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedBatteryLidClosedAction(value int32) error { + return v.service.EmitPropertyChanged(v, "BatteryLidClosedAction", value) +} + +func (v *Manager) setPropBatteryPressPowerBtnAction(value int32) (changed bool) { + if v.BatteryPressPowerBtnAction != value { + v.BatteryPressPowerBtnAction = value + v.emitPropChangedBatteryPressPowerBtnAction(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedBatteryPressPowerBtnAction(value int32) error { + return v.service.EmitPropertyChanged(v, "BatteryPressPowerBtnAction", value) +} + +func (v *Manager) setPropLinePowerLockDelay(value int) (changed bool) { + if v.LinePowerLockDelay != value { + v.LinePowerLockDelay = value + v.emitPropChangedLinePowerLockDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLinePowerLockDelay(value int) error { + return v.service.EmitPropertyChanged(v, "LinePowerLockDelay", value) +} + +func (v *Manager) setPropBatteryLockDelay(value int) (changed bool) { + if v.BatteryLockDelay != value { + v.BatteryLockDelay = value + v.emitPropChangedBatteryLockDelay(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedBatteryLockDelay(value int) error { + return v.service.EmitPropertyChanged(v, "BatteryLockDelay", value) +} + +func (v *Manager) setPropLowPowerNotifyEnable(value bool) (changed bool) { + if v.LowPowerNotifyEnable != value { + v.LowPowerNotifyEnable = value + v.emitPropChangedLowPowerNotifyEnable(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLowPowerNotifyEnable(value bool) error { + return v.service.EmitPropertyChanged(v, "LowPowerNotifyEnable", value) +} + +func (v *Manager) setPropLowPowerNotifyThreshold(value int32) (changed bool) { + if v.LowPowerNotifyThreshold != value { + v.LowPowerNotifyThreshold = value + v.emitPropChangedLowPowerNotifyThreshold(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLowPowerNotifyThreshold(value int32) error { + return v.service.EmitPropertyChanged(v, "LowPowerNotifyThreshold", value) +} + +func (v *Manager) setPropLowPowerAutoSleepThreshold(value int32) (changed bool) { + if v.LowPowerAutoSleepThreshold != value { + v.LowPowerAutoSleepThreshold = value + v.emitPropChangedLowPowerAutoSleepThreshold(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLowPowerAutoSleepThreshold(value int32) error { + return v.service.EmitPropertyChanged(v, "LowPowerAutoSleepThreshold", value) +} + +func (v *Manager) setPropLowPowerAction(value int32) (changed bool) { + if v.LowPowerAction != value { + v.LowPowerAction = value + v.emitPropChangedLowPowerAction(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedLowPowerAction(value int32) error { + return v.service.EmitPropertyChanged(v, "LowPowerAction", value) +} + +func (v *Manager) setPropAmbientLightAdjustBrightness(value bool) (changed bool) { + if v.AmbientLightAdjustBrightness != value { + v.AmbientLightAdjustBrightness = value + v.emitPropChangedAmbientLightAdjustBrightness(value) + return true + } + return false +} + +func (v *Manager) emitPropChangedAmbientLightAdjustBrightness(value bool) error { + return v.service.EmitPropertyChanged(v, "AmbientLightAdjustBrightness", value) +} + func (v *Manager) setPropIsHighPerformanceSupported(value bool) (changed bool) { if v.IsHighPerformanceSupported != value { v.IsHighPerformanceSupported = value diff --git a/session/power1/power_save_plan.go b/session/power1/power_save_plan.go index d701ec47e..f68bb6557 100644 --- a/session/power1/power_save_plan.go +++ b/session/power1/power_save_plan.go @@ -13,13 +13,9 @@ import ( "sync" "time" - gio "github.com/linuxdeepin/go-gir/gio-2.0" - "github.com/linuxdeepin/go-lib/dbusutil/gsprop" - "github.com/godbus/dbus/v5" ConfigManager "github.com/linuxdeepin/go-dbus-factory/org.desktopspec.ConfigManager" "github.com/linuxdeepin/go-lib/dbusutil" - "github.com/linuxdeepin/go-lib/gsettings" "github.com/linuxdeepin/go-lib/procfs" x "github.com/linuxdeepin/go-x11-client" xscreensaver "github.com/linuxdeepin/go-x11-client/ext/screensaver" @@ -56,7 +52,7 @@ type powerSavePlan struct { atomNetWMStateFocused x.Atom fullscreenWorkaroundAppList []string - brightnessSave gsprop.String + brightnessSave string multiBrightnessWithPsm *multiBrightnessWithPsm psmEnabledTime time.Time psmPercentChangedTime time.Time @@ -81,8 +77,18 @@ func newPowerSavePlan(manager *Manager) (string, submodule, error) { } } - p.fullscreenWorkaroundAppList = manager.settings.GetStrv( - "fullscreen-workaround-app-list") + fullscreenWorkaroundAppListConfig, err := manager.dsPowerConfigManager.Value(0, dsettingFullscreenWorkaroundAppList) + if err != nil { + logger.Warning(err) + } else { + variantValue := fullscreenWorkaroundAppListConfig.Value() + if variants, ok := variantValue.([]dbus.Variant); ok { + p.fullscreenWorkaroundAppList = make([]string, len(variants)) + for i, v := range variants { + p.fullscreenWorkaroundAppList[i] = v.Value().(string) + } + } + } err = p.initDsgConfig() if err != nil { @@ -96,28 +102,28 @@ func newPowerSavePlan(manager *Manager) (string, submodule, error) { // 监听 GSettings 值改变, 更新节电计划 func (psp *powerSavePlan) initSettingsChangedHandler() { m := psp.manager - gsettings.ConnectChanged(gsSchemaPower, "*", func(key string) { + m.dsPowerConfigManager.ConnectValueChanged(func(key string) { logger.Debug("setting changed", key) switch key { - case settingKeyLinePowerScreensaverDelay, - settingKeyLinePowerScreenBlackDelay, - settingKeyLinePowerLockDelay, - settingKeyLinePowerSleepDelay: + case dsettingLinePowerScreensaverDelay, + dsettingLinePowerScreenBlackDelay, + dsettingLinePowerLockDelay, + dsettingLinePowerSleepDelay: if !m.OnBattery { logger.Debug("Change OnLinePower plan") psp.OnLinePower() } - case settingKeyBatteryScreensaverDelay, - settingKeyBatteryScreenBlackDelay, - settingKeyBatteryLockDelay, - settingKeyBatterySleepDelay: + case dsettingBatteryScreensaverDelay, + dsettingBatteryScreenBlackDelay, + dsettingBatteryLockDelay, + dsettingBatterySleepDelay: if m.OnBattery { logger.Debug("Change OnBattery plan") psp.OnBattery() } - case settingKeyAmbientLightAdjuestBrightness: + case dsettingAmbientLightAdjustBrightness: psp.manager.claimOrReleaseAmbientLight() } }) @@ -126,17 +132,17 @@ func (psp *powerSavePlan) initSettingsChangedHandler() { func (psp *powerSavePlan) OnBattery() { logger.Debug("Use OnBattery plan") m := psp.manager - psp.Update(m.BatteryScreensaverDelay.Get(), m.BatteryLockDelay.Get(), - m.BatteryScreenBlackDelay.Get(), - m.BatterySleepDelay.Get()) + psp.Update(int32(m.BatteryScreensaverDelay), int32(m.BatteryLockDelay), + int32(m.BatteryScreenBlackDelay), + int32(m.BatterySleepDelay)) } func (psp *powerSavePlan) OnLinePower() { logger.Debug("Use OnLinePower plan") m := psp.manager - psp.Update(m.LinePowerScreensaverDelay.Get(), m.LinePowerLockDelay.Get(), - m.LinePowerScreenBlackDelay.Get(), - m.LinePowerSleepDelay.Get()) + psp.Update(int32(m.LinePowerScreensaverDelay), int32(m.LinePowerLockDelay), + int32(m.LinePowerScreenBlackDelay), + int32(m.LinePowerSleepDelay)) } func (psp *powerSavePlan) Reset() { @@ -155,15 +161,19 @@ func (psp *powerSavePlan) syncBrightnessData(value string) { if err != nil { logger.Warning(err) } - psp.brightnessSave.Set(value) + psp.brightnessSave = value } func (psp *powerSavePlan) Start() error { psp.Reset() psp.initSettingsChangedHandler() - gs := gio.NewSettings(gsSchemaPower) - psp.brightnessSave.Bind(gs, settingKeySaveBrightnessWhilePsm) + brightnessSaveConfig, e := psp.manager.dsPowerConfigManager.Value(0, dsettingSaveBrightnessWhilePsm) + if e != nil { + logger.Warning(e) + } else { + psp.brightnessSave = brightnessSaveConfig.Value().(string) + } psp.multiBrightnessWithPsm = newMultiBrightnessWithPsm() helper := psp.manager.helper @@ -229,7 +239,7 @@ func (psp *powerSavePlan) Start() error { if data != "" { psp.syncBrightnessData(data) state, _ := power.PowerSavingModeEnabled().Get(0) - psp.manager.settings.SetBoolean(settingKeyPowerSavingEnabled, state) + psp.manager.setDsgData(dsettingsPowerSavingModeEnabled, state, psp.manager.dsPowerConfigManager) } else { psp.dealWithPowerSavingModeWhenSystemBoot() } @@ -240,7 +250,13 @@ func (psp *powerSavePlan) Start() error { func (psp *powerSavePlan) dealWithPowerSavingModeWhenSystemBoot() { power := psp.manager.helper.Power newPowerSaveState, _ := power.PowerSavingModeEnabled().Get(0) - if newPowerSaveState != psp.manager.settings.GetBoolean(settingKeyPowerSavingEnabled) { + + powerSavingModeEnabled, err := psp.manager.dsPowerConfigManager.Value(0, dsettingsPowerSavingModeEnabled) + if err != nil { + logger.Warning(err) + return + } + if newPowerSaveState != powerSavingModeEnabled.Value().(bool) { psp.handlePowerSavingModeChanged(true, newPowerSaveState) } } @@ -287,7 +303,7 @@ func (psp *powerSavePlan) handlePowerSavingModeBrightnessDropPercentChanged(hasV psp.manager.PropsMu.RLock() hasLightSensor := psp.manager.HasAmbientLightSensor psp.manager.PropsMu.RUnlock() - if hasLightSensor && psp.manager.AmbientLightAdjustBrightness.Get() { + if hasLightSensor && psp.manager.AmbientLightAdjustBrightness { return } if !psp.manager.isSessionActive() { // 系统级的调节保证只有激活用户才能做逻辑 @@ -299,9 +315,9 @@ func (psp *powerSavePlan) handlePowerSavingModeBrightnessDropPercentChanged(hasV logger.Warning(err) return } - oldLowerBrightnessScale := float64(psp.manager.savingModeBrightnessDropPercent.Get()) + oldLowerBrightnessScale := float64(psp.manager.savingModeBrightnessDropPercent) newLowerBrightnessScale := float64(lowerValue) - psp.manager.savingModeBrightnessDropPercent.Set(int32(lowerValue)) + psp.manager.savingModeBrightnessDropPercent = int32(lowerValue) savingModeEnable, err := psp.manager.helper.Power.PowerSavingModeEnabled().Get(0) if err != nil { logger.Error("get current power savingMode state error : ", err) @@ -328,7 +344,7 @@ func (psp *powerSavePlan) handlePowerSavingModeChanged(hasValue bool, enabled bo } logger.Debug("power saving mode enabled changed to", enabled) - psp.manager.settings.SetBoolean(settingKeyPowerSavingEnabled, enabled) + psp.manager.setDsgData(dsettingsPowerSavingModeEnabled, enabled, psp.manager.dsPowerConfigManager) if !psp.manager.isSessionActive() { // 系统级的调节保证只有激活用户才能做逻辑 return @@ -347,7 +363,7 @@ func (psp *powerSavePlan) handlePowerSavingModeChanged(hasValue bool, enabled bo hasLightSensor := psp.manager.HasAmbientLightSensor psp.manager.PropsMu.RUnlock() - if hasLightSensor && psp.manager.AmbientLightAdjustBrightness.Get() { + if hasLightSensor && psp.manager.AmbientLightAdjustBrightness { return } @@ -356,7 +372,7 @@ func (psp *powerSavePlan) handlePowerSavingModeChanged(hasValue bool, enabled bo logger.Warning(err) return } - brightnessScale := float64(psp.manager.savingModeBrightnessDropPercent.Get()) + brightnessScale := float64(psp.manager.savingModeBrightnessDropPercent) for key, value := range brightnessTable { if enabled { value = psp.powerSavingModeBrightnessDrop(value, brightnessScale) @@ -373,7 +389,7 @@ func (psp *powerSavePlan) handlePowerSavingModeChanged(hasValue bool, enabled bo psp.setToBrightnessSave() psp.psmEnabledTime = time.Now() } else { - psp.brightnessSave.Set("") + psp.brightnessSave = "" } psp.manager.setAndSaveDisplayBrightness(brightnessTable) } @@ -561,8 +577,13 @@ func (psp *powerSavePlan) lock() { func (psp *powerSavePlan) screenBlack() { manager := psp.manager logger.Info("Start screen black") + adjustBrightnessConfig, err := manager.dsPowerConfigManager.Value(0, dsettingAdjustBrightnessEnabled) + if err != nil { + logger.Warning(err) + return + } - adjustBrightnessEnabled := manager.settings.GetBoolean(settingKeyAdjustBrightnessEnabled) + adjustBrightnessEnabled := adjustBrightnessConfig.Value().(bool) if adjustBrightnessEnabled { err := psp.saveCurrentBrightness() @@ -588,7 +609,7 @@ func (psp *powerSavePlan) screenBlack() { taskF := newDelayedTask("screenFullBlack", fullBlackTime, func() { psp.stopScreensaver() logger.Info("Screen full black") - if manager.ScreenBlackLock.Get() { + if manager.ScreenBlackLock { manager.lockWaitShow(5*time.Second, true) } @@ -703,7 +724,7 @@ func (psp *powerSavePlan) HandleIdleOn() { _, err := os.Stat("/etc/deepin/no_suspend") if err == nil { - if psp.manager.ScreenBlackLock.Get() { + if psp.manager.ScreenBlackLock { // m.setDPMSModeOn() // m.lockWaitShow(4 * time.Second) psp.manager.doLock(true) @@ -757,9 +778,9 @@ func (psp *powerSavePlan) handleIdleOff() { func (psp *powerSavePlan) HandleIdleOff() { var powerPressAction int32 if psp.manager.OnBattery { - powerPressAction = psp.manager.BatteryPressPowerBtnAction.Get() + powerPressAction = psp.manager.BatteryPressPowerBtnAction } else { - powerPressAction = psp.manager.LinePowerPressPowerBtnAction.Get() + powerPressAction = psp.manager.LinePowerPressPowerBtnAction } if powerPressAction == powerActionTurnOffScreen { @@ -811,7 +832,7 @@ func (psp *powerSavePlan) setBrightnessFromDisplay() { } func (psp *powerSavePlan) initMultiBrightnessWithPsm() { - b := psp.brightnessSave.Get() + b := psp.brightnessSave err := psp.multiBrightnessWithPsm.toObject(b) if err != nil { @@ -842,7 +863,7 @@ func (psp *powerSavePlan) setToBrightnessSave() { if err != nil { logger.Warning(err) } - psp.brightnessSave.Set(data) + psp.brightnessSave = data psp.manager.helper.Power.PowerSavingModeBrightnessData().Set(0, data) } diff --git a/session/power1/sync_config.go b/session/power1/sync_config.go index cffef0033..2c2107657 100644 --- a/session/power1/sync_config.go +++ b/session/power1/sync_config.go @@ -13,8 +13,8 @@ type syncConfig struct { func (sc *syncConfig) Get() (interface{}, error) { return &syncData{ Version: "1.0", - ScreenBlackLock: sc.m.ScreenBlackLock.Get(), - SleepLock: sc.m.SleepLock.Get(), + ScreenBlackLock: sc.m.ScreenBlackLock, + SleepLock: sc.m.SleepLock, }, nil } @@ -24,8 +24,8 @@ func (sc *syncConfig) Set(data []byte) error { if err != nil { return err } - sc.m.ScreenBlackLock.Set(v.ScreenBlackLock) - sc.m.SleepLock.Set(v.SleepLock) + sc.m.ScreenBlackLock = v.ScreenBlackLock + sc.m.SleepLock = v.SleepLock return nil } diff --git a/session/power1/utils.go b/session/power1/utils.go index 07a98ae61..b9a800200 100644 --- a/session/power1/utils.go +++ b/session/power1/utils.go @@ -14,7 +14,6 @@ import ( dbus "github.com/godbus/dbus/v5" "github.com/linuxdeepin/dde-api/soundutils" . "github.com/linuxdeepin/go-lib/gettext" - "github.com/linuxdeepin/go-lib/gsettings" "github.com/linuxdeepin/go-lib/pulse" "github.com/linuxdeepin/go-x11-client/ext/dpms" ) @@ -104,7 +103,7 @@ func (m *Manager) setDDEBlackScreenActive(active bool) { return } - if !m.SleepLock.Get() { + if !m.SleepLock { logger.Info("setDDEBlackScreenActive GSettings of sleep-lock is false, Not use dde black widget") return } @@ -437,7 +436,7 @@ func (m *Manager) doHibernateByFront() { } func (m *Manager) doTurnOffScreen() { - if m.ScreenBlackLock.Get() { + if m.ScreenBlackLock { logger.Info("Show lock") m.doLock(true) time.Sleep(1 * time.Second) @@ -494,7 +493,7 @@ func doCloseDDELowPower() { } func (m *Manager) sendNotify(icon, summary, body string) { - if !m.LowPowerNotifyEnable.Get() { + if !m.LowPowerNotifyEnable { logger.Info("notify switch is off ") return } @@ -585,41 +584,44 @@ func suspendPulseSources(suspend int) { } } -func (m *Manager) initGSettingsConnectChanged() { - const powerSettingsIcon = "preferences-system" - +func (m *Manager) initDConfigConnectChanged() { isIllegalAction := func(action int32) bool { return (action == powerActionHibernate && !m.canHibernate()) || (action == powerActionSuspend && !m.canSuspend()) } // 监听 session power 的属性的改变,并发送通知 - gsettings.ConnectChanged(gsSchemaPower, "*", func(key string) { + m.dsPowerConfigManager.ConnectValueChanged(func(key string) { logger.Debug("Power Settings Changed :", key) switch key { - case settingKeyLinePowerLidClosedAction: - value := m.LinePowerLidClosedAction.Get() + case dsettingLinePowerLidClosedAction: + value := m.LinePowerLidClosedAction if isIllegalAction(value) { break } - case settingKeyLinePowerPressPowerBtnAction: - value := m.LinePowerPressPowerBtnAction.Get() + case dsettingLinePowerPressPowerButton: + value := m.LinePowerPressPowerBtnAction if isIllegalAction(value) { break } - case settingKeyBatteryLidClosedAction: - value := m.BatteryLidClosedAction.Get() + case dsettingBatteryLidClosedAction: + value := m.BatteryLidClosedAction if isIllegalAction(value) { break } - case settingKeyBatteryPressPowerBtnAction: - value := m.BatteryPressPowerBtnAction.Get() + case dsettingBatteryPressPowerButton: + value := m.BatteryPressPowerBtnAction if isIllegalAction(value) { break } - case settingKeyHighPerformanceEnabled: + case dsettingHighPerformanceEnabled: // 根据systemPower::IsHighPerformanceEnabled GSetting::settingKeyHighPerformanceEnabled - bSettingKeyHighPerformanceEnabled := m.settings.GetBoolean(settingKeyHighPerformanceEnabled) + highPerformanceEnabled, err := m.dsPowerConfigManager.Value(0, dsettingHighPerformanceEnabled) + if err != nil { + logger.Warning(err) + return + } + bSettingKeyHighPerformanceEnabled := highPerformanceEnabled.Value().(bool) if bSettingKeyHighPerformanceEnabled == m.gsHighPerformanceEnabled { return } diff --git a/session/power1/warn_level_config.go b/session/power1/warn_level_config.go index 78ab1396f..be42485c9 100644 --- a/session/power1/warn_level_config.go +++ b/session/power1/warn_level_config.go @@ -8,9 +8,6 @@ import ( "time" dbus "github.com/godbus/dbus/v5" - gio "github.com/linuxdeepin/go-gir/gio-2.0" - "github.com/linuxdeepin/go-lib/dbusutil/gsprop" - "github.com/linuxdeepin/go-lib/gsettings" ) type warnLevelConfig struct { @@ -20,11 +17,11 @@ type warnLevelConfig struct { CriticalTime uint64 ActionTime uint64 LowPowerNotifyThreshold float64 - remindPercentage float64 + remindPercentage float64 // 废弃 LowPercentage float64 // 废弃 DangerPercentage float64 // 废弃 CriticalPercentage float64 // 废弃 - ActionPercentage float64 // 废弃 + ActionPercentage float64 } func (c *warnLevelConfig) isValid() bool { @@ -41,62 +38,89 @@ func (c *warnLevelConfig) isValid() bool { } type WarnLevelConfigManager struct { - UsePercentageForPolicy gsprop.Bool `prop:"access:rw"` - - LowTime gsprop.Int `prop:"access:rw"` - DangerTime gsprop.Int `prop:"access:rw"` - CriticalTime gsprop.Int `prop:"access:rw"` - ActionTime gsprop.Int `prop:"access:rw"` - - LowPowerNotifyThreshold gsprop.Int `prop:"access:rw"` - // LowPercentage、DangerPercentage、CriticalPercentage、ActionPercentage废弃 - // 这4个值不再提供可设置的方法 - LowPercentage gsprop.Int `prop:"access:rw"` // 废弃 - DangerPercentage gsprop.Int `prop:"access:rw"` // 废弃 - CriticalPercentage gsprop.Int `prop:"access:rw"` // 废弃 - ActionPercentage gsprop.Int `prop:"access:rw"` - - settings *gio.Settings + UsePercentageForPolicy bool `prop:"access:rw"` + + LowTime int64 `prop:"access:rw"` + DangerTime int64 `prop:"access:rw"` + CriticalTime int64 `prop:"access:rw"` + ActionTime int64 `prop:"access:rw"` + + LowPowerNotifyThreshold int64 `prop:"access:rw"` + + ActionPercentage int64 `prop:"access:rw"` + changeTimer *time.Timer changeCb func() + + powerManager *Manager } -func NewWarnLevelConfigManager(gs *gio.Settings) *WarnLevelConfigManager { +func NewWarnLevelConfigManager(manager *Manager) *WarnLevelConfigManager { + m := &WarnLevelConfigManager{} + m.powerManager = manager + return m +} - m := &WarnLevelConfigManager{ - settings: gs, +func (m *WarnLevelConfigManager) initDsg() { + needUpdateConfigKeys := []string{ + dsettingUsePercentageForPolicy, + dsettingTimeToEmptyLow, + dsettingTimeToEmptyDanger, + dsettingTimeToEmptyCritical, + dsettingTimeToEmptyAction, + dsettingPercentageAction, + dsettingLowPowerNotifyThreshold, } + for _, key := range needUpdateConfigKeys { + m.getConfig(key) + } + + m.powerManager.dsPowerConfigManager.ConnectValueChanged(func(key string) { + m.getConfig(key) + m.notifyChange() + }) +} - m.UsePercentageForPolicy.Bind(gs, settingKeyUsePercentageForPolicy) - m.LowTime.Bind(gs, settingKeyLowTime) - m.DangerTime.Bind(gs, settingKeyDangerTime) - m.CriticalTime.Bind(gs, settingKeyCriticalTime) - m.ActionTime.Bind(gs, settingKeyActionTime) +func (m *WarnLevelConfigManager) getConfig(key string) { + data, err := m.powerManager.dsPowerConfigManager.Value(0, key) - m.LowPowerNotifyThreshold.Bind(gs, settingKeyLowPowerNotifyThreshold) - m.LowPercentage.Bind(gs, settingKeyLowPercentage) // 废弃 - m.DangerPercentage.Bind(gs, settingKeyDangerlPercentage) // 废弃 - m.CriticalPercentage.Bind(gs, settingKeyCriticalPercentage) // 废弃 - m.ActionPercentage.Bind(gs, settingKeyActionPercentage) + if err != nil { + logger.Warning(err) + return + } - m.connectSettingsChanged() - return m + switch key { + case dsettingUsePercentageForPolicy: + m.UsePercentageForPolicy = data.Value().(bool) + case dsettingTimeToEmptyLow: + m.LowTime = data.Value().(int64) + case dsettingTimeToEmptyDanger: + m.DangerTime = data.Value().(int64) + case dsettingTimeToEmptyCritical: + m.CriticalTime = data.Value().(int64) + case dsettingTimeToEmptyAction: + m.ActionTime = data.Value().(int64) + case dsettingLowPowerNotifyThreshold: + m.LowPowerNotifyThreshold = data.Value().(int64) + case dsettingPercentageAction: + m.ActionPercentage = data.Value().(int64) + } } func (m *WarnLevelConfigManager) getWarnLevelConfig() *warnLevelConfig { return &warnLevelConfig{ - UsePercentageForPolicy: m.UsePercentageForPolicy.Get(), - LowTime: uint64(m.LowTime.Get()), - DangerTime: uint64(m.DangerTime.Get()), - CriticalTime: uint64(m.CriticalTime.Get()), - ActionTime: uint64(m.ActionTime.Get()), + UsePercentageForPolicy: m.UsePercentageForPolicy, + LowTime: uint64(m.LowTime), + DangerTime: uint64(m.DangerTime), + CriticalTime: uint64(m.CriticalTime), + ActionTime: uint64(m.ActionTime), - LowPowerNotifyThreshold: float64(m.LowPowerNotifyThreshold.Get()), + LowPowerNotifyThreshold: float64(m.LowPowerNotifyThreshold), remindPercentage: float64(25), LowPercentage: float64(20), DangerPercentage: float64(15), CriticalPercentage: float64(10), - ActionPercentage: float64(m.ActionPercentage.Get()), + ActionPercentage: float64(m.ActionPercentage), } } @@ -131,19 +155,15 @@ func (m *WarnLevelConfigManager) notifyChange() { } func (m *WarnLevelConfigManager) connectSettingsChanged() { - gsettings.ConnectChanged(gsSchemaPower, "*", func(key string) { + m.powerManager.dsPowerConfigManager.ConnectValueChanged(func(key string) { switch key { - case settingKeyUsePercentageForPolicy, - settingKeyLowPowerNotifyThreshold, - settingKeyLowPercentage, // 废弃 - settingKeyDangerlPercentage, // 废弃 - settingKeyCriticalPercentage, // 废弃 - settingKeyActionPercentage, - - settingKeyLowTime, - settingKeyDangerTime, - settingKeyCriticalTime, - settingKeyActionTime: + case dsettingUsePercentageForPolicy, + dsettingLowPowerNotifyThreshold, + dsettingPercentageAction, + dsettingTimeToEmptyLow, + dsettingTimeToEmptyDanger, + dsettingTimeToEmptyCritical, + dsettingTimeToEmptyAction: logger.Debug("key changed", key) m.notifyChange() @@ -153,17 +173,20 @@ func (m *WarnLevelConfigManager) connectSettingsChanged() { } func (m *WarnLevelConfigManager) Reset() *dbus.Error { - s := m.settings - s.Reset(settingKeyUsePercentageForPolicy) - s.Reset(settingKeyLowPowerNotifyThreshold) - s.Reset(settingKeyLowPercentage) // 废弃 - s.Reset(settingKeyDangerlPercentage) // 废弃 - s.Reset(settingKeyCriticalPercentage) // 废弃 - s.Reset(settingKeyActionPercentage) // 废弃 - s.Reset(settingKeyLowTime) - s.Reset(settingKeyDangerTime) - s.Reset(settingKeyCriticalTime) - s.Reset(settingKeyActionTime) + needResetConfigKeys := []string{ + dsettingUsePercentageForPolicy, + dsettingLowPowerNotifyThreshold, + dsettingPercentageAction, + dsettingTimeToEmptyLow, + dsettingTimeToEmptyDanger, + dsettingTimeToEmptyCritical, + dsettingTimeToEmptyAction, + } + + for _, key := range needResetConfigKeys { + m.powerManager.dsPowerConfigManager.Reset(0, key) + } + return nil }