diff --git a/README.md b/README.md index 502a7d2..e74da9d 100644 --- a/README.md +++ b/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. diff --git a/example/confirm.gui_script b/example/confirm.gui_script index 2dc690b..431ede1 100644 --- a/example/confirm.gui_script +++ b/example/confirm.gui_script @@ -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() diff --git a/example/main.script b/example/main.script index 3166937..f107525 100644 --- a/example/main.script +++ b/example/main.script @@ -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 \ No newline at end of file diff --git a/example/menu.gui_script b/example/menu.gui_script index 2aae36a..17791f6 100644 --- a/example/menu.gui_script +++ b/example/menu.gui_script @@ -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() diff --git a/monarch/monarch.lua b/monarch/monarch.lua index 8bf35ce..09c271d 100644 --- a/monarch/monarch.lua +++ b/monarch/monarch.lua @@ -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) diff --git a/test/data/child.collection b/test/data/child.collection new file mode 100644 index 0000000..93b4d79 --- /dev/null +++ b/test/data/child.collection @@ -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 + } +} diff --git a/test/data/screen2.collection b/test/data/screen2.collection index d5275ea..13c6eba 100644 --- a/test/data/screen2.collection +++ b/test/data/screen2.collection @@ -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 + } +} diff --git a/test/test_monarch.lua b/test/test_monarch.lua index 0fb48ad..80e2828 100644 --- a/test/test_monarch.lua +++ b/test/test_monarch.lua @@ -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)