Patent Publication Number: US-10785310-B1

Title: Method and system implementing dynamic and/or adaptive user interfaces

Description:
BACKGROUND 
     Applications implement user interfaces to enable users to interact with various features of the application. These user interfaces are traditionally static in nature and are difficult to customize. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         FIG. 1  shows an example system in accordance with one or more embodiments of the disclosed technology. 
         FIG. 2  shows the relationship between various components in the example system in accordance with one or more embodiment of the disclosed technology. 
         FIG. 3  shows an example method for tracking user interface (UI) events in accordance with one or more embodiments of the disclosed technology. 
         FIG. 4  shows an example method for implementing dynamic and/or adaptive user interfaces in accordance with one or more embodiments of the disclosed technology. 
         FIGS. 5A, 5B, and 5C  show an example of dynamically modifying UI components in accordance with one or more embodiments of the disclosed technology. 
         FIGS. 6A and 6B  show an example of dynamically modifying a UI screen in accordance with one or more embodiments of the disclosed technology. 
         FIGS. 7A, 7B, and 7C  show an example of dynamically modifying UI screens and the order of UI screens in accordance with one or more embodiments of the disclosed technology. 
         FIG. 8  shows a computing system in accordance with one or more embodiments of the disclosed technology. 
     
    
    
     DETAILED DESCRIPTION 
     Specific embodiments of the disclosed technology will now be described in detail with reference to the accompanying figures. In the following detailed description of embodiments of the disclosed technology, numerous specific details are set forth in order to provide a more thorough understanding of the disclosed technology. However, it will be apparent to one of ordinary skill in the art that the disclosed technology may be practiced without these specific details. In other instances, well-known features have not been described in detail to avoid unnecessarily complicating the description 
     In the following description of  FIGS. 1-8 , any component described with regard to a figure, in various embodiments of the disclosed technology, may be equivalent to one or more like-named components described with regard to any other figure. For brevity, descriptions of these components will not be repeated with regard to each figure. Thus, each and every embodiment of the components of each figure is incorporated by reference and assumed to be optionally present within every other figure having one or more like-named components. 
     Additionally, in accordance with various embodiments of the disclosed technology, any description of the components of a figure is to be interpreted as an optional embodiment which may be implemented in addition to, in conjunction with, or in place of the embodiments described with regard to a corresponding like-named component in any other figure. 
     In general, embodiments of the technology relate to a method and system for implementing dynamic and/or adaptive user interfaces in an application. More specifically, embodiments of the technology monitor how a user(s) interacts with the user interface of a given application and then modifies the user interface in order to improve the user&#39;s use of the application. Modification of the user interface may include, for example, changing the layout of a menu, the layout of the user interface components on a user interface, adding new user interface components to the user interface, and/or modifying content provided by various user interface components in the user interface. 
       FIG. 1  shows an example system in accordance with one or more embodiments of the disclosed technology. The system includes an application server ( 100 ), one or more end user devices ( 102 A,  102 B), and a user interface (UI) analytics repository. Each of these components is described below. 
     In one embodiment of the technology, an application server ( 100 ) is a computing system (e.g., a computing system described in  FIG. 8 ) that includes functionality to host a deployed application (also referred to as a deployed web application ( 108 )). Hosting the deployed web application may include storing the necessary files including source code, images, third party libraries, etc. and then executing the deployed web application. Executing the deployed web application may include receiving HTTP requests from an end user device ( 102 A,  102 B), processing the HTTP requests, generating HTTP responses based on the processing of the HTTP requests, and providing the HTTP responses to the end user device. The application server ( 100 ) may also include functionality to perform all or portion of the steps shown in  FIGS. 3 and 4 . 
     Continuing with the discussion of  FIG. 1 , the term “web application” is used herein to generically refer to the web application executable, the web application design, or another form of the web application. Web applications include webpages. A webpage ( 106 ) is an output of the web application that is displayed on a web browser ( 104 ). In one embodiment of the technology, a webpage ( 106 ) may be considered a UI screen (see  FIG. 2 ). 
     In one embodiment of the technology, the application server ( 100 ) may communicate (e.g., send and receive HTTP requests) with one or more end user devices (e.g., the computing systems in  FIG. 8 ) over any wired network, wireless network, or other network that includes any combination of wired networks or wireless networks. 
     In one embodiment of the technology, the end user devices ( 102 A,  102 B) each include at least one web browser ( 104 ) that permits the end user device to display webpages ( 106 ) (provided with HTTP responses) to the end users. An end user is an individual or group of individuals that uses the web application via the end user device once the web application is deployed. 
     In one embodiment of the technology, the application server ( 102 ) also implements (or executes) a UI analytics engine ( 110 ). The UI analytics engine ( 110 ) may include functionality to: (i) create and store UI event entries in the UI analytics repository ( 112 ); (ii) analyze the UI event entries in the UI analytics repository ( 112 ) in order to generate an application UI action profile (AUIP) (see  FIG. 2 ); and (iii) modify one or more UI screens in an application based on the AUIP (see  FIG. 4-7C ). 
     In one embodiment of the technology, the UI analytics repository ( 112 ) includes persistent storage (e.g., solid state storage, magnetic storage, optical storage, any other type of persistent storage or any combination thereof) in which the UI event entries are stored. The UI analytics repository may store UI event entries using any known or subsequently discovered mechanism. The following describes various examples of the mechanisms that may be used to store UI event entries. The examples are not intended to limit the technology. In a first example, the UI analytics repository may be a set of magnetic hard disks. In a second example, the UI analytics repository may be implemented using a computer cluster that is executing a distributed file system. In a third example, the UI analytics repository may be implemented using a network file server and one or more block-storage devices (i.e., as a Storage Area Network). 
     While  FIG. 1  shows a configuration of components, other configurations may be used without departing from the scope of the technology. For example, various components may be combined to create a single component. As another example, the functionality performed by a single component may be performed by two or more components. 
       FIG. 2  shows various components of the technology and the relationship between various components in the example system in accordance with one or more embodiment of the disclosed technology. 
     In one embodiment of the technology, each deployed application ( 200 ) (described above) is associated with (or includes) one or more UI screens (or webpages) ( 202 ). Each of the UI interface screens ( 202 ) may include one or more UI components ( 206 ) organized according to a UI component layout ( 208 ). Examples of UI components ( 206 ) may include, but are not limited to, checkboxes, buttons, radio buttons, sliders, numeric updown buttons, search boxes, scroll bars, list boxes, text boxes, menus, and icons (i.e., a picture that represents objects such as a file, program, web page, or command). The UI component layout ( 208 ) specifies how the UI components on the particular UI screen are arranged. 
     As discussed above, the application server ( 100 ) includes functionality to create and store UI event entries ( 204 ). Each UI event entry may be associated with one or more of the following: (i) a deployed application (i.e., the application in which the UI event was initiated) and (ii) the user that initiated/triggered the UI event. 
     Each UI event entry may specify ( 204 ) one or more of the following: (i) name of the UI event that was performed (e.g., button A was clicked, UI component B was selected, a menu selection event (i.e. a particular item in a menu is selected), a webpage transition event (i.e., an event that results in the transition to a new UI screen), etc.), (ii) the application in which the UI event was performed, (iii) a UI screen in which the UI event was initiated; (iv) the username of the user that performed the UI event; (v) the role of the user that performed the UI event; (vi) any other information about the user that performed the event; (vii) a timestamp of when the UI event was initiated; (viii) a workflow group with which the event is associated (described below), (ix) any other context information associated with the UI event; and/or (x) any other information that is associated with the UI event. 
     In one embodiment of the technology, the context information for the UI event may include information about the state of the application and/or information about the user at the time the UI event was initiated. For example, if application is designed to assist the user in performing a series of tasks (also referred to as workflows), then if the user triggers a UI event while performing a portion of a workflow such context information may be included in the UI event entry. 
     In another example, the UI event entry may include context information in the form of the geographic location in which the user is located when the user triggered the UI event. For example, the UI entry event may indicate that the user was in geographic location A when the UI event specified in the UI entry was triggered. The context information may be used, for example, to enable a more fine grained modification of the UI screen for a given user when the user is traveling to different geographic locations. For example, a first modified UI screen may be shown to the user when the user is geographic location A and a second modified UI screen may be shown to the user when the user is in geographic location B. 
     Continuing with the discussion of  FIG. 2 , the individual UI event entries may be analyzed in order to generate an application UI interaction profile (AUIP). The AUIP ( 212 ) includes information that is aggregated from the individual UI event entries. For example, the AUIP may indicate that user A spends 70% of her time on UI screen C of a deployed application, where this information may be ascertained based on the number of UI event that are triggered on UI screen C. The AUIP ( 212 ) may also include information about the most common UI events that are performed on a given UI screen and/or within the deployed application as a whole. The AUIP ( 212 ) may include other information without departing from the technology (see e.g.,  FIGS. 5A-7C ). 
     In one embodiment of the technology, each user ( 210 ) is associated with one AUIP for each application that she uses. Alternatively, each user ( 210 ) may be associated with a single AUIP for all deployed applications that the user is using. Further, each deployed application may be associated with one or more AUIPs, where the AUIPs may be associated with specific users and/or with groups of users (e.g., users with the same role). 
     Turning to the flowcharts, while the various steps in the flowcharts are presented and described sequentially, one of ordinary skill will appreciate that some or all of the steps may be executed in different orders, may be combined or omitted, and some or all of the steps may be executed in parallel. 
       FIG. 3  shows an example method for tracking user interface (UI) events in accordance with one or more embodiments of the disclosed technology. 
     In step  300 , a request is received from an end user device. The request may correspond to any request that was initiated based on a user performing a UI event (e.g., clicking on a UI component) on a UI screen within the application. The request may include information about UI event that resulted in the request being generated and sent to the application server. The request may also include various parameters (or values) that need to be processed by the deployed application in order to service the request. 
     In step  302 , information about the UI event associated with the request in step  300  is extracted (or otherwise obtained) from the request. 
     In step  304 , a UI event entry (discussed above) is created and stored in the UI analytics repository. The UI event entry may be created by the UI analytics engine. The information specified in the UI event entry may vary based on the implementation of the technology. 
     In step  306 , the requested is serviced. More specifically, the request is processed by the deployed application and a response is provided by the deployed application to the end user device (which, in various embodiments, may be referred to as a requesting entity). 
     In one embodiment of the technology, servicing the request may include obtaining content and then providing the obtained content to the end user device. In various embodiments of the technology, servicing the request may also include provide another UI screen (or webpage) for the end user device to display. In such cases, servicing the request may include performing steps  402 - 408  (described below). 
     In one or more embodiments of the technology, UI event entries created and stored for all (or a portion) of the requests are processed by the application server or, more specifically, the UI analytics engine. The UI analytics engine (as discussed above) uses this information to generate AUIPs (described above). The UI analytics engine also includes functionality to update the previously generated AUIPs and/or to create new AUIPs based on new UI event entries that are created and stored in the UI analytics repository. 
       FIG. 4  shows an example method for implementing dynamic and/or adaptive user interfaces in accordance with one or more embodiments of the disclosed technology. 
     In step  400 , a request is received from an end user device. The request may correspond to any request that was initiated based on a user performing a UI event (e.g., clicking on a UI component) on a UI screen within the application. The request may include information about UI event that resulting in the request being generated and sent to the application server. The request may also include various parameters (or values) that need to be processed by the deployed application in order to service the request. 
     In step  402 , the deployed application may determine a default UI screen that is to be provided to end user device in response to the request. More specifically, step  402  may include processing the request in order, for example, to determine the nature of the response that is to be provided to the end user device. 
     In some scenarios, the request does not result in a change to the UI screen that is currently being shown to the user via the end user device. In such scenarios, the response, which may include, for example, content that is to be displayed in the UI screen that is currently being shown to the user is obtained by the deployed application and then provided to the end user device and the process ends. 
     In other scenarios, the request results in a change in the UI screen, i.e., the response to the request requires that the end user device display another UI screen to the user. Examples of such requests may include, but are not limited to: (i) logging into an application that results in the home screen being shown; (ii) selecting a menu element that results in a new UI screen associated with the selected menu element being shown; (iii) selecting a UI component on a current UI screen which triggers an action (e.g., a search action, a file upload action, etc.) that results in a new UI screen that displays the result of performing the action that was triggered. 
     In these scenarios, the request is processed and, as part of the processing, the new UI screen that is to be shown to the user is obtained. In certain embodiments the UI screen identified in step  402  is referred to as the default UI screen, i.e., UI screen that was originally created by the application developer. 
     In step  404 , one or more AUIPs associated with the user are obtained. The AUIPs may be, for example, (i) specific to the user; (ii) specific to a role of the user (e.g., human resources employee, regional sales manager, etc.); and/or (iii) specific to the legal entity with which the user is associated (e.g., a company, corporation, partnership, etc.). Further, the AUIP may (or may not be) application specific. For example, the AUIPs obtained in step  404  may be specific to the application. Alternatively, the AUIPs may include both application-specific and non-application specific AUIPs. 
     In step  406 , a determination is made about whether the UI screen (i.e., the UI screen obtained in step  406 ) is to be modified. Said another way, the AUIP(s) obtained in step  404  is analyzed to determine whether the UI should be modified. The determination in step  406  may include: (i) determining whether the AUIP(s) includes any information related to how the user has previously interacted with the UI components on the UI screen identified in step  402  and/or (ii) determining whether the AUIP includes any information about how the user has previously interacted with the application (i.e., the application with which the UI screen is associated). 
     If there is no information available in the AUIP(s) to make such a determination, then the UI analytics engine may take no further action and allow the process to proceed to step  408 . In step  408 , the default UI screen (along with the appropriate content) is provided to the end user device. The process then ends. 
     Returning to step  406 , if there is relevant information in the AUIP that is available then the UI analytics engine proceeds to step  410 . In step  410 , the UI screen is modified based on the AUIP. Modification of the UI screen may include, for example, (i) modifying a UI component and/or UI component layout of UI components on the UI screen (see e.g.,  FIGS. 5A-5C ); (ii) adding and/or removing UI components from a UI screen (see e.g.,  FIG. 6A-6B ); and (iii) adding and/or removing content that is to be displayed in the UI screen (see e.g.,  FIG. 7A-7C ). Other modifications to the UI screen may be performed without departing from the technology. In step  412 , modified UI screen (along with the appropriate content) is provided to the end user device. The process then ends. 
     In one embodiment, as discussed in  FIG. 4 , the modification of UI screens is performed in real-time (i.e., in response the requests from the end user device). 
     In another embodiment, the UI analytics engine analyzes the UI event entries and determines how various UI screens should be modified and/or how each of the various UI screens should be connected. Based on this analysis, one or more of the following UI screen modifications may occur: (i) a new UI screen is created that incorporates content (and/or UI components) from two or more other default UI screens; (ii) one or more default UI screens are removed from the deployed application; (iii) the order in which a user may navigate through one or more UI screens is updated; (iv) one or more UI screens is modified as described above with respect to  FIG. 410 . In one embodiment of the technology, the modified UI screens may be stored in the application server. Further, for any given application, there may be multiple versions of a given UI screen, where each version of the UI screen is modified based on an AUIP associated with a specific user of the application and/or modified based on an AUIP associated with a specific set of users (e.g., users associated with a given role, users located within a given geographic regions, etc.) of the application. 
     The resulting modified UI screens may then be retrieved and provided to the appropriate user(s) in response to received requests. In this manner, the modifications to UI may be performed at some point prior to the request based on a previously obtained AUIP(s) for the user. Accordingly, when a request is received by an end user device (see e.g.,  FIG. 4 , step  400 ), the application and user are identified and, based this information, the previously generated modified UI screen is obtained and presented to the user (populated with appropriate content). 
     The following section describes various examples in accordance with one or more embodiments of the technology. The examples are not intended to limit the scope of the technology. 
       FIGS. 5A-5C  show an example of dynamically modifying UI components in accordance with one or more embodiments of the disclosed technology. The example is not intended to limit the scope of the disclosed technology. 
     Turning to  FIG. 5A , consider a scenario in which a UI screen (not shown) includes a menu that includes a set of menu elements denoted A-D and X-Z, where menu elements A-D are visible in the menu and menu elements X-Z are not visible in the menu; rather, menu elements X-Z can only be accessed by selecting a button (not shown) to further expand the menu to show menu elements X-Z. For the purposes of this example assume that the user, as evidenced by multiple UI event entries, only ever selects menu elements A, X, C, and Z. 
     Accordingly, the UI analytics engine, based on the above UI event entries, may update the menu, as shown in  FIG. 5B , such that menu elements A, X, C, and Z are visible and menu elements B, Y and Z are not visible in the menu. 
     With respect to  FIG. 5C , further assume that a second user also uses the same application; however, the second user only uses menu elements A, X, Y, and Z. Accordingly, for the second user, the UI analytics engine may update the menu, as shown in  FIG. 5C , such that menu elements A, X, Y, and Z are visible and menu elements B, C and D are not visible in the menu. 
       FIGS. 6A-6B  show an example of dynamically modifying a UI screen in accordance with one or more embodiments of the disclosed technology. The example is not intended to limit the scope of the disclosed technology. 
     Turning to  FIG. 6A , consider a scenario in which the application includes a default home screen ( 600 ) as one of the UI screens in the application. The default home screen ( 600 ) includes a top level menu bar ( 602 ) and a content portion ( 604 ). 
     For the purposes of this example assume that the user, as evidenced by multiple UI event entries, routinely performs a file upload action and that the file upload action in the application is located on the third UI screen (shown). Accordingly, to access the file upload action, the user needs to select a first button in a home screen to navigate to a second UI screen and then select a second button on the second UI screen to navigate to the third UI screen. Once the third UI screen is displayed, the user may initiate the file upload action by selecting a corresponding UI component on the third UI screen. 
     Referring to  FIG. 6B , the UI analytics engine, based on the above UI event entries, may modify the home screen UI ( 600 ) in order to generate a modified home screen ( 606 ) that includes a new UI component ( 608 ) that enables a user to directly initiate the upload action from the modified home screen ( 606 ). In this manner, embodiments of the technology enable the user to more efficiently perform the upload action (i.e., in one click from the modified home screen as opposed to three clicks from the default home screen). 
       FIGS. 7A-7C  show an example of dynamically modifying UI screens and the order of UI screens in accordance with one or more embodiments of the disclosed technology. The example is not intended to limit the scope of the disclosed technology. 
     Consider a scenario in which the default UI screen order for an application is shown in  FIG. 7A . More specifically, from the home screen the user may either navigate to UI screen A or UI screen D. Further, from UI screen A the user may navigate to UI screen B and from UI screen B the user may navigate to UI screen C. The user, using the default UI screen order, may not directly navigate to UI screen C from the home screen; rather, the user must navigate at least through UI screen A and UI screen B prior to reaching UI screen B. 
     For the purposes of this example assume that the user, as evidenced by multiple UI event entries, spends 70% of their time on UI screen C. Accordingly, as shown in  FIG. 7B , the UI analytics engine may: modify and/or add one or more UI components (not shown) on the home screen in order to generate a modified home screen ( 700 ). The modified home screen may allow direct access to UI screen C from the modified home screen ( 700 ). 
     With respect to  FIG. 7C , consider a scenario in which the user uses content that is displayed in various UI components (not shown) in UI screen B and UI screen C. More specifically, assume that the user is a regional sales representative and the application includes the following information: (i) contact information for each client in the user&#39;s sales territory on UI screen B and (ii) a summary of sales made to each client on UI screen C. Further, based on the analysis of the UI event entries, the UI analytics engine determines that the user spends a majority of her time switching between UI screen B and UI screen C. 
     Accordingly, the UI analytics engine generates a modified home screen ( 702 ), as shown in  FIG. 7C , that includes content from UI Screen B and content from UI screen C. Further, the modified home screen ( 702 ) may be updated to include a dashboard component (not shown) that includes the content from UI screen B and content from UI screen C. In this manner, embodiments of the technology enable the aggregation of content that is relevant to a user onto a single UI screen. 
     Embodiments of the technology may be implemented on a computing system. Any combination of mobile, desktop, server, embedded, or other types of hardware may be used. For example, as shown in  FIG. 8 , the computing system ( 800 ) may include one or more computer processor(s) ( 802 ), associated memory ( 804 ) (e.g., random access memory (RAM), cache memory, flash memory, etc.), one or more storage device(s) ( 806 ) (e.g., a hard disk, an optical drive such as a compact disk (CD) drive or digital versatile disk (DVD) drive, a flash memory stick, etc.), and numerous other elements and functionalities. The computer processor(s) ( 802 ) may be an integrated circuit for processing instructions. For example, the computer processor(s) may be one or more cores, or micro-cores of a processor. The computing system ( 800 ) may also include one or more input device(s) ( 810 ), such as a touchscreen, keyboard, mouse, microphone, touchpad, electronic pen, or any other type of input device. Further, the computing system ( 800 ) may include one or more output device(s) ( 808 ), such as a screen (e.g., a liquid crystal display (LCD), a plasma display, touchscreen, cathode ray tube (CRT) monitor, projector, or other display device), a printer, external storage, or any other output device. One or more of the output device(s) may be the same or different from the input device(s). The computing system ( 800 ) may be connected to a network ( 812 ) (e.g., a local area network (LAN), a wide area network (WAN) such as the Internet, mobile network, or any other type of network) via a network interface connection (not shown). The input and output device(s) may be locally or remotely (e.g., via the network ( 812 )) connected to the computer processor(s) ( 802 ), memory ( 804 ), and storage device(s) ( 806 ). Many different types of computing systems exist, and the aforementioned input and output device(s) may take other forms. 
     Software instructions in the form of computer readable program code to perform embodiments of the technology may be stored, in whole or in part, temporarily or permanently, on a non-transitory computer readable medium such as a CD, DVD, storage device, a diskette, a tape, flash memory, physical memory, or any other computer readable storage medium. Specifically, the software instructions may correspond to computer readable program code that, when executed by a processor(s), is configured to perform embodiments of the technology. 
     Further, one or more elements of the aforementioned computing system ( 800 ) may be located at a remote location and connected to the other elements over a network ( 812 ). Further, embodiments of the technology may be implemented on a distributed system having a plurality of nodes, where each portion of the technology may be located on a different node within the distributed system. In one embodiment of the technology, the node corresponds to a distinct computing device. Alternatively, the node may correspond to a computer processor with associated physical memory. The node may alternatively correspond to a computer processor or micro-core of a computer processor with shared memory and/or resources. 
     While the disclosed technology has been described with respect to a limited number of embodiments, those skilled in the art, having benefit of this disclosure, will appreciate that other embodiments can be devised which do not depart from the scope of the disclosed technology as disclosed herein. Accordingly, the scope of the disclosed technology should be limited only by the attached claims.