CN112307403B - Page rendering method and device, storage medium and terminal - Google Patents
Page rendering method and device, storage medium and terminal Download PDFInfo
- Publication number
- CN112307403B CN112307403B CN202011259637.4A CN202011259637A CN112307403B CN 112307403 B CN112307403 B CN 112307403B CN 202011259637 A CN202011259637 A CN 202011259637A CN 112307403 B CN112307403 B CN 112307403B
- Authority
- CN
- China
- Prior art keywords
- page
- plug
- data
- surface texture
- native component
- 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
- 238000009877 rendering Methods 0.000 title claims abstract description 92
- 238000000034 method Methods 0.000 title claims abstract description 68
- 230000002194 synthesizing effect Effects 0.000 claims abstract description 30
- 230000015572 biosynthetic process Effects 0.000 claims description 51
- 238000003786 synthesis reaction Methods 0.000 claims description 51
- 238000012544 monitoring process Methods 0.000 claims description 13
- 238000004590 computer program Methods 0.000 claims description 3
- 238000011161 development Methods 0.000 abstract description 20
- 238000012545 processing Methods 0.000 abstract description 9
- 238000010586 diagram Methods 0.000 description 14
- 230000008569 process Effects 0.000 description 14
- 230000006870 function Effects 0.000 description 10
- 239000008186 active pharmaceutical agent Substances 0.000 description 8
- 238000004891 communication Methods 0.000 description 7
- 238000005516 engineering process Methods 0.000 description 4
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 230000003993 interaction Effects 0.000 description 3
- 230000007474 system interaction Effects 0.000 description 3
- 230000006978 adaptation Effects 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 235000002566 Capsicum Nutrition 0.000 description 1
- VYZAMTAEIAYCRO-UHFFFAOYSA-N Chromium Chemical compound [Cr] VYZAMTAEIAYCRO-UHFFFAOYSA-N 0.000 description 1
- 239000006002 Pepper Substances 0.000 description 1
- 235000016761 Piper aduncum Nutrition 0.000 description 1
- 235000017804 Piper guineense Nutrition 0.000 description 1
- 244000203593 Piper nigrum Species 0.000 description 1
- 235000008184 Piper nigrum Nutrition 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000001680 brushing effect Effects 0.000 description 1
- 229910052804 chromium Inorganic materials 0.000 description 1
- 239000011651 chromium Substances 0.000 description 1
- 230000006378 damage Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000007781 pre-processing Methods 0.000 description 1
- 238000011160 research Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/958—Organisation or management of web site content, e.g. publishing, maintaining pages or automatic linking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
- G06F9/44526—Plug-ins; Add-ons
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Databases & Information Systems (AREA)
- Human Computer Interaction (AREA)
- Data Mining & Analysis (AREA)
- Information Transfer Between Computers (AREA)
Abstract
The application discloses a page rendering method, a page rendering device, a storage medium and a terminal, and relates to the technical field of page processing. Acquiring a page code injected by a client frame, and creating a page plug-in corresponding to an original component in the page code; creating a surface texture and a page plugin layer corresponding to the page plugin; and acquiring data of the original assembly through the surface texture, synthesizing the data of the original assembly to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer. Because the page plug-in of the native component can be created according to the page code injected by the client frame and the data of the native component can be obtained through the surface texture, the data of the native component can be synthesized into the page view data corresponding to the page plug-in layer in the browser kernel, the same-layer rendering of the native component and other components in the page plug-in layer can be realized, the development difficulty of a developer on an application program is reduced, and the development efficiency of the developer is greatly improved.
Description
Technical Field
The present application relates to the field of page processing technologies, and in particular, to a page rendering method, a device, a storage medium, and a terminal.
Background
With the development of science and technology, various terminals are appeared in the life of people, and an important role of the terminals is to display pages of various applications, so that the process of rendering pages is also one of the important points of research for those skilled in the art.
In the related art, native components and non-native components may be included in a page of an application, and since the system is defined such that the level corresponding to the native components in the page is greater than the level of the non-native components, the relative level and rendering between the native components and the non-native components cannot be controlled by using conventional commands, so that the development difficulty of the application by a developer is increased, and the development efficiency of the developer is greatly limited.
Disclosure of Invention
The application provides a page rendering method, a page rendering device, a storage medium and a page rendering terminal, which can solve the technical problems that the development difficulty of application programs of developers is increased and the development efficiency of the developers is greatly limited because the relative hierarchy and rendering between native components and non-native components cannot be controlled by using conventional commands in the related art.
In a first aspect, an embodiment of the present application provides a page rendering method, which is applied to a terminal, where the terminal at least includes a browser kernel and a client frame, and the method includes:
Acquiring a page code injected by the client frame, and creating a page plug-in corresponding to an original component in the page code;
Creating a surface texture and creating a page plugin layer corresponding to the page plugin;
And acquiring data of the native component through the surface texture, synthesizing the data of the native component to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer.
Optionally, the creating the page plugin corresponding to the original component in the page code includes: acquiring a protocol plug-in type between the browser kernel and the client framework; analyzing node information of the native component, and obtaining the plug-in type of the page plug-in corresponding to the native component; and if the protocol plug-in type comprises the plug-in type of the page plug-in corresponding to the original component, creating the page plug-in corresponding to the original component in the page code.
Optionally, the creating the surface texture includes: the control main thread initializes the receiving surface texture environment and creates a surface texture by the graphics processor thread.
Optionally, the creating a page plugin layer corresponding to the page plugin includes: and creating a page plug-in layer corresponding to the page plug-in, and inserting the page plug-in layer into a data synthesis tree.
Optionally, before the acquiring the data of the native component by the surface texture, the method further includes: controlling a rendering thread to add surface texture data for monitoring; the acquiring data of the native component through the surface texture includes: binding the native component with the surface texture through the client framework; data of the native component of the surface texture update is acquired and stored.
Optionally, before the synthesizing the data of the native component to the page view data corresponding to the page plug-in layer, the method includes: initializing a task environment of a data synthesis thread; the step of synthesizing the data of the native component to the page view data corresponding to the page plug-in layer comprises the following steps: and acquiring page view data corresponding to the page plug-in layer, and synthesizing the data of the native component into the page view data through the data synthesis tree in the task environment.
Optionally, after the creating the surface texture by the graphics processor thread, the method further includes: marking the surface texture and the page insert by a unique identification; the synthesizing the data of the native component into the page view data through the data synthesis tree in the task environment includes: and acquiring the page plugin corresponding to the surface texture based on the unique identifier, and synthesizing the data of the native component corresponding to the surface texture into the page view data corresponding to the page plugin in the task environment through the data synthesis tree.
In a second aspect, an embodiment of the present application provides a page rendering device, which is applied to a terminal, where the terminal at least includes a browser kernel and a client frame, and the device includes:
the plug-in creation module is used for acquiring the page code injected by the client frame and creating a page plug-in corresponding to an original component in the page code;
The texture creating module is used for creating a surface texture and creating a page plug-in layer corresponding to the page plug-in;
And the data synthesis module is used for obtaining the data of the native component through the surface texture, synthesizing the data of the native component to the page view data corresponding to the page plug-in layer, and displaying the page plug-in layer.
In a third aspect, embodiments of the present application provide a computer storage medium storing a plurality of instructions adapted to be loaded by a processor and to perform steps implementing the method described above.
In a fourth aspect, an embodiment of the present application provides a terminal, including a memory, a processor, and a computer program stored on the memory and executable on the processor, where the processor implements the steps of the method described above when the processor executes the program.
The technical scheme provided by the embodiments of the application has the beneficial effects that at least:
The application provides a page rendering method, which is applied to a terminal, wherein the terminal at least comprises a browser kernel and a client framework, and the method comprises the following steps: acquiring a page code injected by a client frame, and creating a page plug-in corresponding to an original component in the page code; creating a surface texture and a page plugin layer corresponding to the page plugin; and acquiring data of the original assembly through the surface texture, synthesizing the data of the original assembly to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer. Because the page plug-in of the native component can be created according to the page code injected by the client frame and the data of the native component can be obtained through the surface texture, the data of the native component can be synthesized into the page view data corresponding to the page plug-in layer in the browser kernel, the same-layer rendering of the native component and other components in the page plug-in layer can be realized, the development difficulty of a developer on an application program is reduced, and the development efficiency of the developer is greatly improved.
Drawings
In order to more clearly illustrate the embodiments of the application or the technical solutions in the prior art, the drawings that are necessary for the description of the embodiments or the prior art will be briefly described, it being obvious that the drawings in the following description are only some embodiments of the application and that other drawings may be obtained from them without inventive effort for a person skilled in the art.
Fig. 1 is an exemplary system architecture diagram of a page rendering method according to an embodiment of the present application;
FIG. 2 is a system interaction diagram of a page rendering method according to an embodiment of the present application;
FIG. 3 is a flowchart illustrating a page rendering method according to another embodiment of the present application;
FIG. 4 is a flowchart illustrating a page rendering method according to another embodiment of the present application;
FIG. 5 is a diagram of client native rendering according to another embodiment of the present application;
FIG. 6 is a schematic diagram of co-layer rendering according to another embodiment of the present application;
Fig. 7 is a schematic structural diagram of a page rendering device according to another embodiment of the present application;
fig. 8 is a schematic structural diagram of a page rendering device according to another embodiment of the present application;
Fig. 9 is a schematic structural diagram of a terminal according to an embodiment of the present application.
Detailed Description
In order to make the features and advantages of the present application more comprehensible, embodiments accompanied with figures in the present application are described in detail below, wherein the embodiments are described only in some but not all embodiments of the present application. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to be within the scope of the application.
When the following description refers to the accompanying drawings, the same numbers in different drawings refer to the same or similar elements, unless otherwise indicated. The implementations described in the following exemplary examples do not represent all implementations consistent with the application. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the application as detailed in the accompanying claims.
Fig. 1 is an exemplary system architecture diagram of a page rendering method according to an embodiment of the present application.
As shown in fig. 1, the system architecture may include at least one browser core 110 and a client framework 120, where a portion of the browser core is a rendering engine, that is, the browser core 110 in the embodiment of the present application, and the browser core 110 is responsible for interpreting a web page grammar (such as an application HTML, javaScript in a standard universal markup language) and rendering (displaying) the web page. The browser kernel, i.e. the rendering engine employed by the browser, determines how the browser displays the content of the web page and the format information of the page.
Further, the client framework 120 may refer to various applications, which may be one application, for example, an application may be a light application, or an application that implements applet functionality.
It should be appreciated that the number of browser kernels and client frameworks in fig. 1 is merely illustrative and that any number of browser kernels and client frameworks may be used as desired for an implementation.
Referring to fig. 2, fig. 2 is a system interaction diagram of a page rendering method according to an embodiment of the present application, and a system interaction process in the page rendering method will be described with reference to fig. 1 and fig. 2.
S201, the client framework injects page codes into the browser kernel according to the operation of a user.
S202, the browser kernel acquires the page code injected by the client frame and creates a page plug-in corresponding to the original component in the page code.
The method for creating the page plugin corresponding to the original component in the page code comprises the following steps: obtaining a protocol plug-in type between a browser kernel and a client framework; analyzing node information of the original assembly, and obtaining the plug-in type of the page plug-in corresponding to the original assembly; if the protocol plug-in type comprises the plug-in type of the page plug-in corresponding to the original component, the page plug-in corresponding to the original component in the page code is created.
S203, the browser kernel creates a surface texture and creates a page plugin layer corresponding to the page plugin.
Wherein optionally creating the surface texture comprises: the control main thread initializes the receiving surface texture environment and creates a surface texture by the graphics processor thread. Optionally, creating a page plugin layer corresponding to the page plugin further includes: and creating a page plugin layer corresponding to the page plugin, and inserting the page plugin layer into the data synthesis tree.
S204, the browser kernel acquires data of the original assembly through surface textures, synthesizes the data of the original assembly into page view data corresponding to the page plug-in layer, and displays the page plug-in layer.
Wherein before acquiring the data of the native component by the surface texture, the method further comprises: controlling a rendering thread to add surface texture data for monitoring; acquiring data of a native component by surface texture, comprising: binding the native component with the surface texture through the client framework; data of a native component of the surface texture update is acquired and stored.
Optionally, before synthesizing the data of the native component to the page view data corresponding to the page plug-in layer, the method includes: initializing a task environment of a data synthesis thread; synthesizing the data of the native component into page view data corresponding to the page plug-in layer, wherein the page view data comprises: and acquiring page view data corresponding to the page plug-in layer, and synthesizing the data of the native component into the page view data through a data synthesis tree in a task environment.
Wherein after notifying the graphics processor thread to create the surface texture, further comprising: marking the surface texture and the page plug-in by unique identification; synthesizing data of the native component into page view data through a data synthesis tree in a task environment, comprising: and acquiring the page plug-in corresponding to the surface texture based on the unique identifier, and synthesizing the data of the native component corresponding to the surface texture into page view data corresponding to the page plug-in through a data synthesis tree in a task environment.
In the embodiment of the application, the page code injected by the client frame is acquired, and the page plug-in corresponding to the original component in the page code is created; creating a surface texture and a page plugin layer corresponding to the page plugin; and acquiring data of the original assembly through the surface texture, synthesizing the data of the original assembly to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer. Because the page plug-in of the native component can be created according to the page code injected by the client frame and the data of the native component can be obtained through the surface texture, the data of the native component can be synthesized into the page view data corresponding to the page plug-in layer in the browser kernel, the same-layer rendering of the native component and other components in the page plug-in layer can be realized, the development difficulty of a developer on an application program is reduced, and the development efficiency of the developer is greatly improved. .
Referring to fig. 3, fig. 3 is a flowchart illustrating a page rendering method according to another embodiment of the application. In the embodiment of the application, the page rendering method is mainly applied to the terminal, and the terminal at least comprises a browser kernel and a client frame, and optionally, the implementation of the page rendering method provided by the embodiment of the application can be based on an android system.
As shown in fig. 3, the page rendering method includes:
s301, acquiring a page code injected by a client frame, and creating a page plug-in corresponding to an original component in the page code.
In the related art, after receiving an operation or an instruction of a user, a client may call a corresponding native component in a client framework to perform the related operation, for example, when the user clicks a video page in a certain application program, the application program needs to play the video in the video page, but because the process of displaying the video involves not only the native component but also a non-native component or a plug-in, the native component and the non-native component are respectively in different display levels, and because the system limitation causes the priority of the display level of the native component to be greater than that of the non-native component, the relative level and rendering between the native component and the non-native component cannot be controlled by using a conventional command, which increases the development difficulty of the application program by a developer and also greatly limits the development efficiency of the developer.
In the embodiment of the application, the client framework can be used as a medium for interaction between the terminal and the user, the client framework can receive the operation or instruction of the user, and the client can acquire the page code corresponding to the operation or instruction of the user, wherein the page code can comprise the display instruction corresponding to the operation or instruction of the user, the basic display content, the parameters of the native component and the like, namely the page code represents all data when the client framework is implemented for the operation or instruction of the user.
After the client frame acquires the page codes, the page codes can be injected into the browser kernel, so that the subsequent browser kernel can conveniently conduct page rendering work, and the browser kernel can acquire the page codes injected by the client frame.
Because the native component and the non-native component need to be rendered at the same layer, the optional layers of the same layer rendering include a layer corresponding to the native component and a layer corresponding to the non-native component. In order to implement the same-layer rendering, a non-native component that needs to be used by the native component is first created, and in the embodiment of the present application, the page plugin (web plugin) is used to implement the same-layer rendering with the native component, so that the non-native component refers to other plugins such as the page plugin. Meanwhile, other plug-ins such as a Pepper plug-in can be selected to replace the page plug-in according to the actual application situation of page rendering. After the browser kernel acquires the page code, the page code can be analyzed to acquire the plug-in type corresponding to the original component in the page code, and the page plug-in corresponding to the original component is created. The purpose of creating the page plug-in here is to replace the native component with the page plug-in, while the page plug-in and other non-native components may be at the same level, and the page plug-in and other non-native components may be controlled by the browser kernel at the same level, to achieve the same-layer rendering between the native component and the other non-native components.
S302, creating a surface texture and creating a page plugin layer corresponding to the page plugin.
Because the native component and the non-native component need to be rendered in the same layer at the same layer, and the same layer is the layer corresponding to the page plug-in, a data channel is also required to be established between the layers corresponding to the native component and the page plug-in, so that the data of the native component can be transmitted to the page plug-in layer, and the native component and the non-native component can be rendered in the same layer at the same layer. One possible way is for the browser kernel to obtain the data of the native component in time by creating a surface texture and listening to the data of the native component on the surface texture.
In the related art, in the process of displaying a page, the drawing speed of the page content is a core requirement, and in the process of scrolling the page, new content is actually drawn on a screen continuously, wherein texture refers to a basic medium unit used in the process of drawing the page, the texture is used as a limited memory resource, is a bearing medium of the page content, and is finally transmitted to a display screen. The size of the texture is required to be defined before the texture is used, for example, the texture is defined as 256 x 256 pixels, the texture with the defined size is a texture block, and a plurality of texture blocks are put together to form a texture pool. The process of rendering the page to the screen is a process of firstly drawing page contents onto texture blocks and then transmitting texture block data corresponding to the texture blocks to a screen buffer of the graphic processor, and after the process is finished, an image corresponding to the page is displayed on the screen. In the embodiment of the application, the surface texture can be regarded as a texture block or texture pool, and the surface texture is used for acquiring the data of the native component, so that the data of the native component can be acquired by monitoring the data update of the surface texture.
Further, after the data channel is provided, a hierarchy where the native component and the non-native component are rendered in the same layer is required to be created, and since the native component corresponds to the page plug-in, a hierarchy (page plug-in layer) corresponding to the page plug-in needs to be created, after the surface texture and the page plug-in layer are created, the browser kernel can acquire the data of the native component, and the native component and the non-native component are rendered in the same layer in the page plug-in layer.
S303, acquiring data of the native component through the surface texture, synthesizing the data of the native component to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer.
The data channel is established between the native component and the page plug-in layer through the surface texture, so that the data of the native component can be obtained through the surface texture, and further, the page plug-in layer corresponding to the page plug-in is also established, and the page plug-in and the native component are in a corresponding relation, namely, the page view data corresponding to the native component can be obtained through the page view data corresponding to the page plug-in layer, so that the data of the native component can be synthesized into the page view data corresponding to the page plug-in layer, which is equivalent to the step of adding the data of the native component into the view data of the native component in a client frame, and the step of obtaining the data of the native component through the surface texture, and the step of synthesizing the data of the native component into the page view data corresponding to the page plug-in layer are all carried out in the browser kernel.
In the embodiment of the application, the page code injected by the client frame is acquired, and the page plug-in corresponding to the original component in the page code is created; creating a surface texture and a page plugin layer corresponding to the page plugin; and acquiring data of the original assembly through the surface texture, synthesizing the data of the original assembly to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer. Because the page plug-in of the native component can be created according to the page code injected by the client frame and the data of the native component can be obtained through the surface texture, the data of the native component can be synthesized into the page view data corresponding to the page plug-in layer in the browser kernel, the same-layer rendering of the native component and other components in the page plug-in layer can be realized, the development difficulty of a developer on an application program is reduced, and the development efficiency of the developer is greatly improved.
Referring to fig. 4, fig. 4 is a flowchart illustrating a page rendering method according to another embodiment of the application.
As shown in fig. 4, the method steps include:
S401, acquiring the page codes injected by the client frame.
For the description of step S401, please refer to the description of step S301, and the description is omitted here.
S402, acquiring a protocol plug-in type between the browser kernel and the client framework.
The main idea of the embodiment of the application is that firstly, a page plug-in corresponding to a native component is created in a browser kernel, and one possible implementation way is that the native component of a protocol corresponds to a protocol plug-in type of the same-layer rendering, for example, a video component protocol in the protocol plug-in type is a page plug-in type which is a video type, wherein the component protocol needs to be disclosed to a developer of a client framework, so that the developer of the client framework can conveniently design and use the same-layer rendering capability. The method has the advantages that the small program capacity of the client framework can be dynamically expanded, so that page plug-ins corresponding to various service scenes can be developed only by pre-processing protocol native components to correspond to the protocol plug-in types rendered at the same layer, the native components can be expanded to meet the service requirements of more complex scenes, and the browser kernel does not need to be adapted.
S403, analyzing node information of the original component, and obtaining a plug-in type of the page plug-in corresponding to the original component.
Since the plug-in type of the page plug-in corresponding to the native component is required to be obtained after the native component in the page code is obtained, whether the page plug-in can be created and the same-layer rendering can be performed is determined. The parsing method for the node information of the native component may be extracting the plug-in identifier in the native component, or may select an appropriate parsing method according to the actual situation, which is not described herein in detail.
S404, if the protocol plug-in type comprises the plug-in type of the page plug-in corresponding to the original component, creating the page plug-in corresponding to the original component in the page code.
After obtaining the plug-in type of the page plug-in corresponding to the native component, the plug-in type is compared with the protocol plug-in type, if the protocol plug-in type comprises the plug-in type of the page plug-in corresponding to the native component, the plug-in type of the page plug-in corresponding to the native component is subjected to protocol before rendering, and meets the requirement of the contract layer rendering, then the page plug-in corresponding to the native component in the page code can be created, and the setting has the advantages that the page plug-in created by the browser kernel is prevented from not corresponding to the native component of the client frame, so that the matching failure of the browser kernel is caused, and finally the page rendering failure is caused.
For example, if the node information of the native component is analyzed, and the plug-in type of the page plug-in corresponding to the native component is obtained as the map component, but only the video component is included in the protocol plug-in type, the page plug-in cannot be created, and the same-layer rendering cannot be performed. For convenience of description, the following protocol plug-in type is described by taking a plug-in type including a page plug-in corresponding to a native component as an example.
In the embodiment of the application, the calling of various components or the implementation of steps can be realized by adopting a mode of calling an application program interface (Application Programming Interface, API) so as to improve the page rendering speed. Therefore, the process of creating the page plugin corresponding to the original component in the page code can also realize the creation of the page plugin corresponding to the original component in the page code by calling the API of the page plugin corresponding to the original component in the page code. In the embodiment of the application, the design and the number of the surface texture interaction APIs are not limited, but the application scene of the current client framework is required to be covered. Such as a surface texture creation API and a surface texture destruction API, while the APIs need to carry at least native component type information, a surface texture unique identification, and a surface texture.
S405, controlling the main thread to initialize the receiving surface texture environment, and creating the surface texture by the graphics processor thread.
In the embodiment of the application, the normal operation and the logic sequence of the operation among the steps can be realized through threads, and the method can be mainly divided into three threads, namely a data synthesis thread, a rendering thread and a main thread, wherein the three threads are respectively responsible for different functions, and are described one by one in the following description.
Prior to creating the surface texture, the host thread may be controlled to initialize the receiving surface texture environment to create the surface texture based on the surface texture in the surface texture environment, where the way the surface texture is created may be by notifying a graphics processor thread to create the surface texture. The specific manner in which the graphics processor thread creates the surface texture may also be by calling a corresponding surface texture API to create the surface texture.
After the graphic processor thread is informed to create the surface texture in the surface texture environment, the unique identification can be used for marking the surface texture and the page plug-in, so that after the data of the native component is acquired from the surface texture, the corresponding page plug-in and page plug-in layer can be quickly found, and the data synthesis is realized.
S406, creating a page plug-in layer corresponding to the page plug-in, and inserting the page plug-in layer into the data synthesis tree.
The step of creating the page plug-in layer corresponding to the page plug-in may refer to the step S302, and is not described herein in detail. Further, the related API may be called to create a data synthesis tree, so as to facilitate addition and synthesis of each data in the data synthesis process, where the data synthesis tree is a browser kernel synthesis (Chromium Compositor, CC) tree, and is a data structure, where n (n > =1) finite nodes form a set with a hierarchical relationship, the data synthesis tree may be specifically a plug-in or a program module, and each node in the data synthesis tree may receive each data input from the outside, and synthesize each data according to a preset synthesis logic, and output a result of data synthesis. In order to facilitate the composition of data of a native component into page view data corresponding to a page plug-in layer, the page plug-in layer may be inserted into a data composition tree such that after the data of the native component is obtained, the data of the native component is input into nodes of the data composition tree, and the data of the native component in the nodes is composed into the page plug-in layer in the data composition tree.
S407, binding the native component and the surface texture through the client framework.
After the data of the native component is acquired, the client frame is also required to be informed of binding the native component with the surface texture, and in the steps, the surface texture and the page plug-in are marked by using the unique identification, namely, the surface texture is respectively bound with the native component in the client frame and the page plug-in the inner core of the browser, so that a data channel between the native component in the client frame and the inner core of the browser is established based on the surface texture, the inner core of the browser can be timely informed once the valid data is generated by the native component, and the surface texture is encapsulated into a valid data frame in the rendering thread, wherein the valid data frame is a resource which can be used by a synthesizer of the inner core of the browser.
S408, monitoring data update of the surface texture, and acquiring and storing data of a native component of the surface texture update.
Binding the native component and the surface texture through the client frame, when the native component generates effective data, the effective data can be updated on the surface texture, the data generated by the native component can be acquired by monitoring the data update of the surface texture, the data of the native component can be stored after the data of the native component is acquired, and when the stored data reaches a preset capacity or is enough to synthesize a certain page frame, the subsequent data synthesis step is carried out.
Optionally, in order to obtain the data of the native component by monitoring the data update of the surface texture, before the data of the native component is obtained, the rendering thread is controlled to add the surface texture data monitoring, which may be regarded as a plug-in or a program module, and after the rendering thread adds the surface texture data monitoring, the rendering thread is controlled to obtain the data update on the surface texture at any time, so as to update the data of the native component at any time, and ensure the effect and page update during page rendering.
S409, acquiring page view data corresponding to the page plug-in layer, and synthesizing the data of the native component into the page view data through a data synthesis tree in a task environment.
Since the surface texture and the page plug-in are marked by using the unique identification in the above steps, the page plug-in corresponding to the surface texture can be acquired based on the unique identification, in the task environment of the data synthesis thread, the data of the native component corresponding to the surface texture is synthesized into the page view data corresponding to the page plug-in through the data synthesis tree, which is equivalent to adding the data of the native component into the view data of the native component in the client frame, because of the step of creating the page plug-in corresponding to the native component in the page code, and the data of the native component is acquired through the surface texture, the method for rendering the page in the browser kernel realizes the page rendering method for rendering the page in the same layer in the browser kernel, better solves the problem of realizing the difference of rendering the same layer of the different original components and the customization difference of the browser kernel of different manufacturers for realizing the rendering technology in the same layer, achieves the standard consistency, and greatly reduces the adaptation cost of the browser kernel for supporting the rendering in the same layer.
The data of the native component is finally synthesized to the page view data corresponding to the page plug-in layer, so that a task environment of a data synthesis thread corresponding to the data synthesis needs to be prepared before the data synthesis, namely, a basic condition that the data synthesis thread can run, and after the task environment of the data synthesis thread is initialized, the data synthesis thread can perform a data synthesis process in the task environment.
After the data is synthesized, the page plug-in layer can be displayed, namely, the screen-on operation corresponding to the client framework.
Referring to fig. 5 and fig. 6, fig. 5 is a schematic diagram of client native rendering according to another embodiment of the present application, and fig. 6 is a schematic diagram of peer rendering according to another embodiment of the present application. As shown in fig. 5, when native rendering is performed in the client framework, the native component cannot be displayed at a position corresponding to the page plug-in the page plug-in layer due to the fact that the level at which the native component is located is inconsistent with the priority of the page plug-in layer.
As shown in FIG. 6, after the page rendering of the application is used, as a data channel is established between the native component and the browser kernel, the data of the native component can be synthesized and displayed on the page plug-in layer, and the same-layer rendering of the native component on the page plug-in layer is realized. Meanwhile, a developer can do dynamic protocol page plug-in type according to different native component functions and use scenes, native components can be expanded to meet business requirements of more complex scenes, and redundant adaptation is not needed in a browser kernel. The scheme ensures that the light application native component has the capability consistent with CSS, and widens the thought of developing application of a developer. As in the dashed box area of FIG. 6 above, a developer may use Web front-end technology to customize a diverse user scenario. For example, the functions of barrages, sharing, collecting, commenting, etc. on short video or long video; and brushing the functions of gift, comment, praise and the like in an online live broadcast manner. The browser kernel customization method in the embodiment of the application can also be used for hybrid application development. For example, in a scene of higher performance of a Web page pair of the hybrid application, part of the content can be replaced by a system component or a native component, and the embodiment of the application can realize the same-layer rendering and also has corresponding Web capability.
In the embodiment of the application, the page code injected by the client frame is acquired, and the page plug-in corresponding to the original component in the page code is created; creating a surface texture and a page plugin layer corresponding to the page plugin; and acquiring data of the original assembly through the surface texture, synthesizing the data of the original assembly to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer. Because the page plug-in of the native component can be created according to the page code injected by the client frame and the data of the native component can be obtained through the surface texture, the data of the native component can be synthesized into the page view data corresponding to the page plug-in layer in the browser kernel, the same-layer rendering of the native component and other components in the page plug-in layer can be realized, the development difficulty of a developer on an application program is reduced, and the development efficiency of the developer is greatly improved.
Referring to fig. 7, fig. 7 is a schematic structural diagram of a page rendering device according to another embodiment of the application.
As shown in fig. 7, the page rendering device 700 is applied to a terminal, the terminal at least includes a browser kernel 110 and a client frame 120, and the page rendering device 700 includes:
the plug-in creation module 710 is configured to obtain the page code injected by the client frame, and create a page plug-in corresponding to the original component in the page code.
The texture creating module 720 is configured to create a surface texture and create a page plug-in layer corresponding to the page plug-in.
The data synthesis module 730 is configured to obtain data of a native component through a surface texture, synthesize the data of the native component to page view data corresponding to a page plug-in layer, and display the page plug-in layer.
Referring to fig. 8, fig. 8 is a schematic structural diagram of a page rendering device according to another embodiment of the application.
As shown in fig. 8, the page rendering device 800 is applied to a terminal, the terminal at least includes a browser kernel 110 and a client frame 120, and the page rendering device 800 includes:
the code obtaining module 810 is configured to obtain the page code injected by the client framework.
The tag protocol module 820 is configured to obtain a protocol plug-in type between the browser kernel and the client framework.
The plug-in initializing module 830 is configured to parse node information of the native component, and obtain a plug-in type of the page plug-in corresponding to the native component.
The page plug-in creation module 840 is configured to create a page plug-in corresponding to the native component in the page code if the protocol plug-in type includes a plug-in type of the page plug-in corresponding to the native component.
Texture creation module 850 is used to control the main thread to initialize the receiving surface texture environment and create surface textures by the graphics processor thread. The texture creation module 870 is also configured to tag the surface texture with the page plug-in using the unique identification.
The plug-in layer creating module 860 is configured to create a page plug-in layer corresponding to the page plug-in, and insert the page plug-in layer into the data synthesis tree.
An interaction module 870 for binding the native component with the surface texture through the client framework.
A storage module 880 for listening for data updates of the surface texture, retrieving and storing data of the native components of the surface texture updates. Optionally, the page rendering apparatus 800 may further include: and the monitoring module is used for controlling the rendering thread to add surface texture data monitoring.
And the synthesizing module 890 is used for acquiring page view data corresponding to the page plug-in layer, and synthesizing the data of the native component into the page view data through the data synthesis tree in the task environment. Optionally, the page rendering apparatus 800 may further include: and the rendering environment module is used for initializing the task environment of the data synthesis thread.
The synthesizing module 890 is further configured to obtain a page plug-in corresponding to the surface texture based on the unique identifier, and synthesize, in the task environment, data of a native component corresponding to the surface texture to page view data corresponding to the page plug-in through the data synthesis tree.
In an embodiment of the present application, a page rendering device is applied to a terminal, where the terminal at least includes a browser kernel and a client frame, and the device includes: the plug-in creation module is used for acquiring the page codes injected by the client frame and creating page plug-ins corresponding to the original components in the page codes; the texture creating module is used for creating surface textures and page plug-in layers corresponding to the page plug-ins; the data synthesis module is used for obtaining data of the original assembly through the surface texture, synthesizing the data of the original assembly to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer. Because the page plug-in of the native component can be created according to the page code injected by the client frame and the data of the native component can be obtained through the surface texture, the data of the native component can be synthesized into the page view data corresponding to the page plug-in layer in the browser kernel, the same-layer rendering of the native component and other components in the page plug-in layer can be realized, the development difficulty of a developer on an application program is reduced, and the development efficiency of the developer is greatly improved.
Embodiments of the present application also provide a computer storage medium having stored thereon a plurality of instructions adapted to be loaded by a processor and to perform the steps of the method according to any of the embodiments described above.
The embodiment of the application also provides a network device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor performing the steps of the method according to any of the embodiments above.
Referring to fig. 9, fig. 9 is a schematic structural diagram of a terminal according to an embodiment of the present application. As shown in fig. 9, the terminal 900 may include: at least one processor 901, at least one network interface 904, a user interface 903, memory 905, at least one communication bus 902.
Wherein a communication bus 902 is employed to facilitate a coupled communication between the components.
The user interface 903 may include a Display screen (Display) and a Camera (Camera), and the optional user interface 903 may further include a standard wired interface and a wireless interface.
The network interface 904 may optionally include a standard wired interface, a wireless interface (e.g., WI-FI interface), among others.
Processor 901 may include one or more processing cores, among other things. The processor 901 connects various parts within the overall terminal 900 using various interfaces and lines, performs various functions of the terminal 900 and processes data by executing or executing instructions, programs, code sets, or instruction sets stored in the memory 905, and invoking data stored in the memory 905. Alternatively, the processor 901 may be implemented in at least one hardware form of digital signal Processing (DIGITAL SIGNAL Processing, DSP), field-Programmable gate array (Field-Programmable GATE ARRAY, FPGA), programmable logic array (Programmable Logic Array, PLA). The processor 901 may integrate one or a combination of several of a central processing unit (Central Processing Unit, CPU), an image processor (Graphics Processing Unit, GPU), and a modem, etc. The CPU mainly processes an operating system, a user interface, an application program and the like; the GPU is used for rendering and drawing the content required to be displayed by the display screen; the modem is used to handle wireless communications. It will be appreciated that the modem may not be integrated into the processor 901 and may be implemented by a single chip.
The Memory 905 may include a random access Memory (Random Access Memory, RAM) or a Read-Only Memory (ROM). Optionally, the memory 905 includes a non-transitory computer readable medium (non-transitory computer-readable storage medium). The memory 905 may be used to store instructions, programs, code, sets of codes, or sets of instructions. The memory 905 may include a stored program area and a stored data area, wherein the stored program area may store instructions for implementing an operating system, instructions for at least one function (such as a touch function, a sound playing function, an image playing function, etc.), instructions for implementing the above-described respective method embodiments, etc.; the storage data area may store data or the like referred to in the above respective method embodiments. The memory 905 may also optionally be at least one storage device located remotely from the processor 901. As shown in fig. 9, an operating system, a network communication module, a user interface module, and a page rendering program may be included in the memory 905, which is one type of computer storage medium.
In the terminal 900 shown in fig. 9, the user interface 903 is mainly used for providing an input interface for a user, and acquiring data input by the user; and the processor 901 may be configured to call a page rendering program stored in the memory 905 and specifically perform the following operations:
acquiring a page code injected by a client frame, and creating a page plug-in corresponding to an original component in the page code;
Creating a surface texture and a page plugin layer corresponding to the page plugin;
and acquiring data of the original assembly through the surface texture, synthesizing the data of the original assembly to page view data corresponding to the page plug-in layer, and displaying the page plug-in layer.
In one embodiment, the processor 901, when executing a page plug-in corresponding to a native component in creating page code, specifically performs the following steps:
obtaining a protocol plug-in type between a browser kernel and a client framework;
analyzing node information of the original assembly, and obtaining the plug-in type of the page plug-in corresponding to the original assembly;
If the protocol plug-in type comprises the plug-in type of the page plug-in corresponding to the original component, the page plug-in corresponding to the original component in the page code is created.
In one embodiment, the processor 901, when executing the creation of the surface texture, specifically performs the steps of:
The control main thread initializes the receiving surface texture environment and creates a surface texture by the graphics processor thread.
In one embodiment, the processor 901, when executing the page plug-in layer corresponding to the creation page plug-in, specifically performs the following steps:
And creating a page plugin layer corresponding to the page plugin, and inserting the page plugin layer into the data synthesis tree.
In one embodiment, the processor 901, prior to executing the data acquisition of the native component by surface texture, further specifically performs the steps of: controlling a rendering thread to add surface texture data for monitoring; the processor 901, when executing the acquisition of data of a native component by surface texture, specifically performs the following steps: binding the native component with the surface texture through the client framework; data of a native component of the surface texture update is acquired and stored.
In one embodiment, the processor 901 further specifically performs the following steps before executing the composition of the data of the native component to the page view data corresponding to the page plug-in layer: initializing a task environment of a data synthesis thread; when the processor 901 synthesizes the data of the native component into the page view data corresponding to the page plug-in layer, the following steps are specifically executed: and acquiring page view data corresponding to the page plug-in layer, and synthesizing the data of the native component into the page view data through a data synthesis tree in a task environment.
In one embodiment, the processor 901, after executing the creation of the surface texture by the graphics processor thread, also specifically performs the steps of:
Marking the surface texture and the page plug-in by unique identification; synthesizing data of the native component into page view data through a data synthesis tree in a task environment, comprising: and acquiring the page plug-in corresponding to the surface texture based on the unique identifier, and synthesizing the data of the native component corresponding to the surface texture into page view data corresponding to the page plug-in through a data synthesis tree in a task environment.
In the several embodiments provided by the present application, it should be understood that the disclosed apparatus and method may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, e.g., the division of modules is merely a logical function division, and there may be additional divisions of actual implementation, e.g., multiple modules or components may be combined or integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or modules, which may be in electrical, mechanical, or other forms.
The modules illustrated as separate components may or may not be physically separate, and components shown as modules may or may not be physical modules, i.e., may be located in one place, or may be distributed over a plurality of network modules. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of this embodiment.
In addition, each functional module in each embodiment of the present application may be integrated into one processing module, or each module may exist alone physically, or two or more modules may be integrated into one module. The integrated modules may be implemented in hardware or in software functional modules.
The integrated modules, if implemented in the form of software functional modules and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application may be embodied in essence or a part contributing to the prior art or all or part of the technical solution in the form of a software product stored in a storage medium, including several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the methods of the embodiments of the present application. And the aforementioned storage medium includes: a usb disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
It should be noted that, for the sake of simplicity of description, the foregoing method embodiments are all expressed as a series of combinations of actions, but it should be understood by those skilled in the art that the present application is not limited by the order of actions described, as some steps may be performed in other order or simultaneously in accordance with the present application. Further, those skilled in the art will appreciate that the embodiments described in the specification are all preferred embodiments, and that the acts and modules referred to are not necessarily all required for the present application.
In the foregoing embodiments, the descriptions of the embodiments are emphasized, and for parts of one embodiment that are not described in detail, reference may be made to the related descriptions of other embodiments.
The foregoing describes a page rendering method, apparatus, storage medium and terminal provided by the present application, and those skilled in the art should not understand the present application to limit the scope of the present application in view of the foregoing description of the specific embodiments and application range of the present application.
Claims (7)
1. A method for rendering a page, the method being applied to a browser core in a terminal, the terminal comprising at least the browser core and a client framework, the method comprising:
acquiring a page code injected by the client framework, and acquiring a protocol plug-in type between the browser kernel and the client framework;
analyzing node information of a native component, and acquiring a plug-in type of a page plug-in corresponding to the native component;
If the protocol plug-in type comprises the plug-in type of the page plug-in corresponding to the native component, creating the page plug-in corresponding to the native component in the page code;
Creating a surface texture, creating a page plug-in layer corresponding to the page plug-in, and inserting the page plug-in layer into a data synthesis tree;
Marking the surface texture and the page insert by a unique identification;
Binding the native component with the surface texture through the client framework; monitoring data update of the surface texture, and acquiring and storing data of the native component of the surface texture update;
Acquiring page view data corresponding to the page plug-in layer; and acquiring the page plugin corresponding to the surface texture based on the unique identifier, synthesizing the data of the native component corresponding to the surface texture into the page view data corresponding to the page plugin through the data synthesis tree in a task environment, and displaying the page plugin layer.
2. The method of claim 1, wherein the creating a surface texture comprises:
the control main thread initializes the receiving surface texture environment and creates a surface texture by the graphics processor thread.
3. The method of claim 2, wherein prior to the acquiring the data of the native component by the surface texture, further comprising:
Controlling the rendering thread to add surface texture data interception.
4. A method according to claim 3, wherein the compositing the data of the native component to the page view data corresponding to the page plug-in layer is preceded by:
The task environment of the data synthesis thread is initialized.
5. A page rendering device, characterized by being applied to a browser core in a terminal, the terminal comprising at least the browser core and a client framework, the device comprising:
The plug-in creation module is used for acquiring the page codes injected by the client framework and acquiring the protocol plug-in types between the browser kernel and the client framework; analyzing node information of a native component, and acquiring a plug-in type of a page plug-in corresponding to the native component; if the protocol plug-in type comprises the plug-in type of the page plug-in corresponding to the native component, creating the page plug-in corresponding to the native component in the page code;
The texture creating module is used for creating surface textures, creating a page plug-in layer corresponding to the page plug-in, and inserting the page plug-in layer into a data synthesis tree;
The texture creation module is further used for marking the surface texture and the page plug-in through a unique identification;
A data synthesis module for binding the native component with the surface texture through the client framework; monitoring data update of the surface texture, and acquiring and storing data of the native component of the surface texture update; acquiring page view data corresponding to the page plug-in layer; and acquiring the page plugin corresponding to the surface texture based on the unique identifier, synthesizing the data of the native component corresponding to the surface texture into the page view data corresponding to the page plugin through the data synthesis tree in a task environment, and displaying the page plugin layer.
6. A computer storage medium storing a plurality of instructions adapted to be loaded by a processor and to perform the steps of the method according to any one of claims 1 to 4.
7. A terminal comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the steps of the method according to any one of claims 1 to 4 when the program is executed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011259637.4A CN112307403B (en) | 2020-11-12 | 2020-11-12 | Page rendering method and device, storage medium and terminal |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011259637.4A CN112307403B (en) | 2020-11-12 | 2020-11-12 | Page rendering method and device, storage medium and terminal |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112307403A CN112307403A (en) | 2021-02-02 |
| CN112307403B true CN112307403B (en) | 2024-08-13 |
Family
ID=74324898
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011259637.4A Active CN112307403B (en) | 2020-11-12 | 2020-11-12 | Page rendering method and device, storage medium and terminal |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112307403B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113515286B (en) * | 2021-05-08 | 2022-06-17 | 上海安畅网络科技股份有限公司 | Applet generating and running method, device, equipment and storage medium |
| CN116775164A (en) * | 2022-03-08 | 2023-09-19 | 腾讯科技（深圳）有限公司 | Sub-application program running method and device, electronic equipment and readable storage medium |
| CN114942795A (en) * | 2022-04-29 | 2022-08-26 | 湖南茶旅云科技有限公司 | Loading method of live broadcast gift data in small program, electronic device and storage medium |
| CN116257294B (en) * | 2023-01-17 | 2024-01-26 | 成都曾自科技有限公司 | Cross-process independent cloud rendering method, device, equipment and storage medium |
Family Cites Families (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103092612B (en) * | 2012-12-31 | 2016-12-28 | 深圳天珑无线科技有限公司 | Realize method and the electronic installation of Android operation system 3D desktop pinup picture |
| US20150089348A1 (en) * | 2013-09-23 | 2015-03-26 | Yahoo! Inc. | System and method for web page background image delivery |
| US11068643B2 (en) * | 2019-02-08 | 2021-07-20 | Oracle International Corporation | Client-side customization and rendering of web content |
| CN110442822B (en) * | 2019-08-02 | 2024-03-22 | 腾讯科技（深圳）有限公司 | Method, device, equipment and storage medium for displaying small program content |
| CN110704136B (en) * | 2019-09-27 | 2023-06-20 | 北京百度网讯科技有限公司 | Method for rendering applet components, client, electronic device and storage medium |
| CN110888635B (en) * | 2019-11-28 | 2023-07-04 | 百度在线网络技术（北京）有限公司 | Same-layer rendering method and device, electronic equipment and storage medium |
| CN111291292A (en) * | 2020-01-15 | 2020-06-16 | 广州虎牙科技有限公司 | Page rendering method and device, terminal equipment and storage medium |
-
2020
- 2020-11-12 CN CN202011259637.4A patent/CN112307403B/en active Active
Also Published As
| Publication number | Publication date |
|---|---|
| CN112307403A (en) | 2021-02-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112307403B (en) | Page rendering method and device, storage medium and terminal | |
| CN111552473B (en) | Application processing method, device and equipment | |
| KR102115057B1 (en) | Graphic rendering | |
| CN107832108B (en) | Rendering method and device of 3D canvas webpage elements and electronic equipment | |
| CN108959392B (en) | Method, device and equipment for displaying rich text on 3D model | |
| CN113411664B (en) | Video processing method and device based on sub-application and computer equipment | |
| CN110750664B (en) | Picture display method and device | |
| CN111339458A (en) | Page presenting method and device | |
| CN112052416A (en) | Method and device for displaying image elements | |
| US20230343021A1 (en) | Visible element determination method and apparatus, storage medium, and electronic device | |
| CN117609646A (en) | Scene rendering method and device, electronic equipment and storage medium | |
| CN111737614A (en) | Page display method and device, electronic equipment and storage medium | |
| CN111258434A (en) | Method, device, equipment and storage medium for inserting pictures into chat interface | |
| CN117009011A (en) | Data processing method, device, equipment and readable storage medium | |
| CN117376660A (en) | Subtitle element rendering method, device, equipment, medium and program product | |
| CN109905753B (en) | Corner mark display method and device, storage medium and electronic device | |
| CN114866801B (en) | Video data processing method, device, equipment and computer readable storage medium | |
| US20140289656A1 (en) | Systems and Methods for Creating and Using Electronic Content with Displayed Objects Having Enhanced Features | |
| EP4002289A1 (en) | Picture processing method and device, storage medium, and electronic apparatus | |
| CN114904274A (en) | Picture rendering method and device of cloud game, electronic equipment and storage medium | |
| EP4462369A1 (en) | Video processing method and apparatus, electronic device, computer-readable storage medium, and computer program product | |
| Kim et al. | Direct canvas: Optimized WebGL rendering model | |
| CN113111035B (en) | Special effect video generation method and equipment | |
| CN110855539B (en) | Device discovery method, device and storage medium | |
| CN113663328B (en) | Picture recording method, device, computer equipment 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 |