Patent Application
20080034038
The system 104 includes a chat engine 108 and a communication engine 110 for connecting over the network 102. The chat engine 108 can send and receive data content to and from the communication engine 110. When the chat engine is operating, it can generate a chat environment between two or more buddies, where one or more chat sessions can be initiated. The communication engine 10 can send data content over network 102 using a networking protocol or a protocol used for video chat, for example the user datagram protocol (UDP), between the system 104 (here labeled Chatter) and any other system, including the system 106 (here labeled Steve Demo), for example. Received data can be displayed in a recipient's user interface.
The system 104 also includes a graphical user interface (GUI) engine 112 and a sharing engine 114 for displaying and sharing data content, respectively. For example, the GUI engine 112 generates a screen that a chatter can view during a chat session. GUI engine 112 includes an own component 116 for generating the GUI essentially purely from Chatter's system 104. For example, the GUI can be generated from an application program 118 on system 104, or from the chat engine 108. Each application program 118 can include an application programming interface (API) 119. The system 104 can use API 119 techniques to enhance application programs with further functionality. For example, the API 119 can link several applications together for providing a single service on all linked applications. Particularly, the system 104 can use API techniques to enhance application programs with sharing functionality.
The API 119 API can be part of the Instant Message framework. The API can provide the developers with APIs to accomplish any or all of the application-related features described herein. Thus, it is possible to register with the Instant Message framework to receive callbacks, receive notifications when the conference starts, start the playback on demand, render frames in callbacks from Instant Message, provide audio in callbacks using Core Audio, or stop the presentation, to name just a few examples.
The GUI engine 112 also includes a shared component 120 for generating a GUI from data content that is shared by one or more buddies on other systems. For example, the shared component 120 can provide an output in Chatter's system of a GUI or an application window shared by a recipient system (e.g., Steve Demo). This sharing can be initiated during a chat session. In some implementations, the shared component 120 can display the shared data content in a separate GUI window or application that the system currently has open.
The sharing engine 114 included in the system 104 controls the data content that Chatter shares with other buddies. For example, Chatter's system 104 can share one or more applications with another chat partner through the network, and the sharing engine 114 then determines which applications are configured for sharing and performs the operations to forward the shared content. The sharing engine 114 includes a GUI component 122 for sharing a GUI with a chat partner. For example, the chat partner can see an image of Chatter's GUI on the chat partner's screen, optionally with the ability to control Chatter's computer through the presented GUI. In addition, the sharing engine 114 includes an application component 124 for Chatter to share an application output with a chat partner (e.g., via an API of the shared application). For example, Chatter's system 104 can share a video graphics application output with a chat partner and the application component 124 can use an API 119 to properly display the shared video.
The system 104 is a representative computer system in architecture 100. Several systems may exist in the architecture 100 and can contain equivalent components. For example, the chat partner Steve Demo (106) can have a similar system to system 104 with corresponding components. Systems 104, 106, 126, and 128 can all be connected to the network 102 and made available for chatting and sharing data.
While sharing data content and application output are described herein with respect to a personal computer 104, it should be apparent that the disclosed implementations can be incorporated in, or integrated with, any electronic device that has a visual user interface, including without limitation, portable and desktop computers, servers, electronics, media players, game devices, mobile phones, email devices, personal digital assistants (PDAs), embedded devices, televisions, telephones including mobile telephones, set top boxes, etc.
Systems and methods are provided for sharing data content and application output in a chat environment. The systems and methods can be stand alone, or otherwise integrated into a more comprehensive application. In the materials presented below, an integrated system and method for sharing data content is disclosed. However, one of ordinary skill in the art will recognize that the engines, methods, processes and the like that are described can themselves be an individual process or application, part of an operating system, a plug-in, an application or the like. In one implementation, the system and methods can be implemented as one or more plug-ins that are installed and run on a personal computer. The plug-ins are configured to interact with an operating system (e.g., MAC OS® X, WINDOWS XP, LINUX, etc.) and to perform the various functions, as described with respect to the Figures. A system and method for sharing data content can also be implemented as one or more software applications running on the computer. Such a system and method can be characterized as a framework or model that can be implemented on various platforms and/or networks (e.g., client/server networks, portable electronic devices, mobile phones, etc.), and/or embedded or bundled with one or more software applications (e.g., email, media player, browser, etc.).
As shown, Steve Demo 203 is one of the entities listed on the list 202. Here, Chatter wishes to initiate a chat session with Steve Demo and therefore selects Steve Demo 203 from the list. Once the Steve Demo 203 chat partner has been selected, Chatter here selects a share icon 204. The share icon 204 triggers a function that can dynamically create and display a drop down box 206 containing options pertaining to the selected user. For example, two options are shown in drop down box 206 for the user (Chatter) to select from. Here, Chatter can choose a first option 208 to “Share my Screen” or a second option 210 to “Share Steve Demo's Screen”. Chatter chooses the second option 210 to share Steve Demo's screen. Other examples of options that can be displayed here include sharing the output of one of Chatter's applications, or similarly sharing one of Steve Demo's applications.
Choosing to share another chat partner's screen activates the GUI engine 112 on Chatter's system 104 to initiate the shared component 120. The shared component 120 will seek to build a connection with the selected chat partner. Any form of connection available in the chat program can be used. For example, the shared component 120 can retrieve address information for Steve Demo's system 106 from the chat engine 108 to properly contact that system and subsequently receive shared data content. After retrieving an address, the shared component 120 sends an invitation to Steve Demo's system 106 using the communication engine 110. Because Chatter chose the option 210, the invitation to Steve Demo will ask for Steve Demo's screen (GUI) to be shared. In some implementations, no invitation is provided.
Alternatively, Chatter can choose the second option 208 to share his own screen with another chat partner, such as Steve Demo. If the “Share my screen” option 208 is selected, an invitation can be sent to Steve Demo inviting him to share Chatter's screen (or application output etc.). The sharing engine 114 in that example on Chatter's system 104 can send the invitation and address information to Steve Demo's communication engine, which, in turn, transfers the shared screen data to the GUI engine for display on Steve Demo's system 106.
An add user control 212 can be used to add one or more entities to the list 202. In some implementations, Chatter can have multiple chat sessions in progress at one time and share the contents of the chat sessions with any or all of his buddies.
Accepting the invitation enables the GUI component of Steve Demo's sharing engine to start sharing content corresponding to Steve Demo's GUI. For example, Steve Demo's sharing component can alert Steve Demo's communication component to contact Chatter's communication engine 110 to begin sharing data. In some implementations, Steve Demo's communication engine could consult Steve Demo's chat engine to obtain Chatter's address. In other implementations, Chatter's address can be included in Chatter's invitation.
Steve Demo can otherwise choose to decline the invitation and deny access to his desktop for the other chat partner (Chatter). If the “Decline” button 404 were selected, Steve Demo's GUI component could have instructed his sharing component to respond with a rejection to Chatter. In the case of a decline, the dialog box 400 can disappear and Steve Demo's system can return to a previous application. When Steve Demo declines to share his screen, Chatter can receive a dialog box message indicating that the invitation has been declined. In some implementations, a user can send a text reply to the inviter regarding an acceptance or a decline using a “Text Reply” button 410. Text replies can be transmitted at the same time as the acceptance or decline is sent, for example.
A dialog box 500 can be displayed in Chatter's system 104.
Here, Steve Demo has accepted Chatter's invitation. With reference again briefly to
Upon connection, a banner 606 can be displayed alerting Chatter that this is Steve Demo's GUI on display in desktop 600. The banner 606 can be animated to, for example, disappear or roll away as time elapses or upon user interaction. The initial banner 606 can be a useful indicator to avoid confusion when Steve Demo's GUI is displayed in full screen mode on a chat partner's computer system.
Similarly, a notification to Steve Demo can be generated on his computer. For example, the text “Sharing with Chatter . . . ” can be displayed. In one implementation, the text is scrolled from right o left in the menu bar of Steve Demo's screen at regular intervals.
A screen sharing dialog box 608 is shown indicating that a screen is being shared with Steve Demo. The dialog box 608 is generated by Chatter's GUI engine 112 and is similar to the dialog box 500 shown in
Selecting the toggle icon 610 can change the displayed screen to Chatter's GUI and if selected again, can change the screen back to Steve Demo's GUI. In Chatter's system 104, this is essentially switching from displaying data from the Chatter's own component 116 (e.g., after toggle, Chatter's system is shown) and the shared component 120 (e.g., after toggling again, Steve Demo's system is shown). As described in
In some implementations, the icon 610 can also be used for one or more other functions. For example, content can be forwarded to another entity's device by dragging the content (e.g., a file) onto the icon. This causes the local system to transfer the file to the other entity. In one implementation, this is done by the application component 124 identifying the content portion that is being dragged and sending it to the other device.
In addition to viewing Steve Demo's GUI, Chatter can also control Steve Demo's GUI in one implementation. For example, Chatter can control Steve Demo's GUI by making a modification to an application shown in the GUI, such as through a keystroke, mouse click or other user input. In some implementations, not all inputs are transferred when this control feature is in operation. For example, some keystrokes or other inputs can be reserved for controlling the local machine, such as to perform a force-quit operation.
More specifically, when a keystroke is to be forwarded, Chatter's GUI engine 112 can receive the keystroke from Chatter's system 104, and transfer that keystroke to Chatter's communication engine 10. Communication engine 110 can transmit the keystroke or signal to Steve Demo's communication engine. Steve Demo's communication engine can take the received keystroke or signal and send it to an API in Steve Demo's system for the application program Chatter modified. For example, if Chatter modified information for a chat partner in the chat application 602 on Steve Demo's screen, the API connects to the chat application 602 that contains the people list and makes the intended modification (e.g., the information change for the chat partner).
It was mentioned above that the entire GUI contents is not the only content that can be shared in a chat environment. Rather, the output of any or all application programs can be selectively shared, as another example. Such application programs include the Quicktime Player, Keynote and iphoto products that are available from Apple Computer, to name a few examples.
Selecting the “Share with iChat” command 708 can invoke the sharing engine 114 on Chatter's system 104 to determine which chat partner is currently selected through iChat™. In some implementations, more than one chat partner may be selected to receive application output. Upon determining that Steve Demo 703 is currently selected, the application component 124 in Chatter's sharing engine 114 can enable the communication engine 110 to forward the application output to Steve Demo over the network 102.
The iChat™ sharing session can also include a live video cast of a chat session. For example, during a chat session with Steve Demo, a live video of Steve Demo can be displayed in the shared screen. As shown in
The live video feed 802 can be captured by Chatter's iChat™ and forwarded to Steve Demo as application output. For example, Steve Demo's communication engine receives the video feed of Chatter from Chatter's communication engine 110.
The application output is here video and can be sent through the chat engine. For example, Chatter's application component 124 forwards the application output for receipt by Steve Demo's shared component in Steve Demo's GUI engine. Steve Demo's shared component can then display a picture of the application output on his screen. Thus, Steve Demo is viewing Chatter on the shared screen 800 along with an application program output 804 from Chatter's system.
The screen 800 can include screen configuration options such as a sound control 806 and a full screen mode control 808. The sound control 806 can be used to mute and un-mute the microphone during the chat session. For example, Steve Demo may wish to change the volume of Chatter's voice in the video feed 802. Alternatively, the sound control 806 can be used to configure the sound of the shared application program output 804. The full screen mode control 808 can be used to put the window in a full screen mode wherein the video feed window 802 and the application program output 804 are still visible.
Some examples of screen layouts that can be used in a sharing session are shown in
Referring first to
In contrast,
Windows can be stacked or tiled in the tilted position and can be moved anywhere on the desktop 712. For example, Steve Demo could minimize Chatter's video feed 910 and maximize “your application content” 908. In addition, the tilted effect can be turned off or on with any or all windows in the desktop 712. For example, Steve Demo's video feed 1002 is shown from a front perspective without tilt.
In the above description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding. It will be apparent, however, to one skilled in the art that implementations can be practiced without these specific details. In other instances, structures and devices are shown in block diagram form in order to avoid obscuring the disclosure.
In particular, one skilled in the art will recognize that other architectures and graphics environments may be used, and that the examples can be implemented using graphics tools and products other than those described above. In particular, the client/server approach is merely one example of an architecture for providing the functionality described herein; one skilled in the art will recognize that other, non-client/server approaches can also be used. Some portions of the detailed description are presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic 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. An algorithm is here, and generally, conceived to be a self-consistent sequence of steps leading to a desired result. The steps are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.
It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.
An apparatus for performing the operations herein may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or any type of media suitable for storing electronic instructions, and each coupled to a computer system bus.
The algorithms and modules presented herein are not inherently related to any particular computer or other apparatus. Various general-purpose systems may be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatuses to perform the method steps. The required structure for a variety of these systems will appear from the description. In addition, the present examples are not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings as described herein. Furthermore, as will be apparent to one of ordinary skill in the relevant art, the modules, features, attributes, methodologies, and other aspects can be implemented as software, hardware, firmware or any combination of the three. Of course, wherever a component is implemented as software, the component can be implemented as a standalone program, as part of a larger program, as a plurality of separate programs, as a statically or dynamically linked library, as a kernel loadable module, as a device driver, and/or in every and any other way known now or in the future to those of skill in the art of computer programming. Additionally, the present description is in no way limited to implementation in any specific operating system or environment.
It will be understood by those skilled in the relevant art that the above-described implementations are merely exemplary, and many changes can be made without departing from the true spirit and scope of the present invention. Therefore, it is intended by the appended claims to cover all such changes and modifications that come within the true spirit and scope of this invention.
