mirror of
https://github.com/koreader/koreader
synced 2024-11-16 06:12:56 +00:00
292 lines
9.0 KiB
Lua
292 lines
9.0 KiB
Lua
local KindlePowerD = require("ui/device/kindlepowerd")
|
|
local KoboPowerD = require("ui/device/kobopowerd")
|
|
local BasePowerD = require("ui/device/basepowerd")
|
|
local Screen = require("ui/device/screen")
|
|
local util = require("ffi/util")
|
|
local ffi = require("ffi")
|
|
local isAndroid, android = pcall(require, "android")
|
|
-- lfs
|
|
|
|
local Device = {
|
|
screen_saver_mode = false,
|
|
charging_mode = false,
|
|
survive_screen_saver = false,
|
|
is_special_offers = nil,
|
|
touch_dev = nil,
|
|
model = nil,
|
|
firmware_rev = nil,
|
|
powerd = nil,
|
|
has_no_keyboard = nil,
|
|
is_touch_device = nil,
|
|
has_front_light = nil,
|
|
screen = Screen
|
|
}
|
|
|
|
Screen.device = Device
|
|
|
|
function Set (list)
|
|
local set = {}
|
|
for _, l in ipairs(list) do set[l] = true end
|
|
return set
|
|
end
|
|
|
|
function Device:getModel()
|
|
if self.model then return self.model end
|
|
if util.isEmulated() then
|
|
self.model = "Emulator"
|
|
return self.model
|
|
end
|
|
self.model = ""
|
|
local kindle_sn = io.open("/proc/usid", "r")
|
|
if kindle_sn then
|
|
local kindle_devcode = string.sub(kindle_sn:read(),3,4)
|
|
kindle_sn:close()
|
|
-- NOTE: Update me when new devices come out :)
|
|
local k2_set = Set { "02", "03" }
|
|
local dx_set = Set { "04", "05" }
|
|
local dxg_set = Set { "09" }
|
|
local k3_set = Set { "08", "06", "0A" }
|
|
local k4_set = Set { "0E", "23" }
|
|
local touch_set = Set { "0F", "11", "10", "12" }
|
|
local pw_set = Set { "24", "1B", "1D", "1F", "1C", "20" }
|
|
local pw2_set = Set { "D4", "5A", "D5", "D6", "D7", "D8", "F2" }
|
|
|
|
if k2_set[kindle_devcode] then
|
|
self.model = "Kindle2"
|
|
elseif dx_set[kindle_devcode] then
|
|
self.model = "Kindle2"
|
|
elseif dxg_set[kindle_devcode] then
|
|
self.model = "Kindle2"
|
|
elseif k3_set[kindle_devcode] then
|
|
self.model = "Kindle3"
|
|
elseif k4_set[kindle_devcode] then
|
|
self.model = "Kindle4"
|
|
elseif touch_set[kindle_devcode] then
|
|
self.model = "KindleTouch"
|
|
elseif pw_set[kindle_devcode] then
|
|
self.model = "KindlePaperWhite"
|
|
elseif pw2_set[kindle_devcode] then
|
|
self.model = "KindlePaperWhite2"
|
|
end
|
|
else
|
|
local kg_test_fd = lfs.attributes("/bin/kobo_config.sh")
|
|
if kg_test_fd then
|
|
local std_out = io.popen("/bin/kobo_config.sh 2>/dev/null", "r")
|
|
local codename = std_out:read()
|
|
self.model = "Kobo_" .. codename
|
|
local version_file = io.open("/mnt/onboard/.kobo/version", "r")
|
|
self.firmware_rev = string.sub(version_file:read(),24,28)
|
|
version_file:close()
|
|
end
|
|
end
|
|
return self.model
|
|
end
|
|
|
|
function Device:getFirmVer()
|
|
if not self.model then self:getModel() end
|
|
return self.firmware_rev
|
|
end
|
|
|
|
function Device:isKindle4()
|
|
return (self:getModel() == "Kindle4")
|
|
end
|
|
|
|
function Device:isKindle3()
|
|
return (self:getModel() == "Kindle3")
|
|
end
|
|
|
|
function Device:isKindle2()
|
|
return (self:getModel() == "Kindle2")
|
|
end
|
|
|
|
function Device:isKindle()
|
|
local is_kindle = false
|
|
local kindle_sn = io.open("/proc/usid", "r")
|
|
if kindle_sn then
|
|
is_kindle = true
|
|
kindle_sn:close()
|
|
end
|
|
return is_kindle
|
|
end
|
|
|
|
function Device:isKobo()
|
|
return string.find(self:getModel() or "", "Kobo_") == 1
|
|
end
|
|
|
|
Device.isAndroid = util.isAndroid
|
|
|
|
-- device has qwerty keyboard
|
|
function Device:hasKeyboard()
|
|
if self.has_keyboard ~= nil then return self.has_keyboard end
|
|
if not isAndroid then
|
|
local model = self:getModel()
|
|
self.has_keyboard = (model == "Kindle2") or (model == "Kindle3")
|
|
or util.isEmulated()
|
|
else
|
|
self.has_keyboard = ffi.C.AConfiguration_getKeyboard(android.app.config)
|
|
== ffi.C.ACONFIGURATION_KEYBOARD_QWERTY
|
|
end
|
|
return self.has_keyboard
|
|
end
|
|
|
|
function Device:hasNoKeyboard()
|
|
return not self:hasKeyboard()
|
|
end
|
|
|
|
-- device has hardware keys for pagedown/pageup
|
|
function Device:hasKeys()
|
|
if self.has_keys ~= nil then return self.has_keys end
|
|
local model = self:getModel()
|
|
self.has_keys = (model ~= "KindlePaperWhite") and (model ~= "KindlePaperWhite2")
|
|
and (model ~= "KindleTouch") and not self:isKobo()
|
|
return self.has_keys
|
|
end
|
|
|
|
function Device:isTouchDevice()
|
|
if self.is_touch_device ~= nil then return self.is_touch_device end
|
|
if not isAndroid then
|
|
local model = self:getModel()
|
|
self.is_touch_device = (model == "KindlePaperWhite") or (model == "KindlePaperWhite2")
|
|
or (model == "KindleTouch") or self:isKobo() or util.isEmulated()
|
|
else
|
|
self.is_touch_device = ffi.C.AConfiguration_getTouchscreen(android.app.config)
|
|
~= ffi.C.ACONFIGURATION_TOUCHSCREEN_NOTOUCH
|
|
end
|
|
return self.is_touch_device
|
|
end
|
|
|
|
function Device:hasFrontlight()
|
|
if self.has_front_light ~= nil then return self.has_front_light end
|
|
local model = self:getModel()
|
|
self.has_front_light = (model == "KindlePaperWhite") or (model == "KindlePaperWhite2")
|
|
or (model == "Kobo_dragon") or (model == "Kobo_kraken") or (model == "Kobo_phoenix")
|
|
or util.isEmulated()
|
|
return self.has_front_light
|
|
end
|
|
|
|
function Device:setTouchInputDev(dev)
|
|
self.touch_dev = dev
|
|
end
|
|
|
|
function Device:getTouchInputDev()
|
|
return self.touch_dev
|
|
end
|
|
|
|
function Device:intoScreenSaver()
|
|
--os.execute("echo 'screensaver in' >> /mnt/us/event_test.txt")
|
|
if self.charging_mode == false and self.screen_saver_mode == false then
|
|
self.screen:saveCurrentBB()
|
|
--UIManager:show(InfoMessage:new{
|
|
--text = "Going into screensaver... ",
|
|
--timeout = 2,
|
|
--})
|
|
--util.sleep(1)
|
|
--os.execute("killall -cont cvm")
|
|
self.screen_saver_mode = true
|
|
end
|
|
end
|
|
|
|
function Device:outofScreenSaver()
|
|
--os.execute("echo 'screensaver out' >> /mnt/us/event_test.txt")
|
|
if self.screen_saver_mode == true and self.charging_mode == false then
|
|
-- wait for native system update screen before we recover saved
|
|
-- Blitbuffer.
|
|
util.usleep(1500000)
|
|
--os.execute("killall -stop cvm")
|
|
self.screen:restoreFromSavedBB()
|
|
self.screen:refresh(0)
|
|
self.survive_screen_saver = true
|
|
end
|
|
self.screen_saver_mode = false
|
|
end
|
|
|
|
function Device:prepareSuspend() -- currently only used for kobo devices
|
|
local powerd = self:getPowerDevice()
|
|
if powerd ~= nil then
|
|
powerd.fl:sleep()
|
|
end
|
|
self.screen:refresh(0)
|
|
self.screen_saver_mode = true
|
|
end
|
|
|
|
function Device:Suspend() -- currently only used for kobo devices
|
|
os.execute("./suspend.sh")
|
|
end
|
|
|
|
function Device:Resume() -- currently only used for kobo devices
|
|
os.execute("echo 0 > /sys/power/state-extended")
|
|
self.screen:refresh(0)
|
|
local powerd = self:getPowerDevice()
|
|
if powerd ~= nil then
|
|
powerd.fl:restore()
|
|
end
|
|
self.screen_saver_mode = false
|
|
end
|
|
|
|
function Device:usbPlugIn()
|
|
--os.execute("echo 'usb in' >> /mnt/us/event_test.txt")
|
|
if self.charging_mode == false and self.screen_saver_mode == false then
|
|
self.screen:saveCurrentBB()
|
|
--UIManager:show(InfoMessage:new{
|
|
--text = "Going into USB mode... ",
|
|
--timeout = 2,
|
|
--})
|
|
--util.sleep(1)
|
|
--os.execute("killall -cont cvm")
|
|
end
|
|
self.charging_mode = true
|
|
end
|
|
|
|
function Device:usbPlugOut()
|
|
--os.execute("echo 'usb out' >> /mnt/us/event_test.txt")
|
|
if self.charging_mode == true and self.screen_saver_mode == false then
|
|
--util.usleep(1500000)
|
|
--os.execute("killall -stop cvm")
|
|
self.screen:restoreFromSavedBB()
|
|
self.screen:refresh(0)
|
|
end
|
|
|
|
--@TODO signal filemanager for file changes 13.06 2012 (houqp)
|
|
self.charging_mode = false
|
|
end
|
|
|
|
function Device:getPowerDevice()
|
|
if self.powerd ~= nil then
|
|
return self.powerd
|
|
else
|
|
local model = self:getModel()
|
|
if model == "KindleTouch" or model == "KindlePaperWhite" or model == "KindlePaperWhite2" then
|
|
self.powerd = KindlePowerD:new{model = model}
|
|
elseif self:isKobo() then
|
|
self.powerd = KoboPowerD:new()
|
|
else -- emulated FrontLight
|
|
self.powerd = BasePowerD:new()
|
|
end
|
|
end
|
|
return self.powerd
|
|
end
|
|
|
|
function Device:isSpecialOffers()
|
|
if self.is_special_offers ~= nil then return self.is_special_offers end
|
|
-- K5 only
|
|
if self:isTouchDevice() and self:isKindle() then
|
|
-- Look at the current blanket modules to see if the SO screensavers are enabled...
|
|
local lipc = require("liblipclua")
|
|
local lipc_handle = nil
|
|
if lipc then
|
|
lipc_handle = lipc.init("com.github.koreader.device")
|
|
end
|
|
if lipc_handle then
|
|
local loaded_blanket_modules = lipc_handle:get_string_property("com.lab126.blanket", "load")
|
|
if string.find(loaded_blanket_modules, "ad_screensaver") then
|
|
self.is_special_offers = true
|
|
end
|
|
lipc_handle:close()
|
|
else
|
|
end
|
|
end
|
|
return self.is_special_offers
|
|
end
|
|
|
|
return Device
|