CN106708967B

CN106708967B - Page display method and device

Info

Publication number: CN106708967B
Application number: CN201611094848.0A
Authority: CN
Inventors: 董红光; 吴华
Original assignee: Beijing Xiaomi Mobile Software Co Ltd
Current assignee: Beijing Xiaomi Mobile Software Co Ltd
Priority date: 2016-11-30
Filing date: 2016-11-30
Publication date: 2020-06-02
Anticipated expiration: 2036-11-30
Also published as: CN106708967A

Abstract

The disclosure relates to a page display method and a device, belonging to the technical field of computers, wherein the method comprises the following steps: the method comprises the steps of obtaining configuration information of a target page, wherein the target page is any page in a currently used application, the configuration information comprises information of a browser kernel which is required to be used for displaying the target page, the browser kernel is any one of a plurality of browser kernels, a kernel object which is required to be used by the browser kernel is created based on the configuration information, and the target page is displayed through the browser kernel based on the kernel object. Therefore, different browser kernels are dynamically switched to be used for page display according to the configuration information of the pages, and the pertinence of the page display is enhanced.

Description

Page display method and device

Technical Field

The present disclosure relates to the field of computer technologies, and in particular, to a page display method and apparatus.

Background

With the rapid development of computer technology, various types of pages have appeared, for example, HTML (Hyper text Markup Language) pages, WML (Wireless Markup Language) pages, and the like. In actual application, the terminal can display the page through the browser kernel, and the browser kernels required to be used are different according to different page types.

Currently, some terminals may include multiple browser kernels at the same time, for example, the terminal may include its own browser kernel and a browser kernel provided by a third party. In addition, the application running in the terminal may include multiple types of pages, and in the related art, the terminal may only display all the pages of the application through one of the browser kernels, that is, the terminal may display all the pages of the application only through the browser kernel provided by the terminal itself according to actual requirements, or may display all the pages of the application only through the browser kernel provided by a third party.

Disclosure of Invention

In order to overcome the problems in the related art, the present disclosure provides a page display method and apparatus.

In a first aspect, a method for displaying a page is provided, where the method includes:

acquiring configuration information of a target page, wherein the target page is any page in a currently used application, the configuration information comprises information of a browser kernel required to be used for displaying the target page, and the browser kernel is any one of a plurality of browser kernels;

creating a kernel object required for using the browser kernel based on the configuration information;

and displaying the target page through the browser kernel based on the kernel object.

Optionally, before creating a kernel object required to use the browser kernel based on the configuration information, the method further includes:

judging whether the kernel object exists or not based on the identification of the target page;

when the kernel object does not exist, the step of creating the kernel object required for using the browser kernel based on the configuration information is executed.

Optionally, the determining whether the kernel object exists based on the identifier of the target page includes:

whether an object interface corresponding to the identification of the target page exists is inquired from the local, and the object interface is used for indicating the kernel object;

and when an object interface corresponding to the identification of the target page exists, determining that the kernel object exists.

Optionally, the displaying the page through the browser kernel based on the kernel object includes:

calling an object interface of the kernel object;

and operating the browser kernel through the called object interface to display the target page.

Optionally, the running the browser kernel through the called object interface includes:

loading a view object in the kernel object into a view component, wherein the view object is used for displaying the target page, and the view component is used for caching the view object;

and operating the browser kernel by calling the interface of the view component.

In a second aspect, there is provided a page display apparatus, the apparatus comprising:

the system comprises an acquisition module, a display module and a display module, wherein the acquisition module is used for acquiring configuration information of a target page, the target page is any page in a currently used application, the configuration information comprises information of a browser kernel required to be used for displaying the target page, and the browser kernel is any one of a plurality of browser kernels;

a creating module, configured to create, based on the configuration information acquired by the acquiring module, a kernel object required for using the browser kernel;

and the display module is used for displaying the target page through the browser kernel based on the kernel object created by the creation module.

Optionally, the apparatus further comprises:

the judging module is used for judging whether the kernel object exists or not based on the identification of the target page;

and the triggering module is used for triggering the creating module to execute the step of creating the kernel object required by using the browser kernel based on the configuration information when the kernel object does not exist.

Optionally, the determining module includes:

the query submodule is used for locally querying whether an object interface corresponding to the identification of the target page exists or not, and the object interface is used for indicating the kernel object;

and the determining submodule is used for determining that the kernel object exists when an object interface corresponding to the identification of the target page exists.

Optionally, the display module comprises:

the calling submodule is used for calling an object interface of the kernel object;

and the operation submodule is used for operating the browser kernel through the object interface called by the calling submodule so as to display the target page.

Optionally, the run submodule is configured to:

In a third aspect, there is provided a page display apparatus, the apparatus comprising:

a processor;

a memory for storing processor-executable instructions;

wherein the processor is configured to:

The technical scheme provided by the embodiment of the disclosure can have the following beneficial effects: the method comprises the steps of obtaining configuration information of a target page, wherein the configuration information comprises information of a browser kernel required to be used for displaying the target page, and based on the configuration information, a kernel object required for using the browser kernel can be created, so that based on the kernel object, the target page can be displayed through the browser kernel.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosure.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present disclosure and together with the description, serve to explain the principles of the disclosure.

FIG. 1 is a flowchart illustrating a page display method according to an exemplary embodiment.

Fig. 2 is a flowchart illustrating a page display method according to another exemplary embodiment.

Fig. 3A is a block diagram illustrating a page display apparatus according to an exemplary embodiment.

Fig. 3B is a block diagram illustrating a page display apparatus according to another exemplary embodiment.

Fig. 4 is a block diagram illustrating a page display apparatus 400 according to an exemplary embodiment.

Detailed Description

Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like numbers in different drawings represent the same or similar elements unless otherwise indicated. The implementations described in the exemplary embodiments below are not intended to represent all implementations consistent with the present disclosure. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the present disclosure, as detailed in the appended claims.

In the related art, since the terminal can display all pages of the application only through one browser core, but one browser core may not support part of the pages of the application, for example, the U2 core cannot parse the Web page, and therefore, a page display failure may be caused, or a display effect on the page may be poor. Therefore, in the embodiment of the present disclosure, a page display method is provided, which may dynamically switch and use different browser kernels to check and display different target pages, so as to solve the above technical problem.

The page display method provided by the embodiment of the disclosure can be executed by a terminal, an application can be installed and run in the terminal, and the application can include a plurality of pages. The terminal may be a mobile phone, a tablet computer, a computer, and the like, which is not limited in this disclosure.

Fig. 1 is a flowchart illustrating a page display method according to an exemplary embodiment, which is used in a terminal, as shown in fig. 1, and includes the following steps.

In step 101, configuration information of a target page is obtained, where the target page is any page in an application currently used, the configuration information includes information of a browser kernel that is required to be used for displaying the target page, and the browser kernel is any one of a plurality of browser kernels that are included in the browser kernel.

In step 102, based on the configuration information, a kernel object required to use the browser kernel is created.

In step 103, the target page is displayed through the browser kernel based on the kernel object.

In the embodiment of the disclosure, the configuration information of the target page is obtained, where the configuration information includes information of a browser kernel that is required to be used for displaying the target page, and based on the configuration information, a kernel object that is required to be used for the browser kernel can be created, so that based on the kernel object, the target page can be displayed by the browser kernel.

Optionally, before creating a kernel object required for using the browser kernel based on the configuration information, the method further includes:

when the kernel object does not exist, the step of creating a kernel object required to use the browser kernel based on the configuration information is performed.

Optionally, determining whether the kernel object exists based on the identifier of the target page includes:

and when the object interface corresponding to the identification of the target page exists, determining that the kernel object exists.

Optionally, displaying the page through the browser kernel based on the kernel object includes:

calling an object interface of the kernel object;

and running the browser kernel through the called object interface to display the target page.

Optionally, running the browser kernel through the called object interface includes:

and executing the browser kernel by calling the interface of the view component.

All the above optional technical solutions can be combined arbitrarily to form optional embodiments of the present disclosure, and the embodiments of the present disclosure are not described in detail again.

Fig. 2 is a flowchart illustrating a page display method according to another exemplary embodiment, the page display method being used in a terminal as illustrated in fig. 2, the page display method including the steps of:

in step 201, configuration information of a target page is obtained, where the target page is any page in an application currently used, the configuration information includes information of a browser kernel that is required to be used for displaying the target page, and the browser kernel is any one of a plurality of browser kernels that are included in the browser kernel.

As described above, some terminals may include multiple browser kernels at the same time, for example, a terminal of an android operating system may include a browser kernel of the terminal itself at the same time, and may further include one or more browser kernels provided by a third party. The application installed in the terminal may include multiple pages, and in the embodiment of the present disclosure, the terminal may dynamically switch to use different browser cores of the multiple browser cores included for different pages to implement page display.

In one possible implementation, the target page may be any Web page (Web) in an application currently used. In the process of displaying a certain target page of an application currently used, in order to facilitate a terminal to know which browser core needs to be used to display the target page, before obtaining configuration information of the target page, a user may configure the configuration information in advance, where the configuration information may include a name of a browser core, and for example, if the user wants to display the target page through the browser core a, the name of the browser core corresponding to the target page may be configured as a in the configuration information. In this way, before the terminal displays the target page, the configuration information can be obtained, and based on the configuration information, it can be determined which browser kernel needs to be used to display the target page.

In addition, in a possible implementation manner, the configuration information may be contained in a page configuration file, the page configuration file may be configured in advance by a user according to actual requirements, the page configuration file may include a plurality of nodes, and each node is the configuration information of each page, which is not specifically limited in the embodiment of the present disclosure.

In an actual implementation process, the terminal may read the configuration information through a class, where the class may be referred to as a factory class, that is, before the target page is displayed, the terminal runs the factory class, and the factory class reads the configuration information during running.

In step 202, it is determined whether the kernel object exists based on the identification of the target page.

As described above, after the terminal reads the configuration information, it can determine which browser kernel needs to be used to display the target web page. When a browser kernel is used, a kernel object of the browser kernel is generally required to be used, for example, the kernel object includes a view object and the like, wherein the view object is used for displaying a target page. Of course, the kernel object may also include other objects, and the other objects may be used to assist the view object to implement the display of the page, and are not specifically limited herein.

For some pages, for example, a local page, the kernel object may already exist. While for other pages, such as web pages, the kernel object may not exist. Therefore, after determining which browser kernel needs to be used to display the target page, the terminal also needs to determine whether a kernel object of the browser kernel exists.

In this embodiment of the present disclosure, it may be determined whether the kernel object exists based on the identifier of the target page, where determining whether the kernel object exists based on the identifier of the target page may include: and inquiring whether an object interface corresponding to the identification of the target page exists from the local, wherein the object interface is used for indicating the kernel object, and when the object interface corresponding to the identification of the target page exists, determining that the kernel object exists.

The local area includes, but is not limited to, a database, a hard disk, a memory, and other storage locations of the terminal.

The identifier of the target page may be used to uniquely identify a target page. The above object interface may be implemented by the browser kernel a. That is, if there is an object interface corresponding to the identifier of the target page locally, the identifier of the target page and the object interface may be stored correspondingly by an event, and in a possible implementation manner, the corresponding storage manner between the identifier of the target page and the object interface may be as shown in table 1 below:

TABLE 1

Identification	Object interface
		ID 1
…
		ID n	Interface A

For example, when the identifier of the target page is ID1, it can be known that the ID1 has no corresponding object interface by querying the above table 1, and therefore, it can be determined that the kernel object does not exist. When the identifier of the target page is ID n, the Interface corresponding to ID n may be obtained as Interface a by querying table 1, and therefore, the terminal may determine that the kernel object exists.

It should be noted that, in this embodiment of the present disclosure, when there is an object interface corresponding to the identifier of the target page, the example is only to store the identifier of the target page and the object interface in a corresponding manner in the form of table 1, in another embodiment, the terminal may also store the identifier of the target page and the object interface in a corresponding manner in another form, which is not limited in this embodiment of the present disclosure.

When the object interface corresponding to the identifier of the target page exists, the terminal determines that the kernel object exists, in this case, step 204 is directly performed, and when the object interface does not exist, the terminal determines that the kernel object does not exist, in this case, step 203 is performed.

In step 203, when the kernel object does not exist, a kernel object required for using the browser kernel is created based on the configuration information.

When it is determined that the kernel object does not exist through the step 202, the terminal needs to create a kernel object required for using the browser kernel based on the configuration information, and in an actual implementation process, the implementation process may include: the terminal determines a browser kernel to be used based on the configuration information, and then runs a class (class) corresponding to the browser kernel, thereby creating a kernel object required for using the browser kernel.

For example, if the terminal determines that the browser kernel to be used is a based on the configuration information, then the terminal runs class a corresponding to the browser kernel a, thereby creating a kernel object required to use the browser kernel.

In step 204, the target page is displayed by the browser kernel based on the kernel object.

Based on the kernel object, the implementation process of displaying the target page through the browser kernel may include: and calling an object interface of the kernel object, and operating the browser kernel through the called object interface so as to display the target page.

In addition, the implementation process of running the browser kernel through the called object interface includes: loading the view object in the kernel object into a view component, wherein the view object is used for displaying the target page, the view component is used for caching the view object, and the browser kernel is operated by calling an interface of the view component.

The view component can be displayed on the interface of the terminal, and the view component is equivalent to a container and used for caching the view object. Depending on the browser kernel required to display the target page, the view objects cached in the view component are different, i.e., the view objects in the view component are dynamically generated.

That is, the view component interface and the actual view object in the view component are in a decoupled state, and only when the browser kernel needs to be run to realize page display, the terminal loads the view object which needs to be used actually into the view component, and the browser kernel is run by calling the view component interface.

The view component plays a role of bridging, and by providing a uniform interface of the view component and the view component externally, the terminal can realize the display function of different pages by loading view objects of different browser kernels under the condition that a program is not required to be modified, so that the pertinence of page display is enhanced. Meanwhile, convenience is provided for adding a browser kernel.

Fig. 3A is a block diagram illustrating a page display apparatus according to an exemplary embodiment. Referring to fig. 3A, the apparatus includes an acquisition module 310, a creation module 320, and a display module 330.

An obtaining module 310, configured to obtain configuration information of a target page, where the target page is any page in an application currently used, and the configuration information includes information of a browser kernel that is required to be used for displaying the target page, and the browser kernel is any one of multiple browser kernels that are included in the target page;

a creating module 320, configured to create a kernel object required to use the browser kernel based on the configuration information acquired by the acquiring module 310;

a display module 330, configured to display the target page through the browser kernel based on the kernel object created by the creating module 320.

Optionally, referring to fig. 3B, the apparatus further includes:

a determining module 340, configured to determine whether the kernel object exists based on the identifier of the target page;

a triggering module 350, configured to trigger the creating module 320 to perform the step of creating the kernel object required to use the browser kernel based on the configuration information when the kernel object does not exist.

Optionally, the determining module 340 includes:

and the determining submodule is used for determining that the kernel object exists when the object interface corresponding to the identification of the target page exists.

Optionally, the display module 330 includes:

Optionally, the run submodule is configured to:

With regard to the apparatus in the above-described embodiment, the specific manner in which each module performs the operation has been described in detail in the embodiment related to the method, and will not be elaborated here.

Fig. 4 is a block diagram illustrating a page display apparatus 400 according to an exemplary embodiment. For example, the apparatus 400 may be a mobile phone, a computer, a digital broadcast terminal, a messaging device, a game console, a tablet device, a medical device, an exercise device, a personal digital assistant, and the like.

Referring to fig. 4, the apparatus 400 may include one or more of the following components: processing components 402, memory 404, power components 406, multimedia components 408, audio components 410, input/output (I/O) interfaces 412, sensor components 414, and communication components 416.

The processing component 402 generally controls overall operation of the apparatus 400, such as operations associated with display, telephone calls, data communications, camera operations, and recording operations. The processing component 402 may include one or more processors 420 to execute instructions to perform all or a portion of the steps of the methods described above. Further, the processing component 402 can include one or more modules that facilitate interaction between the processing component 402 and other components. For example, the processing component 402 can include a multimedia module to facilitate interaction between the multimedia component 408 and the processing component 402.

The memory 404 is configured to store various types of data to support operations at the apparatus 400. Examples of such data include instructions for any application or method operating on the device 400, contact data, phonebook data, messages, pictures, videos, and so forth. The memory 404 may be implemented by any type or combination of volatile or non-volatile memory devices such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disks.

Power supply components 406 provide power to the various components of device 400. The power components 406 may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power supplies for the apparatus 400.

The multimedia component 408 includes a screen that provides an output interface between the device 400 and the user. In some embodiments, the screen may include a Liquid Crystal Display (LCD) and a Touch Panel (TP). If the screen includes a touch panel, the screen may be implemented as a touch screen to receive an input signal from a user. The touch panel includes one or more touch sensors to sense touch, slide, and gestures on the touch panel. The touch sensor may not only sense the boundary of a touch or slide action, but also detect the duration and pressure associated with the touch or slide operation. In some embodiments, the multimedia component 408 includes a front facing camera and/or a rear facing camera. The front camera and/or the rear camera may receive external multimedia data when the apparatus 400 is in an operation mode, such as a photographing mode or a video mode. Each front camera and rear camera may be a fixed optical lens system or have a focal length and optical zoom capability.

The audio component 410 is configured to output and/or input audio signals. For example, audio component 410 includes a Microphone (MIC) configured to receive external audio signals when apparatus 400 is in an operational mode, such as a call mode, a recording mode, and a voice recognition mode. The received audio signals may further be stored in the memory 404 or transmitted via the communication component 416. In some embodiments, audio component 410 also includes a speaker for outputting audio signals.

The I/O interface 412 provides an interface between the processing component 402 and peripheral interface modules, which may be keyboards, click wheels, buttons, etc. These buttons may include, but are not limited to: a home button, a volume button, a start button, and a lock button.

The sensor component 414 includes one or more sensors for providing various aspects of status assessment for the apparatus 400. For example, the sensor assembly 414 may detect an open/closed state of the apparatus 400, the relative positioning of the components, such as a display and keypad of the apparatus 400, the sensor assembly 414 may also detect a change in the position of the apparatus 400 or a component of the apparatus 400, the presence or absence of user contact with the apparatus 400, orientation or acceleration/deceleration of the apparatus 400, and a change in the temperature of the apparatus 400. The sensor assembly 414 may include a proximity sensor configured to detect the presence of a nearby object without any physical contact. The sensor assembly 414 may also include a light sensor, such as a CMOS or CCD image sensor, for use in imaging applications. In some embodiments, the sensor assembly 414 may also include an acceleration sensor, a gyroscope sensor, a magnetic sensor, a pressure sensor, or a temperature sensor.

The communication component 416 is configured to facilitate wired or wireless communication between the apparatus 400 and other devices. The apparatus 400 may access a wireless network based on a communication standard, such as WiFi, 2G or 3G, or a combination thereof. In an exemplary embodiment, the communication component 416 receives broadcast signals or broadcast related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component 416 further includes a Near Field Communication (NFC) module to facilitate short-range communications. For example, the NFC module may be implemented based on Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, Ultra Wideband (UWB) technology, Bluetooth (BT) technology, and other technologies.

In an exemplary embodiment, the apparatus 400 may be implemented by one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), controllers, micro-controllers, microprocessors or other electronic components for performing the above-described methods.

In an exemplary embodiment, a non-transitory computer-readable storage medium comprising instructions, such as the memory 404 comprising instructions, executable by the processor 420 of the apparatus 400 to perform the above-described method is also provided. For example, the non-transitory computer readable storage medium may be a ROM, a Random Access Memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, and the like.

A non-transitory computer readable storage medium, wherein instructions of the storage medium, when executed by a processor of a mobile terminal, enable the mobile terminal to perform the page display method according to the embodiment of fig. 1 or fig. 2.

Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the disclosure disclosed herein. This application is intended to cover any variations, uses, or adaptations of the disclosure following, in general, the principles of the disclosure and including such departures from the present disclosure as come within known or customary practice within the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.

It will be understood that the present disclosure is not limited to the precise arrangements described above and shown in the drawings and that various modifications and changes may be made without departing from the scope thereof. The scope of the present disclosure is limited only by the appended claims.

Claims

1. A page display method is applied to a terminal, and the method comprises the following steps:

acquiring configuration information of a target page, wherein the target page is any page in an application which is currently used, the configuration information comprises information of a browser kernel which is required to be used for displaying the target page, the browser kernel is any one of a plurality of browser kernels, and the browser kernels required to be used by different pages in the application which is currently used are different;

calling an object interface of the kernel object;

the browser kernel is operated by calling an interface of the view component to display the target page, wherein the view component and the interface of the view component are provided by the terminal externally and uniformly;

the interface of the view component and the actual view object in the view component are in a decoupling state, the view object which is actually needed to be used is loaded into the view component only when the browser kernel is needed to be operated to realize page display, and the operation of the browser kernel is realized by calling the interface of the view component.

2. The method of claim 1, wherein prior to creating the kernel object needed to use the browser kernel based on the configuration information, further comprising:

3. The method of claim 2, wherein said determining whether the kernel object exists based on the identification of the target page comprises:

4. A page display device is applied to a terminal, and the device comprises:

the system comprises an acquisition module, a display module and a display module, wherein the acquisition module is used for acquiring configuration information of a target page, the target page is any page in an application which is currently used, the configuration information comprises information of a browser kernel which is required to be used for displaying the target page, the browser kernel is any one of a plurality of browser kernels, and the browser kernels required to be used by different pages in the application which is currently used are different;

the display module is used for calling an object interface of the kernel object; loading a view object in the kernel object into a view component, wherein the view object is used for displaying the target page, and the view component is used for caching the view object; the browser kernel is operated by calling an interface of the view component to display the target page, wherein the view component and the interface of the view component are provided by the terminal externally and uniformly;

5. The apparatus of claim 4, wherein the apparatus further comprises:

6. The apparatus of claim 5, wherein the determining module comprises:

7. A page display device is applied to a terminal, and the device comprises:

a processor;

a memory for storing processor-executable instructions;

wherein the processor is configured to:

calling an object interface of the kernel object;

8. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the method of any one of claims 1 to 3.