mirror of
https://github.com/britzl/monarch.git
synced 2025-06-27 02:17:53 +02:00
Added queue support to Monarch (#49)
* Created queue and added show() as a queuable action * Improved logic in confirm popup - It should not crash if there is no next screen in data * Fixed indentation * Made the new queue a lot more stable. Fixed tests. * Removed debug output * Fixed issue with html5 builds
This commit is contained in:
Björn Ritzl
GitHub
parent
478835f888
commit
49dd390812
16
README.md
16
README.md
@ -292,7 +292,7 @@ Both the ```monarch.show()``` and ```monarch.back()``` functions take an optiona
|
||||
## Monarch API
|
||||
|
||||
### monarch.show(screen_id, [options], [data], [callback])
|
||||
Show a Monarch screen. Note that the screen must be registered before it can be shown. The ```init()``` function of the ```screen.script``` takes care of registration.
|
||||
Show a Monarch screen. Note that the screen must be registered before it can be shown. The ```init()``` function of the ```screen.script``` takes care of registration. This operation will be added to the queue if Monarch is busy.
|
||||
|
||||
**PARAMETERS**
|
||||
* ```screen_id``` (string|hash) - Id of the screen to show.
|
||||
@ -306,12 +306,9 @@ The options table can contain the following fields:
|
||||
* ```reload``` (boolean) - If the `reload` flag is set Monarch will reload the collection proxy if it's already loaded (this can happen if the previous screen was a popup).
|
||||
* ```no_stack``` (boolean) - If the `no_stack` flag is set Monarch will load the screen without adding it to the screen stack.
|
||||
|
||||
**RETURN**
|
||||
* ```success``` (boolean) - True if the process of showing the screen was started successfully. False if already busy showing/hiding a screen.
|
||||
|
||||
|
||||
### monarch.hide(screen_id, [callback])
|
||||
Hide a screen that has been shown using the `no_stack` option. If used on a screen that was shown without the `no_stack` option it will only hide it if the screen is on top of the stack and the behavior will be exactly like if `monarch.back()` had been called.
|
||||
Hide a screen that has been shown using the `no_stack` option. If used on a screen that was shown without the `no_stack` option it will only hide it if the screen is on top of the stack and the behavior will be exactly like if `monarch.back()` had been called. This operation will be added to the queue if Monarch is busy.
|
||||
|
||||
**PARAMETERS**
|
||||
* ```screen_id``` (string|hash) - Id of the screen to hide.
|
||||
@ -322,18 +319,15 @@ Hide a screen that has been shown using the `no_stack` option. If used on a scre
|
||||
|
||||
|
||||
### monarch.back([data], [callback])
|
||||
Go back to a previous Monarch screen
|
||||
Go back to a previous Monarch screen. This operation will be added to the queue if Monarch is busy.
|
||||
|
||||
**PARAMETERS**
|
||||
* ```data``` (table) - Optional data to associate with the screen you are going back to. Retrieve using ```monarch.data()```.
|
||||
* ```callback``` (function) - Optional function to call when the previous screen is visible.
|
||||
|
||||
**RETURN**
|
||||
* ```success``` (boolean) - True if the process of going back to a previous screen was started successfully. False if already busy showing/hiding a screen.
|
||||
|
||||
|
||||
### monarch.preload(screen_id, [callback])
|
||||
Preload a Monarch screen. This will load but not enable the screen. This is useful for content heavy screens that you wish to be able to show without having to wait for it load.
|
||||
Preload a Monarch screen. This will load but not enable the screen. This is useful for content heavy screens that you wish to be able to show without having to wait for it load. This operation will be added to the queue if Monarch is busy.
|
||||
|
||||
**PARAMETERS**
|
||||
* ```screen_id``` (string|hash) - Id of the screen to preload.
|
||||
@ -359,7 +353,7 @@ Invoke a callback when a screen has been preloaded.
|
||||
|
||||
|
||||
### monarch.unload(screen_id, [callback])
|
||||
Unload a preloaded Monarch screen. A preloaded screen will automatically get unloaded when hidden, but this function can be useful if a screen has been preloaded and it needs to be unloaded again without actually hiding it.
|
||||
Unload a preloaded Monarch screen. A preloaded screen will automatically get unloaded when hidden, but this function can be useful if a screen has been preloaded and it needs to be unloaded again without actually hiding it. This operation will be added to the queue if Monarch is busy.
|
||||
|
||||
**PARAMETERS**
|
||||
* ```screen_id``` (string|hash) - Id of the screen to unload.
|
||||
|
||||
@ -18,9 +18,13 @@ function on_input(self, action_id, action)
|
||||
if action_id == hash("touch") and action.released then
|
||||
if gui.pick_node(self.yes, action.x, action.y) then
|
||||
print("yes")
|
||||
monarch.show(monarch.data("confirm").next, nil, nil, function()
|
||||
print("next screen show done")
|
||||
end)
|
||||
if monarch.data("confirm").next then
|
||||
monarch.show(monarch.data("confirm").next, nil, nil, function()
|
||||
print("next screen show done")
|
||||
end)
|
||||
else
|
||||
print("no next screen in data")
|
||||
end
|
||||
elseif gui.pick_node(self.no, action.x, action.y) then
|
||||
print("no")
|
||||
monarch.back(function()
|
||||
|
||||
@ -8,8 +8,7 @@ end
|
||||
|
||||
function on_message(self, message_id, message, sender)
|
||||
if message_id == hash("init_monarch") then
|
||||
monarch.show(hash("background"), { no_stack = true }, nil, function()
|
||||
monarch.show(hash("menu"))
|
||||
end)
|
||||
monarch.show(hash("background"), { no_stack = true })
|
||||
monarch.show(hash("menu"))
|
||||
end
|
||||
end
|
||||
@ -19,7 +19,7 @@ function on_input(self, action_id, action)
|
||||
end)
|
||||
elseif gui.pick_node(gui.get_node("about_button"), action.x, action.y) then
|
||||
monarch.show(hash("about"), nil, nil, function()
|
||||
print("showing about done")
|
||||
print("showing about done")
|
||||
end)
|
||||
elseif gui.pick_node(gui.get_node("back_button"), action.x, action.y) then
|
||||
monarch.back()
|
||||
|
||||
@ -31,6 +31,7 @@ M.SCREEN_TRANSITION_IN_STARTED = hash("monarch_screen_transition_in_started")
|
||||
M.SCREEN_TRANSITION_IN_FINISHED = hash("monarch_screen_transition_in_finished")
|
||||
M.SCREEN_TRANSITION_OUT_STARTED = hash("monarch_screen_transition_out_started")
|
||||
M.SCREEN_TRANSITION_OUT_FINISHED = hash("monarch_screen_transition_out_finished")
|
||||
M.SCREEN_TRANSITION_FAILED = hash("monarch_screen_transition_failed")
|
||||
|
||||
|
||||
-- all registered screens
|
||||
@ -77,6 +78,43 @@ local function cowait(delay)
|
||||
coroutine.yield()
|
||||
end
|
||||
|
||||
|
||||
|
||||
local queue = {}
|
||||
|
||||
local function queue_error(message)
|
||||
log(message)
|
||||
log("queue() error - clearing queue")
|
||||
while next(queue) do
|
||||
table.remove(queue)
|
||||
end
|
||||
end
|
||||
|
||||
local process_queue
|
||||
process_queue = function()
|
||||
if M.is_busy() then
|
||||
log("queue() busy")
|
||||
return
|
||||
end
|
||||
action = table.remove(queue, 1)
|
||||
if not action then
|
||||
log("queue() empty")
|
||||
return
|
||||
end
|
||||
log("queue() next action", action)
|
||||
local ok, err = pcall(action, process_queue, queue_error)
|
||||
if not ok then
|
||||
queue_error(err)
|
||||
end
|
||||
end
|
||||
|
||||
local function queue_action(action)
|
||||
log("queue() adding", action)
|
||||
table.insert(queue, action)
|
||||
process_queue()
|
||||
end
|
||||
|
||||
|
||||
local function notify_transition_listeners(message_id, message)
|
||||
log("notify_transition_listeners()", message_id)
|
||||
for _,url in pairs(transition_listeners) do
|
||||
@ -234,6 +272,8 @@ function M.unregister(id)
|
||||
assert(id, "You must provide a screen id")
|
||||
id = tohash(id)
|
||||
assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
|
||||
log("unregister()", id)
|
||||
local screen = screens[id]
|
||||
screens[id] = nil
|
||||
end
|
||||
|
||||
@ -282,9 +322,8 @@ local function change_context(screen)
|
||||
end
|
||||
|
||||
local function unload(screen, force)
|
||||
log("unload()", screen.id)
|
||||
|
||||
if screen.proxy then
|
||||
log("unload() proxy", screen.id)
|
||||
if screen.auto_preload and not force then
|
||||
msg.post(screen.proxy, DISABLE)
|
||||
screen.loaded = false
|
||||
@ -298,6 +337,7 @@ local function unload(screen, force)
|
||||
screen.wait_for = nil
|
||||
end
|
||||
elseif screen.factory then
|
||||
log("unload() factory", screen.id)
|
||||
for id, instance in pairs(screen.factory_ids) do
|
||||
go.delete(instance)
|
||||
end
|
||||
@ -311,6 +351,11 @@ local function unload(screen, force)
|
||||
screen.preloaded = false
|
||||
end
|
||||
end
|
||||
-- we need to wait here in case the unloaded screen contained any screens
|
||||
-- if this is the case we need to let these sub-screens have their final()
|
||||
-- functions called so that they have time to call unregister()
|
||||
cowait(0)
|
||||
cowait(0)
|
||||
end
|
||||
|
||||
|
||||
@ -320,14 +365,17 @@ local function preload(screen)
|
||||
|
||||
if screen.preloaded then
|
||||
log("preload() screen already preloaded", screen.id)
|
||||
return
|
||||
return true
|
||||
end
|
||||
|
||||
screen.preloading = true
|
||||
if screen.proxy then
|
||||
log("preload() proxy")
|
||||
screen.wait_for = PROXY_LOADED
|
||||
msg.post(screen.proxy, ASYNC_LOAD)
|
||||
coroutine.yield()
|
||||
elseif screen.factory then
|
||||
log("preload() factory")
|
||||
if collectionfactory.get_status(screen.factory) == collectionfactory.STATUS_UNLOADED then
|
||||
collectionfactory.load(screen.factory, function(self, url, result)
|
||||
assert(coroutine.resume(screen.co))
|
||||
@ -336,11 +384,16 @@ local function preload(screen)
|
||||
end
|
||||
|
||||
if collectionfactory.get_status(screen.factory) ~= collectionfactory.STATUS_LOADED then
|
||||
log("preload() error loading factory resources")
|
||||
return
|
||||
local error_message = ("preload() error while loading factory resources for screen %s"):format(tostring(screen.id))
|
||||
log(error_message)
|
||||
screen.preloading = false
|
||||
return false, error_message
|
||||
end
|
||||
end
|
||||
log("preload() preloading done", screen.id)
|
||||
screen.preloaded = true
|
||||
screen.preloading = false
|
||||
return true
|
||||
end
|
||||
|
||||
local function load(screen)
|
||||
@ -349,14 +402,13 @@ local function load(screen)
|
||||
|
||||
if screen.loaded then
|
||||
log("load() screen already loaded", screen.id)
|
||||
return
|
||||
return true
|
||||
end
|
||||
|
||||
preload(screen)
|
||||
|
||||
if not screen.preloaded then
|
||||
local ok, err = preload(screen)
|
||||
if not ok then
|
||||
log("load() screen wasn't preloaded", screen.id)
|
||||
return
|
||||
return false, err
|
||||
end
|
||||
|
||||
if screen.proxy then
|
||||
@ -368,6 +420,7 @@ local function load(screen)
|
||||
end
|
||||
screen.loaded = true
|
||||
screen.preloaded = false
|
||||
return true
|
||||
end
|
||||
|
||||
local function transition(screen, message_id, message)
|
||||
@ -419,20 +472,22 @@ local function reset_timestep(screen)
|
||||
end
|
||||
end
|
||||
|
||||
local function run_coroutine(screen, cb, fn)
|
||||
local function run_coroutine(screen, done_cb, fn)
|
||||
local co
|
||||
co = coroutine.create(function()
|
||||
screen.co = co
|
||||
-- don't pcall the function!
|
||||
-- it may contain a call to for instance change_context()
|
||||
-- this will result in a yield across metamethod/C call boundary
|
||||
fn()
|
||||
screen.co = nil
|
||||
pcallfn(cb)
|
||||
pcallfn(done_cb)
|
||||
end)
|
||||
assert(coroutine.resume(co))
|
||||
end
|
||||
|
||||
local function disable(screen, next_screen)
|
||||
log("disable()", screen.id)
|
||||
local next_is_popup = next_screen and next_screen.popup
|
||||
run_coroutine(screen, nil, function()
|
||||
change_context(screen)
|
||||
release_input(screen, next_screen)
|
||||
@ -488,13 +543,14 @@ local function show_in(screen, previous_screen, reload, add_to_stack, cb)
|
||||
if reload and screen.loaded then
|
||||
log("show_in() reloading", screen.id)
|
||||
unload(screen, reload)
|
||||
-- we need to wait here in case the unloaded screen contained any screens
|
||||
-- if this is the case we need to let these sub-screens have their final()
|
||||
-- functions called so that they have time to call unregister()
|
||||
cowait(0)
|
||||
cowait(0)
|
||||
end
|
||||
load(screen)
|
||||
local ok, err = load(screen)
|
||||
if not ok then
|
||||
log("show_in()", err)
|
||||
active_transition_count = active_transition_count - 1
|
||||
notify_transition_listeners(M.SCREEN_TRANSITION_FAILED, { screen = screen.id })
|
||||
return
|
||||
end
|
||||
if add_to_stack then
|
||||
stack[#stack + 1] = screen
|
||||
end
|
||||
@ -513,7 +569,13 @@ local function back_in(screen, previous_screen, cb)
|
||||
active_transition_count = active_transition_count + 1
|
||||
notify_transition_listeners(M.SCREEN_TRANSITION_IN_STARTED, { screen = screen.id, previous_screen = previous_screen and previous_screen.id })
|
||||
change_context(screen)
|
||||
load(screen)
|
||||
local ok, err = load(screen)
|
||||
if not ok then
|
||||
log("back_in()", err)
|
||||
active_transition_count = active_transition_count - 1
|
||||
notify_transition_listeners(M.SCREEN_TRANSITION_FAILED, { screen = screen.id })
|
||||
return
|
||||
end
|
||||
reset_timestep(screen)
|
||||
if previous_screen and not previous_screen.popup then
|
||||
transition(screen, M.TRANSITION.BACK_IN, { previous_screen = previous_screen.id })
|
||||
@ -580,83 +642,86 @@ end
|
||||
-- This would be the case if doing a show() from a popup on the screen just below the popup.
|
||||
-- @param data (*) - Optional data to set on the screen. Can be retrieved by the data() function
|
||||
-- @param cb (function) - Optional callback to invoke when screen is shown
|
||||
-- @return success True if screen is successfully shown, false if busy performing another operation
|
||||
function M.show(id, options, data, cb)
|
||||
assert(id, "You must provide a screen id")
|
||||
if M.is_busy() then
|
||||
log("show() monarch is busy, ignoring request")
|
||||
return false
|
||||
end
|
||||
|
||||
local callbacks = callback_tracker()
|
||||
|
||||
id = tohash(id)
|
||||
assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
|
||||
|
||||
local screen = screens[id]
|
||||
screen.data = data
|
||||
log("show() queuing action", id)
|
||||
queue_action(function(action_done, action_error)
|
||||
log("show()", id)
|
||||
local screen = screens[id]
|
||||
if not screen then
|
||||
action_error(("show() there is no longer a screen with id %s"):format(tostring(id)))
|
||||
return
|
||||
end
|
||||
screen.data = data
|
||||
|
||||
log("show()", screen.id)
|
||||
local co
|
||||
co = coroutine.create(function()
|
||||
|
||||
local co
|
||||
co = coroutine.create(function()
|
||||
local top = stack[#stack]
|
||||
-- a screen can ignore the stack by setting the no_stack to true
|
||||
local add_to_stack = not options or not options.no_stack
|
||||
if add_to_stack then
|
||||
-- manipulate the current top
|
||||
-- close popup(s) if needed
|
||||
-- transition out
|
||||
if top then
|
||||
-- keep top popup visible if new screen can be shown on top of a popup
|
||||
if top.popup and screen.popup_on_popup then
|
||||
disable(top, screen)
|
||||
else
|
||||
-- close all popups, one by one
|
||||
while top.popup do
|
||||
stack[#stack] = nil
|
||||
show_out(top, screen, function()
|
||||
assert(coroutine.resume(co))
|
||||
end)
|
||||
coroutine.yield()
|
||||
top = stack[#stack]
|
||||
end
|
||||
-- unload and transition out from top
|
||||
-- unless we're showing the same screen as is already visible
|
||||
if top and top.id ~= screen.id then
|
||||
show_out(top, screen, callbacks.track())
|
||||
local callbacks = callback_tracker()
|
||||
|
||||
local top = stack[#stack]
|
||||
-- a screen can ignore the stack by setting the no_stack to true
|
||||
local add_to_stack = not options or not options.no_stack
|
||||
if add_to_stack then
|
||||
-- manipulate the current top
|
||||
-- close popup(s) if needed
|
||||
-- transition out
|
||||
if top then
|
||||
-- keep top popup visible if new screen can be shown on top of a popup
|
||||
if top.popup and screen.popup_on_popup then
|
||||
disable(top, screen)
|
||||
else
|
||||
-- close all popups, one by one
|
||||
while top.popup do
|
||||
stack[#stack] = nil
|
||||
show_out(top, screen, function()
|
||||
assert(coroutine.resume(co))
|
||||
end)
|
||||
coroutine.yield()
|
||||
top = stack[#stack]
|
||||
end
|
||||
-- unload and transition out from top
|
||||
-- unless we're showing the same screen as is already visible
|
||||
if top and top.id ~= screen.id then
|
||||
show_out(top, screen, callbacks.track())
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- if the screen we want to show is in the stack
|
||||
-- already and the clear flag is set then we need
|
||||
-- to remove every screen on the stack up until and
|
||||
-- including the screen itself
|
||||
if options and options.clear then
|
||||
log("show() clearing")
|
||||
while M.in_stack(id) do
|
||||
table.remove(stack)
|
||||
-- if the screen we want to show is in the stack
|
||||
-- already and the clear flag is set then we need
|
||||
-- to remove every screen on the stack up until and
|
||||
-- including the screen itself
|
||||
if options and options.clear then
|
||||
log("show() clearing")
|
||||
while M.in_stack(id) do
|
||||
table.remove(stack)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- show screen, wait until preloaded if it is already preloading
|
||||
-- this can typpically happen if you do a show() on app start for a
|
||||
-- screen that has Preload set to true
|
||||
if M.is_preloading(id) then
|
||||
M.when_preloaded(id, function()
|
||||
assert(coroutine.resume(co))
|
||||
-- show screen, wait until preloaded if it is already preloading
|
||||
-- this can typpically happen if you do a show() on app start for a
|
||||
-- screen that has Preload set to true
|
||||
if M.is_preloading(id) then
|
||||
M.when_preloaded(id, function()
|
||||
assert(coroutine.resume(co))
|
||||
end)
|
||||
coroutine.yield()
|
||||
end
|
||||
show_in(screen, top, options and options.reload, add_to_stack, callbacks.track())
|
||||
|
||||
callbacks.when_done(function()
|
||||
pcallfn(cb)
|
||||
pcallfn(action_done)
|
||||
end)
|
||||
coroutine.yield()
|
||||
end
|
||||
show_in(screen, top, options and options.reload, add_to_stack, callbacks.track())
|
||||
|
||||
if cb then callbacks.when_done(cb) end
|
||||
end)
|
||||
assert(coroutine.resume(co))
|
||||
end)
|
||||
assert(coroutine.resume(co))
|
||||
|
||||
return true
|
||||
return true -- return true for legacy reasons (before queue existed)
|
||||
end
|
||||
|
||||
|
||||
@ -664,18 +729,12 @@ end
|
||||
-- visible but not added to the stack (through the no_stack option)
|
||||
-- @param id (string|hash) - Id of the screen to show
|
||||
-- @param cb (function) - Optional callback to invoke when the screen is hidden
|
||||
-- @return true if successfully hiding, false if busy performing another operation
|
||||
-- @return true if successfully hiding, false if busy or for some other reason unable to hide the screen
|
||||
function M.hide(id, cb)
|
||||
if M.is_busy() then
|
||||
log("hide() monarch is busy, ignoring request")
|
||||
return false
|
||||
end
|
||||
|
||||
assert(id, "You must provide a screen id")
|
||||
id = tohash(id)
|
||||
assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
|
||||
|
||||
local screen = screens[id]
|
||||
log("hide()", screen.id)
|
||||
if M.in_stack(id) then
|
||||
if not M.is_top(id) then
|
||||
log("hide() you can only hide the screen at the top of the stack", id)
|
||||
@ -683,55 +742,67 @@ function M.hide(id, cb)
|
||||
end
|
||||
return M.back(id, cb)
|
||||
else
|
||||
if M.is_visible(id) then
|
||||
back_out(screen, nil, cb)
|
||||
else
|
||||
pcallfn(cb)
|
||||
end
|
||||
log("hide() queuing action", id)
|
||||
queue_action(function(action_done, action_error)
|
||||
log("hide()", id)
|
||||
local callbacks = callback_tracker()
|
||||
if M.is_visible(id) then
|
||||
local screen = screens[id]
|
||||
if not screen then
|
||||
action_error(("hide() there is no longer a screen with id %s"):format(tostring(id)))
|
||||
return
|
||||
end
|
||||
back_out(screen, nil, callbacks.track())
|
||||
end
|
||||
callbacks.when_done(function()
|
||||
pcallfn(cb)
|
||||
pcallfn(action_done)
|
||||
end)
|
||||
end)
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
|
||||
-- Go back to the previous screen in the stack
|
||||
-- Go back to the previous screen in the stack.
|
||||
-- @param data (*) - Optional data to set for the previous screen
|
||||
-- @param cb (function) - Optional callback to invoke when the previous screen is visible again
|
||||
-- @return true if successfully going back, false if busy performing another operation
|
||||
function M.back(data, cb)
|
||||
if M.is_busy() then
|
||||
log("back() monarch is busy, ignoring request")
|
||||
return false
|
||||
end
|
||||
log("back() queuing action")
|
||||
|
||||
local callbacks = callback_tracker()
|
||||
|
||||
local screen = table.remove(stack)
|
||||
if screen then
|
||||
log("back()", screen.id)
|
||||
local top = stack[#stack]
|
||||
-- if we go back to the same screen we need to first hide it
|
||||
-- and wait until it is hidden before we show it again
|
||||
if top and screen.id == top.id then
|
||||
back_out(screen, top, function()
|
||||
if data then
|
||||
top.data = data
|
||||
queue_action(function(action_done)
|
||||
local callbacks = callback_tracker()
|
||||
local screen = table.remove(stack)
|
||||
if screen then
|
||||
log("back()", screen.id)
|
||||
local top = stack[#stack]
|
||||
-- if we go back to the same screen we need to first hide it
|
||||
-- and wait until it is hidden before we show it again
|
||||
if top and screen.id == top.id then
|
||||
back_out(screen, top, function()
|
||||
if data then
|
||||
top.data = data
|
||||
end
|
||||
back_in(top, screen, callbacks.track())
|
||||
end)
|
||||
else
|
||||
back_out(screen, top, callbacks.track())
|
||||
if top then
|
||||
if data then
|
||||
top.data = data
|
||||
end
|
||||
back_in(top, screen, callbacks.track())
|
||||
end
|
||||
back_in(top, screen, callbacks.track())
|
||||
end)
|
||||
else
|
||||
back_out(screen, top)
|
||||
if top then
|
||||
if data then
|
||||
top.data = data
|
||||
end
|
||||
back_in(top, screen, callbacks.track())
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if cb then callbacks.when_done(cb) end
|
||||
callbacks.when_done(function()
|
||||
pcallfn(cb)
|
||||
pcallfn(action_done)
|
||||
end)
|
||||
end)
|
||||
|
||||
return true
|
||||
return true -- return true for legacy reasons (before queue existed)
|
||||
end
|
||||
|
||||
|
||||
@ -770,37 +841,44 @@ end
|
||||
-- @param id (string|hash) - Id of the screen to preload
|
||||
-- @param cb (function) - Optional callback to invoke when screen is loaded
|
||||
function M.preload(id, cb)
|
||||
if M.is_busy() then
|
||||
log("preload() monarch is busy, ignoring request")
|
||||
return false
|
||||
end
|
||||
|
||||
assert(id, "You must provide a screen id")
|
||||
id = tohash(id)
|
||||
assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
|
||||
|
||||
local screen = screens[id]
|
||||
log("preload()", screen.id)
|
||||
if screen.preloaded or screen.loaded then
|
||||
pcallfn(cb)
|
||||
return true
|
||||
end
|
||||
|
||||
local function when_preloaded()
|
||||
-- invoke any listeners added using monarch.when_preloaded()
|
||||
while #screen.preload_listeners > 0 do
|
||||
pcallfn(table.remove(screen.preload_listeners), id)
|
||||
log("preload() queuing action", id)
|
||||
queue_action(function(action_done, action_error)
|
||||
log("preload()", id)
|
||||
|
||||
local screen = screens[id]
|
||||
if not screen then
|
||||
action_error(("preload() there is no longer a screen with id %s"):format(tostring(id)))
|
||||
return
|
||||
end
|
||||
-- invoke the normal callback
|
||||
pcallfn(cb)
|
||||
end
|
||||
run_coroutine(screen, when_preloaded, function()
|
||||
screen.preloading = true
|
||||
change_context(screen)
|
||||
preload(screen)
|
||||
screen.preloading = false
|
||||
|
||||
if screen.preloaded or screen.loaded then
|
||||
pcallfn(cb)
|
||||
pcallfn(action_done)
|
||||
return
|
||||
end
|
||||
|
||||
local function when_preloaded()
|
||||
-- invoke any listeners added using monarch.when_preloaded()
|
||||
while #screen.preload_listeners > 0 do
|
||||
pcallfn(table.remove(screen.preload_listeners), id)
|
||||
end
|
||||
-- invoke the normal callback
|
||||
pcallfn(cb)
|
||||
pcallfn(action_done)
|
||||
end
|
||||
run_coroutine(screen, when_preloaded, function()
|
||||
change_context(screen)
|
||||
local ok, err = preload(screen)
|
||||
if not ok then
|
||||
action_error(err)
|
||||
end
|
||||
end)
|
||||
end)
|
||||
return true
|
||||
return true -- return true for legacy reasons (before queue existed)
|
||||
end
|
||||
|
||||
|
||||
@ -808,31 +886,41 @@ end
|
||||
-- @param id (string|hash) - Id of the screen to unload
|
||||
-- @param cb (function) - Optional callback to invoke when screen is unloaded
|
||||
function M.unload(id, cb)
|
||||
if M.is_busy() then
|
||||
log("unload() monarch is busy, ignoring request")
|
||||
return false
|
||||
end
|
||||
assert(id, "You must provide a screen id")
|
||||
id = tohash(id)
|
||||
assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
|
||||
|
||||
if M.is_visible(id) then
|
||||
log("You can't unload a visible screen")
|
||||
return false
|
||||
end
|
||||
log("unload() queuing action", id)
|
||||
queue_action(function(action_done, action_error)
|
||||
if M.is_visible(id) then
|
||||
action_error("unload() you can't unload a visible screen")
|
||||
return
|
||||
end
|
||||
|
||||
local screen = screens[id]
|
||||
log("unload()", screen.id)
|
||||
if not screen.preloaded and not screen.loaded then
|
||||
log("unload() screen is not loaded", tostring(id))
|
||||
pcallfn(cb)
|
||||
return true
|
||||
end
|
||||
run_coroutine(screen, cb, function()
|
||||
change_context(screen)
|
||||
unload(screen)
|
||||
log("unload()", id)
|
||||
local screen = screens[id]
|
||||
if not screen then
|
||||
action_error(("unload() there is no longer a screen with id %s"):format(tostring(id)))
|
||||
return
|
||||
end
|
||||
|
||||
if not screen.preloaded and not screen.loaded then
|
||||
log("unload() screen is not loaded", tostring(id))
|
||||
pcallfn(cb)
|
||||
pcallfn(action_done)
|
||||
return
|
||||
end
|
||||
|
||||
local function when_unloaded()
|
||||
pcallfn(cb)
|
||||
pcallfn(action_done)
|
||||
end
|
||||
run_coroutine(screen, when_unloaded, function()
|
||||
change_context(screen)
|
||||
unload(screen)
|
||||
end)
|
||||
end)
|
||||
return true
|
||||
return true -- return true for legacy reasons (before queue existed)
|
||||
end
|
||||
|
||||
|
||||
@ -851,8 +939,8 @@ function M.post(id, message_id, message)
|
||||
assert(message_id, "You must provide a message_id")
|
||||
id = tohash(id)
|
||||
assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
|
||||
local screen = screens[id]
|
||||
|
||||
local screen = screens[id]
|
||||
if screen.proxy then
|
||||
if screen.receiver_url then
|
||||
log("post() sending message to", screen.receiver_url)
|
||||
|
||||
22
test/data/child.collection
Normal file
22
test/data/child.collection
Normal file
@ -0,0 +1,22 @@
|
||||
name: "child"
|
||||
scale_along_z: 0
|
||||
embedded_instances {
|
||||
id: "go"
|
||||
data: ""
|
||||
position {
|
||||
x: 0.0
|
||||
y: 0.0
|
||||
z: 0.0
|
||||
}
|
||||
rotation {
|
||||
x: 0.0
|
||||
y: 0.0
|
||||
z: 0.0
|
||||
w: 1.0
|
||||
}
|
||||
scale3 {
|
||||
x: 1.0
|
||||
y: 1.0
|
||||
z: 1.0
|
||||
}
|
||||
}
|
||||
@ -35,3 +35,66 @@ embedded_instances {
|
||||
z: 1.0
|
||||
}
|
||||
}
|
||||
embedded_instances {
|
||||
id: "child"
|
||||
data: "components {\n"
|
||||
" id: \"screen_proxy\"\n"
|
||||
" component: \"/monarch/screen_proxy.script\"\n"
|
||||
" position {\n"
|
||||
" x: 0.0\n"
|
||||
" y: 0.0\n"
|
||||
" z: 0.0\n"
|
||||
" }\n"
|
||||
" rotation {\n"
|
||||
" x: 0.0\n"
|
||||
" y: 0.0\n"
|
||||
" z: 0.0\n"
|
||||
" w: 1.0\n"
|
||||
" }\n"
|
||||
" properties {\n"
|
||||
" id: \"screen_id\"\n"
|
||||
" value: \"child\"\n"
|
||||
" type: PROPERTY_TYPE_HASH\n"
|
||||
" }\n"
|
||||
" properties {\n"
|
||||
" id: \"popup\"\n"
|
||||
" value: \"true\"\n"
|
||||
" type: PROPERTY_TYPE_BOOLEAN\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"embedded_components {\n"
|
||||
" id: \"collectionproxy\"\n"
|
||||
" type: \"collectionproxy\"\n"
|
||||
" data: \"collection: \\\"/test/data/child.collection\\\"\\n"
|
||||
"exclude: false\\n"
|
||||
"\"\n"
|
||||
" position {\n"
|
||||
" x: 0.0\n"
|
||||
" y: 0.0\n"
|
||||
" z: 0.0\n"
|
||||
" }\n"
|
||||
" rotation {\n"
|
||||
" x: 0.0\n"
|
||||
" y: 0.0\n"
|
||||
" z: 0.0\n"
|
||||
" w: 1.0\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
""
|
||||
position {
|
||||
x: 0.0
|
||||
y: 0.0
|
||||
z: 0.0
|
||||
}
|
||||
rotation {
|
||||
x: 0.0
|
||||
y: 0.0
|
||||
z: 0.0
|
||||
w: 1.0
|
||||
}
|
||||
scale3 {
|
||||
x: 1.0
|
||||
y: 1.0
|
||||
z: 1.0
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,6 +6,7 @@ local monarch = require "monarch.monarch"
|
||||
local SCREEN1_STR = hash("screen1")
|
||||
local SCREEN1 = hash(SCREEN1_STR)
|
||||
local SCREEN2 = hash("screen2")
|
||||
local CHILD = hash("child")
|
||||
local SCREEN_PRELOAD = hash("screen_preload")
|
||||
local FOCUS1 = hash("focus1")
|
||||
local BACKGROUND = hash("background")
|
||||
@ -14,6 +15,26 @@ local POPUP2 = hash("popup2")
|
||||
local FOOBAR = hash("foobar")
|
||||
local TRANSITION1 = hash("transition1")
|
||||
|
||||
local function check_stack(expected_screens)
|
||||
local actual_screens = monarch.get_stack()
|
||||
if #actual_screens ~= #expected_screens then
|
||||
return false, "Stack length mismatch"
|
||||
end
|
||||
for i=1,#actual_screens do
|
||||
if actual_screens[i] ~= expected_screens[i] then
|
||||
return false, "Stack content not matching"
|
||||
end
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
local telescope = require "deftest.telescope"
|
||||
telescope.make_assertion(
|
||||
"stack",
|
||||
function(_, ...) return telescope.assertion_message_prefix .. "stack to match" end,
|
||||
function(expected_screens) return check_stack(expected_screens) end
|
||||
)
|
||||
|
||||
return function()
|
||||
|
||||
local screens_instances = {}
|
||||
@ -26,6 +47,10 @@ return function()
|
||||
return not monarch.is_visible(screen_id)
|
||||
end
|
||||
|
||||
local function is_preloading(screen_id)
|
||||
return monarch.is_preloading(screen_id)
|
||||
end
|
||||
|
||||
local function wait_timeout(fn, ...)
|
||||
local args = { ... }
|
||||
cowait(function() return fn(unpack(args)) end, 5)
|
||||
@ -46,23 +71,18 @@ return function()
|
||||
local function wait_until_hidden(screen_id)
|
||||
return wait_timeout(is_hidden, screen_id)
|
||||
end
|
||||
local function wait_until_preloading(screen_id)
|
||||
return wait_timeout(is_preloading, screen_id)
|
||||
end
|
||||
local function wait_until_not_busy()
|
||||
return wait_timeout(function() return not monarch.is_busy() end)
|
||||
end
|
||||
|
||||
local function assert_stack(expected_screens)
|
||||
local actual_screens = monarch.get_stack()
|
||||
if #actual_screens ~= #expected_screens then
|
||||
error("Stack length mismatch", 2)
|
||||
end
|
||||
for i=1,#actual_screens do
|
||||
if actual_screens[i] ~= expected_screens[i] then
|
||||
error("Stack content not matching", 2)
|
||||
end
|
||||
end
|
||||
local function wait_until_loaded(screen_id)
|
||||
wait_until_done(function(done)
|
||||
monarch.when_preloaded(screen_id, done)
|
||||
end)
|
||||
end
|
||||
|
||||
|
||||
|
||||
describe("monarch", function()
|
||||
before(function()
|
||||
mock_msg.mock()
|
||||
@ -72,6 +92,7 @@ return function()
|
||||
end)
|
||||
|
||||
after(function()
|
||||
print("[TEST] done")
|
||||
while #monarch.get_stack() > 0 do
|
||||
monarch.back()
|
||||
wait_until_not_busy()
|
||||
@ -171,7 +192,7 @@ return function()
|
||||
assert_stack({ SCREEN1 })
|
||||
end)
|
||||
|
||||
it("should be able to pass data to a screen when showning it or going back to it", function()
|
||||
it("should be able to pass data to a screen when showing it or going back to it", function()
|
||||
local data1 = { foo = "bar" }
|
||||
monarch.show(SCREEN1, nil, data1)
|
||||
assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
|
||||
@ -185,7 +206,7 @@ return function()
|
||||
|
||||
local data_back = { going = "back" }
|
||||
monarch.back(data_back)
|
||||
assert_stack({ SCREEN1 })
|
||||
assert(wait_until_shown(SCREEN1))
|
||||
|
||||
assert(monarch.data(SCREEN1) == data_back, "Expected data on screen1 doesn't match actual data")
|
||||
end)
|
||||
@ -226,23 +247,32 @@ return function()
|
||||
assert_stack({ SCREEN1, POPUP1, POPUP2 })
|
||||
end)
|
||||
|
||||
|
||||
it("should prevent further operations while hiding/showing a screen", function()
|
||||
assert(monarch.show(SCREEN1) == true)
|
||||
assert(monarch.show(SCREEN2) == false)
|
||||
assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
|
||||
assert_stack({ SCREEN1 })
|
||||
|
||||
assert(monarch.show(SCREEN2) == true)
|
||||
it("should prevent further operations while hiding/showing a screen", function()
|
||||
monarch.show(SCREEN1)
|
||||
monarch.show(SCREEN2)
|
||||
assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
|
||||
assert(wait_until_shown(SCREEN2), "Screen2 was never shown")
|
||||
assert_stack({ SCREEN1, SCREEN2 })
|
||||
|
||||
assert(monarch.back() == true)
|
||||
assert(monarch.back() == false)
|
||||
assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
|
||||
assert_stack({ SCREEN1 })
|
||||
assert(monarch.back())
|
||||
assert(monarch.back())
|
||||
assert(wait_until_hidden(SCREEN1), "Screen1 was never hidden")
|
||||
assert(wait_until_hidden(SCREEN2), "Screen2 was never hidden")
|
||||
end)
|
||||
|
||||
|
||||
|
||||
it("should not perform further operations if an operation fails", function()
|
||||
monarch.show(SCREEN2) -- SCREEN2 contains CHILD
|
||||
wait_until_not_busy()
|
||||
assert_stack({ SCREEN2 })
|
||||
monarch.back() -- this will unload SCREEN2 and CHILD
|
||||
monarch.show(CHILD) -- this will fail since CHILD has been unloaded
|
||||
monarch.show(SCREEN1) -- this should be ignored
|
||||
wait_until_not_busy()
|
||||
assert_stack({ })
|
||||
end)
|
||||
|
||||
|
||||
it("should close any open popups when showing a popup without the Popup On Popup flag", function()
|
||||
monarch.show(SCREEN1)
|
||||
@ -308,7 +338,6 @@ return function()
|
||||
it("should be able to preload a screen and wait for it", function()
|
||||
assert(not monarch.is_preloading(TRANSITION1))
|
||||
monarch.preload(TRANSITION1)
|
||||
assert(monarch.is_preloading(TRANSITION1))
|
||||
wait_until_done(function(done)
|
||||
monarch.when_preloaded(TRANSITION1, done)
|
||||
end)
|
||||
@ -364,14 +393,13 @@ return function()
|
||||
assert(mock_msg.messages(URL1)[7].message.screen == SCREEN2)
|
||||
assert(mock_msg.messages(URL1)[8].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
|
||||
assert(mock_msg.messages(URL1)[8].message.screen == SCREEN1)
|
||||
assert(mock_msg.messages(URL1)[9].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
|
||||
assert(mock_msg.messages(URL1)[9].message.screen == SCREEN2)
|
||||
assert(mock_msg.messages(URL1)[10].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
|
||||
assert(mock_msg.messages(URL1)[10].message.screen == SCREEN1)
|
||||
assert(mock_msg.messages(URL1)[9].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
|
||||
assert(mock_msg.messages(URL1)[9].message.screen == SCREEN1)
|
||||
assert(mock_msg.messages(URL1)[10].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
|
||||
assert(mock_msg.messages(URL1)[10].message.screen == SCREEN2)
|
||||
end)
|
||||
|
||||
it("should be able to show a screen even while it is preloading", function()
|
||||
assert(monarch.is_preloading(SCREEN_PRELOAD))
|
||||
monarch.show(SCREEN_PRELOAD, nil, { count = 1 })
|
||||
assert(wait_until_shown(SCREEN_PRELOAD), "Screen_preload was never shown")
|
||||
end)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user