CN106502662A - Multizone pattern drawing method and device for intelligent operating system - Google Patents

Abstract

The present invention proposes a kind of multizone pattern drawing method and device for intelligent operating system.The method is comprised the following steps：Multiple threads that render that Java ends create are bound with multiple rendering engine examples that Native ends create；One or more of figure rendering tasks are submitted to Native ends based on the corresponding thread that renders；Obtain at Native ends and rendered with carrying out figure with the rendering engine example for rendering thread binding corresponding to one or more of figure rendering tasks；And in the screen area corresponding to the rendering engine example that the rendering result of one or more of figure rendering tasks is respectively displayed on and is rendered.Present invention achieves multiple Open GL context environmentals are managed in the process simultaneously, with thread independence, internal memory and multizone can not be limited while the advantage that renders while carry out the technique effect of graphic plotting in multiple regions so as to reach.

Description

Multi-area graphics drawing method and device for intelligent operating system

technical field

The present invention relates to the field of graphics drawing, and more specifically, to a multi-region graphics drawing method and device for an intelligent operating system.

Background technique

Generally, a smart operating system provides a packaged view framework to implement functions such as graphics drawing, transformation, and animation. The most obvious defect of this method is that the rendering of graphics runs on the business logic thread. For scenarios with frequent graphics refresh requirements, it will put pressure on the business logic thread, resulting in graphics refresh lag. On the other hand, in this way, for scenes that use a large number of pictures, the loading of pictures will consume a lot of application layer memory. But for a single application, the allocated memory is very limited, and this scenario can easily cause the application to crash.

Open GL (Open Graphics Library) is usually implemented in a smart operating system as a support for graphics rendering. This graphics library directly operates the graphics card for rendering. On the one hand, this library is implemented in a native way (C, C++), so the memory occupied during rendering does not belong to the application layer memory, so there will be no memory allocation restrictions; on the other hand On the other hand, rendering using this library can be done in a separate thread.

The inventors found that in the current graphics engine solutions that encapsulate Open GL, such as Cocos2d, only one area is allowed to be rendered in one process at the same time, which greatly limits the usage scenarios. Therefore, it is necessary to develop a method and device for rendering graphics on multiple areas of the screen at the same time.

The information disclosed in the background of the present invention is only intended to deepen the understanding of the general background of the present invention, and should not be regarded as an acknowledgment or any form of suggestion that the information constitutes the prior art known to those skilled in the art.

Contents of the invention

The purpose of the present invention is to provide a high-performance multi-area graphics drawing method and device for an intelligent operating system, so as to realize graphics rendering in multiple areas of the screen at the same time.

According to one aspect of the present invention, a multi-region graphics drawing method for an intelligent operating system is proposed. The method may include the following steps: binding multiple rendering threads created on the Java side to multiple rendering engine instances created on the Native side; submitting one or more graphics rendering tasks received by the Java side to different rendering threads respectively , and submit the one or more graphics rendering tasks to the Native side based on the corresponding rendering threads; obtain the rendering engine instance bound to the rendering threads corresponding to the one or more graphics rendering tasks on the Native side to performing graphics rendering; and displaying the rendering results of the one or more graphics rendering tasks in the screen areas corresponding to the rendering engine instances performing rendering.

Preferably, the binding to the plurality of rendering threads is performed by putting the plurality of rendering engine instances into thread private data.

Preferably, the Natvie side acquires the rendering engine instances bound to the rendering threads based on the thread private data corresponding to the graphics rendering task.

Preferably, the rendering engine performs graphics rendering through Open GL commands.

Preferably, the method further includes: after the graphics rendering task is completed, the Native end calls back the rendering status to the Java end.

According to another aspect of the present invention, a multi-region graphics rendering device for an intelligent operating system is proposed. The device may include: a unit for binding multiple rendering threads created by the Java end to multiple rendering engine instances created by the Native end; for submitting one or more graphics rendering tasks received by the Java end to the In different rendering threads, and submit the one or more graphics rendering tasks to the unit of the Native side based on the corresponding rendering threads; for obtaining the rendering threads corresponding to the one or more graphics rendering tasks at the Native side A bound rendering engine instance for graphics rendering; and a unit for displaying the rendering results of the one or more graphics rendering tasks in screen areas corresponding to the rendering engine instances performing rendering.

Preferably, the binding to the plurality of rendering threads is performed by putting the plurality of rendering engine instances into thread private data.

Preferably, the Natvie side acquires the rendering engine instances bound to the rendering threads based on the thread private data corresponding to the graphics rendering task.

Preferably, the rendering engine performs graphics rendering through Open GL commands.

Preferably, the device further includes: a unit for causing the Native side to call back the rendering state to the Java side after the graphics rendering task is completed.

The present invention realizes simultaneous management of multiple Open GL context environments in one process through the singleton design mode of the Native part and the thread private data TSD, combined with the multi-threading method of the Java part, so as to achieve the ability to draw graphics in multiple areas at the same time technical effect. It has the advantages of thread independence, unlimited memory and simultaneous rendering of multiple regions.

The method of the present invention has other features and advantages that will be apparent from, or will be apparent from, the drawings and detailed description that follow, incorporated herein. The drawings and specific examples are set forth in detail in the examples, and these drawings and specific examples together serve to explain certain principles of the invention.

Description of drawings

The above and other objects, features and advantages of the present invention will become more apparent by describing the exemplary embodiments of the present invention in more detail with reference to the accompanying drawings, wherein, in the exemplary embodiments of the present invention, the same reference numerals generally represent same parts.

FIG. 1 is a flowchart of a multi-region drawing method for an intelligent operating system according to an embodiment of the present invention.

Fig. 2 is a screen including two graphics drawing areas, wherein the upper left figure is p1, and the lower right figure is p2.

detailed description

The present invention will be described in more detail below with reference to the accompanying drawings. Although preferred embodiments of the invention are shown in the drawings, it should be understood that the invention may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

Fig. 1 shows a multi-region graphics drawing method for an intelligent operating system according to an embodiment of the present invention.

The intelligent operating system environment of this embodiment is Android, which supports Open GL. The implementation steps can be roughly divided into two parts, namely the Java part and the Native part. Among them, the Java part is realized by the Java language program and runs on the Android virtual machine; the Native part is realized by the C/C++ language and runs on the local server.

Open GL has two main characteristics:

1. It is a software interface that has nothing to do with hardware and can be transplanted between different platforms;

2. It can work in a client/server system, that is, it has network functions.

The multi-region graphics drawing method for an intelligent operating system in this embodiment may include the following steps:

1) Bind multiple rendering threads created on the Java side with multiple rendering engine instances created on the Native side.

Multiple rendering threads can be created at the same time on the Java side. Correspondingly, multiple rendering thread environments are provided for the Native side and multiple contexts are generated. That is, create multiple rendering view instances on the Java side.

The rendering view is essentially a controller used to control the rendering of the Native side on the Java side. The rendering view class can include surface view (GLSurfaceView) instances and texture view (GLTexureView) instances, which provide the rendering thread environment for the Native side.

The Java side generates a context environment for rendering graphics using the Open GL library interface through the Open GL library interface.

The Open GL context environment, namely GLContext, is used to store all state information of Open GL drawing. It actually represents the default framebuffer for rendering command graphics, the GLContext is destroyed, and Open GL no longer exists.

Create multiple threads, that is, generate multiple contexts for Open GL, and a thread can only have one context. Correspondingly, a context can only belong to one thread and cannot be shared by different threads at the same time.

The multiple rendering threads created on the Java side are threads independent of the main thread, in order to ensure that the rendering performance is not affected by the business logic thread.

On the Native side, a rendering engine instance is created based on the multiple rendering thread environments created on the Java side. At the same time, an Open GL rendering environment is initialized through the rendering engine instance.

Initializing the Open GL rendering environment is mainly to set the important properties of the Open GL window, including pixel format and buffer mode, color bits and depth bits, and so on.

Open GL provides two color modes: RGB (RGBA) mode and color index mode. In the RGBA mode, the definition of all colors is represented by three RGB values, and sometimes an Alpha value representing transparency is also added. The color of each pixel in the color index mode is represented by a certain color index value in the color index table.

Open GL can provide double buffering to draw images. That is, while displaying the image in the front buffer, the background buffer draws the second image. When the background drawing is completed, the image in the background buffer is displayed. At this time, the original front buffer begins to draw the third image, and so on, so as to increase the output speed of the image.

Each rendering engine instance created by the Native side corresponds to an area of the screen.

The rendering engine instance actually completes all graphics rendering work, that is, completes Open GL rendering environment initialization, texture generation, coordinate change, color setting, graphics rendering, etc.

The rendering engine instance initializes the Open GL rendering environment through the Open GL library interface.

Bind multiple rendering threads created on the Java side with multiple rendering engine instances created on the Native side. In an exemplary embodiment, the binding to the plurality of rendering threads is performed by putting the plurality of rendering engine instances into thread private data (TSD).

As we all know, in a multi-threaded environment, since the data space is shared, global variables are also shared by all threads. A global variable, all threads can use it and change its value, so one thread's modification of the global variable will affect the access of another thread. Therefore, it is necessary to provide thread-private global variables in application design, which use thread-related data structures with the same name but different variable addresses. On the surface, it seems that it is a global variable, which can be used by all threads, and its value is stored separately in each thread. Such data structures are called thread-private data.

Before allocating thread-private data, it is necessary to create a key (key) associated with the thread-private data, and set the key value of the thread-private data. Although the key of the thread-private data TSD is shared among multiple threads, the key value can be different for each thread.

On the Native side, the rendering engine is in singleton mode externally, but it is actually required to be multi-instance when drawing multi-region graphics. In this example, the thread-based multi-instance mode is realized by combining the singleton mode with the thread private data technology, that is, the instances obtained through the singleton mode are also different for different threads, that is, the obtained instances correspond to the threads.

Specifically, multiple rendering threads can be created on the Java side, and the key of the thread-private data TSD can be shared between multiple threads, that is, the access right of thread-private data is shared among multiple rendering threads. On the Native side, a new rendering engine instance is created in the rendering thread environment provided by each rendering thread, and each rendering engine instance is placed in the TSD of its related rendering thread. That is to say, the key value of the thread private data in each rendering thread represents its associated rendering engine. In this way, the binding of the rendering thread and the rendering engine is realized, and the management of the rendering instance is completed through the rendering thread bound to it, and the rendering instance is only visible to the thread bound to it.

The advantage of this method is that the Native side can be designed according to the singleton design pattern, eliminating the need to manage multiple instances. The traditional singleton design means that the current class has only one instance externally, and generally speaking, this instance is only provided externally through one interface. With the introduction of TSD technology, although the singleton design pattern is still used, that is, only one interface is provided to obtain instances externally, the instances obtained by the same thread are always the same, and different instances are obtained by different threads. . That is to say, in this thread, anywhere, the same instance is obtained through the same interface. In this way, the management of multiple instances is omitted in the same thread.

2) Submit one or more graphics rendering tasks received by the Java side to different rendering threads, and submit the one or more graphics rendering tasks to the Native side based on the corresponding rendering threads.

When the Java side receives multiple graphics rendering tasks, different graphics rendering tasks are submitted to different rendering threads, and are submitted to the Native side based on their respective rendering threads.

3) Obtain a rendering engine instance bound to the rendering thread corresponding to the one or more graphics rendering tasks on the Native side to perform graphics rendering.

The Natvie side acquires the rendering engine instances bound to the rendering threads based on the thread private data corresponding to the graphics rendering task, and performs graphics rendering.

The rendering engine instance performs graphics rendering through Open GL commands.

Graphics rendering usually includes the following stages:

a) Designate geometric objects, such as some geometric units such as points, lines, and triangles.

b) Vertex processing operations. The data received at this stage is the attribute characteristics of each vertex, and the output is the transformed vertex data.

c) Primitive assembly. After vertex processing, all the attributes of the vertices have been determined, and at this stage the vertices will be assembled into primitives according to primitive rules.

d) Graphic element processing, mainly cropping and collapse.

e) Rasterization operation. The primitive data passed by the primitive processing stage will be decomposed into smaller units and correspond to each pixel of the frame buffer. These units are called fragments. A fragment may contain properties such as window left, depth, color, texture coordinates, etc.

f) Fragment processing. Including texture texture, that is, to obtain the corresponding color in the texture memory through texture coordinates; atomization, to modify the color of the current viewpoint position through the fragment distance; color summary: texture, main defined color, atomized color, secondary color The colors computed by the lighting stages are summed together.

g) Fragment-by-fragment operations. Including pixel ownership, clipping, alpha testing, stencil testing, depth testing, mixing, etc., these operations will eventually affect its color value in the frame buffer.

h) Frame buffer operation. After the graphics rendering is completed, the rendering engine exchanges the rendering results to the display buffer through the Open GL interface to complete the display. Since each rendering engine instance corresponds to an area of the screen, the rendered result will be directly displayed on the corresponding screen area.

4) Displaying the rendering results of the one or more graphics rendering tasks in the screen areas corresponding to the rendering engine instances performing rendering.

Since different rendering engine instances correspond to different areas of the screen, rendering results of graphics rendering tasks executed by different rendering engine instances may be displayed in different areas of the screen at the same time. In this way, the multi-region graphics drawing of the intelligent operating system is realized.

In an exemplary embodiment, the multi-region graphics drawing method for an intelligent operating system may further include: after the graphics rendering task is completed, the Native side calls back the rendering state to the Java side.

When the rendering engine on the Native end finishes rendering, the rendering engine will return the rendering state to the rendering view on the Java end. That is, the Java side is notified that the rendering has been completed or the rendering failed.

The advantage of the multi-region graphics drawing method for the intelligent operating system of this embodiment is:

(1) The graphics rendering task is executed by the rendering engine instance on the Native side, so it is not limited by memory.

(2) The rendering thread is independent of the main thread and is not affected by the business logic thread;

(3) It can be simultaneously rendered in multiple areas of the screen at the same time;

(4) Realize thread-based multi-instance mode through the single-instance mode + thread private data technology of the rendering engine.

According to another embodiment of the present invention, a multi-region graphics drawing device for an intelligent operating system is provided. The device may include: a unit for binding multiple rendering threads created by the Java end to multiple rendering engine instances created by the Native end; for submitting one or more graphics rendering tasks received by the Java end to the In different rendering threads, and submit the one or more graphics rendering tasks to the unit of the Native side based on the corresponding rendering threads; for obtaining the rendering threads corresponding to the one or more graphics rendering tasks at the Native side A bound rendering engine instance for graphics rendering; and a unit for displaying the rendering results of the one or more graphics rendering tasks in screen areas corresponding to the rendering engine instances performing rendering.

In an exemplary embodiment, the binding to the plurality of rendering threads is performed by placing the plurality of rendering engine instances into thread private data.

In an exemplary implementation, the Natvie side obtains respectively the rendering engine instances bound to the rendering threads based on the thread private data corresponding to the graphics rendering task.

In an exemplary embodiment, the rendering engine performs graphics rendering through Open GL commands.

In an exemplary embodiment, the device further includes: a unit for causing the Native side to call back the rendering status to the Java side after the graphics rendering task is completed.

In this embodiment, through the singleton design mode of the Native part and the thread private data TSD, combined with the multi-threading method of the Java part, it is possible to manage multiple Open GL contexts in one process at the same time, so that graphics can be drawn in multiple areas at the same time technical effect. It has the advantages of thread independence, unlimited memory and simultaneous rendering of multiple regions.

Application example

In order to facilitate the understanding of the solutions and effects of the embodiments of the present invention, a specific application example is given below. Those skilled in the art will understand that this example is only for the purpose of facilitating the understanding of the present invention, and any specific details thereof are not intended to limit the present invention in any way.

The following example draws two graphics in two areas of the screen through the multi-region graphics drawing method and device for an intelligent operating system of the present invention, the upper left picture is p1, and the lower right picture is p2. In this example, the smart operating system environment is Android, which supports Open GL 2.0.

Specific steps are as follows:

1) Create a first rendering thread and a second rendering process on the Java side.

Specifically, a first rendering thread and a second rendering process are created on the Java side, respectively provide rendering thread environments for the Native side, and generate two Open GL context environments.

2) On the Native side, create a first rendering engine instance and a second rendering engine instance in the rendering environments provided by the two rendering threads.

3) Put the first rendering engine instance and the second rendering engine instance into the TSDs of the first rendering thread and the second rendering thread respectively, so as to bind the first rendering engine instance to the first rendering thread, and bind the second rendering engine instance The rendering instance is bound to the second rendering thread.

4) Based on the first rendering thread, submit the rendering task of p1 to the first rendering engine on the native side bound to it, and the task points to the path of p1; based on the second rendering thread, submit it to the second rendering engine on the native side bound to it The rendering task of p2, which points to the path of p2.

5) The first rendering engine and the second rendering engine get rendering tasks respectively, and the types to be rendered are all images, and then the first rendering engine and the second rendering engine call the Open GL interface to load p1 and p2 as textures into the memory, and The memory buffer is exchanged to the display buffer through the Open GL interface, and the display in the corresponding screen areas of the first rendering engine and the second rendering engine is completed.

Due to the implementation of multi-threading, the display of p1 and p2 is simultaneous.

Those skilled in the art should understand that the purpose of the above description of the embodiments of the present invention is only to illustrate the beneficial effects of the embodiments of the present invention, and is not intended to limit the embodiments of the present invention to any given examples.

The invention may be an apparatus, method and/or computer program product. A computer program product may include a computer readable storage medium having computer readable program instructions thereon for causing a processor to implement various aspects of the present invention.

A computer readable storage medium may be a tangible device that can retain and store instructions for use by an instruction execution device. A computer readable storage medium may be, for example, but is not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of computer-readable storage media include: portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), or flash memory), static random access memory (SRAM), compact disc read only memory (CD-ROM), digital versatile disc (DVD), memory stick, floppy disk, mechanically encoded device, such as a printer with instructions stored thereon A hole card or a raised structure in a groove, and any suitable combination of the above. As used herein, computer-readable storage media are not to be construed as transient signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., pulses of light through fiber optic cables), or transmitted electrical signals.

Computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to a respective computing/processing device, or downloaded to an external computer or external storage device over a network, such as the Internet, a local area network, a wide area network, and/or a wireless network. The network may include copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers, and/or edge servers. A network adapter card or a network interface in each computing/processing device receives computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in each computing/processing device .

Computer program instructions for carrying out operations of the present invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, state setting data, or Source or object code written in any combination, including object-oriented programming languages—such as Smalltalk, C++, etc., and conventional procedural programming languages—such as the “C” language or similar programming languages. Computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer, or entirely on the remote computer or server implement. In cases involving a remote computer, the remote computer can be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (such as via the Internet using an Internet service provider). connect). In some embodiments, an electronic circuit, such as a programmable logic circuit, field programmable gate array (FPGA), or programmable logic array (PLA), can be customized by utilizing state information of computer-readable program instructions, which can Various aspects of the invention are implemented by executing computer readable program instructions.

Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It should be understood that each block of the flowcharts and/or block diagrams, and combinations of blocks in the flowcharts and/or block diagrams, can be implemented by computer-readable program instructions.

These computer-readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine such that when executed by the processor of the computer or other programmable data processing apparatus , producing an apparatus for realizing the functions/actions specified in one or more blocks in the flowchart and/or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium, and these instructions cause computers, programmable data processing devices and/or other devices to work in a specific way, so that the computer-readable medium storing instructions includes An article of manufacture comprising instructions for implementing various aspects of the functions/acts specified in one or more blocks in flowcharts and/or block diagrams.

It is also possible to load computer-readable program instructions into a computer, other programmable data processing device, or other equipment, so that a series of operational steps are performed on the computer, other programmable data processing device, or other equipment to produce a computer-implemented process , so that instructions executed on computers, other programmable data processing devices, or other devices implement the functions/actions specified in one or more blocks in the flowcharts and/or block diagrams.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, a portion of a program segment, or an instruction that includes one or more Executable instructions. In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified function or action , or may be implemented by a combination of dedicated hardware and computer instructions.

Having described various embodiments of the present invention, the foregoing description is illustrative, not exhaustive, and is not limited to the disclosed embodiments. Many modifications and alterations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen to best explain the principle of each embodiment, practical application or improvement of technology in the market, or to enable other ordinary skilled in the art to understand each embodiment disclosed herein.

Claims (10)

1. A method for drawing multi-region graphics for an intelligent operating system, comprising the following steps: Bind multiple rendering threads created on the Java side with multiple rendering engine instances created on the Native side; Submitting one or more graphics rendering tasks received by the Java end to different rendering threads, and submitting the one or more graphics rendering tasks to the Native end based on the corresponding rendering threads; Obtain a rendering engine instance bound to the rendering thread corresponding to the one or more graphics rendering tasks on the Native side to perform graphics rendering; and The rendering results of the one or more graphics rendering tasks are respectively displayed in the screen areas corresponding to the rendering engine instances performing rendering. 2. The multi-region graphics drawing method for an intelligent operating system according to claim 1, wherein the binding to the multiple rendering threads is performed by putting the multiple rendering engine instances into thread private data. 3. The multi-region graphics drawing method for an intelligent operating system according to claim 2, wherein, the Natvie side acquires respectively the rendering engine instances bound to the rendering threads based on the thread private data corresponding to the graphics rendering task. 4. The multi-region graphics drawing method for an intelligent operating system according to claim 1, wherein the rendering engine performs graphics rendering through Open GL commands. 5. The multi-region graphics drawing method for an intelligent operating system according to claim 1, wherein said method further comprises: After the graphics rendering task is completed, the Native side will call back the rendering status to the Java side. 6. A multi-region graphics drawing device for an intelligent operating system, characterized in that the device comprises: A unit for binding multiple rendering threads created on the Java side with multiple rendering engine instances created on the Native side; A unit for submitting one or more graphics rendering tasks received by the Java side to different rendering threads, and submitting the one or more graphics rendering tasks to the Native side based on the corresponding rendering threads; A unit for obtaining a rendering engine instance bound to a rendering thread corresponding to the one or more graphics rendering tasks on the Native side for graphics rendering; and A unit for displaying the rendering results of the one or more graphics rendering tasks in the screen areas corresponding to the rendering engine instances performing rendering. 7. The multi-region graphics rendering device for an intelligent operating system according to claim 6, wherein the binding to the plurality of rendering threads is performed by putting the plurality of rendering engine instances into thread private data. 8 . The multi-region graphics drawing device for an intelligent operating system according to claim 7 , wherein the Natvie side obtains the rendering engine instances bound to the rendering threads based on the thread private data corresponding to the graphics rendering task. 9. The multi-region graphics drawing device for an intelligent operating system according to claim 6, wherein the rendering engine performs graphics rendering through Open GL commands. 10. The multi-region graphics drawing device for an intelligent operating system according to claim 6, wherein said device further comprises: It is used to make the Native side call back the rendering state to the Java side unit after the graphics rendering task is completed.