WO2019042329A1 - Method and apparatus for rendering user interface - Google Patents

Abstract

Disclosed in the present application is a method for rendering a user interface. The method comprises: triggering rendering of a user interface of a to-be-rendered object according to a main thread; switching the main thread to a sub-thread, and drawing a bitmap corresponding to the to-be-tendered object by means of the sub-thread; calling back to the main thread, and applying the drawn bitmap to displayed content of the to-be-tendered object; and rendering the user interface according to the displayed content of the to-be-tendered object. By means of the method for rendering a user interface, a bitmap drawing operation originally executed in the main thread is transferred to the sub-thread to perform execution, thereby reducing the load of the main thread, an avoiding the freeze of the user interface when the main thread in heavy tasks timely handles a rendering task.

Description

Method and device for rendering user interface

The present application claims priority to Chinese Patent Application No. 200910755049.1, entitled "A Method and Apparatus for User Interface Rendering", filed on August 29, 2017, the entire contents of which are incorporated herein by reference. In the application.

Technical field

The present application relates to the field of UI rendering technologies, and in particular, to a method for user interface rendering. The application also relates to a device for rendering a user interface, and an electronic device.

Background technique

In the terminal device, the CPU (Central Processing Unit), the GPU (Graphics Processing Unit), and the display perform the user interface (UI, User Interface) rendering, and work together in the following manner: when the frame synchronization signal arrives After that, the application is notified to perform user interface rendering, and the main thread of the application starts to calculate the display content in the CPU, such as view creation, layout calculation, image decoding, text drawing, etc., after the calculation is completed, the CPU submits the display content to the GPU. The GPU converts, merges, and renders according to the displayed content. After the rendering is completed, the GPU puts the rendering result into the frame buffer area, and waits for the next frame synchronization signal to arrive, and then transfers the data of the frame buffer area to the display for display.

Take the iOS system as an example. The application uses the UIKit and CoreAnimation frameworks provided by the system to render the user interface. However, these frameworks must be operated on the main thread. The internal implementation is also performed by the main thread on the CPU, such as preparation. View hierarchy, set layer properties, draw bitmaps, and decode images. When the user interface level is complicated or the content is complicated, the task cannot be completed within one refresh cycle, and the user interface content cannot be updated to the screen in time, which may cause the user interface to be stuck. In addition, if the main thread is performing other heavy tasks, such as responding to user touches and clicks in the main thread, the main thread may not be able to process the rendering task in time, which may also cause the user interface to be stuck.

Summary of the invention

The present application provides a method for user interface rendering to solve the problem of user interface jams existing in the prior art.

The application also relates to a device for rendering a user interface, and an electronic device.

The application provides a method for rendering a user interface, including:

Triggering user interface rendering for the object to be rendered based on the main thread;

Switching from the main thread to the child thread, and drawing, by the child thread, a bitmap corresponding to the object to be rendered;

Calling back the main thread, and applying the drawn bitmap to the display content of the object to be rendered;

And rendering a user interface according to the display content of the object to be rendered.

Optionally, the step of switching from the main thread to the child thread, and drawing the bitmap corresponding to the object to be rendered by the child thread, before performing the step of performing the following steps:

Determining a view hierarchy tree of the object to be rendered;

Rectifying nodes in the view hierarchy tree;

The bitmap corresponding to the object to be rendered is drawn according to a rasterization result of nodes in the view hierarchy tree.

Optionally, the method for rendering the user interface includes:

Determining, according to the attribute information of the object to be rendered, a node attribute of a node in the view hierarchy tree;

The node attributes include: a rasterized attribute and a non-rasterized attribute;

Correspondingly, the nodes in the view hierarchy tree include: a rasterized root node, a rasterized child node, and a non-rasterized node.

Optionally, the rasterized root node is configured with a state identifier, where the state identifier includes: a first state identifier that allows rasterization with the rasterized child node, and a second state that does not allow rasterization with the rasterized child node Status identifier.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node, and if so, selecting a level of the rasterized root node or the non-rasterized node existing in the ancestor node and a level of the node The nearest rasterized root node or non-rasterized node is used as the candidate node;

Determining whether the node attribute of the node is a rasterization attribute, and if so, determining whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier, and if so, merging the nodes Go to the candidate node.

Optionally, if the judgment result of the step of determining whether the rasterized root node or the non-rasterized node is present in the ancestor node found is no, perform the following operations:

Determining whether the node attribute of the node is a rasterization attribute, and if so, using the node as a rasterization root node, and setting a status identifier of the node as the first status identifier.

Optionally, if the determining whether the node attribute of the node is a rasterization attribute sub-step is negative, perform the following operations:

Setting the candidate node as a parent node of the node;

Determining whether the candidate node is a rasterized root node, and if so, marking the status identifier of the candidate node as the second status identifier.

Optionally, if the determining whether the candidate node is a rasterized root node and determining whether the status identifier of the candidate node is the first state identifier substep is no, perform the following operations:

The candidate node is set as the parent node of the node.

Optionally, the method for rendering the user interface includes:

Determining whether the nodes in the view hierarchy tree are traversed, and if not, performing the depth-first rule to traverse the node sub-steps in the view hierarchy tree.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node, and if so, selecting a level of the rasterized root node or the non-rasterized node existing in the ancestor node and a level of the node The nearest rasterized root node or non-rasterized node is used as the candidate node;

Determining whether the node attribute of the node is a rasterization attribute, and if so, determining whether the candidate node is a rasterized root node, and if so, determining whether the state identifier of the candidate node is a first state identifier, and if so, the node Merged onto the candidate node.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node;

Determining whether the state identifier of the candidate node is the first state identifier, and if so, determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node;

Determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.

Optionally, the mapping of the bitmap corresponding to the object to be rendered is implemented as follows:

And according to the result of the combination of the node and the candidate node, the node view corresponding to the node and the node view corresponding to the candidate node are drawn on a bitmap.

Optionally, the method is implemented based on a terminal device, where the terminal device is configured with a central processing unit, a graphics processor, and a display screen;

The step of triggering a user interface for the object to be rendered based on the main thread, the step of switching from the main thread to the child thread, drawing a bitmap step corresponding to the object to be rendered by the child thread, and the step Calling back the main thread, applying the drawn bitmap to the display content of the object to be rendered, based on the central processor;

The step of rendering a user interface according to the display content of the object to be rendered is implemented based on the graphics processor;

After the step of executing the step of executing the step of performing the rendering of the bitmap to the display content of the object to be rendered, and the step of performing the rendering of the user interface according to the display content of the object to be rendered, The central processor submits the display content to the graphics processor;

After rendering the user interface according to the display content of the object to be rendered, the graphics processor passes the rendering result to the display screen.

The application also provides a device for rendering a user interface, including:

a rendering trigger unit for triggering a user interface rendering for the object to be rendered based on the main thread;

a bitmap drawing unit, configured to switch from the main thread to a child thread, by using the child thread to draw a bitmap corresponding to the object to be rendered;

a bitmap application unit, configured to call back the main thread, and apply the drawn bitmap to the display content of the object to be rendered;

And a user interface rendering unit, configured to render the user interface according to the display content of the object to be rendered.

Optionally, the device for rendering the user interface includes:

a view level tree determining unit, configured to determine a view level tree of the object to be rendered;

a rasterizing unit, configured to rasterize nodes in the view hierarchy tree;

The bitmap drawing unit performs rendering according to the rasterization result of the rasterization unit.

Optionally, the device for rendering the user interface includes:

a node attribute determining unit, configured to determine a node attribute of a node in the view level tree according to the attribute information of the object to be rendered;

The node attributes include: a rasterized attribute and a non-rasterized attribute;

Correspondingly, the nodes in the view hierarchy tree include: a rasterized root node, a rasterized child node, and a non-rasterized node.

Optionally, the rasterized root node is configured with a state identifier, where the state identifier includes: a first state identifier that allows rasterization with the rasterized child node, and a second state that does not allow rasterization with the rasterized child node Status identifier.

Optionally, the rasterizing unit includes:

The first node traverses the subunit, and is configured to traverse the nodes in the view hierarchy tree by using a depth-first rule, each traversing one node, and running the first ancestor node search subunit and the first ancestor node judgment subunit for the traversed node;

The first ancestor node search subunit is configured to search for an ancestor node of the node in the view hierarchy tree;

The first ancestor node determining subunit is configured to determine whether a rasterized root node or a non-rasterized node exists in the found ancestor node, and if present, run the first candidate node determining subunit and the first rasterized attribute determiner unit;

The first candidate node determining subunit is configured to select, in a rasterized root node or a non-rasterized node existing in the ancestor node, a rasterized root node whose level is closest to the level of the node or non-rasterization The node acts as a candidate node;

The first rasterization attribute determining subunit is configured to determine whether a node attribute of the node is a rasterization attribute, and if yes, running a first candidate node to determine a subunit;

The first candidate node determining subunit is configured to determine whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier, and if yes, running the first node merging subunit;

The first node merges subunits for merging the nodes onto the candidate nodes.

The application also provides an electronic device, including:

Memory, central processing unit and graphics processor;

The memory is for storing computer executable instructions, and the central processor is configured to execute computer executable instructions as follows:

Triggering user interface rendering for the object to be rendered based on the main thread;

Switching from the main thread to the child thread, and drawing, by the child thread, a bitmap corresponding to the object to be rendered;

Calling back the main thread, and applying the drawn bitmap to the display content of the object to be rendered;

The graphics processor is configured to execute computer executable instructions to render a user interface according to display content of the object to be rendered.

The method for rendering the user interface provided by the present application includes: triggering a user interface rendering for an object to be rendered based on a main thread; switching from the main thread to a child thread, and drawing, by the child thread, a corresponding object to be rendered a bitmap; the callback is applied to the main thread, and the drawn bitmap is applied to the display content of the object to be rendered; and the user interface is rendered according to the display content of the object to be rendered.

The method for rendering the user interface, in the process of rendering the user interface, when the user interface rendering of the object to be rendered is triggered based on the main thread, switching from the main thread to the child thread, and performing the sub-thread The bitmap is drawn, and is switched back to the main thread after the drawing is completed, where the main thread applies bitmap rendering to the corresponding display content to be rendered, and finally performs a user interface according to the corresponding display content to be rendered. Rendering, thereby transferring the bitmap drawing operation originally performed by the main thread to the sub-thread, reducing the load of the main thread, and reducing the user interface card caused by the main thread failing to process the rendering task in time when the task is heavy pause.

DRAWINGS

1 is a process flow diagram of an embodiment of a method for user interface rendering provided by the present application;

2 is a timing diagram of a user interface rendering provided by the present application;

Figure 3 is a schematic diagram of a view hierarchy tree provided by the present application;

4 is a schematic diagram of a rasterization process provided by the present application;

FIG. 5 is a schematic diagram of an apparatus embodiment for user interface rendering provided by the present application; FIG.

6 is a schematic diagram of an embodiment of an electronic device provided by the present application.

Detailed ways

Numerous specific details are set forth in the description below in order to provide a thorough understanding of the application. However, the present invention can be implemented in many other ways than those described herein, and those skilled in the art can make similar promotion without departing from the scope of the present application, and thus the present application is not limited by the specific embodiments disclosed below.

The present application provides a method for user interface rendering, and the present application also provides a device for rendering a user interface, and an electronic device. The following is a detailed description of the embodiments of the embodiments provided herein, and the various steps of the method are explained.

A method for implementing user interface rendering provided by the present application is as follows:

1 is a process flow diagram of a method for rendering a user interface provided by the present application. Referring to FIG. 2, a timing diagram of user interface rendering provided by the present application is shown. FIG. 3 is a schematic diagram showing a view hierarchy tree provided by the present application. Referring to FIG. 4, a schematic diagram of a rasterization process provided by the present application is shown.

Step S101, triggering a user interface rendering for the object to be rendered based on the main thread.

Taking the iOS system as an example, the user interface rendering (UI rendering) is performed by the main thread of the application, but subject to the processing power of the main thread and the performance of the CPU, the task processing in the main thread is heavy or CPU performance. At lower levels, UI rendering on iOS devices may cause page jams. For this situation, the method for rendering the user interface provided by the present application, as shown in FIG. 2, is used for the rendering of the UI included in the rendering task 1 or the rendering task 2, and the main thread of the application performs the operation in the CPU. Asynchronous processing, the part of the operation originally executed by the main thread of the application is transferred to the sub-thread of the application, and after the execution of the sub-thread is completed, the execution result is synchronized to the main thread, and the execution is continued in the main thread. In order to alleviate the load of the main thread, and at the same time reduce the user interface jam caused by the main thread unable to process the rendering task in time when the task is heavy.

In the UI rendering process, the main thread performs UI rendering according to the frame synchronization signal. Generally, the period of the frame synchronization signal in the UI rendering process is fixed. For example, the period of the frame synchronization signal in the iOS system is 1/60 s. That is: the user interface displayed on the screen needs to be refreshed 60 times per second. In this step, the application-based main thread triggers UI rendering for the object to be rendered, which is triggered after receiving the rendering command, and is triggered after the frame synchronization signal arrives at the application after receiving the rendering command.

The object to be rendered in the embodiment of the present application may be any element on the user interface, or may be the user interface as a whole; correspondingly, the UI rendering of the object to be rendered may be any for the user interface. A rendering task in which an element performs UI rendering may also be a rendering task that is updated overall for the user interface. Further, if any one of the elements on the user interface changes, the rendering mechanism in the UI rendering may be UI rendering only for the changed element, or the UI of the user interface where the changed element is located. The rendering mechanism of the rendering of the object to be rendered can be configured according to the actual situation, which is not limited herein.

Step S102: Switch from the main thread to the sub-thread, and draw a bitmap corresponding to the object to be rendered by the sub-thread.

As shown in FIG. 2, frame1 to frame5 represent the period of the frame synchronization signal, that is, the rendering period of the UI rendering, specifically, after the frame synchronization signal reaches the application, the UI for the object to be rendered is triggered in the main thread. Rendering, and switching from the main thread to the child thread, by which the bitmap corresponding to the object to be rendered is drawn.

In a specific implementation, the main thread and the sub-thread may also adopt an asynchronous processing manner, and do not affect each other, but the main thread and the sub-thread can implement data sharing, and the triggering is performed based on the main thread. In the process of UI rendering of the object to be rendered, before the thread switching, that is, before switching from the main thread to the child thread, the view hierarchy tree of the object to be rendered may be determined, and the view is The nodes in the hierarchical tree are rasterized. The rasterization in the embodiment of the present application refers to merging a plurality of nodes into one node in the view hierarchy tree, and respectively displaying the display characteristics of each node on the view of the merged node.

Specifically, the nodes in the view hierarchy tree have respective node attributes, and the node attributes include a rasterization attribute and a non-rasterized attribute. If a node attribute of a node is a rasterization attribute, the node may be related to the view level. Other nodes in the tree are rasterized; conversely, if a node's node property is a non-rasterized property, the node cannot be rasterized with other nodes. It should be noted that performing rasterization processing on the nodes in the view hierarchy tree is implemented based on the node attributes corresponding to the nodes, and therefore, before performing rasterization on the nodes in the view hierarchy tree. And determining, according to the attribute information of the object to be rendered, a node attribute of a node in the view level tree. In general, nodes in the view hierarchy tree can be divided into a root node and a child node, wherein the child node can be either a child node of the root node or an ancestor node of its child node. In addition, the nodes in the view hierarchy tree have corresponding node attributes: rasterized attributes and non-rasterized attributes. Specifically, in this embodiment, the nodes in the view hierarchy tree are divided into: a rasterized root node, a rasterized child node, and a non-rasterized node.

On this basis, a corresponding state identifier may be set for the rasterized root node in the view level tree, and the state identifier is used to determine whether the rasterized root node can receive the rasterized child node and rasterize it. The state identifier of the rasterized root node includes a first state identifier and a second state identifier, and if the state identifier of the rasterized root node is the first state identifier, allowing the rasterized root node and the rasterizer The node performs rasterization; conversely, if the state of the rasterized root node is identified as the second state identifier, the rasterized root node and the rasterized child node are not allowed to be rasterized. In this embodiment, the status of the rasterized root node identifies that the initial default state identifier is the first state identifier, but when the rasterized root node encounters a descendant node that cannot be rasterized during the traversal process, The state identifier of the rasterized root node is changed to the second state identifier. A view hierarchy tree as shown in FIG. 3, wherein node 1, node 7, and node 8 are rasterized root nodes, node 2, node 3, node 4, node 5, and node 9 are rasterized child nodes, and node 6 is non- Rasterization node; in addition, node 1, node 7, and node 8 are also provided with a state identifier as a rasterized root node. In this embodiment, the state identifiers of node 1, node 7, and node 8 are set to the first state at initialization. Logo.

Referring to the schematic diagram of the rasterization process shown in FIG. 4, the process of rasterizing the nodes in the view hierarchy tree is as follows:

Starting from the root node in the view hierarchy tree, the nodes in the view hierarchy tree are traversed by depth-first rules, and each node is traversed, and the following operations are performed for the traversed nodes:

1) searching for an ancestor node of the node in the view hierarchy tree;

The view hierarchy tree shown in FIG. 3 is traversed from the root node in the view hierarchy tree in the process of traversing the nodes in the view hierarchy tree by using a depth-first rule. The specific traversal order is: node 1-> Node 2 -> Node 3 -> Node 4 -> Node 5 -> Node 6 -> Node 7 -> Node 8 -> Node 9. When traversing to a certain node, searching for the ancestor node of the node in the view hierarchy tree, specifically searching for the ancestor node of the node, starting from the parent node closest to the hierarchical relationship of the node, and sequentially looking up the node in the All ancestor nodes in the view hierarchy tree. If the ancestor node of the node is not found in the view hierarchy tree, it indicates that the node is a root node in the view hierarchy tree, such as node 1 in the view hierarchy tree shown in FIG. 3, because there is no ancestor node Therefore, it is impossible to rasterize with the ancestor node, and without processing, continue to traverse the next node (node 2) in the view hierarchy tree.

2) determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node (for the ancestor node found by the node), if present, performing the following steps 3) and 4); Node 2 in the view hierarchy tree, whose ancestor node is node 1, and node 1 is the rasterized root node, performs the next processing for node 2.

If it does not exist, it indicates that the found ancestor nodes are rasterized child nodes. As mentioned above, only the rasterized root node can receive the rasterization with the rasterized child nodes. It can be seen that if the found ancestors are rasterized A child node indicates that the node cannot be rasterized with the found ancestor node. In this case, it is further determined whether the node attribute of the node is a rasterization attribute, and if so, the node is used as a rasterization root node, and the state identifier of the node is set as the first state identifier.

3) selecting, in the rasterized root node or the non-rasterized node existing in the ancestor node, a rasterized root node or a non-rasterized node whose level is closest to the level of the node as a candidate node;

As node 2 in the view hierarchy tree shown in Figure 3, there is only one ancestor node of node 2: rasterize root node 1, so rasterized root node 1 is used as a candidate node for node 2. In addition, for node 3 in the view hierarchy tree, there are two ancestor nodes: node 2 and node 1, the level of node 2 is adjacent to the level of node 3, and the level of node 1 is different from the level of node 3, which is visible. The level at which node 2 is located is the closest to the level at which node 3 is located, so node 2 is the candidate node for node 3.

4) determining whether the node attribute of the node is a rasterization attribute, and if so, performing the following step 5); as shown in Figure 3, node 2 in the view hierarchy tree is a rasterized child node, and the node attribute is rasterized. Attribute, then perform the next step for node 2.

If not, the candidate node is set as a parent node of the node, and it is determined whether the candidate node is a rasterized root node, and if so, the state identifier of the candidate node is marked as the second state identifier. When traversing to node 6, the ancestor nodes of node 6 include: node 1, node 4, and node 5, and the node attribute of node 6 is a non-rasterized attribute. It can be seen that only node 1 satisfies the condition, so node 1 is set to a candidate node of the node 6; furthermore, since the node 1 is a rasterized root node, the state of the node 1 is identified as the second state identifier, that is, after the node 1 does not allow the rasterized child node to be rasterized thereafter .

5) determining whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier, and if yes, performing the following step 6), rasterizing the node to the candidate node Up, ie, merging the nodes onto the candidate nodes. If the candidate node (node 1) of the node 2 in the view hierarchy tree shown in FIG. 3 is a rasterized root node, and the state identifier of the node 1 is the first state identifier, the rasterized root node and the rasterizer are allowed. The node is rasterized and node 2 is rasterized onto node 1.

If not, the candidate node is set as the parent of the node. As shown in the view hierarchy tree shown in FIG. 3, the parent node of node 2 is node 1, where the candidate node of node 2 (node 1) is set as the parent node of node 2, and the view of node 2 and node 1 is not changed. Hierarchy and connection relationships in the hierarchy tree.

6) Merging the node onto the candidate node.

The above rasterization process is mainly described by taking node 2 as an example, and provides a specific process of rasterizing node 2 to node 1, such as the view hierarchy tree shown in FIG. 3, combined with the above rasterization process, node 3, node 4 and The processing steps of node 5 during the traversal process are similar to those of node 2, and are eventually rasterized onto node 1.

When traversing to node 6, the ancestor nodes of node 6 include: node 1, node 4, and node 5, and the node attribute of node 6 is a non-rasterized attribute. It can be seen that only node 1 satisfies the condition, so node 1 is set to a candidate node of the node 6; furthermore, since the node 1 is a rasterized root node, the state of the node 1 is identified as the second state identifier, that is, after the node 1 does not allow the rasterized child node to be rasterized thereafter .

When traversing to node 7, the ancestor node of node 7 includes: node 1 and node 4, while the node attribute of node 7 is a rasterization attribute, node 4 does not satisfy the condition set as a candidate node, and node 1 is set to node 7. Candidate node, although node 1 is a rasterized root node, since the state identifier of node 1 is set to the second state identifier during the traversal of node 6, it can be seen that node 7 is not allowed to be rasterized onto node 1, then Node 1 is set as the parent node of node 7, that is, the parent node of node 7 is changed from node 4 to node 1. The processing of node 8 in the traversal process is similar to that of node 7, and finally, the parent node of node 8 is set to node 1, but since the initial parent node of node 8 is also node 1, the level of node 8 in the view hierarchy tree is No change has taken place. When traversing to node 9, the ancestor node of node 9 has node 1 and node 8. Since the level of node 8 is adjacent to the level of node 9, node 8 is the candidate node of device node 9, and node 8 is rasterized. The root node and the status identifier are the first status identifier, so node 9 is merged onto node 8.

In a specific implementation, in order to ensure that all the nodes in the view hierarchy tree are traversed during the traversal process, the nodes in the view hierarchy tree are prevented from being missed, and each node in the view hierarchy tree may be traversed. Performing a traversal determination operation of: determining whether the nodes in the view hierarchy tree are traversed, and if so, ending the traversal process for the nodes in the view hierarchy tree; if not, continuing the traversal, according to the depth priority rule Nodes that have not been traversed in the view hierarchy tree are traversed.

In addition to the implementation of the rasterization process provided above, the rasterization process can also be implemented in a similar implementation, such as the three implementations provided below:

Implementation one:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

a) looking up the ancestor node of the node in the view hierarchy tree;

b) determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node, if yes, performing step c) and step d) described below; if not, determining whether the node attribute of the node is a rasterization attribute, if it is a rasterization attribute, the node is used as a rasterization root node, and the state identifier of the node is set as the first state identifier;

c) selecting, in the rasterized root node or the non-rasterized node existing in the ancestor node, a rasterized root node or a non-rasterized node whose level is closest to the level of the node as a candidate node;

d) determining whether the node attribute of the node is a rasterization attribute, and if so, performing the following step e); if not, setting the candidate node as a parent node of the node, and determining whether the candidate node is a raster a root node, if it is a rasterized root node, marking the state identifier of the candidate node as the second state identifier;

e) determining whether the candidate node is a rasterized root node, and if so, performing the following step f); if not, setting the candidate node as a parent node of the node;

f) determining whether the state identifier of the candidate node is the first state identifier, and if so, performing the following step g); if not, setting the candidate node as the parent node of the node;

g) merging the nodes onto the candidate nodes.

Implementation 2:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node; Determining whether the state identifier of the candidate node is the first state identifier, and if so, determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.

Implementation three:

The depth-first rule is used to traverse the nodes in the view hierarchy tree. Each time a node is traversed, the following operations are performed on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node; Determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.

After the step is switched from the main thread to the sub-thread, the bitmap of the object to be rendered is drawn according to the result of the rasterization, and the bitmap of the object to be rendered is specifically drawn, according to the node and the As a result of the combination of the candidate nodes, the node view corresponding to the node and the node view corresponding to the candidate node are drawn on a bitmap. As shown in the view hierarchy tree shown in FIG. 3, the node view corresponding to the rasterized and merged nodes is drawn on a bitmap, for example, node 2, node 3, node 4, and node 5 are rasterized onto node 1. Then, the corresponding node views of the nodes 1 to 5 are drawn on a bitmap, that is, the display characteristics of the node views corresponding to the nodes 2 to 5 are represented on the node view corresponding to the node 1. Similarly, the node view corresponding to node 8 and node 9 is drawn on a bitmap. It should be emphasized that for node 6 and node 7, since node 6 and node 7 are not merged into other nodes in the view hierarchy tree, ie, node 6 and node 7 are not associated with the view hierarchy tree. The other nodes are rasterized. Therefore, for node 6 and node 7, the corresponding node views may be respectively drawn on a bitmap according to actual needs, or may not be processed.

It should be noted that, in an actual application, the process of drawing the bitmap corresponding to the object to be rendered and the rasterization process are transferred to the application by switching the main thread of the application to the sub-thread of the application. The child thread executes, which relieves the load on the application's main thread. Meanwhile, since the main thread and the sub-thread of the application are both executed on the CPU, when the CPU has a plurality of processing cores, the main thread and the sub-threads can be processed based on different processing cores of the CPU, respectively, thereby being able to Take advantage of multiple processing cores of the CPU.

Step S103, the main thread is called back, and the drawn bitmap is applied to the display content of the object to be rendered.

In the above step S102, the bitmap corresponding to the object to be rendered is drawn in the sub-thread. In this step, the main thread is called back, that is, the sub-thread is switched back to the main thread, and the main thread is drawn. A good bitmap is applied to the display content of the object to be rendered. Specifically, as shown in FIG. 3, the bitmap tree corresponding to the node 1 to the node 5 is applied to the data structure of the object to be rendered, and similarly, the bitmap corresponding to the node 8 and the node 9 is applied. In the data structure, since the node 6 and the node 7 are not rasterized with other nodes in the view hierarchy tree, the display features of the node 6 and the node 7 saved in the data structure of the object to be rendered are No change has occurred, so node 6 and node 7 are not processed.

Step S104: Render a user interface according to the display content of the object to be rendered.

The method for the user interface rendering provided by the present application is implemented based on an iOS device configured by a CPU (Central Processing Unit), a GPU (Graphics Processor), and a display screen. Correspondingly, the above steps S101 to S103 are based on the In the CPU implementation of the iOS device configuration, the UI rendering performed according to the display content of the object to be rendered in this step is implemented based on the GPU. As shown in FIG. 2, after the step S103 is performed, the CPU submits the display content of the object to be rendered to the GPU, and the GPU performs UI rendering according to the submitted display content of the object to be rendered. The rendered user interface is passed to the display.

Specifically, in the process of performing UI rendering by the GPU according to the display content of the object to be rendered, if the rasterization process is not performed, respectively, the nodes 1 to 9 in the view hierarchy tree are respectively rendered, but After the nodes in the view hierarchy tree are rasterized, nodes 2 to 5 are rasterized onto node 1, and node 9 is rasterized onto node 8. As can be seen, the hierarchy of the view hierarchy tree is greatly reduced. The UI rendering is shorter according to the display content of the object to be rendered, which reduces the processing time of the CPU during the UI rendering process, and further reduces the time consuming time for the GPU to perform UI rendering.

In summary, the user interface rendering method, when performing the user interface rendering process, when the main thread is triggered to render the user interface for the object to be rendered, switching from the main thread to the child thread, The sub-thread performs bitmap rendering, and switches back to the main thread after the drawing, and applies the bitmap drawing to the corresponding display content to be rendered in the main thread, and finally according to the corresponding to be rendered. Displaying content for user interface rendering, thereby transferring the bitmap drawing operation originally performed by the main thread to the sub-thread, reducing the load of the main thread, and reducing the main thread cannot process the rendering task in time when the task is heavy The resulting user interface is stuck.

An apparatus implementation for user interface rendering provided by the present application is as follows:

In the above embodiment, a method for rendering a user interface is provided. Correspondingly, the present application further provides a device for rendering a user interface, which will be described below with reference to the accompanying drawings.

Referring to FIG. 5, a schematic diagram of an apparatus embodiment of a user interface rendering provided by the present application is shown.

Since the device embodiment is basically similar to the method embodiment, the description is relatively simple. For related parts, refer to the corresponding description of the method embodiment provided above. The device embodiments described below are merely illustrative.

The application provides a device for rendering a user interface, including:

a rendering trigger unit 501, configured to trigger a user interface rendering for the object to be rendered based on the main thread;

a bitmap drawing unit 502, configured to switch from the main thread to a sub-thread, by using the sub-thread to draw a bitmap corresponding to the object to be rendered;

a bitmap application unit 503, configured to call back the main thread, and apply the drawn bitmap to the display content of the object to be rendered;

The user interface rendering unit 504 is configured to render a user interface according to the display content of the object to be rendered.

Optionally, the device for rendering the user interface includes:

a view level tree determining unit, configured to determine a view level tree of the object to be rendered;

a rasterizing unit, configured to rasterize nodes in the view hierarchy tree;

The bitmap drawing unit 502 performs rendering according to the rasterization result of the rasterization unit.

Optionally, the device for rendering the user interface includes:

a node attribute determining unit, configured to determine a node attribute of a node in the view level tree according to the attribute information of the object to be rendered;

The node attributes include: a rasterized attribute and a non-rasterized attribute;

Correspondingly, the nodes in the view hierarchy tree include: a rasterized root node, a rasterized child node, and a non-rasterized node.

Optionally, the rasterized root node is configured with a state identifier, where the state identifier includes: a first state identifier that allows rasterization with the rasterized child node, and a second state that does not allow rasterization with the rasterized child node Status identifier.

Optionally, the rasterizing unit includes:

The first node traverses the subunit, and is configured to traverse the nodes in the view hierarchy tree by using a depth-first rule, each traversing one node, and running the first ancestor node search subunit and the first ancestor node judgment subunit for the traversed node;

The first ancestor node search subunit is configured to search for an ancestor node of the node in the view hierarchy tree;

The first ancestor node determining subunit is configured to determine whether a rasterized root node or a non-rasterized node exists in the found ancestor node, and if present, run the first candidate node determining subunit and the first rasterized attribute determiner unit;

The first candidate node determining subunit is configured to select, in a rasterized root node or a non-rasterized node existing in the ancestor node, a rasterized root node whose level is closest to the level of the node or non-rasterization The node acts as a candidate node;

The first rasterization attribute determining subunit is configured to determine whether a node attribute of the node is a rasterization attribute, and if yes, running a first candidate node to determine a subunit;

The first candidate node determining subunit is configured to determine whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier, and if yes, running the first node merging subunit;

The first node merges subunits for merging the nodes onto the candidate nodes.

Optionally, if the first ancestor node determines that the output of the subunit is a result that the found ancestor node does not have a rasterized root node or a non-rasterized node, running the second rasterization attribute determining subunit;

The second rasterization attribute determining subunit is configured to determine whether the node attribute of the node is a rasterization attribute, and if so, the node is used as a rasterization root node, and the state identifier of the node is set to The first status identifier.

Optionally, if the determination result output by the first rasterization attribute determining subunit is that the node attribute of the node is not a rasterization attribute, running the first parent node update subunit and the second candidate node judgment subunit;

The first parent node update subunit, configured to set the candidate node as a parent node of the node;

The second candidate node determining subunit is configured to determine whether the candidate node is a rasterized root node, and if yes, mark the state identifier of the candidate node as the second state identifier.

Optionally, if the first candidate node determines that the output of the subunit is a result that the candidate node is not a rasterized root node or the state identifier of the candidate node is not the first state identifier, running the second parent node is updated. Subunit

The second parent node updates the subunit, and is configured to set the candidate node as a parent node of the node.

Optionally, the rasterizing unit includes:

The traversing determination subunit is configured to determine whether the node in the view hierarchy tree is traversed, and if not, running the first node to traverse the subunit.

Optionally, the rasterizing unit includes:

The second node traverses the sub-units for traversing the nodes in the view hierarchy tree by using depth-first rules, each traversing one node, and running a second ancestor node search sub-unit and a second ancestor node judgment sub-unit for the traversed nodes;

The second ancestor node search subunit is configured to search for an ancestor node of the node in the view hierarchy tree;

The second ancestor node determining subunit is configured to determine whether a rasterized root node or a non-rasterized node exists in the found ancestor node, and if so, running the second candidate node determining subunit and the third rasterization attribute determiner unit;

The second candidate node determining subunit is configured to select, in the rasterized root node or the non-rasterized node existing in the ancestor node, a rasterized root node whose level is closest to the level of the node or non-rasterization The node acts as a candidate node;

The third rasterization attribute determining subunit is configured to determine whether a node attribute of the node is a rasterization attribute, and if so, running a third candidate node to determine a subunit;

The third candidate node determining subunit is configured to determine whether the candidate node is a rasterized root node, and if yes, determining whether the state identifier of the candidate node is a first state identifier, and if so, running the second node merging subunit ;

The second node merging subunit is configured to merge the node onto the candidate node.

Optionally, the rasterizing unit includes:

The third node traverses the sub-units for traversing the nodes in the view hierarchy tree by using a depth-first rule, each traversing one node, and running a third ancestor node search sub-unit and a third ancestor node judgment sub-unit for the traversed node;

The third ancestor node search subunit is configured to search for an ancestor node of the node in the view hierarchy tree;

The third ancestor node determining subunit is configured to determine whether a rasterized root node exists in the found ancestor node, and if so, running a third candidate node determining subunit and a second state identifier determining subunit;

The third candidate node determining subunit is configured to select, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the level of the node as a candidate node;

The second state identifier determining subunit is configured to determine whether the state identifier of the candidate node is the first state identifier, and if yes, running a fourth rasterization attribute determining subunit;

The fourth rasterization attribute determining subunit is configured to determine whether the node attribute of the node is a rasterization attribute, and if so, running the third node to merge the subunit;

The third node merging subunit is configured to merge the node onto the candidate node.

Optionally, the rasterizing unit includes:

The fourth node traverses the sub-units for traversing the nodes in the view hierarchy tree by using a depth-first rule, each traversing one node, and running a fourth ancestor node search sub-unit and a fourth ancestor node judgment sub-unit for the traversed nodes;

The fourth ancestor node search subunit is configured to search for an ancestor node of the node in the view hierarchy tree;

The fourth ancestor node determining subunit is configured to determine whether a rasterized root node exists in the found ancestor node, and if yes, running a fourth candidate node determining subunit and a fifth rasterizing attribute determining subunit;

The fourth candidate node determining subunit is configured to select, as a candidate node, a rasterized root node whose stratum is located closest to the stratum of the node in the rasterized root node existing in the ancestor node;

The fifth rasterization attribute determining subunit is configured to determine whether the node attribute of the node is a rasterization attribute, and if so, running the fourth node to merge the subunit;

The fourth node merging subunit is configured to merge the node onto the candidate node.

Optionally, the bitmap drawing unit 502 is configured to: in accordance with a combination result of the node and the candidate node, draw a node view corresponding to the node and a node view corresponding to the candidate node in a single bit On the map.

Optionally, the device for rendering the user interface is implemented based on a terminal device, where the terminal device is provided with a central processing unit, a graphics processor, and a display screen;

The rendering trigger unit 501, the bitmap rendering unit 502, and the bitmap application unit 503 are executed based on the central processing unit;

The user interface rendering unit 504 operates based on the graphics processor;

The display content output by the bitmap application unit 503 is submitted to the graphics processor by the central processing unit;

After rendering the user interface according to the display content of the object to be rendered, the graphics processor passes the rendering result to the display screen.

An electronic device implementation provided by the present application is as follows:

In the above embodiment, a method for rendering a user interface is provided. In addition, the present application further provides an electronic device for implementing the method for rendering the user interface, which will be described below with reference to the accompanying drawings.

Referring to FIG. 6, a schematic diagram of an electronic device provided by the embodiment is shown.

The embodiment of the electronic device provided by the present application is described in a relatively simple manner. For related parts, refer to the corresponding description of the method embodiment of the user interface rendering provided above. The embodiments described below are merely illustrative.

The application provides an electronic device, including:

a memory 601, a central processing unit 602 and a graphics processor 603;

The memory 601 is configured to store computer executable instructions, and the central processor 602 is configured to execute computer executable instructions as follows:

Triggering user interface rendering for the object to be rendered based on the main thread;

Switching from the main thread to the child thread, and drawing, by the child thread, a bitmap corresponding to the object to be rendered;

Calling back the main thread, and applying the drawn bitmap to the display content of the object to be rendered;

The graphics processor 603 is configured to execute computer executable instructions to render a user interface according to display content of the object to be rendered.

Optionally, the switching from the main thread to the sub-thread, before the execution of the bitmap instruction corresponding to the object to be rendered by the sub-thread, the central processor 602 is further configured to execute the following computer-executable instruction :

Determining a view hierarchy tree of the object to be rendered;

Rectifying nodes in the view hierarchy tree;

The bitmap corresponding to the object to be rendered is drawn according to a rasterization result of nodes in the view hierarchy tree.

Optionally, the central processing unit 602 is further configured to execute the following computer executable instructions:

Determining, according to the attribute information of the object to be rendered, a node attribute of a node in the view hierarchy tree;

The node attributes include: a rasterized attribute and a non-rasterized attribute;

Correspondingly, the nodes in the view hierarchy tree include: a rasterized root node, a rasterized child node, and a non-rasterized node.

Optionally, the rasterized root node is configured with a state identifier, where the state identifier includes: a first state identifier that allows rasterization with the rasterized child node, and a second state that does not allow rasterization with the rasterized child node Status identifier.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node, and if so, selecting a level of the rasterized root node or the non-rasterized node existing in the ancestor node and a level of the node The nearest rasterized root node or non-rasterized node is used as the candidate node;

Determining whether the node attribute of the node is a rasterization attribute, and if so, determining whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier, and if so, merging the nodes Go to the candidate node.

Optionally, if the judgment result of the step of determining whether the rasterized root node or the non-rasterized node is present in the ancestor node found is no, perform the following operations:

Determining whether the node attribute of the node is a rasterization attribute, and if so, using the node as a rasterization root node, and setting a status identifier of the node as the first status identifier.

Optionally, if the determining whether the node attribute of the node is a rasterization attribute sub-step is negative, perform the following operations:

Setting the candidate node as a parent node of the node;

Determining whether the candidate node is a rasterized root node, and if so, marking the status identifier of the candidate node as the second status identifier.

Optionally, if the determining whether the candidate node is a rasterized root node and determining whether the status identifier of the candidate node is the first state identifier substep is no, perform the following operations:

The candidate node is set as the parent node of the node.

Optionally, the central processing unit 602 is further configured to execute the following computer executable instructions:

Determining whether the nodes in the view hierarchy tree are traversed, and if not, performing the depth-first rule to traverse the node sub-steps in the view hierarchy tree.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node, and if so, selecting a level of the rasterized root node or the non-rasterized node existing in the ancestor node and a level of the node The nearest rasterized root node or non-rasterized node is used as the candidate node;

Determining whether the node attribute of the node is a rasterization attribute, and if so, determining whether the candidate node is a rasterized root node, and if so, determining whether the state identifier of the candidate node is a first state identifier, and if so, the node Merged onto the candidate node.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node;

Determining whether the state identifier of the candidate node is the first state identifier, and if so, determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.

Optionally, the rasterizing the nodes in the view hierarchy tree is implemented as follows:

The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

Finding an ancestor node of the node in the view hierarchy tree;

Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node;

Determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.

Optionally, the mapping of the bitmap corresponding to the object to be rendered is implemented as follows:

And according to the result of the combination of the node and the candidate node, the node view corresponding to the node and the node view corresponding to the candidate node are drawn on a bitmap.

Optionally, the electronic device is provided with a display screen;

The calling back the main thread, applying the drawn bitmap to the execution of the instruction in the display content of the object to be rendered, and executing the user interface instruction according to the display content of the object to be rendered The central processing unit 602 submits the display content to the graphics processor 603;

The graphics processor 603, after rendering the user interface according to the display content of the object to be rendered, delivers the rendering result to the display screen.

The present application is disclosed in the above preferred embodiments, but it is not intended to limit the present application, and any person skilled in the art can make possible changes and modifications without departing from the spirit and scope of the present application. The scope of protection should be based on the scope defined by the claims of the present application.

In a typical configuration, a computing device includes one or more processors, input/output interfaces, network interfaces, and memory.

The memory may include non-persistent memory, random access memory (RAM), and/or non-volatile memory in a computer readable medium, such as read only memory (ROM) or flash memory. Memory is an example of a computer readable medium.

Computer readable media includes both permanent and non-persistent, removable and non-removable media. Information storage can be implemented by any method or technology. The information can be computer readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read only memory. (ROM), electrically erasable programmable read only memory (EEPROM), flash memory or other memory technology, compact disk read only memory (CD-ROM), digital versatile disk (DVD) or other optical storage, Magnetic tape cartridges, magnetic tape storage or other magnetic storage devices or any other non-transportable media can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include non-transitory computer readable media, such as modulated data signals and carrier waves.

Those skilled in the art will appreciate that embodiments of the present application can be provided as a method, system, or computer program product. Thus, the present application can take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment in combination of software and hardware. Moreover, the application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) including computer usable program code.

Claims (20)

1. A method for rendering a user interface, comprising:

   Triggering user interface rendering for the object to be rendered based on the main thread;

   Switching from the main thread to the child thread, and drawing, by the child thread, a bitmap corresponding to the object to be rendered;

   Calling back the main thread, and applying the drawn bitmap to the display content of the object to be rendered;

   And rendering a user interface according to the display content of the object to be rendered.
2. The method for rendering user interface according to claim 1, wherein the step of switching from the main thread to the child thread, and drawing the bitmap corresponding to the object to be rendered by the child thread is performed before the execution is performed Steps:

   Determining a view hierarchy tree of the object to be rendered;

   Rectifying nodes in the view hierarchy tree;

   The bitmap corresponding to the object to be rendered is drawn according to a rasterization result of nodes in the view hierarchy tree.
3. The method for rendering a user interface according to claim 2, comprising:

   Determining, according to the attribute information of the object to be rendered, a node attribute of a node in the view hierarchy tree;

   The node attributes include: a rasterized attribute and a non-rasterized attribute;

   Correspondingly, the nodes in the view hierarchy tree include: a rasterized root node, a rasterized child node, and a non-rasterized node.
4. The method for rendering a user interface according to claim 3, wherein the rasterized root node is provided with a state identifier, and the state identifier comprises:

   A first state identification that allows rasterization with the rasterized child nodes, and a second state identification that does not allow rasterization with the rasterized child nodes.
5. The method for rendering a user interface according to claim 4, wherein the rasterizing the nodes in the view hierarchy tree is implemented as follows:

   The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

   Finding an ancestor node of the node in the view hierarchy tree;

   Determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node, and if so, selecting a level of the rasterized root node or the non-rasterized node existing in the ancestor node and a level of the node The nearest rasterized root node or non-rasterized node is used as the candidate node;

   Determining whether the node attribute of the node is a rasterization attribute, and if so, determining whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier, and if so, merging the nodes Go to the candidate node.
6. The method for rendering a user interface according to claim 5, wherein if the determination result of the step of determining whether the rasterized root node or the non-rasterized node is present in the found ancestor node is no, the following operations are performed:

   Determining whether the node attribute of the node is a rasterization attribute, and if so, using the node as a rasterization root node, and setting a status identifier of the node as the first status identifier.
7. The method for rendering a user interface according to claim 5, wherein if the determining whether the node attribute of the node is a rasterization attribute sub-step is negative, performing the following operations:

   Setting the candidate node as a parent node of the node;

   Determining whether the candidate node is a rasterized root node, and if so, marking the status identifier of the candidate node as the second status identifier.
8. The method for rendering user interface according to claim 5, wherein if the determining whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier substep If the judgment result is no, perform the following operations:

   The candidate node is set as the parent node of the node.
9. The method for rendering a user interface according to claim 5, comprising:

   Determining whether the nodes in the view hierarchy tree are traversed, and if not, performing the depth-first rule to traverse the node sub-steps in the view hierarchy tree.
10. The method for rendering a user interface according to claim 4, wherein the rasterizing the nodes in the view hierarchy tree is implemented as follows:

    The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

    Finding an ancestor node of the node in the view hierarchy tree;

    Determining whether there is a rasterized root node or a non-rasterized node in the found ancestor node, and if so, selecting a level of the rasterized root node or the non-rasterized node existing in the ancestor node and a level of the node The nearest rasterized root node or non-rasterized node is used as the candidate node;

    Determining whether the node attribute of the node is a rasterization attribute, and if so, determining whether the candidate node is a rasterized root node, and if so, determining whether the state identifier of the candidate node is a first state identifier, and if so, the node Merged onto the candidate node.
11. The method for rendering a user interface according to claim 4, wherein the rasterizing the nodes in the view hierarchy tree is implemented as follows:

    The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

    Finding an ancestor node of the node in the view hierarchy tree;

    Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node;

    Determining whether the state identifier of the candidate node is the first state identifier, and if so, determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.
12. The method for rendering a user interface according to claim 3, wherein the rasterizing the nodes in the view hierarchy tree is implemented as follows:

    The depth-first rule is used to traverse the nodes in the view hierarchy tree, each time traversing one node, and performing the following operations on the traversed nodes:

    Finding an ancestor node of the node in the view hierarchy tree;

    Determining whether there is a rasterized root node in the found ancestor node, and if so, selecting, in the rasterized root node existing in the ancestor node, a rasterized root node whose level is closest to the layer where the node is located as a candidate node;

    Determining whether the node attribute of the node is a rasterization attribute, and if so, merging the node onto the candidate node.
13. The method for rendering a user interface according to any one of claims 5 to 12, wherein the drawing a bitmap corresponding to the object to be rendered is implemented as follows:

    And according to the result of the combination of the node and the candidate node, the node view corresponding to the node and the node view corresponding to the candidate node are drawn on a bitmap.
14. The method for rendering user interface according to any one of claims 1 to 12, wherein the method is implemented based on a terminal device, where the terminal device is provided with a central processing unit, a graphics processor and a display screen;

    The step of triggering a user interface for the object to be rendered based on the main thread, the step of switching from the main thread to the child thread, drawing a bitmap step corresponding to the object to be rendered by the child thread, and the step Calling back the main thread, applying the drawn bitmap to the display content of the object to be rendered, based on the central processor;

    The step of rendering a user interface according to the display content of the object to be rendered is implemented based on the graphics processor;

    After the step of executing the step of executing the step of performing the rendering of the bitmap to the display content of the object to be rendered, and the step of performing the rendering of the user interface according to the display content of the object to be rendered, The central processor submits the display content to the graphics processor;

    After rendering the user interface according to the display content of the object to be rendered, the graphics processor passes the rendering result to the display screen.
15. A device for rendering a user interface, comprising:

    a rendering trigger unit for triggering a user interface rendering for the object to be rendered based on the main thread;

    a bitmap drawing unit, configured to switch from the main thread to a child thread, by using the child thread to draw a bitmap corresponding to the object to be rendered;

    a bitmap application unit, configured to call back the main thread, and apply the drawn bitmap to the display content of the object to be rendered;

    And a user interface rendering unit, configured to render the user interface according to the display content of the object to be rendered.
16. The apparatus for rendering a user interface according to claim 15, comprising:

    a view level tree determining unit, configured to determine a view level tree of the object to be rendered;

    a rasterizing unit, configured to rasterize nodes in the view hierarchy tree;

    The bitmap drawing unit performs rendering according to the rasterization result of the rasterization unit.
17. The apparatus for rendering a user interface according to claim 16, comprising:

    a node attribute determining unit, configured to determine a node attribute of a node in the view level tree according to the attribute information of the object to be rendered;

    The node attributes include: a rasterized attribute and a non-rasterized attribute;

    Correspondingly, the nodes in the view hierarchy tree include: a rasterized root node, a rasterized child node, and a non-rasterized node.
18. The apparatus for rendering user interface according to claim 17, wherein the rasterized root node is provided with a status identifier, and the status identifier comprises:

    A first state identification that allows rasterization with the rasterized child nodes, and a second state identification that does not allow rasterization with the rasterized child nodes.
19. The apparatus for rendering a user interface according to claim 18, wherein the rasterizing unit comprises:

    The first node traverses the subunits for traversing the nodes in the view hierarchy tree by using depth-first rules, each traversing one node, and running the first ancestor node lookup subunit and the first ancestor node judgment subunit for the traversed node;

    The first ancestor node search subunit is configured to search for an ancestor node of the node in the view hierarchy tree;

    The first ancestor node determining subunit is configured to determine whether a rasterized root node or a non-rasterized node exists in the found ancestor node, and if present, run the first candidate node determining subunit and the first rasterized attribute determiner unit;

    The first candidate node determining subunit is configured to select, in a rasterized root node or a non-rasterized node existing in the ancestor node, a rasterized root node whose level is closest to the level of the node or non-rasterization The node acts as a candidate node;

    The first rasterization attribute determining subunit is configured to determine whether a node attribute of the node is a rasterization attribute, and if yes, running a first candidate node to determine a subunit;

    The first candidate node determining subunit is configured to determine whether the candidate node is a rasterized root node and whether the state identifier of the candidate node is the first state identifier, and if yes, running the first node merging subunit;

    The first node merges subunits for merging the nodes onto the candidate nodes.
20. An electronic device, comprising:

    Memory, central processing unit and graphics processor;

    The memory is for storing computer executable instructions, and the central processor is configured to execute computer executable instructions as follows:

    Triggering user interface rendering for the object to be rendered based on the main thread;

    Switching from the main thread to the child thread, and drawing, by the child thread, a bitmap corresponding to the object to be rendered;

    Calling back the main thread, and applying the drawn bitmap to the display content of the object to be rendered;

    The graphics processor is configured to execute computer executable instructions to render a user interface according to display content of the object to be rendered.

Images