Hardware element abstraction

Abstract

Implementing a configurable input component includes detecting a user input via a configurable input component of a device, determining, by the device, contextual information, and identifying a set of actions associated with a first application. A next action is selected based on the contextual information, and the application is caused to perform the selected next action.

Description

Technical Field

[0001] Embodiments described herein relate to input techniques for mobile devices. More specifically, embodiments described herein relate to providing an abstraction layer. Background Art

[0002] Portable wearable electronic devices typically have limited input components due to their small form factor. For example, a watch may typically have 1 to 2 buttons and / or a small touch display on the face. Traditionally, hardware elements such as buttons may be configured to perform a predetermined action when pressed. However, the computing power of these small wearable devices is rapidly growing, providing functionality for many different kinds of applications. As a result, improvements in input mechanisms are needed to support the increased functionality of the device. BRIEF DESCRIPTION OF THE DRAWINGS

[0003] The embodiments described herein are illustrated by way of example and not limitation in the accompanying drawings, in which like reference numerals represent similar features. In addition, some conventional details have been omitted from the drawings so as not to obscure the inventive concepts described herein.

[0004] Figure 1 A network diagram is illustrated in block diagram form in which a configurable input component may be used according to one or more embodiments.

[0005] Figure 2 A flow diagram for performing actions based on a configurable input component according to one or more embodiments is illustrated.

[0006] Figure 3 Techniques for utilizing configurable input components according to one or more embodiments are illustrated in flowchart form.

[0007] Figure 4 A flow diagram for performing actions based on a configurable input component according to one or more embodiments is illustrated.

[0008] Figure 5 A simplified functional block diagram of an exemplary programmable electronic device according to one embodiment is illustrated. DETAILED DESCRIPTION

[0009] The present disclosure relates to systems, methods, and computer-readable media for providing a user input component that is user-configurable and application-configurable and whose input is not known to third-party applications. The present disclosure also relates to one or more APIs that act as an abstraction layer between the user input component and the application that uses the user input, thereby protecting user privacy.

[0010] In one or more embodiments, first-party applications and third-party applications ("apps") may be configured to interact with buttons to perform one or more actions when activated. In the prior art, applications typically "listen" for button presses to perform actions. According to one or more embodiments, the one or more APIs may act as an abstraction layer, detecting user input in the system and sending signals to applications to perform actions. Thus, the application only receives notifications to perform actions without paying attention to the context or event that caused the instruction. One advantage is user privacy achieved by shielding the application from the user activity that caused the instruction. Another advantage is improved flexibility in the application. For example, a built-in application can run even if the hardware associated with the user-configurable input device changes. That is, because the application only receives signals to perform actions without listening to specific user input, the application can be flexible across platforms. Therefore, the embodiments described herein decouple the connection between signals from user input and actions to be performed by the application via abstraction.

[0011] Steering Figure 1 , the embodiments described herein may operate within and interact with applications from an application store, from which one or more users using a client device may search for and download one or more applications (also referred to as apps). The application store 130 may include one or more servers, such as a server 132, that may provide the functionality described herein. For example, the server 132 may interact with a client device 140 or other device such as the electronic device 100 to provide third-party applications. The storage device 134 may store data related to the application. The electronic device 100 and the client device 140 may take a variety of different forms (e.g., a tablet computer such as an iPad, a smart phone such as an iPhone, a laptop computer, a desktop computer, a network media player such as an Apple TV, a game / entertainment system, a wearable device such as a head-mounted device, a watch, or other consumer electronic device). The electronic device 100 and the client device 140 may be coupled to the application store 100 via one or more networks 120 (such as the Internet), which provide data communication between the client device and the application store, so that the client device can transmit a search query to the application store, receive search results and transmit a request to download one or more applications, and then receive the download of one or more applications.

[0012] According to one or more embodiments, the electronic device 100 may be a user device configured to run one or more applications 112. The electronic device may be communicatively coupled to the application store 130 via the network interface 110 through the network 120. The application 112 is processed by one or more processors 106 from the memory 102. The processor 106 may include one or more different types of processors, such as a central processing unit (CPU), a graphics processing unit (GPU), etc. In some embodiments, the processor 106 may be a system on a chip. The memory 102 may include a memory cache, a read-only memory (ROM), and / or a random access memory (RAM). The storage device 104 may store appropriate data for executing the application 112, such as user settings 116 and other data. The storage device 104 may include one or more non-transitory storage media, which include, for example, disks (fixed hard disks, floppy disks, and removable disks) and tapes, optical media such as CD-ROMs and digital video disks (DVDs), and semiconductor memory devices such as electrically programmable read-only memories (EPROMs), and electrically erasable programmable read-only memories (EEPROMs).

[0013] The electronic device may include a configurable input component 108. The configurable input component 108 may be an input mechanism for which an associated action may be configured by a user when activated, such as in user settings 116. The configurable input component may be, for example, a mechanical button, a digital button, or other input mechanism. That is, the user input component may be a hardware component, a software component, or other input component. According to some embodiments, a user may configure a button to cause a specific action provided by one or more applications 112. In particular, the input abstraction layer may be a system-level module that facilitates one or more application program interfaces (APIs) to cause an application to perform an action.

[0014] Steering Figure 2 , presents a flow chart illustrating a system architecture in which embodiments of the present disclosure may be practiced. The flow chart includes a memory 102 of an electronic device 100. According to one or more embodiments, the memory 102 includes an application 112 and an input abstraction layer 114. For example, from the perspective of the electronic device 100, the application 112 may include a first-party application or a third-party application.

[0015] According to one or more embodiments, the application layer 112 may include a progressive action framework 204. The progressive action framework may be a set of actions 202A to 202N that can be executed by the application, and the set of actions is configured to be executed in a specific order. According to one or more embodiments, an action is a functional unit within the application 112. The application 112 can host one or more sets of actions. Each set of actions can be associated with an action type. Examples of action types include, but are not limited to: exercise, stopwatch, flashlight, waypoints, backtracking, diving, and shortcuts. In some embodiments, various action types can be used to implement in first-party applications and / or third-party applications. In order to utilize a configurable input component, the application 112 can be configured to communicate with an API associated with the input abstraction layer 114. The application 112 can provide a set of actions 202A to 202N of action types, and the set of actions can each be associated with a specific context under which they should be executed.

[0016] According to one or more embodiments, the application 112 may make the progressive action framework 204 and actions 202A to 202N available to the system, for example, during installation. The progressive action framework and associated actions indicate how the application should perform when the configurable input component is activated. The configurable input component may also be configured by the user. That is, the configurable input component may be assigned a selected action type by the user. Thus, the selected action type of the configurable component 108 may be stored in the user settings 116 in association with the user profile, for example, in the storage device 104 or in a network storage device.

[0017] In some embodiments, the progressive action framework 204 includes a series of actions 202A to 202N that are performed within a session. In some embodiments, a session can be initiated when an initial action, such as action A 202A, is initiated by the application 112. In some embodiments, a session can be initiated separately from input via the configurable input component 108, or by other means, such as an input component for the application 112.

[0018] In some embodiments, the application 112 may provide contextual information to the input abstraction layer to indicate the current state of the progressive action framework 204. The contextual information may be provided in the form of a "donation," which is data provided by the application 112 indicating the state of the application 112. In some embodiments, the donation may provide an indication of what is currently happening in the application, the current action of the progressive action framework 204 being executed, and / or the next action of the progressive action framework 204 that should be executed. Thus, the donation will allow the application to pass to the input abstraction layer 114 the information needed to determine what is most relevant at a given moment.

[0019] According to one or more embodiments, when the configurable input component 108 is activated, the input abstraction layer 114 may identify the set of actions to be performed, for example, based on the user settings 116. The user settings 116 may thus indicate that activation of the configurable input component 108 should involve action types associated with the actions 202A to 202N. The input abstraction layer 114 may then determine the nearest and related actions from the actions 202A to 202N and invoke the determined actions in the application 112. Thus, the input abstraction layer 114 allows the configurable input component 108 to perform predefined and independent "actions" rather than providing input that requires interpretation.

[0020] Figure 3 A flow chart of a technique for utilizing a configurable input component according to one or more embodiments is depicted. Although various actions are depicted in a particular order, in some embodiments, the various actions may be performed in a different order. In other embodiments, two or more actions may occur simultaneously. According to other embodiments, some actions may not be required or may include other actions. For clarity, the description of the various actions is omitted. Figure 1 The flowcharts are described with reference to various components. However, it should be understood that various actions may be performed by alternative components according to one or more implementations.

[0021] Flowchart 300 begins at block 302, where the abstraction layer detects user input via a configurable input component. As described above, the configurable input component can be a mechanical component, an electronic component, a digital component, etc. In some embodiments, the abstraction layer can be configured to detect when the configurable input component is activated. The configurable input component can be activated, for example, based on a user action (e.g., pressing, selecting, etc.).

[0022] The flowchart continues at box 304, and a determination is made as to whether the current session is active. In some embodiments, a configurable input component may be associated with a particular action type, for which a set of actions may be provided, for example, by an application. The determination at 304 may be related to a user-configurable action type. That is, the abstraction layer may determine whether a session is active for a particular action type selected by a user according to user settings. As described above, in some embodiments, an application may provide a progressive action framework that includes a series of actions that may be performed continuously or in a particular order. The session may be initiated by a configurable input component or by other input or device actions. For example, in some embodiments, a user may select an input component provided by an application to perform the first action in a session. As another example, in some embodiments, the first action may be automatically initiated, for example, based on a user context and / or a device context.

[0023] If it is determined at block 304 that there is no currently active session, then the flowchart continues at block 306 and a session type is determined for the configurable input component. As described above, in some embodiments, a user may select the type of action to be performed by the configurable input component. Thus, the session type may be determined based on a user configuration. Then, at block 308, a session is initialized based on the session type. According to some embodiments, an application may implement an initialization action and implement associated background functionality. Thus, when a configurable input component is activated while not in a session, an initialization action is invoked and a session is initiated.

[0024] The flow chart continues at block 310, and the abstraction layer continues to monitor input via the configurable input component. In some embodiments, the abstraction layer may additionally monitor contextual information received from the application, such as in the form of donations. Thus, the abstraction layer may track the next action that should be performed when user input via the configurable input component is detected.

[0025] Returning to box 304, if it is determined that there is a currently active session, the flowchart continues at box 312. At box 312, once the session is running, the abstraction layer can obtain context information, based on which the state of the application can be determined. In some embodiments, the abstraction layer can query the context information from the application and / or other system components. Additionally or alternatively, the application can submit or provide context information to the abstraction layer in the form of donations from time to time. Therefore, the current state can be determined as needed, or can be determined continuously. In some embodiments, the current state can refer to the last action being performed in the set of actions in the progressive action framework or the current action being performed. The current user state can be determined based on the context information provided by the application in the form of a donation function. Thus, the abstraction layer can track the history of actions called by the abstraction layer and actions called by other means. For example, if the exercise is started by another mechanism (such as an in-application button), the application can use the donation function to indicate to the abstraction layer that the next action is not an initialization action, but another action in the framework.

[0026] At box 314, the next action is identified based on the current user state, logically determining which action should be performed next so that the action flow is intuitively executed during the session. According to some embodiments, when the application performs an operation that affects the action that should be performed next, the application can provide contextual information so that the next action is assigned to the configurable input component accordingly. For example, when running on a track, input via the configurable input component can be used to mark a lap. For other types of exercises, such as a hockey tracker application, the configurable input component can be used to mark a scored ball. These in-session actions can be custom and defined by the application.

[0027] According to some embodiments, when the abstraction layer determines the next action, the system also displays a notification to the user of the system about the new button function. The notification can improve the user interface by educating the user about the new behavior within the application. For example, when the exercise is active, the next action can be a pause exercise action. As another example, if the action type is running, the next action can be a new lap demarcation action.

[0028] Flowchart 300 continues to block 316 and signals the application to cause the system to perform the next action. Thus, a single press within a session can result in progressive actions within an application-defined action framework.

[0029] Once the action is performed at 316, or during monitoring at block 310, a determination is made as to whether additional input is received at block 318. If no additional input is received at block 318, the flowchart ends. However, if additional input is received via the configurable input component at block 318, the flowchart returns to block 304 and a determination is made as to whether the current session is active. For example, in some embodiments, the session may time out, or may exit after the last action of the progressive action framework. The flowchart then continues and additional actions are performed.

[0030] Figure 4 A flow chart of a technique for using a configurable input component 108 according to some embodiments is depicted. Initially, at 402, an application 112 performs a current action of a progressive action framework. At block 404, user input is received via the configurable input component. Thus, input may be received while an application is performing a particular action. At block 406, the input is detected by the input abstraction layer 114.

[0031] In response to detecting input via the configurable input component, the flowchart continues to block 408, and an application is identified in association with the configurable input component by the input abstraction layer 114. For example, the input abstraction layer may determine what application and / or action type the configurable input component should be associated with based on user settings.

[0032] At block 410, in some embodiments, the application 112 may provide contextual data in the form of a donation, and the input abstraction layer 114 may determine the current state based on the contextual data, as shown at 412. In some embodiments, the contextual information may include a history of actions performed, current user actions, current actions being performed, the current processing state of the application, etc. At block 412, the current state may be determined, for example, based on the provided state information. Additionally or alternatively, the current state may be determined based on previously performed actions in the session.

[0033] At box 414, in some embodiments, the next action may be selected from one of a set of actions that include a progressive framework. The application may provide the system with one or more predefined action groups that can be used as configurable actions of a user-configurable input component. Thus, the abstract layer can access the framework. In one or more embodiments, the predefined action group can be a progressive action group. That is, the group of actions can form a timeline based on different states of the application. At box 416, the abstract layer can signal or trigger the application to perform the selected next action. From this, the input abstraction layer 114 can trigger the application to perform the next action. The flowchart ends at box 418, and the selected next action is performed by the application 112. If for some reason, your application cannot perform the action, an error is thrown from the "execute" function. The system will warn the user that the action cannot be completed.

[0034] According to some embodiments, the user input component should appear as an accurate input into the system.To account for any delays introduced by the software stack between activations of configurable input components, functionality may be used to account for latency of timestamps.

[0035] According to the above embodiment, the application may not receive a signal from the activated configurable input component, but only receive an indication that the application should move to its next state or should specify its next action. Thus, the state information of the application is updated based on the progress in the application.

[0036] According to some embodiments, not allowing applications to detect that a button was pressed or to receive a signal from a configurable input component can achieve user privacy as well as forward configurability of the action-based framework. Thus, when future hardware with different input components is released, applications that specify a next action via an abstraction layer (which does not rely on a signal from the configurable input component) can continue to operate with future updates to the same device, and can work with new devices because those updated or new devices can specify which inputs trigger the next action functionality.

[0037] Reference now Figure 5, a simplified functional block diagram of an exemplary programmable electronic device 500 for providing access to an application store according to one embodiment is shown. The electronic device 500 may be, for example, a mobile phone, a personal media device, a portable camera, or a system of a tablet, a laptop or a desktop computer. As shown, the electronic device 500 may include a processor 505, a display 510, a user interface 515, graphics hardware 520, a device sensor 525 (e.g., a proximity sensor / ambient light sensor, an accelerometer and / or a gyroscope), a microphone 530, an audio codec 535, a speaker 540, a communication circuit 545, an image capture circuit or unit 550 (e.g., it may include multiple camera units / optical sensors with different characteristics (and a camera unit housed outside the device 500 but in electronic communication with the device)), a video codec 555, a memory 560, a storage device 565, and a communication bus 570.

[0038] The processor 505 may execute instructions necessary to implement or control the operation of the various functions performed by the device 500 (e.g., such as the generation and / or processing of DA according to various embodiments described herein). The processor 505 may, for example, drive the display 510 and may receive user input from the user interface 515. The user interface 515 may take a variety of forms, such as buttons, keypads, dials, click wheels, keyboards, display screens, and / or touch screens. The user interface 515 may, for example, be a conduit through which a user can view a captured video stream and / or indicate a particular image that the user wants to capture or share (e.g., by clicking a physical or virtual button at the moment when the desired image is being displayed on the device's display screen).

[0039] In one embodiment, the display 510 may display a video stream captured while the processor 505 and / or graphics hardware 520 and / or image capture circuitry simultaneously stores the video stream (or a single image frame from the video stream) in the memory 560 and / or storage device 565. The processor 505 may be a system on a chip (such as those found in mobile devices) and may include one or more dedicated graphics processing units (GPUs). The processor 505 may be based on a reduced instruction set computer (RISC) or complex instruction set computer (CISC) architecture or any other suitable architecture and may include one or more processing cores. The graphics hardware 520 may be dedicated computing hardware for processing graphics and / or assisting the processor 505 in performing computing tasks. In one embodiment, the graphics hardware 520 may include one or more programmable graphics processing units (GPUs).

[0040] For example, according to the present disclosure, the image capture circuit 550 may include one or more camera units configured to capture images. The output from the image capture circuit 550 may be processed at least in part by: a video codec 555 and / or a processor 505 and / or graphics hardware 520 and / or a dedicated image processing unit incorporated into the circuit 550. Such captured images may be stored in a memory 560 and / or a storage device 565. The memory 560 may include one or more different types of media used by the processor 505, the graphics hardware 520, and the image capture circuit 550 to perform device functions. For example, the memory 560 may include a memory cache, a read-only memory (ROM), and / or a random access memory (RAM). The storage device 565 may store media (e.g., audio files, image files, and video files), computer program instructions or software, preference information, device profile information, and any other suitable data. The storage device 565 may include one or more non-transitory storage media, including, for example, magnetic disks (fixed hard disks, floppy disks, and removable disks) and tapes, optical media such as CD-ROMs and digital video disks (DVDs), and semiconductor memory devices such as electrically programmable read-only memories (EPROMs), and electrically erasable programmable read-only memories (EEPROMs). The memory 560 and the storage device 565 may be used to maintain computer program instructions or codes organized into one or more modules and written in any desired computer programming language. For example, when executed by the processor 505, such computer program code may implement one or more of the methods described herein. The power supply 575 may include a rechargeable battery (e.g., a lithium-ion battery, etc.) or other electrical connection to a power source (e.g., to a power source) for managing the electronic components and associated circuits of the electronic device 500 and / or providing power to the electronic components and associated circuits of the electronic device.

[0041] In the foregoing description, many specific details such as specific configurations, attributes and processes, etc. are described to provide a thorough understanding of the embodiments. In other examples, well-known processes and manufacturing techniques have not been described in particular detail so as not to unnecessarily obscure the embodiments. Throughout this specification, references to "one embodiment", "embodiment", "another embodiment", "other embodiments", "some embodiments" and their variations mean that the specific features, structures, configurations or characteristics described in conjunction with the embodiment are included in at least one embodiment. Therefore, the phrases "for an embodiment", "for an embodiment", "for another embodiment", "in other embodiments", "in some embodiments" or their variations in various positions that appear throughout this specification do not necessarily refer to the same embodiment. In addition, specific features, structures, constructions or characteristics can be combined in one or more embodiments in any appropriate manner.

[0042] In the following description and claims, the terms "coupled" and "connected" and their derivatives may be used. It should be understood that these terms are not intended to be synonymous with each other. "Coupled" is used herein to indicate that two or more elements or components that may or may not be in direct physical or electrical contact with each other cooperate or interact with each other. "Connected" is used to indicate the establishment of communication between two or more elements or components that are coupled to each other.

[0043] Certain portions of the foregoing detailed description have been presented in terms of algorithms and symbolic representations of operations on data bits in a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the art of data processing to most effectively convey the substance of their work to others skilled in the art. An algorithm is here and generally refers to a self-consistent sequence of operations leading to a desired result. These operations are those requiring physical manipulation of physical quantities. However, it should be kept in mind that all of these and similar terms are associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless otherwise specifically stated, it will be apparent from the above discussion that it should be understood that throughout this specification, discussions utilizing terms such as those set forth in the following claims refer to operations and processes of a computer system or similar electronic computing system that can manipulate data represented as physical (electronic) quantities in computer system registers and memories and convert them into other data that are also displayed as physical quantities in computer memories, registers, or other such information storage, transmission, or display devices.

[0044] The embodiments described herein may relate to a device for executing a computer program (e.g., the operations described herein, etc.). Such a computer program may be stored in a non-temporary computer-readable medium. A machine-readable medium includes any mechanism for storing information in a machine (e.g., computer) readable form. For example, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., computer) readable storage medium (e.g., read-only memory ("ROM"), random access memory ("RAM"), magnetic disk storage medium, optical storage medium, flash memory device).

[0045] Although the above describes operations or methods according to some sequential operations, it should be understood that some of the operations described can be performed in different orders. In addition, some operations can also be performed in parallel rather than in order. The embodiments described herein are not described with reference to any specific programming language. It should be understood that various embodiments of the disclosed subject matter can be implemented using various programming languages. In utilizing the various aspects of the embodiments described herein, it will be apparent to those skilled in the art that the combination, modification or variation of the above embodiments is possible for the components of the management processing system to increase the power and performance of at least one component in those components. Therefore, it is obvious that various modifications can be made to it without departing from the broad essence and scope of at least one disclosed concept in the disclosed concepts set forth in the appended claims. Therefore, the specification and the accompanying drawings are regarded as illustrative rather than restrictive.

[0046] In the development of any actual implementation of one or more of the disclosed concepts (e.g., such as a software and / or hardware development project, etc.), many decisions must be made to achieve the developer's specific goals (e.g., to comply with system-related constraints and / or business-related constraints). These goals may vary from implementation to implementation, and such variations may affect the actual implementation of one or more of the disclosed concepts set forth in the embodiments described herein. Such development work may be complex and time consuming, but may still be a daily routine for those of ordinary skill in the art in the design and / or implementation of one or more of the inventive concepts set forth in the embodiments described herein.

[0047] As used above and in the claims below, the phrases "at least one of A, B, or C" and "one or more of A, B, or C" include A alone, B alone, C alone, a combination of A and B, a combination of B and C, a combination of A and C, and a combination of A, B, and C. That is, the phrases "at least one of A, B, or C" and "one or more of A, B, or C" mean A, B, C, or any combination thereof, so that one or more of a group of elements consisting of A, B, and C should not be interpreted as requiring at least one of each of the listed elements A, B, and C, regardless of whether A, B, and C are related to a category or otherwise. In addition, the use of the articles "a" or "the" when introducing an element should not be interpreted as excluding multiple elements. Moreover, the expression "A, B, and / or C" is equivalent to "at least one of A, B, or C". Moreover, "a" as used in the present disclosure means "one or more". For example, "DA" means "a DA" or "a group of DAs".

Claims

1. A method, comprising: detecting user input via a configurable input component of a device; determining, by the device, context information; identifying a set of actions associated with the first application; selecting a next action in the set of actions based on the context information; as well as Causes the application to perform the selected next action. 2 . The method of claim 1 , wherein determining the context information comprises determining a currently active session, wherein the set of actions is associated with the currently active session. The method of claim 1 , wherein the set of actions is defined by the first application. 4 . The method of claim 1 , wherein the set of actions is further identified based on user profile data indicating a user-defined configuration of the configurable input component. The method of claim 1 , wherein the set of actions includes a plurality of progressive application executable actions.

6. The method of claim 1, wherein an abstraction layer causes the application to perform the selected next action without indicating that the user input was detected via the user-configurable input component.

7. The method of claim 1, wherein the context information is determined in part by state information received from the first application.

8. A non-transitory computer readable medium comprising computer readable code executable by one or more processors to: detecting user input via a configurable input component of a device; determining, by the device, context information; identifying a set of actions associated with the first application; selecting a next action in the set of actions based on the context information; as well as Causes the application to perform the selected next action.

9. The non-transitory computer readable medium of claim 8, wherein the computer readable code for determining the context information comprises computer readable code for determining a currently active session, wherein the set of actions is associated with the currently active session.

10. The non-transitory computer readable medium of claim 8, wherein the set of actions is defined by the first application.

11. The non-transitory computer readable medium of claim 8, wherein the set of actions is further identified based on user profile data indicating a user-defined configuration of the configurable input component.

12. The non-transitory computer-readable medium of claim 8, wherein the set of actions includes a plurality of progressive application executable actions.

13. The non-transitory computer-readable medium of claim 8, wherein an abstraction layer causes the application to perform the selected next action without indicating that the user input was detected via the user-configurable input component.

14. The non-transitory computer-readable medium of claim 8, wherein the context information is determined in part by state information received from the first application.

15. A system, comprising: one or more processors; and One or more computer readable media comprising computer readable code executable by the one or more processors to: detecting user input via a configurable input component of a device; determining, by the device, context information; identifying a set of actions associated with the first application; selecting a next action in the set of actions based on the context information; as well as Causes the application to perform the selected next action.

16. The system of claim 15, wherein the computer readable code for determining the context information comprises computer readable code for determining a currently active session, wherein the set of actions is associated with the currently active session.

17. The system of claim 15, wherein the set of actions is defined by the first application.

18. The system of claim 15, wherein the set of actions is further identified based on user profile data indicating a user-defined configuration of the configurable input component.

19. The system of claim 15, wherein the set of actions includes a plurality of progressive application executable actions.

20. The system of claim 15, wherein an abstraction layer causes the application to perform the selected next action without indicating that the user input was detected via the user-configurable input component.

21. The system of claim 15, wherein the context information is determined in part by state information received from the first application.

Images