From the point of view of the end-user, Onlive is an App they install on their smartphone.
When people use the Onlive app, they automatically become part of Groups. When you are in a venue, the user can automatically become part of the group in that venue, together with staff and other guests. When the user is in a meeting room, it becomes automatically part of a group which consists of all other people in the room. A group can be small or big; in theory, there could also be a group for the entire city.
Onlive facilitates interaction among people and devices (that are part of the same group), but it does not define what this interaction should be; this is determined by Plugins. Plugins can be seen as mini-Apps that are available in a group and that are automatically downloaded on the smartphone when the user becomes part of that group. Plugins can be developed by anyone. There could be generic plugins that facilitates common interactions, but there can also be branded plugins for specific locations or specific events. Plugins allow End users to interact with their surroundings (interaction with other people, with organisations or with devices).
“Interactions” is a relatively abstract term. An interaction could be sending someone a link to a website, it can be a file, it can be contact information, it can be a vote on a poll, it can be an answer to a quiz, but it can also be something much more dynamic, such as controlling a virtual character in a game. Each of these example interactions will require a different plugin. Sometimes people would like to save those interactions when they make use of a plugin, sometimes it makes no sense to save them. In order to provide a structure that allows people to save interactions for which that makes sense, we introduced the concept of a Card. A card can be seen as a file on a computer. It can be stored and it can be transmitted. But a file on its own is usually not very useful. You need a program in order to open the file. In Onlive, this program is the Plugin.
In the following sections, the concepts Group, Plugin, and Card are described in more detail.
When the user opens the Onlive App, a list of currently available groups is shown (image below). Available groups are determined automatically; the user doesn’t have to find a group manually. There are two types of groups in Onlive, which have slightly different mechanics.
The Nearby group is always available and consists of End users who are physically near to each other and/or in the same room. There is only one Nearby group. When there is a meeting going on in a meeting room, all users should be part of the same group, and no one outside of the meeting room can be part of the group. Right now Onlive makes use of Google Nearby, a library that makes use of ultrasound signals in order to determine which phones are near to each other. Ultrasound cannot be heard by humans, but cannot travel through walls (unlike radio signals like Bluetooth and WIFI). This way, groups are formed in a way that is likely to make sense to users in the real world; people in the same room are in a group together. The downside of Google Nearby is that it requires an Internet connection to operate (that’s why we use it only for the Proof of Concept).
Users are always part of the nearby group. When no other Onlive users are nearby, the group will consist of the end-user himself/herself.
In contrast to the Nearby group, there can be many Context groups. Context groups are defined for people who share the same context; this can, for example, be a physical location (a certain venue) or an event (a location in combination with a certain period). Context groups are defined using Context rules, which are evaluated by the Context engine, which was originally developed in the Transient Apps project.
Context groups are defined by the Onlive backend. For example, a store might want to define a group for people who are physically present in the store. In contrast to the Nearby group, which is always available, Context groups need to be created manually by someone in order to become available to users.
The advantages of creating a Context group over the Nearby group are:
group size is not limited by ultrasound (so it’s usable in bigger areas)
complete control over the available plugins (so clients can determine what there clients/end users can do when they are in their group)
Control over branding/styling
A Card is how users experience a Plugin. A card represents a piece of data, which can be handled by a Plugin.
Whenever a user opens a Group which is available in the Onlive App, it enters the Stage (the right image). On the Stage, all the cards that are currently published in that Group are shown. A Card can be published by people, organizations or machines. When the user taps on the card, the card is taken in the Hand (the image below). In the Hand end users can decide if they want to:
Save the card for later (swipe to the right)
Throw the card away (swipe the card to the left)
Use the card right now (press the card) -->Plugin will be launched
After the card is edited, publish the card in the group (swipe the card up)
When the card is pressed the Plugin is launched, displaying the information that was stored in the Card. How the information inside the card is represented, is determined by the Plugin. When a group allows multiple Plugins to be used, there are also multiple types of Card that can be present on the Stage. Each Plugin is associated with one type of Card.
Users can decide to save a card from the stage (if the card is a savable card). When they do that, the card is saved locally on the smartphone. Saved cards can also be found and opened later under saved cards. It is also possible for users to publish saved cards to groups it is part of. So, for example, it is possible to save a card from the stage of Group A, and then later publish it in Group B, given that the user is part of both groups and both groups allow the usage of the Plugin the card is associated with.
Users can also use a Plugin to create a new Card. When they decide to create a new Card of a certain type, the associated Plugin is launched and a wizard is shown to create the new card. How a new Card should be created is determined by the Plugin.
Plugins are the mini-Apps (web apps) that can be developed by third parties (everyone who can build a website can develop a plugin). Plugins allow people to interact with each other in a specific way in a group. For example, there could be a Plugin which allows users to play a game together when they are near each other. For each group, there is a list of which Plugins are available to the End users in that Group. For the Nearby group, Onlive determines which Plugins are available, for Context groups this is defined by the group host (the one who created the group).
Plugins are mini-Apps that are automatically downloaded and installed whenever people become part of a Group or are removed when they leave the Group. Plugins are executables. Users don’t have to worry about Plugins, and they don’t directly interact with them. Rather they interact through them.