mirror of https://github.com/koreader/koreader
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
300 lines
13 KiB
Lua
300 lines
13 KiB
Lua
local ConfirmBox = require("ui/widget/confirmbox")
|
|
local Device = require("device")
|
|
local Event = require("ui/event")
|
|
local InfoMessage = require("ui/widget/infomessage")
|
|
local InputContainer = require("ui/widget/container/inputcontainer")
|
|
local Screen = Device.screen
|
|
local SpinWidget = require("ui/widget/spinwidget")
|
|
local UIManager = require("ui/uimanager")
|
|
local powerd = Device:getPowerDevice()
|
|
local _ = require("gettext")
|
|
local T = require("ffi/util").template
|
|
|
|
local ReaderDeviceStatus = InputContainer:new{
|
|
}
|
|
|
|
function ReaderDeviceStatus:init()
|
|
self.has_battery = powerd:getCapacity() > 0 or powerd:isCharging()
|
|
if self.has_battery then
|
|
self.battery_interval = G_reader_settings:readSetting("device_status_battery_interval") or 10
|
|
self.battery_threshold = G_reader_settings:readSetting("device_status_battery_threshold") or 20
|
|
self.checkLowBatteryLevel = function()
|
|
local battery_capacity = powerd:getCapacity()
|
|
if powerd:isCharging() then
|
|
powerd:setDismissBatteryStatus(false)
|
|
elseif powerd:getDismissBatteryStatus() ~= true and battery_capacity <= self.battery_threshold then
|
|
powerd:setDismissBatteryStatus(true)
|
|
UIManager:show(ConfirmBox:new {
|
|
text = T(_("Low battery level: %1%\n\nDismiss low battery alarm?"), battery_capacity),
|
|
ok_text = _("Dismiss"),
|
|
dismissable = false,
|
|
cancel_callback = function()
|
|
powerd:setDismissBatteryStatus(false)
|
|
end,
|
|
})
|
|
elseif powerd:getDismissBatteryStatus() and battery_capacity > self.battery_threshold then
|
|
powerd:setDismissBatteryStatus(false)
|
|
end
|
|
UIManager:scheduleIn(self.battery_interval * 60, self.checkLowBatteryLevel)
|
|
end
|
|
self:startBatteryChecker()
|
|
end
|
|
|
|
if not Device:isAndroid() then
|
|
self.memory_interval = G_reader_settings:readSetting("device_status_memory_interval") or 5
|
|
self.memory_threshold = G_reader_settings:readSetting("device_status_memory_threshold") or 100
|
|
self.checkHighMemoryUsage = function()
|
|
local statm = io.open("/proc/self/statm", "r")
|
|
if statm then
|
|
local dummy, rss = statm:read("*number", "*number")
|
|
statm:close()
|
|
rss = math.floor(rss * 4096 / 1024 / 1024)
|
|
if rss >= self.memory_threshold then
|
|
if Device:canRestart() then
|
|
if UIManager:getTopWidget() == "ReaderUI"
|
|
and G_reader_settings:isTrue("device_status_memory_auto_restart") then
|
|
UIManager:show(InfoMessage:new{
|
|
text = _("High memory usage!\n\nKOReader is restarting..."),
|
|
icon = "notice-warning",
|
|
})
|
|
UIManager:nextTick(function()
|
|
self.ui:handleEvent(Event:new("Restart"))
|
|
end)
|
|
else
|
|
UIManager:show(ConfirmBox:new {
|
|
text = T(_("High memory usage: %1 MB\n\nRestart KOReader?"), rss),
|
|
ok_text = _("Restart"),
|
|
dismissable = false,
|
|
ok_callback = function()
|
|
UIManager:show(InfoMessage:new{
|
|
text = _("High memory usage!\n\nKOReader is restarting..."),
|
|
icon = "notice-warning",
|
|
})
|
|
UIManager:nextTick(function()
|
|
self.ui:handleEvent(Event:new("Restart"))
|
|
end)
|
|
end,
|
|
})
|
|
end
|
|
else
|
|
UIManager:show(ConfirmBox:new {
|
|
text = T(_("High memory usage: %1 MB\n\nExit KOReader?"), rss),
|
|
ok_text = _("Exit"),
|
|
dismissable = false,
|
|
ok_callback = function()
|
|
self.ui:handleEvent(Event:new("Exit"))
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
UIManager:scheduleIn(self.memory_interval * 60, self.checkHighMemoryUsage)
|
|
end
|
|
self:startMemoryChecker()
|
|
end
|
|
|
|
self.ui.menu:registerToMainMenu(self)
|
|
end
|
|
|
|
function ReaderDeviceStatus:addToMainMenu(menu_items)
|
|
menu_items.device_status_alarm = {
|
|
text = _("Devise status alarm"),
|
|
sub_item_table = {},
|
|
}
|
|
if self.has_battery then
|
|
table.insert(menu_items.device_status_alarm.sub_item_table,
|
|
{
|
|
text = _("Low battery level"),
|
|
checked_func = function()
|
|
return G_reader_settings:isTrue("device_status_battery_alarm")
|
|
end,
|
|
callback = function()
|
|
G_reader_settings:flipNilOrFalse("device_status_battery_alarm")
|
|
if G_reader_settings:isTrue("device_status_battery_alarm") then
|
|
self:startBatteryChecker()
|
|
else
|
|
self:stopBatteryChecker()
|
|
powerd:setDismissBatteryStatus(false)
|
|
end
|
|
end,
|
|
})
|
|
table.insert(menu_items.device_status_alarm.sub_item_table,
|
|
{
|
|
text_func = function()
|
|
return T(_("Check interval (%1 min)"), self.battery_interval)
|
|
end,
|
|
enabled_func = function()
|
|
return G_reader_settings:isTrue("device_status_battery_alarm")
|
|
end,
|
|
keep_menu_open = true,
|
|
callback = function(touchmenu_instance)
|
|
UIManager:show(SpinWidget:new{
|
|
width = math.floor(Screen:getWidth() * 0.6),
|
|
value = self.battery_interval,
|
|
value_min = 1,
|
|
value_max = 60,
|
|
default_value = 10,
|
|
value_hold_step = 5,
|
|
title_text = _("Battery check interval"),
|
|
callback = function(spin)
|
|
self.battery_interval = spin.value
|
|
G_reader_settings:saveSetting("device_status_battery_interval", self.battery_interval)
|
|
touchmenu_instance:updateItems()
|
|
powerd:setDismissBatteryStatus(false)
|
|
UIManager:scheduleIn(self.battery_interval * 60, self.checkLowBatteryLevel)
|
|
end,
|
|
})
|
|
end,
|
|
})
|
|
table.insert(menu_items.device_status_alarm.sub_item_table,
|
|
{
|
|
text_func = function()
|
|
return T(_("Threshold (%1%)"), self.battery_threshold)
|
|
end,
|
|
enabled_func = function()
|
|
return G_reader_settings:isTrue("device_status_battery_alarm")
|
|
end,
|
|
keep_menu_open = true,
|
|
callback = function(touchmenu_instance)
|
|
UIManager:show(SpinWidget:new{
|
|
width = math.floor(Screen:getWidth() * 0.6),
|
|
value = self.battery_threshold,
|
|
value_min = 1,
|
|
value_max = 99,
|
|
default_value = 20,
|
|
value_hold_step = 5,
|
|
title_text = _("Battery alarm threshold"),
|
|
callback = function(spin)
|
|
self.battery_threshold = spin.value
|
|
G_reader_settings:saveSetting("device_status_battery_threshold", self.battery_threshold)
|
|
touchmenu_instance:updateItems()
|
|
powerd:setDismissBatteryStatus(false)
|
|
end,
|
|
})
|
|
end,
|
|
separator = true,
|
|
})
|
|
end
|
|
if not Device:isAndroid() then
|
|
table.insert(menu_items.device_status_alarm.sub_item_table,
|
|
{
|
|
text = _("High memory usage"),
|
|
checked_func = function()
|
|
return G_reader_settings:isTrue("device_status_memory_alarm")
|
|
end,
|
|
callback = function()
|
|
G_reader_settings:flipNilOrFalse("device_status_memory_alarm")
|
|
if G_reader_settings:isTrue("device_status_memory_alarm") then
|
|
self:startMemoryChecker()
|
|
else
|
|
self:stopMemoryChecker()
|
|
end
|
|
end,
|
|
})
|
|
table.insert(menu_items.device_status_alarm.sub_item_table,
|
|
{
|
|
text_func = function()
|
|
return T(_("Check interval (%1 min)"), self.memory_interval)
|
|
end,
|
|
enabled_func = function()
|
|
return G_reader_settings:isTrue("device_status_memory_alarm")
|
|
end,
|
|
keep_menu_open = true,
|
|
callback = function(touchmenu_instance)
|
|
UIManager:show(SpinWidget:new{
|
|
width = math.floor(Screen:getWidth() * 0.6),
|
|
value = self.memory_interval,
|
|
value_min = 1,
|
|
value_max = 60,
|
|
default_value = 5,
|
|
value_hold_step = 5,
|
|
title_text = _("Memory check interval"),
|
|
callback = function(spin)
|
|
self.memory_interval = spin.value
|
|
G_reader_settings:saveSetting("device_status_memory_interval", self.memory_interval)
|
|
touchmenu_instance:updateItems()
|
|
UIManager:scheduleIn(self.memory_interval*60, self.checkHighMemoryUsage)
|
|
end,
|
|
})
|
|
end,
|
|
})
|
|
table.insert(menu_items.device_status_alarm.sub_item_table,
|
|
{
|
|
text_func = function()
|
|
return T(_("Threshold (%1 MB)"), self.memory_threshold)
|
|
end,
|
|
enabled_func = function()
|
|
return G_reader_settings:isTrue("device_status_memory_alarm")
|
|
end,
|
|
keep_menu_open = true,
|
|
callback = function(touchmenu_instance)
|
|
UIManager:show(SpinWidget:new{
|
|
width = math.floor(Screen:getWidth() * 0.6),
|
|
value = self.memory_threshold,
|
|
value_min = 20,
|
|
value_max = 500,
|
|
default_value = 100,
|
|
value_step = 5,
|
|
value_hold_step = 10,
|
|
title_text = _("Memory alarm threshold"),
|
|
callback = function(spin)
|
|
self.memory_threshold = spin.value
|
|
G_reader_settings:saveSetting("device_status_memory_threshold", self.memory_threshold)
|
|
touchmenu_instance:updateItems()
|
|
end,
|
|
})
|
|
end,
|
|
})
|
|
table.insert(menu_items.device_status_alarm.sub_item_table,
|
|
{
|
|
text = _("Automatic restart"),
|
|
enabled_func = function()
|
|
return G_reader_settings:isTrue("device_status_memory_alarm") and Device:canRestart()
|
|
end,
|
|
checked_func = function()
|
|
return G_reader_settings:isTrue("device_status_memory_auto_restart")
|
|
end,
|
|
callback = function()
|
|
G_reader_settings:flipNilOrFalse("device_status_memory_auto_restart")
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
function ReaderDeviceStatus:startBatteryChecker()
|
|
if G_reader_settings:isTrue("device_status_battery_alarm") then
|
|
self.checkLowBatteryLevel()
|
|
end
|
|
end
|
|
|
|
function ReaderDeviceStatus:stopBatteryChecker()
|
|
UIManager:unschedule(self.checkLowBatteryLevel)
|
|
end
|
|
|
|
function ReaderDeviceStatus:startMemoryChecker()
|
|
if G_reader_settings:isTrue("device_status_memory_alarm") then
|
|
self.checkHighMemoryUsage()
|
|
end
|
|
end
|
|
|
|
function ReaderDeviceStatus:stopMemoryChecker()
|
|
UIManager:unschedule(self.checkHighMemoryUsage)
|
|
end
|
|
|
|
function ReaderDeviceStatus:onResume()
|
|
self:startBatteryChecker()
|
|
self:startMemoryChecker()
|
|
end
|
|
|
|
function ReaderDeviceStatus:onSuspend()
|
|
self:stopBatteryChecker()
|
|
self:stopMemoryChecker()
|
|
end
|
|
|
|
function ReaderDeviceStatus:onCloseWidget()
|
|
self:stopBatteryChecker()
|
|
self:stopMemoryChecker()
|
|
end
|
|
|
|
return ReaderDeviceStatus
|