Simulation platform for training with multiple applications

Abstract

A software training platform may simultaneously display a plurality of interface portions of a third-party software application on a virtual canvas, wherein the displaying comprises loading or rendering each interface portion, and wherein the interface portions are arranged in a workflow. The platform may receive an input from a user on one of the displayed interface portions, generate an API call for the application based on the received input, transmit the API call to the application, receive a response to the API call from the application, and update the virtual canvas based on the response to the API call.

Description

SIMULATION PLATFORM FOR TRAINING WITH MULTIPLE APPLICATIONSCROSS-REFERENCE TO RELATED APPLICATION

[0001] This application claims the benefit of priority to US provisional application no. 63 / 538,692, which is hereby incorporated by reference in its entirety.TECHNICAL FIELD

[0002] The instant disclosure relates to managing and providing a system for simulating user interactions with multiple third-party applications.BRIEF DESCRIPTION OF THE DRAWINGS

[0003] FIG. 1 is a block diagram of an example system for providing a simulation and managing interactions with the simulation for multiple applications.

[0004] FIG. 2 is a flow chart illustrating an example method of generating and updating a simulated interface involving the system of FIG. 1.

[0005] FIG. 3 is a sequence diagram illustrating the example method of FIG. 2.

[0006] FIG. 4 is a flow chart illustrating an example method of managing a simulation canvas involving the system of FIG. 1.

[0007] FIG. 5 is a diagrammatic view of an example canvas with a plurality of sequences of displays.DETAILED DESCRIPTION

[0008] Generally, training users on new software requires a balance between enabling a user to experience the new software themselves but managing the user’s experience in order to facilitate learning rather than outright experimentation. On one extreme, a training protocol may include simply opening the new software up to the user and giving them broad objectives before setting them loose to experiment within the program. While this may work for some enterprisingusers, such a protocol is unscalable, time-insensitive, and inconsistently effective. On the other extreme, a training protocol may include a printed-out or otherwise fixed diagram of possible workflows within the new software, which a user may study in order to subsequently perform the same workflow themselves. However, this approach may lead to a narrowly-trained user that is only able to reproduce the same workflows, and may also disadvantage those users who learn most-effectively in a hands-on environment.

[0009] Accordingly, there is need for a platform capable of creating a guided learning experience for a user through one or more third-party applications, as described herein. In particular, some embodiments described herein disclose a system configured to load or render an interface from a third-party application onto a central canvas of the system, to enable a user to move or otherwise manipulate the interface on the central canvas, and to communicate directly with the third-party application in order to provide an accurate experience to the user. To this end, the system may be configured to receive inputs from the user on the interface of the central canvas, to convert the user’s inputs into Application Programming Interface (API) calls for the third-party application, and to update the interface based on the data returned by the third-party application in response to the API calls or causing the third-party application to launch in response to the API calls - thereby providing a fully-simulated, “in-universe” training environment to the user.

[0010] Referring to the drawings, wherein like reference numerals refer to the same or similar features in the various views, FIG. 1 is a block diagram of an example system 100 for providing user training on third-party applications. The system 100 may include a simulation system 110, a group of third-party applications 120, and a user computing device 130. Each of the simulation system 110, third-party applications 120, and the user computing device 130 may be in electroniccommunication with one another and / or with other components via a network. The network may include any suitable connection (or combinations of connections) for transmitting data to and from each of the components of the system, and may include one or more communication protocols that dictate and control the exchange of data. Furthermore, each of the simulation system 110 and third-party applications 120 may be cloud-based, such that the each may be hosted on a remote server accessed by the user device 130 over the network.

[0011] As shown, the simulation system 110 may include one or more functional modules 114, 116, and 118 embodied in hardware and / or software. In an embodiment, the functional modules 114, 116, and 118 of the simulation system 110 may be embodied in a processor 111 and a memory 112 (i.e., a non-transitory, computer-readable medium) storing instructions that, when executed by the processor 111, cause the simulation system 110 to perform the functionality of one or more of the functional modules 114, 116, and 118 and / or other functionality of this disclosure. For example, the simulation system 110 may provide a digital canvas 136 (e.g., a graphical user interface (GUI)) for the user device 130 that may enable the user to interact with one or more functions of simulation system 110 and / or the third-party applications 120.

[0012] The third-party applications 120 may include multiple applications 122a, 122b, 122c (when referring to a single representative application, “application 122”), each of which may be any suitable computer- and / or mobile-based program and set of instructions that, when executed, cause the hosting device to perform a set of operations. For example, the applications 120 may be broadcast platforms (e.g., for tracking, drafting, planning, laying out, and / or otherwise creating informative or entertaining shows), project management software, resource planning tools, organizational applications, etc. Although reference is made herein to the applications 120being in the broadcast-development space, it should be understood that this disclosure is not limited to the field of broadcast-development, and should be read as providing a training and simulation service based on any computer-based application.

[0013] In some embodiments, the applications 120 may be accessed directly from the user device 130, such that the applications 120 may not be directly stored on the memory 112 of the simulation system 110 and may exist independently of the simulation system 110. For example, an application 122 may be stored and executed on a remote server, and the user device 130 and / or the simulation system 110 may access the application 122 as part of a license agreement, such that the application 122 is accessed by the user on a Software-as-a-Service (SaaS) basis.

[0014] The functional modules 114, 116, and 118 of the simulation system 110 may include a display module 114 configured to communicate with the third-party applications 120 in order to load or render an interface of an application 122 onto the canvas 136 of the user device, or to cause the application 122 to perform certain functionality in response to commands from the simulation system 110. In those embodiments in which the application 122 is a SaaS program, the display module 114 may regularly (e.g., at set intervals) refresh the rendered display on the canvas 136 in order to maintain the most up-to-date version of the application 122. In this manner, the display module 114 (and simulation system 110 generally) may be considered “versioned” rather than dormant or static - further enabling an accurate training experience and avoiding training a user on an outdated version of the application 122. In those embodiments in which the application 122 is not a SaaS program and is instead a fixed-version application stored in the user device memory 134, the display module 114 may retrieve a version identifier for the application 122 to enable the user to train on the same version of the application 122 that they would be using in practice. For example, the display module 114 may determine the versionidentifier associated with a particular user by determining a version of the application 122 stored on the user device 130 (e.g., in a non-SaaS example), may determine a licensed version of the application 122 available to the user based on the user’s login information to the application 122, etc.

[0015] In some embodiments, the display module 114 may be configured to request a particular portion or process from the application 122, such that the interface displayed by the display module 114 on the canvas 136 may be only the particular portion of the application 122 to enable full functionality with limited range. The particular portion may be a preset portion for all users, a preset portion for some users, or a preset portion corresponding to a selected training regimen (e.g., “Beginner Level,” “Advanced Editing Techniques,” etc.) for a specific user type. In some embodiments, a starting block (e.g., initial landing page, home screen, starting point, etc.) may be preset for a user, but the subsequent blocks (e.g., within the workflow) may be dynamically determined in response to the user’s interactions with the canvas 136.

[0016] In addition to the responsiveness described below with reference to the input module 116, the display module 114 may determine a flow for the user’s training based on a perceived pattern of the user’s interactions, which may be stored by and retrieved from the input module 116. For example, in response to the user performing actions within the rendered display that are considered higher-level (e.g., advanced, expert, etc.) actions within the application 122, the display module 114 may determine that the user should be interacting with a more advanced training regimen, and may dynamically determine the next blocks in response. In these embodiments, different users may be presented different training workflows for the same application 122 due to the evaluation of the display module 114 and / or the input module 116, which is differentiable from static training regimens of pre-set and pre-ordered cards.

[0017] The functional modules 114, 116, and 118 of the simulation system 110 may include an input module 116 configured to receive an input from the user on the user device 130 (e.g., via the canvas 136), determine an API call for a relevant application 122 based on the input, and send the API call to the application 122. In some embodiments, the input module 116 may coordinate with the display module 114 to update the displayed application 122 on the canvas 136 based on the data returned in response to the API call. In order to determine the corresponding API call, the input module 116 may determine a nature or characteristic of the user’s interaction (e.g., a tap, a drag, a hold, a multi-click, etc.) and a location of the user’s interaction (e.g., on a pixel-basis, a defined input window basis, etc.). The input module 116 may correlate the characteristic and location of the user’s interaction to a corresponding (simulated) interaction on the application 122, and may generate an API call for the application 122 that would instruct the application 122 to respond as if the simulated interaction had been performed. In some embodiments, the display module 114 may render a simulated interface of the application 122 that mimics the returned API call, while in other embodiments, the input module 116 may re-direct (or open in a window separately from the canvas 136) the user to the application 122 directly.

[0018] In some embodiments, API calls from the input module 116 to the application 122 may cause the application 122 to launch the relevant interface portion and / or response to the user action. For example, the user may be interacting with a simulated interface portion that corresponds to a broadcast display arrangement feature. When the user clicks of the simulated broadcast display arrangement interface portion, the input module 116 may transmit an API call to the application 122 that instructs the application 122 to launch and display the actual broadcast display arrangement interface. In another example, where the simulated broadcast displayarrangement interface portion includes an input button for changing a text color, when the user selects the input button in the simulated interface (e.g., in response to a training instruction to do so), the input module 116 may transmit an API call to the application 122 that provides that actual input to the application 122 so that the user can see how the application 122 responds. In such examples, the user may use the application 122 and the canvas 136 simultaneously (e.g., side-by-side in separate windows) to receive and review training instructions via the canvas 136 and to see the trained behaviors in action in the application 122.

[0019] In addition to responding to and generating API calls based on user interactions, the input module 116 may store a user’s interaction history as associated with the particular user. These stored histories may be utilized, as described above, by the display module 114 to dynamically determine training regimens. In some embodiments, the stored histories may be analyzed (e.g., by the input module 116) to provide statistics on user engagement (or performance) within the canvas 136.

[0020] The functional modules 114, 116, and 118 of the simulation system 110 may include a canvas module 118 configured to provide a central workspace (e.g., canvas 136) for one or more displayed interfaces rendered by the display module 114 to be presented to a user. The canvas module 118 may generate the canvas 136 as an interactable 2-dimensional space with fully- enabled navigation (e.g., zooming, panning, rotating, etc.). As a display is rendered, the canvas module 118 may present the display on a particular part of the canvas 136, and may enable a user to re-size, re-position, and re-orient the rendered display within the canvas 136. To this end, the canvas 136 may be scalable such that a user is not limited in their ability to manipulate the rendered display. In some embodiments, the canvas module 118 may respond to commands from the display module 114 to re-order the rendered displays (e.g., based on the display module 114determining a pattern of training). Each interface portion or display presented on the canvas 136 may be presented as a “card” or other modular element on the canvas, and the canvas 136 may present various sequences of cards that correlate to different training regimens or protocols for different user types.

[0021] In addition to positioning rendered displays on the canvas 136, the canvas module 118 may be further configured to analyze the content of each rendered display in order to provide a fully-searchable resource for the user. The canvas module 118 may also facilitate links between different rendered displays and / or training flows, such that a user who wants to learn more about a particular application 122 or application 122 feature shown in but not addressed by a current training flow may be directed by a link to the portion of the canvas 136 that addresses such an application 122 or application 122 feature. The canvas module 118 may determine and generate these links based on the analyzed content. For example, the canvas module 118 may determine that the term “New Story” is used most frequently in a particular pre-set training regimen, and may generate a link for any other instance of the term “New Story” to direct the user to that particular pre-set training regimen. By interacting with the link, the view of the canvas 136 shown to the user may be manipulated to show the portion of the canvas 136 that includes the linked regimen. In this manner, each rendered display (and workflow) may be associated with a coordinate (e.g., spatial position) within the canvas. Accordingly, the canvas module 118 may compile an index of terms, displays, and regimens in order to guide a user’s experience within the canvas 136, with each entry in the index corresponding to a set of coordinates.

[0022] FIG. 2 is a flow chart illustrating an example method 200 of generating and updating a simulated interface. The method 200, or one or more portions of the method 200, may beperformed by system 100 and particularly the simulation system 110 (shown in FIG. 1), in some embodiments, and thus the method 200 may be computer-implemented.

[0023] The method 200 may include, at block 210, loading or rendering an interface from a third-party application (e.g., application 122). As described above with reference to the display module 114, the interface rendered may be a pre-set landing page or may be dynamically determined based on a user’s previous interactions with the application 122.

[0024] The method 200 may also include, at block 220, receiving an input from a user on the rendered interface. The input may be received via a device (e.g., user device 130) on which the display is rendered.

[0025] The method 200 may further include, at block 230, generating an API call for the application 122 based on the received input.

[0026] The method 200 may also include, at block 240, sending the generated API call to the application 122.

[0027] The method 200 may further include, at block 250, updating the rendered interface based on the response to the API call. In some embodiments, the update may include re-loading the displayed interface to reflect any changes introduced by the received input. In some embodiments, the update may include loading a new displayed interface to reflect a new page, screen, interface, etc. that may be generated by the application 122 in response to the received input.

[0028] FIG. 3 is a sequence diagram illustrating an example process 300 of generating and updating a simulated interface. The process 300 may run in parallel with the method 200 of FIG.2, with each block of the method 200 performed by the simulation system 110 while each operation of the process 300 may be performed by different components, as shown in FIG. 3.

[0029] The process 300 may include, at operation 310, third-party application 120 transmitting data to the simulation system 110 that may be sufficient for the simulation system 110 to render a window, display, or interface of the third-party application 120.

[0030] The process 300 may also include, at operation 320, the simulation system 110 presenting the rendered interface to the user device 130.

[0031] The process 300 may further include, at operation 330, the simulation system 110 receiving an input on the interface from the user device 130.

[0032] The process 300 may also include, at operation 340, the simulation system 110 generating and transmitting an API call to the third-party application 120 based on the input received from the user device 130.

[0033] The process may further include, at operation 350, the third-party application 120 responding to the API call.

[0034] The process may also include, at operation 360, the simulation system 110 generating and presenting an updated interface to the user device 130 based on the response to the API call.

[0035] FIG. 4 is a flow chart illustrating an example method 400 of managing a simulation canvas. The method 400, or one or more portions of the method 400, may be performed by system 100 and particularly the simulation system 110 (shown in FIG. 1), in some embodiments, and thus the method 400 may be computer-implemented.

[0036] The method 400 may include, at block 410, rendering a first application (e.g., application 122a) on a canvas (e.g., canvas 136), and, at block 420, rendering a second application (e.g., application 122b) on the canvas 136. The canvas 136 may be presented on the user device 130, and each application may be rendered as a separate window.

[0037] The method 400 may include, at block 430, receiving an input from a user (e.g., via the user device 130) regarding a position, orientation, or size of the rendering of the first application 122a on the canvas 136, and, at block 440, updating the render of the first application 122a without changing the render of the second application 122b. Accordingly, the method 400 may enable a user to customize the canvas 136 to their liking.

[0038] FIG. 5 is a diagrammatic view of an example canvas 136 which may include various training regimens for an example application. The example canvas 136 is shown in FIG. 5 as including two training regimens 502, 504, but the canvas 136 may include any number of training regimens on a single searchable, indexed canvas.

[0039] Each training regimen (e.g., training flow or workflow) 502, 504 may include a sequence of cards 506 (four such cards 506a, 506b, 506c, 506x are labeled in FIG. 5), with each card 506 including a simulated interface portion from the application. For example, each card 506 may include a respective simulated interface portion from the application and one or more instructions for how the user should interact with that interface portion to achieve a particular goal relevant to the user type. Accordingly, each training regimen 502, 504 may be designed for a particular user type. As described above, if a user selects a particular card 506b or an input element on the interface portion of card 506b, an API call may be generated and sent to the application so that the user can observe the actual response of the application or the actual interface portion of the application.

[0040] Cards 506 within a training regimen 502, 504 may be arranged so that, if the user follows the instructions associated with a given card, the corresponding response or responses of the application is shown in a next card presented either next to, above, or below the card. That is, card 506a may include an instruction to the user that, if followed, results in the interfaceportion of card 506b, and so on. Accordingly, branching workflows that are relevant to a given task may be presented in horizontally-parallel sets of cards within a single regimen, in some embodiments.

[0041] The canvas 136 may be zoomable and scrollable by the user. The illustration of FIG. 5 represents a zoomed-out view of the canvas 136. The user may zoom in on one or more particular cards 506 to view the interface portions and instructions on those cards 506 in detail. In some embodiments, zooming in the canvas may zoom both the distance between cards as well as the cards themselves, along with associated text.

[0042] In some embodiments, a single canvas 136 may be specific to a set of related tasks or goals of a specific user. Accordingly, training regimens 502, 504 may be respective of related tasks for a particular user type within the application.

[0043] As noted above, the cards 506 may be individually indexed and searchable to simplify user navigation between cards and regimens within the canvas 136. For example, the user may see an input button on card 506b that, in the application, would navigate the user to a separate interface portion. The user may select that input button and, instead or in addition to an API call to the application, the canvas may quickly direct the user to another card (e.g., card 506x) that includes the simulated separate interface portion based the indexing of cards. The user may be directed by automatically scrolling the canvas to card 506x, by highlighting card 506x, or through other navigational output. Such indexing may be particularly useful, for example, to enable users to explore functionality outside of a designed regimen.

[0044] Similarly, a user may find a term on a card (e.g., card 506c) and may want to find where else in the application that term is used. Accordingly, the user may enter a search query for that term (e.g., using a search query input portion 508 provided on the canvas), and interfaceportions that match the search query may be highlighted on the canvas 136, the user may automatically be navigated to those cards on the canvas, etc.

[0045] In a first aspect of the present disclosure, a computer-implemented method is provided that includes simultaneously displaying, by a computing system, a plurality of interface portions of a third-party software application on a virtual canvas, wherein the displaying comprises loading or rendering each interface portion, receiving, by the computing system, an input from a user on one of the displayed interface portions, generating, by the computing system, an API call for the application based on the received input and transmitting the API call to the application, and receiving, by the computing system, a response to the API call from the application and updating the virtual canvas based on the response to the API call.

[0046] In an embodiment of the first aspect, the method further includes displaying, by the computing system in response to the input, the running third-party software application. In a further embodiment of the first aspect, the method further includes launching, by the computing system in response to the input, the third-party application. In an embodiment of the first aspect, the running third-party application is displayed in a separate window from the virtual canvas.

[0047] In an embodiment of the first aspect, the method further includes retrieving a version identifier indicative of a version of the third-party application on which the user is to be trained, wherein the plurality of interface portions correspond to the version.

[0048] In an embodiment of the first aspect, the simultaneous display further comprises respective instructions associated with each interface portion.

[0049] In an embodiment of the first aspect, the plurality of interface portions are arranged in a workflow.

[0050] In an embodiment of the first aspect, the virtual canvas is zoomable and scrollable by the user.

[0051] In a second aspect of the present disclosure, a computing system is provided that includes a processor and a non-transitory, computer-readable memory storing instructions that, when executed by the processor, cause the computing system to perform operations that include simultaneously displaying a plurality of interface portions of a third-party software application on a virtual canvas, wherein the displaying includes loading or rendering each interface portion, receiving an input from a user on one of the displayed interface portions, generating an API call for the application based on the received input and transmitting the API call to the application, and receiving a response to the API call from the application and updating the virtual canvas based on the response to the API call.

[0052] In an embodiment of the second aspect, the computing system is a server and the application executes on a local computing device of the user.

[0053] In an embodiment of the second aspect, the operations further include causing a computing device of the user to display, in response to the input, the running third-party software application.

[0054] In an embodiment of the second aspect, the operations further include causing a computing device of the user to launch, in response to the input, the third-party application. In a further embodiment of the second aspect, the running third-party application is displayed in a separate window from the virtual canvas.

[0055] In an embodiment of the second aspect, the operations further include retrieving a version identifier indicative of a version of the third-party application on which the user is to be trained, wherein the plurality of interface portions correspond to the version.

[0056] In an embodiment of the second aspect, the virtual canvas is zoomable and scrollable by the user.

[0057] While this disclosure has described certain embodiments, it will be understood that the claims are not intended to be limited to these embodiments except as explicitly recited in the claims. On the contrary, the instant disclosure is intended to cover alternatives, modifications and equivalents, which may be included within the spirit and scope of the disclosure.Furthermore, in the detailed description of the present disclosure, numerous specific details are set forth in order to provide a thorough understanding of the disclosed embodiments. However, it will be obvious to one of ordinary skill in the art that systems and methods consistent with this disclosure may be practiced without these specific details. In other instances, well known methods, procedures, components, and circuits have not been described in detail as not to unnecessarily obscure various aspects of the present disclosure.

[0058] Some portions of the detailed descriptions of this disclosure have been presented in terms of procedures, logic blocks, processing, and other symbolic representations of operations on data bits within a computer or digital system memory. These descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. A procedure, logic block, process, etc., is herein, and generally, conceived to be a self-consi stent sequence of steps or instructions leading to a desired result. The steps are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these physical manipulations take the form of electrical or magnetic data capable of being stored, transferred, combined, compared, and otherwise manipulated in a computer system or similar electronic computing device. For reasons of convenience, and with reference to common usage, such data is referred to as bits, values,elements, symbols, characters, terms, numbers, or the like, with reference to various presently disclosed embodiments. It should be borne in mind, however, that these terms are to be interpreted as referencing physical manipulations and quantities and are merely convenient labels that should be interpreted further in view of terms commonly used in the art. Unless specifically stated otherwise, as apparent from the discussion herein, it is understood that throughout discussions of the present embodiment, discussions utilizing terms such as “determining” or “outputting” or “transmitting” or “recording” or “locating” or “storing” or “displaying” or “receiving” or “recognizing” or “utilizing” or “generating” or “providing” or “accessing” or “checking” or “notifying” or “delivering” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data. The data is represented as physical (electronic) quantities within the computer system’s registers and memories and is transformed into other data similarly represented as physical quantities within the computer system memories or registers, or other such information storage, transmission, or display devices as described herein or otherwise understood to one of ordinary skill in the art.

Claims

CLAIMSWhat is claimed is:

1. A computer-implemented method comprising: simultaneously displaying, by a computing system, a plurality of interface portions of a third-party software application on a virtual canvas, wherein the displaying comprises loading or rendering each interface portion; receiving, by the computing system, an input from a user on one of the displayed interface portions; generating, by the computing system, an API call for the application based on the received input and transmitting the API call to the application; and receiving, by the computing system, a response to the API call from the application and updating the virtual canvas based on the response to the API call.

2. The computer-implemented method of claim 1, further comprising: displaying, by the computing system in response to the input, the running third-party software application.

3. The computer-implemented method of claim 2, further comprising: launching, by the computing system in response to the input, the third-party application.

4. The computer-implemented method of claim 2, wherein the running third-party application is displayed in a separate window from the virtual canvas.

5. The computer-implemented method of claim 1, further comprising:retrieving a version identifier indicative of a version of the third-party application on which the user is to be trained; wherein the plurality of interface portions correspond to the version.

6. The computer-implemented method of claim 1, wherein the simultaneous display further comprises respective instructions associated with each interface portion.

7. The computer-implemented method of claim 1, wherein the plurality of interface portions are arranged in a workflow.

8. The computer-implemented method of claim 1, wherein the virtual canvas is zoomable and scrollable by the user.

9. A computing system comprising: a processor; and a non-transitory, computer-readable memory storing instructions that, when executed by the processor, cause the computing system to perform operations comprising: simultaneously displaying a plurality of interface portions of a third-party software application on a virtual canvas, wherein the displaying comprises loading or rendering each interface portion; receiving an input from a user on one of the displayed interface portions; generating an API call for the application based on the received input and transmitting the API call to the application; and receiving a response to the API call from the application and updating the virtual canvas based on the response to the API call.

10. The computing system of claim 9, wherein the computing system is a server and the application executes on a local computing device of the user.

11. The computing system of claim 9, wherein the operations further comprise: causing a computing device of the user to display, in response to the input, the running third-party software application.

12. The computing system of claim 11, wherein the operations further comprise: causing a computing device of the user to launch, in response to the input, the third-party application.

13. The computing system of claim 12, wherein the running third-party application is displayed in a separate window from the virtual canvas.

14. The computing system of claim 9, wherein the operations further comprise: retrieving a version identifier indicative of a version of the third-party application on which the user is to be trained; wherein the plurality of interface portions correspond to the version.

15. The computing system of claim 9, wherein the virtual canvas is zoomable and scrollable by the user.

Images