Virtual application execution system and method

• US 7,950,026 B1
• Filed: 06/23/2005
• Issued: 05/24/2011
• Est. Priority Date: 06/24/2004
• Status: Active Grant

• Current Assignee: Julian Michael Urbach
• Original Assignee: Julian Michael Urbach
• Inventors: Urbach, Julian Michael
• Primary Examiner(s): Sough; Hyung S
• Assistant Examiner(s): JORDAN, KIMBERLY L
• Application Number:
  US11/166,663
• Time in Patent Office: 2,161 Days
• Field of Search: 717/136, 709/218, 709/231
• US Class Current: 719/329
• CPC Class Codes: G09G 2340/10 Mixing of images, i.e. displayed pixel being the result of an operation, e.g. adding, on the corresponding input pixels
• CPC Class Codes: G09G 2340/12 Overlay of images, i.e. displayed pixel being the result of switching between the corresponding input pixels
• CPC Class Codes: G09G 5/14 Display of multiple viewports
• CPC Class Codes: H04L 67/02 based on web technology, e.g. hypertext transfer protocol [HTTP]
• CPC Class Codes: H04L 67/10 in which an application is distributed across nodes in the network software deployment G06F8/60; multiprogramming arrangements G06F9/46
• CPC Class Codes: H04L 69/03 Protocol definition or specification protocol conformance testing H04L1/244

Abstract

A virtual execution environment for software applications and other code objects. In one implementation, the present invention allows for virtual execution of applications by transparently capturing the rendered output of natively executed applications, and delivering the output to other processes on the same platform or to remote devices in a platform agnostic manner.

Claims

1. In an application hosting engine executing within a computing environment comprising a processor, a memory connected to the processor and an operating system stored in the memory, a method for virtually executing an executable code object, comprising

receiving, by the application hosting engine, a trigger to launch an executable code object locally within the context of the operating system;

launching, by the application hosting engine, the executable code object locally as a silent process within the context of the operating system, wherein the silent process is operative to cause a root window to be created locally within the context of the operating system and render an output to the root window;

intercepting, by the application hosting engine, the output rendered by the silent process, wherein intercepting the output rendered by the silent process comprises

iteratively scanning, in response to launching the executable code object and as the executable code object launches, system windows of the operating system against a set of expected attributes to initially detect the root window, wherein the set of expected attributes comprises a process identifier, a window name and an indication of a root window; and

writing the intercepted, rendered output to an off-screen memory.

2. The method of claim 1 wherein the off-screen memory is an off-screen buffer.

3. The method of claim 1 wherein the off-screen memory is a non-viewable, managed graphics context.

4. The method of claim 1 further comprising

blitting the rendered output from the off-screen memory to the context of a rendering engine.

5. The method of claim 1 further comprising

converting the rendered output to a data stream over a communications session;

and

transmitting the data stream to a remote node.

6. The method of claim 5 wherein the communications session is an HTTP session.

7. The method of claim 6 wherein the data stream is an HTML data stream.

8. The method of claim 7 wherein the HTTP session is a two-way communication with the remote node.

9. The method of claim 8 further comprising

receiving an HTTP response to the HTML data stream from the remote node;

and

converting the response to at least one event; and

writing the at least one event to the silent process.

10. The method of claim 1 wherein the rendered output is a graphics context.

11. The method of claim 1 wherein the executable code object supports an external application interface, and wherein the method further comprises accessing additional functionality associated with the executable code object through the external application interface.

12. The method of claim 1 further comprising translating the rendered output stored in the off-screen memory into an HTML over HTTP stream.

13. The method of claim 1 wherein the intercepting step further comprises

changing at least one attribute of the root window to intercept the rendered output of the silent process.

14. The method of claim 13 wherein the changing step comprises

changing a first procedure pointer assigned to the root window by the operating system to a second procedure pointer.

15. The method of claim 1, wherein the root window further comprises an event loop, and wherein the method further comprises

sub-classing the event loop to intercept input events corresponding to the silent process.

16. The method of claim 5 wherein the data stream comprises a script that, when executed by the remote node, is operative to dynamically generate a two-way communications session with the remote node.

17. An apparatus for virtually executing an application, comprising:

a processor;

a memory;

an operating system stored in the memory; and

a virtual application execution engine, physically stored in the memory, comprising instructions operable to cause the processor and the apparatus to;

receive, by the virtual application hosting engine, a trigger to launch an executable code object locally within the context of the operating system;

launch, by the virtual application hosting engine, the executable code object locally as a silent process within the context of the operating system, wherein the silent process is operative to cause a root window to be created locally within the context of the operating system and render an output to the root window;

intercept, by the virtual application hosting engine, the output rendered by the silent process by iteratively scanning, in response to launching the executable code object and as the executable code object launches, system windows of the operating system against a set of expected attributes to initially detect the root window, wherein the set of expected attributes comprises a process identifier, a window name and an indication of a root window; and

write the intercepted, rendered output to an off-screen buffer in the memory.

18. The apparatus of claim 17 further comprising a network interface, and wherein the virtual application execution engine comprises a server application comprising instructions operable to cause the processor, the network interface, and the apparatus to

communicate with a remote host;

and

wherein the virtual application execution engine further comprises instructions operable to cause the processor and the apparatus to

convert the rendered output to an HTML data stream over an HTTP session; and

transmitting the HTML data stream to the remote host.

19. The apparatus of claim 18 wherein the virtual application execution engine further comprises instructions operable to cause the processor and the apparatus to

receive an HTTP response to the HTML data stream from the remote host;

convert the response to at least one event; and

write the at least one event to the silent process.

20. The apparatus of claim 17 wherein the virtual application execution engine further comprises instructions operable to cause the processor and the apparatus to

change at least one attribute of the window to intercept the rendered output of the silent process.

21. The apparatus of claim 18 wherein the virtual application execution engine further comprises an instant messaging client operative to transmit a link to rendered, output stored in the off-screen buffer.

22. A non-transitory machine-readable medium comprising an application hosting engine for virtually executing a software application within the context of an operating system, the application hosting engine comprising instructions operable to cause a programmable processor to:

receive, by the application hosting engine, a trigger to launch an executable code object locally within the context of the operating system;

launch, by the application hosting engine, the executable code object locally as a silent process within the context of the operating system, wherein the silent process is operative to cause a window to be created locally within the context of the operating system and render an output to the window;

intercept, by the application hosting engine, the output rendered by the silent by iteratively scanning, in response to launching the executable code object and as the executable code object launches, system windows of the operating system against a set of expected attributes to initially detect the root window, wherein the set of expected attributes comprises a process identifier, a window name and an indication of a root window; and

write the intercepted, rendered output to an off-screen buffer or managed graphics context in a computer readable memory.

23. In an application hosting engine executing within a computing environment comprising a processor, a memory connected to the processor and an operating system stored in the memory, a method for virtually executing an executable code object, comprising:

receiving, by the application hosting engine, a trigger to launch an executable code object locally within the context of the operating system;

launching, by the application hosting engine, the executable code object locally as a silent process within the context of the operating system, wherein the silent process is operative to cause a window to be created locally within the context of the operating system and render a native output to the window;

intercepting, by the application hosting engine, the native output rendered by the silent process by iteratively scanning, in response to launching the executable code object and as the executable code object launches, system windows of the operating system against a set of expected attributes to initially detect the window, wherein the set of expected attributes comprises a process identifier, a window name and an indication of a root window; and

converting the native output of the silent process to a first network protocol stream; and

transmitting the first network protocol stream to a remote node.

24. The method of claim 23 wherein the first network protocol stream comprises information that allows a remote node to generate an input for the silent process formatted as a second network protocol stream.

25. The method of claim 23 wherein the first network protocol stream is an HTTP stream.

26. The method of claim 23 further comprising

receiving a second network protocol stream from the remote node, wherein the second network protocol stream comprises an input for the silent process;

translating the input for the silent process from the second network protocol stream to a native input; and

writing the native input to the silent process.