KR20040065833A - Thin client system and method for transmitting an off-screen image of applets running between internet hosts and mobile devices over wireless data network - Google Patents

Abstract

PURPOSE: An applet execution image transmitting method and system is provided to display a GUI(Graphic User Interface) image of a JAVA applet, executed at a server, on a wireless terminal. CONSTITUTION: The method comprises several steps. Data on a screen size and a color model of a wireless terminal, where an applet is executed, is transmitted from the wireless terminal located at a remote place(S12). A virtual graphic device, having an environment of the same as the screen size and the color model, is generated(S13). Screen image data to be buffered at a memory of the virtual graphic device is obtained(S14-S17). The image data is transmitted to the wireless terminal over a network(S18). The data on a user event transmitted by the wireless terminal is analyzed and returned to the applet(S19).

Description

Thin client system and method for transmitting an off-screen image of applets running between internet hosts and mobile devices over wireless data network}

The present invention relates to a thin client system and method for transmitting only screen input / output information. More particularly, the present invention relates to a thin client, which is intended to show GUI screen image data of a Java applet executed on a server side to a client based on a wireless terminal. The system and method thereof.

Early computing environments were centralized, with one mainframe computer connected to dummy terminals with simple inputs and outputs. Since then, general PCs such as desktops, laptops, notebooks, etc. have emerged. As users become familiar with the GUI (Graphic User Interface), it is common to perform various tasks on the PC side. The PC user base has been expanded and the work done has been advanced, and the network concept of the client / server model has been recently introduced to build a system in a wide range of fields.

However, with these developments, the increase in total cost of ownership (TCO), including the management of PCs, has become a big problem. In other words, the price of PC hardware is relatively low, but the burden on users to install, set up, and upgrade operating systems and applications is increased. In addition, operational problems, such as hardware failures and virus infections, have resulted in loss of time and effort by users, including those who used the PC.

Recently, a thin client concept has emerged as a solution to this problem. The thin client runs all applications on a 100% server, and the client acts as a simple terminal that only shows the server's execution results and provides a means of user input, such as a keyboard or mouse. Therefore, if you want to introduce and use a new application and install only on the server, all the clients associated with the server can use the application and do not need to install separately on the client. The introduction of new applications eliminates the need to upgrade the client's hardware specifications and eliminates the need to worry about software deployment or installation, resulting in lower client prices, lower maintenance costs, and easier data backup and management.

Hardware initiatives based on the thin client concept include network computers (NCs) developed by Oracle and Sun Microsystems, and net PCs developed by Intel and Microsoft, but have not received much attention in the market.

Software implementations using existing hardware intact include Unix's de facto standard Windows system, the X Window System, Citrix's Independent Computing Architecture (ICA), and Microsoft's Terminal Services.

Among them, as shown in FIG. 1, the ICA and the Terminal Service transmit all or part of the graphic screen of the server 200 to the client 100 as it is (300), and transmit user input from the client back to the server. (400) has similarities. That is, the thin client implementation of the screen image data transmission method.

Recently, a wireless device such as a mobile phone (100c) or a PDA (100b) connected to the wireless Internet can be used as a thin client. As such, the thin client technology of the screen image data transmission method is applicable. Usability has been greatly increased. It is difficult to apply component-based client / server technology to wireless terminal devices with various platforms, and it is difficult to apply random disconnection and disconnection compared to the thin client. This is due to the fact that reconnection has little effect on the state of the session at the server.

However, the ICA and the terminal service have the following limitations in common to use a multi-user system or to use a wireless terminal as a client.

First, it intercepts graphical operations at the operating system level and thus depends on the specific operating system. All work only on Microsoft's Windows operating system and are not portable to other operating systems.

Second, it uses a lot of server resources because it runs the user's application as a separate process. Therefore, use as a multi-user server system is difficult or limited.

Third, the client is limited to a particular display environment. Client terminals that do not support the optional screen size and color of the Windows operating system, particularly wireless terminals with different graphics environments, are difficult to use as clients.

Introduced by Sun Microsystems in 1996, Java runs on virtual machines and is emerging as a development tool for applications that are independent of the platform (operating system and hardware architecture).

Java applets are small Java programs that are made up of components of the Abstract Window Toolkit (AWT), a collection of classes for building GUIs, and can be downloaded and included in web pages on the Web.

Applets are attracting attention by enabling dynamic programs on static Web documents, while also reducing the cost of installing client computers. In other words, with an applet, both client and server components need only be installed on the server machine, and client components are downloaded from the server to the client computer when needed, and do not need to be installed separately on the client.

However, applets can only be downloaded and run through a web browser. That is, there is a limitation that applets cannot be used in a client environment in which there is no web browser or a limited function thereof, such as a wireless terminal device.

Accordingly, an object of the present invention is to provide a thin client system and method for transmitting an execution screen to a wireless terminal using a Java applet as an application.

Another object of the present invention is to provide a server apparatus and method for using a mobile terminal of various platforms as a client and having a multi-user function in the thin client system.

1 illustrates a thin client / server environment and the contents of data to be transmitted;

2 is a diagram illustrating a client-server data transmission flow and respective internal processing according to the present invention.

3 is an internal block diagram of a thin client device in accordance with the present invention;

The present invention utilizes the functionality provided by the Abstract Window Toolkit (AWT) package of Java. The AWT package is a collection of classes used for building GUIs of Java applications or applets.

As described above, an applet is a Java application that creates a GUI with AWT components and sends it to a remote browser via the web for execution. The remote browser extracts the applet from the web page and sends it to the Java virtual machine for execution. Applets run on the Java virtual machine and can run on any machine that has a Java virtual machine installed.

The present invention is fundamentally different from the existing method of downloading a class and executing it in the client (web browser) in that the server is responsible for executing the applet and transmits only the image data of the GUI screen of the executed result to the client. .

In addition, the present invention is to create a virtual graphics device so as not to be affected by the operating system (OS) and the physical graphics device of the machine running the applet, and to draw a GUI screen using the graphics object of the device There is a gist.

The virtual graphic device is configured to have the same screen size and color model as seen on the client terminal. Therefore, the GUI screen of the applet using the graphic object of the virtual device can be seen as it is in the client terminal. This means that the client radio terminal of various platforms can be used as the client device of the system provided by the present invention.

The virtual graphics device is a buffered image existing in memory created at the Java application level and does not need to be displayed on a physical graphic screen. This means that multiple client sessions are completely independent of the operating system or graphics device in processing the requested applet execution and minimize the use of system resources, including memory. The creation of a virtual graphics device that exists only in memory at the application level can be implemented through a function of Java's AWT package.

The virtual graphics device creation associated with the execution of the applet requested by the multiple client sessions is all done at the Java application level and on a single Java virtual machine. This allows the server device provided by the present invention to have a multi-user function. That is, it is possible to create as many client sessions as long as system resources are allowed, which is different from existing thin client systems that have a limitation of the number of client sessions at the operating system level.

Hereinafter, with reference to the accompanying drawings an embodiment of the present invention will be described in detail.

FIG. 2 is a diagram illustrating a data transmission flow between a client 100 and a server 200 and an internal processing procedure in each step according to the present invention. First, a client-server connection is made in S10. In this step, the server creates a client session and allocates the necessary resources.

Next, in step S12, the client determines the size and color model of the applet to be displayed on its screen display device, and delivers it to the server. The step S11 may be performed before the client-server connection step S10.

In step S13, the server creates a virtual graphic device having the same environment as the applet size and color model of the client. The virtual graphics device is an image buffered on memory as described above. In step S14, the graphic object of the virtual graphic device generated in step S13 is obtained. In step S15, execution of the applet is started (the applet's init and start functions are called). The URL of the applet to be executed at this time may be prepared in advance by the server, or may be determined by a client's request in step S11.

Subsequently, step S16 is to draw an applet whose execution is started in step S15 using the graphic object of step S14. This is done by passing the graphic object as its argument when calling the applet's paint function.

The next step S17 is to perform area calculation and data compression for obtaining the data of the buffered image of S13 and transmitting it to the client when calling the paint function of the applet in step S16. This step occurs only when the paint function is called because a change is made to the screen only when the paint function is called. In addition, calculating and compressing the area with the data is to minimize the amount of data to be transmitted when the screen image data is transmitted to the client in the next step S18.

In step S18, the server transmits the screen image data including the area information to the client, and in step S19, the client restores the received data and displays it on the graphic screen.

3 is a diagram illustrating an internal block diagram of a client device according to the present invention. The screen 110 is a general bitmap display device, and a keyboard / keypad 120a, a mouse 120b, and a pointing device 120c may be used as the input device 120.

When the compressed screen image data is received from the server, the data restoration unit 130 may display the image data by transferring the original image data to a buffer of the screen through a restoration process.

Event occurs internally when user input keyboard, mouse, etc. At this time, the client device transmits the information by the event processing unit 140 so that the server can interpret the event.

The server receiving the event returns this to the applet so that the applet can interact with the user's input.

The thin client system according to the present invention can show an application written in a Java applet on various wireless client terminals. This means that the client can get the same applet execution results as the user without having to download and execute the Java applet classes from the server as in the conventional method.

Recently, various wireless terminal devices capable of wireless Internet can be used as client devices of the system provided by the present invention, thereby overcoming the limitations of processing performance or storage devices and providing a rich application program to a user.

Claims (5)

Receiving information about a screen size and a color model in which an applet is to be executed from a remote client; Creating the virtual graphics device in the same environment as the screen size and color model; Obtaining screen image data buffered on a memory of the virtual graphics device; Transmitting the image data to a client via a network; Interpreting and returning an input event of a user transmitted by the client to an applet; Configuring the server to ensure that the execution result of the applet executed in the server is identical to the client; The method of claim 1 Creating a virtual graphics device in memory that is not a physical graphics device in executing a Java applet; Obtaining a graphic object of the virtual graphics device; Passing the graphic object as an argument to the applet's paint function so that the applet can present a GUI screen using the graphic object; How to configure the applet execution status to proceed without being shown on the physical screen. In a client / server system, Means for creating a virtual graphics device having arbitrary screen size and color model information at the client's request; Means for creating a plurality of said virtual graphics devices that are not dependent on each other, Means for obtaining buffered image data of the virtual graphics device; Means for transmitting said image data to said client. A client device that can be connected to a server device that transmits screen image data, Means for the application to determine the screen size and color model information of the local graphical display device; Means for transmitting the information to a server; A client device comprising means for displaying the screen image data received from the server on a local screen The method of claim 4, wherein Means for accepting user input, Means for eventing the user input; Means for converting the event into information that the server can interpret; Means for transmitting the information to a server.