CN107818588B - Device and method for calling Qt drawing based on JNI multithreading in Android system - Google Patents
Device and method for calling Qt drawing based on JNI multithreading in Android system Download PDFInfo
- Publication number
- CN107818588B CN107818588B CN201610819635.3A CN201610819635A CN107818588B CN 107818588 B CN107818588 B CN 107818588B CN 201610819635 A CN201610819635 A CN 201610819635A CN 107818588 B CN107818588 B CN 107818588B
- Authority
- CN
- China
- Prior art keywords
- thread
- dynamic library
- jni
- class
- surfaceview
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T11/00—2D [Two Dimensional] image generation
- G06T11/20—Drawing from basic elements, e.g. lines or circles
- G06T11/203—Drawing of straight lines or curves
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T1/00—General purpose image data processing
- G06T1/20—Processor architectures; Processor configuration, e.g. pipelining
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T13/00—Animation
- G06T13/80—2D [Two Dimensional] animation, e.g. using sprites
Abstract
The invention discloses a device and a method for calling Qt drawing classes based on JNI multithreading in an Android system, wherein the device comprises the following steps: running an Android system, emptying a system memory, initializing a canvas, activating a so dynamic library to call Qt drawing classes, and if the canvas initialization fails, re-activating the so dynamic library; after the so dynamic library is successfully activated, simultaneously starting an image data sampling thread and a SurfaceView drawing thread under the environment of a first language; and executing an operation of an image data sampling thread, generating a coordinate point through a drawing action MotionEvent event, drawing a rectangular frame according to the generated coordinate point by adopting a Rect command, loading a point coordinate float (x, y) into a so dynamic library, drawing Qt drawing according to the point coordinate float (x, y), executing a SurfaceView drawing thread, drawing by utilizing the SurfaceView of the Android system, and displaying a drawing surface drawn by the SurfaceView in a display. Therefore, the drawing speed is obviously improved, and cross-platform calling is realized.
Description
Technical Field
The invention relates to the field of drawing of an embedded platform, in particular to a device and a method for calling Qt drawing by Android based on JNI multithreading.
Background
Currently, an intelligent terminal adopting an Android operating system is widely used. The Android system generally uses a graphic processing engine, a 2D part is provided in an Android SDK by itself, a 3D part is used by Open GL ES 1.0, and apis used by the 2D part are mainly in Android and Android. In terms of graphic processing, pictures, shapes or self-defined text contents are most frequently drawn on a View, but the contents are all realized by Canvas at present, a Canvas object in the View is obtained, a plurality of self-defined shapes are drawn, then a View is refreshed by calling a View. invalidate method, and then a new shape is drawn, so that a 2D animation effect is achieved. The Canvas object can be obtained in two ways: one is by overwriting the view. In practice, however, Android draws slowly through canvas, which is difficult to meet requirements, and causes waste of cost.
Disclosure of Invention
In view of this, the present invention provides a device and a method for calling Qt drawing by an Android system through JNI multithreading, which employ a surfaview local refresh technology, a multithreading technology, and a Qt drawing technology to effectively solve the problem that the Android system draws slowly through canvas.
The invention provides a JNI multithreading-based Qt drawing class calling method for an Android system, which comprises the following steps:
a canvas initialization step, namely operating an Android system, emptying a system memory, initializing the canvas, activating a so dynamic library to call Qt drawing classes, and if the canvas initialization fails, re-activating the so dynamic library;
a thread starting step, after the so dynamic library is successfully activated, simultaneously starting a first thread and a second thread under the environment of a first language, wherein the first thread is an image data sampling thread, and the second thread is a surface View drawing thread; and
and an image drawing step, wherein the operation of the first thread is executed, a coordinate point is generated through a drawing action MotionEvent event, a rectangular frame is drawn according to the generated coordinate point by adopting a Rect command, a point coordinate float (x, y) is loaded to a so dynamic library, a Qt drawing class draws according to the point coordinate float (x, y), a second thread is executed simultaneously, drawing is carried out by utilizing the self SurfaceView of the Android system, and a drawing surface drawn by the SurfaceView is displayed in a display.
Preferably, according to the method for calling Qt drawing classes of the present invention, in the step of drawing the image, the second thread is executed, and the drawing with the self-SurfaceView of the Android includes the following steps:
requesting picture data from a so dynamic library by the SurfaceView according to Rect generated by drawing action MotionEvent in the first thread;
the so dynamic library generates picture data according to the Rect and transmits the picture data to a Qt drawing class, the Qt drawing class obtains the picture data, and a drawing result Qimap is transmitted back to the so dynamic library; the so dynamic library transmits Qimage to a JNI layer for JNI data conversion;
the JNI is converted into byte [ ] data types required by the Android through data conversion; and
and drawing the SurfaceView of the Android system according to the transmitted byte [ ] data.
Preferably, according to the Qt drawing class calling method of the present invention, the specific execution step of the first thread includes:
declaring a local method in a Java class;
generating a header file with an extension name h;
the local method is written so as to realize the following method: the name of the method is the same as the method declared in a header file generated by a javah command; and
an mk file is written and a so file is automatically generated.
Preferably, according to the Qt drawing class calling method of the present invention, by loading the API provided by the so file in the Android system: load, thereby completing the file to call the so dynamic library.
Preferably, according to the method for calling the Qt drawing class of the present invention, a preset calling interface is used to implement the fusion of the first language and the second language environment, the first language is Java, the second language is C + +, and the preset calling interface is a Java native interface JNI.
In another aspect of the present invention, an apparatus for calling Qt drawing classes based on JNI multithreading in an Android system is provided, where the apparatus includes:
the canvas initialization module runs an Android system, clears a system memory, initializes the canvas, activates the so dynamic library to call and prepare Qt drawing classes, and reactivates the so dynamic library if the canvas initialization fails;
and the thread starting module is used for starting a first thread and a second thread simultaneously under the environment of the first language after the so dynamic library is successfully activated, wherein the first thread is an image data acquisition thread, and the second thread is a surface View drawing thread.
And the drawing control module is used for controlling the operation of the first thread and the second thread, calling the Qt drawing class realized by the second language through a preset calling interface to perform graphic drawing and displaying the drawing completed drawing in a display of the equipment.
Further, according to the Qt drawing class calling device of the present invention, the first language is Java, the second language is C + +, and the preset calling interface is a Java native interface JNI.
Further, according to the Qt drawing class calling apparatus of the present invention, the drawing control module (103) comprises:
the system comprises a pre-calling module, a Java class and a Java library, wherein the pre-calling module loads a class library generated after compiling a specified C file in the Java class, the C file contains the Qt drawing class realized by using C/C + +, a JNI.h header file is introduced into the C file, and the Qt drawing class is declared in the Java class;
the calling execution module adopts the preset calling interface to directly call the Qt drawing class; and
and the drawing execution module is used for drawing according to the Qt drawing class called by the calling execution module and the self surfaceView of the Android system.
Further, according to the Qt drawing class calling device of the present invention, the drawing execution module executes the operation of the first thread, generates a coordinate point by a drawing action MotionEvent event, draws a rectangular frame according to the generated coordinate point by using a Rect command, and loads a point coordinate float (x, y) to the so dynamic library, and the Qt drawing class performs drawing according to the point coordinate float (x, y), and executes a second thread, performs drawing by using the self-SurfaceView of the Android system, and displays a drawing by the SurfaceView in the display.
According to the method, after the Android system calls the third-party So dynamic library for drawing through JNI multithreading, the drawing speed is obviously improved, the previous pause feeling is avoided, linearity is consistent, and user experience is improved. And cross-platform is realized: the Qt drawing program can also generate dynamic libraries required by the iOS and the Windows Phone, and can also be directly called on the iOS and the Windows Phone, and only one set of core code is maintained. Thus, development time is saved and work efficiency is improved.
Drawings
Fig. 1 is a flowchart of a method for calling Qt drawing classes based on JNI multithreading in an Android system according to an embodiment of the present invention.
Fig. 2 is a flowchart illustrating specific execution steps of a first thread in a method for calling a Qt drawing class by an Android system based on JNI multithreading according to an embodiment of the present invention.
Fig. 3 is a block diagram of a device for calling Qt drawing classes based on JNI multithreading in an Android system according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to specific embodiments and the accompanying drawings.
It should be noted that all expressions using "first" and "second" in the embodiments of the present invention are used for distinguishing two entities with the same name but different names or different parameters, and it should be noted that "first" and "second" are merely for convenience of description and should not be construed as limitations of the embodiments of the present invention, and they are not described in any more detail in the following embodiments.
As is well known to those skilled in the art, Qt is a cross-platform C + + graphical user interface application framework developed by Olympic technologies in 1991, which provides application developers with all the functionality required to build artistic-level graphical user interfaces, which has a very superior performance in embedded platform drawing.
As stated in the background art of the present application, Android draws slowly through canvas, and the drawing efficiency is far lower than Qt, so the inventor of the present application tries to call Qt for drawing by the Android system, and adopts the so dynamic library written by Qt, thereby solving the technical problem that Android draws slowly through canvas.
The Application and the Application framework of the upper layer of the Android system are written by Java, the bottom layer comprises the system and numerous Libraries are written by C/C + +, so that the upper layer Java calls the C/C + + function library of the bottom layer and is realized by JNI of the Java. JNI (abbreviation of Java Native Interface, wherein the term is "Java Native Interface") is a bridge for communicating Java code running in JVM with Native code running outside JVM (mainly C or C + +), which is a very important technology for connecting Java and Native C resources, and provides several APIs (abbreviation of Application Programming Interface, which term is "Application Programming Interface") to enable communication between Java and other languages (mainly C & C + +). Starting from Java1.1, the JNI standard becomes part of the Java platform, which allows interaction between Java code and code written in other languages. In addition, JNI has the advantages of: the method has the advantages of improving the program execution efficiency, high-performance application logic, confidential application logic, preventing decompilation, and having great advantages in the aspects of integration of a plurality of systems and code reuse.
The android system is characterized in that the android system uses JNI technology, adopts SurfaceView to perform local refreshing technology, multithreading technology and Qt drawing technology. The invention is mainly applied to the following occasions: situations requiring complex mathematical operations and consuming relatively high hardware resources, such as drawing, PDF, chm parsing, and the like; the project requirement of cross-platform programming, for example, a relatively large project is developed to run on Android, iOS and Windows Phone, at this time, the core project module can be taken out and implemented by c/c + +, and dynamic libraries required by each system are generated, that is, direct calling on the Android, iOS and Windows Phone can be implemented, so that development time is saved, working efficiency is improved, and code security is improved.
In the invention, in order to realize the calling of the Android system to the Qt to realize the quick drawing function, the Android system uses JNI to call the Qt, and the JNI and the Qt interact in the following way.
1. Implementing the Qt program methods (native methods: native methods) using JNI and calling them in the JAVA program;
JNI supports a "call interface" that allows a JVM to be embedded in a Qt program that can link a local library implementing the JVM and then execute software modules written in the JAVA language using the "call interface".
The following describes a principle of the Android system of the present invention that calls Qt drawing classes and completes drawing based on JNI multithreading with reference to the accompanying drawings.
As shown in fig. 1, a flowchart of a method for calling Qt drawing classes based on JNI multithreading in an Android system of the present invention is shown, which mainly includes the following steps.
Firstly, the Android system is operated, so that the so dynamic library is activated (namely, the system memory is emptied, the canvas initialization is executed), the Qt drawing class calling preparation stage is entered, and if the canvas initialization fails, the so dynamic library is activated again (which may be referred to as "canvas initialization step" for short).
Secondly, after the so dynamic library is successfully activated, a first thread and a second thread are started simultaneously under the environment of the first language, wherein the first thread is an image data sampling thread, and the second thread is a surface view drawing thread (which can be referred to as a thread starting step for short).
And finally, executing the operation of a first thread, generating a coordinate point through an onTouchervent event, drawing a rectangular frame according to the generated coordinate point by adopting a Rect command, loading a point coordinate float (x, y) into a so dynamic library, drawing a Qt drawing type according to the point coordinate float (x, y), executing a second thread, drawing by utilizing the self SurfaceView of the Android, and displaying a drawing surface drawn by the SurfaceView in a display (which can be referred to as an image drawing step for short).
In the image drawing step, executing a second thread, and drawing by using the self-Android SurfaceView, wherein the drawing work comprises the following steps:
firstly, the SurfaceView requests picture data from the so dynamic library according to Rect generated by drawing action MotionEvent in the first thread.
And secondly, generating picture data according to the Rect by the so dynamic library and transmitting the picture data to a Qt drawing class, obtaining the picture data by the Qt drawing class, and transmitting a drawing result Qimap back to the so dynamic library.
And thirdly, the so dynamic library transmits Qimage to a JNI layer to perform JNI data conversion.
And fourthly, converting the JNI into byte [ ] data types required by the Android through data conversion.
And fifthly, drawing the SurfaceView of the Android system according to the transmitted byte [ ] data.
In the invention, the dynamic library file (. so) called in the Android system is an API provided by loading the so file in the Android system: load (String path name).
In the invention, the fusion of two language environments is realized by adopting a preset calling interface. As an example, the first language is Java, the second language is C + +, and the predetermined call interface is preferably a Java native interface JNI.
In the present invention, a Qt drawing function is called by a JNI, and fig. 2 is a flowchart of specific execution steps of a first thread according to an embodiment of the present invention, as shown in fig. 2, the specific execution steps include: first, in step S201, a native method is declared in a Java class.
Load library ("jnipain") in the present invention, preferably, a static block is loaded, and what needs to be noted is system. The parameter "JniPaint" of (1) is the name of the dynamic library, and part of the code is as follows:
next, in step S202, a header file with an extension h is generated.
The h-file is equivalent to an interface in a Java class, and a Java _ com _ hht _ jnipair _ mousePress method is declared, and then the method is implemented in the local method.
In step S203, the local method is written, so that the following method is implemented: the name of the method is the same as the method declared in the header file generated by the javah command.
In step S204, an mk file is written, and one so file is automatically generated.
According to the embodiment, according to the calling method, after the Android system calls the Qt drawing classes based on JNI multithreading, the drawing speed is obviously improved, the previous pause feeling is avoided, and linearity is consistent.
The invention further provides a device for calling Qt drawing classes based on JNI multithreading in an Android system. As shown in fig. 3, a device for invoking Qt drawing classes by the Android through JNI multithreading according to an embodiment of the present invention is shown, where the device 100 includes:
the canvas initialization module 101 is configured to run an Android system, empty a system memory, initialize a canvas, activate a so dynamic library to prepare for calling Qt drawing classes, and reactivate the so dynamic library if the canvas initialization fails.
And the thread starting module 102 is used for starting a first thread and a second thread simultaneously under the environment of the first language after the so dynamic library is successfully activated, wherein the first thread is an image data acquisition thread, and the second thread is a surface view drawing thread.
And the drawing control module 103 controls the operation of the first thread and the second thread, calls the Qt drawing class realized by the second language through a preset calling interface to perform graphic drawing, and displays the drawing completed drawing in a display of the device.
Preferably, in the present invention, a preset call interface is used to implement fusion of two language environments. As an example, the first language is Java, the second language is C + +, and the preset calling interface is a Java native interface JNI.
In the present invention, the drawing control module 103 includes:
a pre-call module 1031, configured to load a class library generated after compiling a specified C file in a Java class, where the C file includes the Qt drawing class implemented using C/C + +, and a jni.h header file is introduced into the C file, and the Qt drawing class is declared in the Java class.
And the calling execution module 1032 directly calls the Qt drawing class by adopting a preset calling interface.
And the drawing execution module 1033 is used for drawing according to the Qt drawing class called by the calling execution module 1032 and the self surfaceView of the Android system.
In the present invention, the drawing execution module 1033 executes an operation of a first thread, generates a coordinate point through an onTouchEvent event, draws a rectangular frame according to the generated coordinate point by adopting a Rect command, loads a point coordinate float (x, y) to a so dynamic library, draws a Qt drawing class according to the point coordinate float (x, y), executes a second thread at the same time, draws a drawing by using a SurfaceView of an Android system itself, and displays a drawing surface drawn by the SurfaceView in a display.
Alternatively, the dynamic libraries of the present invention can also be written by MFCs or third party libraries such as: open source graphics library FreeImage, open source graphics library CxImage, etc.
Furthermore, in the invention, the Qt drawing program can also generate dynamic libraries required by the iOS and the Windows Phone, the dynamic libraries can be directly called on the iOS and the Windows Phone, and the core code is only maintained in one set, so the development time can be saved and the working efficiency can be improved.
As described above, according to the calling device of the present invention, after the Android system calls the third-party So library for drawing based on JNI multithreading, the drawing speed is significantly increased, and meanwhile, cross-platform calling is realized.
Those of ordinary skill in the art will understand that: the discussion of any embodiment above is meant to be exemplary only, and is not intended to intimate that the scope of the disclosure, including the claims, is limited to these examples; within the idea of the invention, also technical features in the above embodiments or in different embodiments may be combined and there are many other variations of the different aspects of the invention as described above, which are not provided in detail for the sake of brevity. Therefore, any omissions, modifications, substitutions, improvements and the like that may be made without departing from the spirit and principles of the invention are intended to be included within the scope of the invention.
Claims (7)
1. A JNI multithreading-based Qt drawing class calling method for an Android system is characterized by comprising the following steps:
a canvas initialization step, namely operating an Android system, emptying a system memory, initializing the canvas, activating a so dynamic library to call Qt drawing classes, and if the canvas initialization fails, re-activating the so dynamic library;
a thread starting step, after the so dynamic library is successfully activated, simultaneously starting a first thread and a second thread under the environment of a first language, wherein the first thread is an image data sampling thread, and the second thread is a surface View drawing thread; and
an image drawing step, namely executing the operation of the first thread, generating a coordinate point through a drawing action MotionEvent event, drawing a rectangular frame according to the generated coordinate point by adopting a Rect command, loading a point coordinate float (x, y) into a so dynamic library, drawing a Qt drawing class according to the point coordinate float (x, y), executing a second thread, drawing by utilizing the self SurfaceView of the Android system, and displaying a drawing surface drawn by the SurfaceView in a display;
in the image drawing step, executing a second thread, and drawing by using the self-Android surfaceView of the Android, wherein the drawing comprises the following steps:
requesting picture data from a so dynamic library by the SurfaceView according to Rect generated by drawing action MotionEvent in the first thread;
the so dynamic library generates picture data according to the Rect and transmits the picture data to a Qt drawing class, the Qt drawing class obtains the picture data, and a drawing result Qimap is transmitted back to the so dynamic library;
the so dynamic library transmits Qimage to a JNI layer for JNI data conversion;
the JNI is converted into byte [ ] data types required by the Android through data conversion; and
and drawing the SurfaceView of the Android system according to the transmitted byte [ ] data.
2. The method of claim 1, wherein the specific execution of the first thread comprises:
declaring a local method in a Java class;
generating a header file with an extension name h;
the local method is written so as to realize the following method: the name of the method is the same as the method declared in a header file generated by a javah command; and
an mk file is written and a so file is automatically generated.
3. Method according to one of claims 1-2, characterized in that the API provided by loading the so file in the Android system: load, thereby invoking the so dynamic library file.
4. The method according to one of claims 1-2,
and realizing the fusion of the first language environment and the second language environment by adopting a preset calling interface, wherein the first language is Java, the second language is C + +, and the preset calling interface is a Java native interface JNI.
5. An apparatus for calling Qt drawing classes based on JNI multithreading in an Android system, the apparatus comprising:
the canvas initialization module (101) runs the Android system, empties a system memory, initializes the canvas, activates the so dynamic library to call and prepare Qt drawing classes, and reactivates the so dynamic library if the canvas initialization fails;
the thread starting module (102) is used for starting a first thread and a second thread simultaneously under the environment of a first language after the so dynamic library is successfully activated, wherein the first thread is an image data acquisition thread, and the second thread is a surface View drawing thread;
the drawing control module (103) controls the operation of the first thread and the second thread, calls a Qt drawing class realized by a second language through a preset calling interface to perform graphic drawing, and displays the drawn drawing in a display of the equipment;
the drawing control module (103) comprises:
the drawing execution module (1033) is used for executing the operation of the first thread, generating a coordinate point through a drawing action MotionEvent event, drawing a rectangular frame according to the generated coordinate point by adopting a Rect command, loading a point coordinate float (x, y) into a so dynamic library, drawing Qt drawing according to the point coordinate float (x, y) and simultaneously executing a second thread, drawing by utilizing the self SurfaceView of the Android system, and displaying a drawing surface drawn by the SurfaceView in a display;
the executing of the second thread, drawing by using the self surfaceView of the Android, comprises the following steps:
requesting picture data from a so dynamic library by the SurfaceView according to Rect generated by drawing action MotionEvent in the first thread;
the so dynamic library generates picture data according to the Rect and transmits the picture data to a Qt drawing class, the Qt drawing class obtains the picture data, and a drawing result Qimap is transmitted back to the so dynamic library;
the so dynamic library transmits Qimage to a JNI layer for JNI data conversion;
the JNI is converted into byte [ ] data types required by the Android through data conversion; and
and drawing the SurfaceView of the Android system according to the transmitted byte [ ] data.
6. The apparatus according to claim 5, wherein the first language is Java, the second language is C + +, and the predetermined calling interface is a Java native interface JNI.
7. The apparatus according to claim 5 or 6, wherein the drawing control module (103) comprises:
a pre-call module (1031) that loads a class library generated after compiling a specified C file in a Java class, wherein the C file contains the Qt drawing class implemented using C/C + +, a jni.h header file is introduced into the C file, and the Qt drawing class is declared in the Java class;
a calling execution module (1032) for directly calling the Qt drawing class by adopting the preset calling interface; and
and the drawing execution module (1033) is used for drawing according to the Qt drawing class called by the calling execution module (1032) and the self surfaceView of the Android system.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610819635.3A CN107818588B (en) | 2016-09-12 | 2016-09-12 | Device and method for calling Qt drawing based on JNI multithreading in Android system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610819635.3A CN107818588B (en) | 2016-09-12 | 2016-09-12 | Device and method for calling Qt drawing based on JNI multithreading in Android system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN107818588A CN107818588A (en) | 2018-03-20 |
| CN107818588B true CN107818588B (en) | 2021-12-28 |
Family
ID=61601230
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201610819635.3A Active CN107818588B (en) | 2016-09-12 | 2016-09-12 | Device and method for calling Qt drawing based on JNI multithreading in Android system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107818588B (en) |
Families Citing this family (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108446147B (en) * | 2018-03-23 | 2021-01-12 | 携程旅游网络技术（上海）有限公司 | Multithreading calculation method and system of mobile terminal |
| CN109032604B (en) * | 2018-07-03 | 2022-02-22 | 瑞芯微电子股份有限公司 | Method for generating Qt library capable of running on Android system |
| CN109343838A (en) * | 2018-09-17 | 2019-02-15 | 北京智明星通科技股份有限公司 | Chat feature development approach and system, terminal and computer readable storage medium |
| CN109375980B (en) * | 2018-10-29 | 2021-10-15 | 四川长虹教育科技有限公司 | Touch drawing method based on Andriod system |
| CN112799583B (en) * | 2021-04-13 | 2021-08-24 | 北京三维天地科技股份有限公司 | Point location schematic drawing system based on android platform |
| CN115272524B (en) * | 2022-09-23 | 2023-01-03 | 安徽华云安科技有限公司 | Multi-curve parallel drawing method, device, equipment and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103985284A (en) * | 2014-05-26 | 2014-08-13 | 四川川大智胜软件股份有限公司 | Cross-platform teacher control console system and control method thereof based on Qt |
| CN104166552A (en) * | 2014-08-15 | 2014-11-26 | 成都天奥信息科技有限公司 | Transplantable memory bitmap graphics library application method |
| CN105204881A (en) * | 2014-06-25 | 2015-12-30 | 中兴通讯股份有限公司 | Method and device for operating J2me application program on Android system |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8583795B2 (en) * | 2010-08-09 | 2013-11-12 | Mskynet Inc. | URI service system and method |
| TWI520069B (en) * | 2010-08-11 | 2016-02-01 | 緯創資通股份有限公司 | Application method for integrating heterogeneous operating systems based on the same system kernel |
| US8554938B2 (en) * | 2010-08-31 | 2013-10-08 | Millind Mittal | Web browser proxy-client video system and method |
-
2016
- 2016-09-12 CN CN201610819635.3A patent/CN107818588B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103985284A (en) * | 2014-05-26 | 2014-08-13 | 四川川大智胜软件股份有限公司 | Cross-platform teacher control console system and control method thereof based on Qt |
| CN105204881A (en) * | 2014-06-25 | 2015-12-30 | 中兴通讯股份有限公司 | Method and device for operating J2me application program on Android system |
| CN104166552A (en) * | 2014-08-15 | 2014-11-26 | 成都天奥信息科技有限公司 | Transplantable memory bitmap graphics library application method |
Non-Patent Citations (3)
| Title |
|---|
| Android传感器之绘图篇-Handle学习;逐梦_person;《https://blog.csdn.net/u014675538》;20151220;第1页 * |
| Android图形图像处理技术的研究综述;李钦华 等;《无线互联科技》;20150510(第9期);第110-111页 * |
| Real-time visualization of signals from electronic control units on mobile platforms;Ivan Rajkoviü 等;《2015 23rd Telecommunications Forum Telfor (TELFOR)》;20160111;第966-969页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN107818588A (en) | 2018-03-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107818588B (en) | Device and method for calling Qt drawing based on JNI multithreading in Android system | |
| CN110691136B (en) | Data interaction method and device, electronic equipment and storage medium | |
| US11164280B2 (en) | Graphics layer processing in a multiple operating systems framework | |
| CN107992301B (en) | User interface implementation method, client and storage medium | |
| US11036345B2 (en) | System and method for on-screen graphical user interface encapsulation and reproduction | |
| US10013503B2 (en) | Canvas element rendering method and apparatus implemented on android system based on GPU | |
| US6983357B2 (en) | Hardware accelerator for an object-oriented programming language | |
| US9098297B2 (en) | Hardware accelerator for an object-oriented programming language | |
| US6330659B1 (en) | Hardware accelerator for an object-oriented programming language | |
| US20220292628A1 (en) | Image processing method and apparatus | |
| KR101416104B1 (en) | A dynamic loading apparatus and method of java script code performing native functions of hybrid web applications | |
| AU2016269452A1 (en) | User interface displaying and processing method and user interface displaying and processing device | |
| WO2019238145A1 (en) | Webgl-based graphics rendering method, apparatus and system | |
| CN104866318A (en) | Method and device for displaying label pages in multiple windows | |
| CN104573110B (en) | The Dynamic Display method and device of figure in a kind of browser | |
| CN110727504B (en) | Code execution method and device and rendering equipment | |
| CN113419712A (en) | Cross-platform application generation method, cross-platform application calling method and development device | |
| CN110764779B (en) | Encapsulation method, registration method, device and rendering equipment | |
| CN106648623B (en) | Display method and device for characters in android system | |
| CN109918598B (en) | Web page rendering method based on Android television browser | |
| US8203567B2 (en) | Graphics processing method and apparatus implementing window system | |
| CN113407259B (en) | Scene loading method, device, equipment and storage medium | |
| CN116010736A (en) | Vector icon processing method, device, equipment and storage medium | |
| CN111913711B (en) | Video rendering method and device | |
| CN110648272A (en) | Graphic resource conversion method, apparatus, electronic device and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |