CN110020276B - Compatibility processing method and device for embedding H5 page in APP - Google Patents
Compatibility processing method and device for embedding H5 page in APP Download PDFInfo
- Publication number
- CN110020276B CN110020276B CN201710724725.9A CN201710724725A CN110020276B CN 110020276 B CN110020276 B CN 110020276B CN 201710724725 A CN201710724725 A CN 201710724725A CN 110020276 B CN110020276 B CN 110020276B
- Authority
- CN
- China
- Prior art keywords
- size
- webview
- page
- function
- html
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/957—Browsing optimisation, e.g. caching or content distillation
- G06F16/9577—Optimising the visualization of content, e.g. distillation of HTML documents
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Information Transfer Between Computers (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides a compatibility processing method for embedding an H5 page in an APP, which comprises the steps of injecting a JavaScript function for acquiring the size of a WebView area into the WebView; loading the H5 page according to the pre-configured address; calling the JavaScript function to obtain the size of the WebView area, and setting the font size of an HTML root element according to the obtained size; and setting the font size of each HTML child node according to the font size of the HTML root element. According to the invention, the JavaScript function of the WebView window size is injected into the WebView, and the real information of the device screen is transmitted to the H5 page through the function, so that the purpose that the H5 page is adapted to different mobile devices is achieved, the method is simple and easy to implement, and the development efficiency can be effectively improved.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a processing method and a processing device for compatibility of an embedded H5 page in an APP.
Background
At present, due to the need of improving user participation, an H5(Html5) page is usually embedded in APP (application software) in a WebView (browser component built in an operating system) manner, so as to improve user experience, so as to guide a user to participate in activities and improve the enthusiasm of user participation.
When the H5 page is embedded in the APP, due to the difference of operating system platforms (currently, mainly Android system and iOS system), the different versions of the same operating system, the different versions of WebView, the different sizes of the screens of various mobile devices, and the different screen resolutions, the presence of these objective factors makes it difficult for the H5 page to maintain the consistency of the display style and content on different mobile devices, and solves the problem of the compatibility of the H5 page, and therefore, a method is needed to solve the problem of the compatibility of the page after the H5 page is embedded in the APP.
Disclosure of Invention
In order to solve the compatibility problem after embedding an H5 page in an APP, the invention provides a compatibility processing method and device for embedding an H5 page in the APP.
According to one aspect of the invention, a compatibility processing method for embedding an H5 page in an APP is provided, which comprises the following steps:
s1, when embedding the WebView in the APP, injecting a JavaScript function for acquiring the size of the WebView region into the WebView by initializing the JavaScript bridge;
s2, loading an H5 page according to a preset address after WebView creation and JavaScript function injection are completed;
s3, after the H5 page is loaded, calling the JavaScript function to obtain the size of the WebView area, and setting the font size of an HTML root element according to the obtained size;
and S4, setting the font size of each HTML child node according to the font size of the HTML root element.
The step of calling the JavaScript function to obtain the WebView area size in S3 further includes:
s31, calling a callback function which is loaded by the H5 page, and determining a system platform of the APP which runs currently by analyzing a user agent of Webview in the callback function;
s32, calling the JavaScript function through the JavaScript bridge interface corresponding to the system platform, and obtaining the size of the WebView area.
Wherein the step S32 further includes:
and when the calling of the JavaScript function is abnormal, the size of the WebView area is obtained by calling an element.
Wherein the step of setting the font size of the HTML root element according to the obtained size in S3 further includes:
in an initialization function of the H5 page, calling window.
And calling a setFontSize function to calculate the font size of the HTML root element according to the size of the WebView area and the screen pixel ratio, and setting the font size into a font-size CSS attribute of the HTML root element.
Wherein the step S4 further includes:
and proportionally setting the font size of the HTML root element as the font size of each HTML child node based on a REM mechanism supported by the browser.
Wherein, after step S4, the method further comprises:
and displaying the H5 page after final setting is finished based on the font size of the HTML root element and the font size of each HTML child node.
According to another aspect of the present invention, there is provided a compatibility processing apparatus for embedding an H5 page in an APP, including:
the injection module is used for injecting a JavaScript function for acquiring the size of the WebView region into the WebView by initializing a JavaScript Bridge when the WebView is embedded into the APP;
the loading module is used for loading an H5 page according to a preset address after WebView creation and JavaScript function injection are completed;
the first size acquisition module is used for calling the JavaScript function to acquire the size of the WebView area after the H5 page is loaded, and setting the font size of an HTML root element according to the acquired size;
and the second size acquisition module is used for setting the font size of each HTML child node according to the font size of the HTML root element.
The first size obtaining module is specifically configured to:
calling a callback function which is loaded by an H5 page, and determining a system platform of the APP which runs currently by analyzing a user agent of Webview in the callback function;
and calling the JavaScript function through a JavaScript Bridge interface corresponding to the system platform to obtain the size of the WebView area.
According to another aspect of the present invention, there is provided a compatibility processing device for embedding an H5 page in an APP, including: a memory, a processor, and a bus,
the processor and the memory complete mutual communication through the bus;
the memory stores program instructions executable by the processor, which invokes the program instructions in the memory to perform a method as described in any of the preceding.
According to yet another aspect of the invention, there is provided a non-transitory computer readable storage medium storing computer instructions for causing the computer to perform the method of any of the preceding claims.
According to the compatibility processing method and device for embedding the H5 page into the APP, provided by the invention, the JavaScript function of the WebView window size is obtained by injecting into the WebView, and the real information of the device screen is transmitted to the H5 page through the function, so that the purpose that the H5 page is adapted to different mobile devices is achieved, the compatibility processing method and device are simple and easy to implement, and the development efficiency can be effectively improved.
Drawings
Fig. 1 is a schematic flowchart of a compatibility processing method for embedding an H5 page in an APP according to an embodiment of the present invention;
fig. 2 is a schematic structural diagram of a compatibility processing apparatus for embedding an H5 page in an APP according to another embodiment of the present invention;
fig. 3 is a schematic structural diagram of a compatibility processing device with an APP embedded with an H5 page according to another embodiment of the present invention.
Detailed Description
The following detailed description of embodiments of the present invention is provided in connection with the accompanying drawings and examples. The following examples are intended to illustrate the invention but are not intended to limit the scope of the invention.
As shown in fig. 1, a schematic flowchart of a compatibility processing method for embedding an H5 page in an APP according to an embodiment of the present invention includes:
s1, when embedding the WebView in the APP, injecting a JavaScript function for acquiring the size of the WebView region into the WebView by initializing the JavaScript bridge;
s2, loading an H5 page according to a preset address after WebView creation and JavaScript function injection are completed;
s3, after the H5 page is loaded, calling the JavaScript function to obtain the size of the WebView area, and setting the font size of an HTML root element according to the obtained size;
and S4, setting the font size of each HTML child node according to the font size of the HTML root element.
Specifically, in step S1, in order to embed H5 page in APP, a developer of web version APP (webapp) needs to embed WebView, which is a browser component built in the operating system, in APP first. When the WebView is embedded, a JavaScript function getScreenWidth for acquiring the size of the WebView area is injected into the WebView by initializing a JavaScript Bridge. At present, the main reason that the page compatibility problem occurs when embedding the H5 page in the APP is that the H5 page obtains an incorrect result when calling element. A JavaScript function for acquiring the size of the WebView area size is injected into the WebView, so that the real information of the device screen can be transmitted to the H5 page, and the purpose that the H5 page is adapted to different mobile device platforms is achieved. Moreover, JavaScriptBridge is a cross-platform open source solution, can run on Android and iOS, is simple and easy to deploy, and provides a uniform solution for development of embedding H5 pages in APP.
S2, after the WebView is created and the JavaScript function getScreenWidth is successfully injected into the WebView, the APP end loads a corresponding H5 page through a preset address by using the WebView. The APP starts to load the H5 page after the getScreenWidth function is injected, and the process ensures the page loading time sequence, so that the function can be ensured to exist when the JavaScript function getScreenWidth is called, and the abnormal occurrence probability of function calling can be reduced.
S3, after the H5 page is loaded, the event processing function of the H5 page bound page loading completion is called, in the event processing function, the H5 page calls a getScreen Width function injected by the APP end, the real size of the current WebView area can be obtained through the JavaScript function, and the font size of the HTML root element of the H5 page can be set through the size.
Then, in step S4, the obtained font size of the HTML root element is used as a reference, and the font size of each HTML child node, that is, the font size or the element size corresponding to different DOM nodes, is set, so as to achieve the purpose of adapting to different mobile devices.
According to the compatibility processing method for embedding the H5 page into the APP, provided by the embodiment of the invention, the JavaScript function of the WebView window size is obtained by injecting into the WebView, and the real information of the device screen is transmitted to the H5 page through the function, so that the purpose that the H5 page is adapted to different mobile devices is achieved, the compatibility processing method can be operated on Android and iOS, is simple and easy to deploy, a uniform solution is provided for the compatibility problem of the development of embedding the H5 page into the APP, and the development efficiency can be effectively improved.
Based on the above embodiment, the step of calling the JavaScript function to obtain the WebView area size in S3 further includes:
s31, calling a callback function which is loaded by the H5 page, and determining a system platform of the APP which runs currently by analyzing a user agent of Webview in the callback function;
s32, calling the JavaScript function through the JavaScript bridge interface corresponding to the system platform, and obtaining the size of the WebView area.
Specifically, after the H5 page is loaded, a specified callback function of the page loaded is called, the callback function is specifically a windows _ onload or a document _ onload, in the callback function, firstly, a JavaScript code of the H5 page determines a system platform of a currently running APP by analyzing a user agent of the WebView, that is, whether the currently running APP is an Android version or an iOS version is judged, and then, the JavaScript function getScreenWidth for obtaining the size of the WebView area is tried to be called through a JavaScript Bridge interface corresponding to the system platform, so that the size of the current WebView area is obtained.
The platform for judging the current H5 page running is judged by the Useragent which is the native support mode of the browser, the method is efficient and easy to implement, only pattern matching is carried out through a regular expression, and in addition, the cross-platform performance and the portability of the method and the code are ensured by calling the corresponding JavaScriptBridge interface according to different platforms.
In one embodiment, when the calling of the JavaScript function is abnormal, the size of the WebView area is obtained by calling an element. That is, when the JavaScript Bridge does not derive the JavaScript function getScreenWidth, or the exception is thrown by calling the getScreenWidth function, the size of the WebView area is obtained by calling element. The fault tolerance and the robustness of the program are enhanced through exception handling, because the size of the WebView can be obtained through the native element of the WebView after the JavaScriptBridge interface fails to call the getScreenWidth function or the APP itself is abnormal, so that the H5 page embedded in the APP can still be normally displayed on most mobile devices, and the user experience of embedding the H5 page in the APP is greatly enhanced.
Based on the above embodiment, the step of setting the font size of the HTML root element according to the obtained size in S3 further includes:
in an initialization function of the H5 page, calling window.
And calling a setFontSize function to calculate the font size of the HTML root element according to the size of the WebView area and the screen pixel ratio, and setting the font size into a font-size CSS attribute of the HTML root element.
Specifically, after the size of the WebView is obtained, the initialization function of the H5 page obtains a screen Pixel Ratio (Device Pixel Ratio) of the current Device through the window.
Based on the above embodiments, the step S4 further includes:
and proportionally setting the font size of the HTML root element as the font size of each HTML child node based on a REM mechanism supported by the browser.
REM is one new relative unit (root em) of CSS3, and the multiple of the calculated value of font-size with respect to the root element (i.e., html element) is a unit of the font size with respect to the root element only (font size soft root element). Simply stated, it is a relative unit. Simple responsive layout can be realized by using REM, and the value of font-size can be set by using the ratio of the size of a font in an html element to the size between screens, so that the element is changed when the resolution of the screen is changed.
Since REM is the mechanism supported by browser, and after the font-size CSS attribute of HTML root element is set or modified, the font-size of each HTML sub-element will be dynamically modified by browser automatically according to the font-size of HTML root element, ensuring that H5 page can be displayed well on different mobile devices. This greatly ensures the operating efficiency of the H5 page and reduces the workload of developers.
Based on the above embodiments, after step S4, the method further includes:
and displaying the H5 page after final setting is finished based on the font size of the HTML root element and the font size of each HTML child node.
After the font-size of the HTML root node and the font-size of each HTML child node are set, the size and the position of each HTML element are finally determined, so that the page can be completely displayed, the user experience on each mobile device is consistent, the function codes can be executed finally, and the page can still be well displayed even if each element is added, modified and deleted in the later period.
As shown in fig. 2, a schematic structural diagram of a compatibility processing apparatus for embedding an H5 page in an APP according to another embodiment of the present invention includes: an injection module 21, a loading module 22, a first size obtaining module 22 and a second size obtaining module 23, wherein,
the injection module 21 is configured to inject a JavaScript function for acquiring the size of the WebView region into the WebView by initializing the JavaScript bridge when the WebView is embedded in the APP;
the loading module 22 is used for loading an H5 page according to a pre-configured address after the WebView creation and the JavaScript function injection are completed;
the first size obtaining module 23 is configured to, after the H5 page is loaded, call the JavaScript function to obtain a WebView area size, and set a font size of an HTML root element according to the obtained size;
and the second size obtaining module 24 is configured to set the font size of each HTML child node according to the font size of the HTML root element.
Specifically, to implement embedding H5 pages in APP, a developer of web version APP (webapp) first needs to embed WebView, which is a browser component built into the operating system, in APP. The injection module 21 is configured to inject a JavaScript function getScreenWidth for acquiring the size of the WebView area into the WebView by initializing the JavaScript bridge when the WebView is embedded. At present, the main reason that the page compatibility problem occurs when embedding the H5 page in the APP is that the H5 page obtains an incorrect result when calling element. A JavaScript function for acquiring the size of the WebView area size is injected into the WebView, so that the real information of the device screen can be transmitted to the H5 page, and the purpose that the H5 page is adapted to different mobile device platforms is achieved. Moreover, JavaScriptBridge is a cross-platform open source solution, can run on Android and iOS, is simple and easy to deploy, and provides a uniform solution for development of embedding H5 pages in APP.
After the WebView creation is completed and the JavaScript function getScreenWidth is successfully injected into the WebView, the loading module 22 uses the WebView to load the H5 page through a pre-configured address. The APP starts to load the H5 page after the getScreenWidth function is injected, and the process ensures the page loading time sequence, so that the function can be ensured to exist when the JavaScript function getScreenWidth is called, and the abnormal occurrence probability of function calling can be reduced.
After the H5 page is loaded, the H5 page firstly binds an event processing function for completing page loading, and once the page is loaded, the function is called, in the event processing function, the first size obtaining module 23 is configured to call a getScreenWidth function injected at the APP end, and through the JavaScript function, the real size of the current WebView area can be obtained, and through this size, the font size of the HTML root element on the H5 plane can be set.
The second size obtaining module 24 is configured to set a font size of each HTML child node, that is, a font size or an element size corresponding to different DOM nodes, based on the size of the HTML root element, so as to achieve the purpose of adapting to different mobile devices.
According to the compatibility processing device for embedding the H5 page into the APP, provided by the embodiment of the invention, the JavaScript function of the WebView window size is injected into the WebView, and the real information of the device screen is transmitted to the H5 page through the function, so that the purpose that the H5 page is adapted to different mobile devices is achieved, the compatibility processing device can be operated on Android and iOS, is simple and easy to deploy, provides a uniform solution for the compatibility problem of embedding the H5 page into the APP for development, and can effectively improve the development efficiency.
Based on the above embodiment, the first size obtaining module is specifically configured to:
calling a callback function which is loaded by an H5 page, and determining a system platform of the APP which runs currently by analyzing a user agent of Webview in the callback function;
and calling the JavaScript function through a JavaScript Bridge interface corresponding to the system platform to obtain the size of the WebView area.
Specifically, after the H5 page is loaded, a specified callback function of the page loaded is called, the callback function is specifically a windows _ onload or a document _ onload, in the callback function, firstly, a JavaScript code of the H5 page determines a system platform of a currently running APP by analyzing a user agent of the WebView, that is, whether the currently running APP is an Android version or an iOS version is judged, and then, the JavaScript function getScreenWidth for obtaining the size of the WebView area is tried to be called through a JavaScript Bridge interface corresponding to the system platform, so that the size of the current WebView area is obtained.
Wherein the first size obtaining module is further configured to:
and when the calling of the JavaScript function is abnormal, the size of the WebView area is obtained by calling an element.
Based on the above embodiment, the first size obtaining module is configured to:
in an initialization function of the H5 page, calling window.
And calling a setFontSize function to calculate the font size of the HTML root element according to the size of the WebView area and the screen pixel ratio, and setting the font size into a font-size CSS attribute of the HTML root element.
Wherein the second size obtaining module is configured to:
and proportionally setting the font size of the HTML root element as the font size of each HTML child node based on a REM mechanism supported by the browser.
Wherein, still include:
and the display module is used for displaying the H5 page after final setting is finished based on the font size of the HTML root element and the font size of each HTML child node.
As shown in fig. 3, a schematic structural diagram of a compatibility processing device for embedding an H5 page in an APP according to another embodiment of the present invention includes: a memory 31, a processor 32, and a bus 33,
the processor 32 and the memory 31 complete mutual communication through the bus 33;
the memory 31 stores program instructions executable by the processor 32, and the processor 32 calls the program instructions in the memory 31 to perform the method according to the embodiments, for example, including: s1, when embedding the WebView in the APP, injecting a JavaScript function for acquiring the size of the WebView region into the WebView by initializing the JavaScript bridge; s2, loading an H5 page according to a preset address after WebView creation and JavaScript function injection are completed; s3, after the H5 page is loaded, calling the JavaScript function to obtain the size of the WebView area, and setting the font size of an HTML root element according to the obtained size; and S4, setting the font size of each HTML child node according to the font size of the HTML root element.
According to yet another aspect of the present invention, there is provided a non-transitory computer readable storage medium storing computer instructions that cause the computer to perform a method as described in the various embodiments above, for example comprising: s1, when embedding the WebView in the APP, injecting a JavaScript function for acquiring the size of the WebView region into the WebView by initializing the JavaScript bridge; s2, loading an H5 page according to a preset address after WebView creation and JavaScript function injection are completed; s3, after the H5 page is loaded, calling the JavaScript function to obtain the size of the WebView area, and setting the font size of an HTML root element according to the obtained size; and S4, setting the font size of each HTML child node according to the font size of the HTML root element.
Those of ordinary skill in the art will understand that: all or part of the steps for implementing the method embodiments may be implemented by hardware related to program instructions, and the program may be stored in a computer readable storage medium, and when executed, the program performs the steps including the method embodiments; and the aforementioned storage medium includes: various media that can store program codes, such as ROM, RAM, magnetic or optical disks.
The compatibility processing device for embedding the H5 page in the APP described above is only illustrative, where the units described as separate components may or may not be physically separate, and the components displayed as units may or may not be physical units, that is, may be located in one place, or may also be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. One of ordinary skill in the art can understand and implement it without inventive effort.
Through the above description of the embodiments, those skilled in the art will clearly understand that each embodiment can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware. With this understanding in mind, the above-described technical solutions may be embodied in the form of a software product, which can be stored in a computer-readable storage medium such as ROM/RAM, magnetic disk, optical disk, etc., and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute the methods described in the embodiments or some parts of the embodiments.
Finally, the method of the present invention is only a preferred embodiment and is not intended to limit the scope of the present invention. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (10)
1. A compatibility processing method for embedding an H5 page in an APP is characterized by comprising the following steps:
s1, when embedding the WebView in the APP, injecting a JavaScript function getScreenWidth for acquiring the size of the WebView area into the WebView by initializing the JavaScript bridge;
s2, loading an H5 page according to a preset address after WebView creation and JavaScript function injection are completed;
s3, after the H5 page is loaded, calling the JavaScript function to obtain the size of the WebView area, and setting the font size of an HTML root element according to the obtained size;
and S4, setting the font size of each HTML child node according to the font size of the HTML root element.
2. The method of claim 1, wherein the step of calling the JavaScript function to obtain the WebView area size in S3 further comprises:
s31, calling a callback function which is loaded by the H5 page, and determining a system platform of the APP which runs currently by analyzing a user agent of Webview in the callback function;
s32, calling the JavaScript function through the JavaScript bridge interface corresponding to the system platform, and obtaining the size of the WebView area.
3. The method according to claim 2, wherein the step S32 further comprises:
and when the calling of the JavaScript function is abnormal, calling an element.
4. The method according to claim 2 or 3, wherein the step of setting the font size of the HTML root element according to the obtained size in S3 further comprises:
in an initialization function of the H5 page, calling window.
And calling a setFontSize function to calculate the font size of the HTML root element according to the size of the WebView area and the screen pixel ratio, and setting the font size into a font-size CSS attribute of the HTML root element.
5. The method according to claim 4, wherein the step S4 further comprises:
and proportionally setting the font size of the HTML root element as the font size of each HTML child node based on a REM mechanism supported by the browser.
6. The method according to claim 1, further comprising, after step S4:
and displaying the H5 page after final setting is finished based on the font size of the HTML root element and the font size of each HTML child node.
7. A compatibility processing device for embedding an H5 page in an APP (application), comprising:
the injection module is used for injecting a JavaScript function getScreenWidth for acquiring the size of the WebView area into the WebView by initializing a JavaScript Bridge when the WebView is embedded into the APP;
the loading module is used for loading an H5 page according to a preset address after WebView creation and JavaScript function injection are completed;
the first size acquisition module is used for calling the JavaScript function to acquire the size of the WebView area after the H5 page is loaded, and setting the font size of an HTML root element according to the acquired size;
and the second size acquisition module is used for setting the font size of each HTML child node according to the font size of the HTML root element.
8. The apparatus of claim 7, wherein the first size obtaining module is specifically configured to:
calling a callback function which is loaded by an H5 page, and determining a system platform of the APP which runs currently by analyzing a user agent of Webview in the callback function;
and calling the JavaScript function through a JavaScript Bridge interface corresponding to the system platform to obtain the size of the WebView area.
9. A compatibility processing device for embedding an H5 page in an APP (application), comprising: a memory, a processor, and a bus,
the processor and the memory complete mutual communication through the bus;
the memory stores program instructions executable by the processor, which invokes the program instructions in the memory to perform the method of any of claims 1 to 6.
10. A non-transitory computer-readable storage medium storing computer instructions that cause a computer to perform the method of any one of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710724725.9A CN110020276B (en) | 2017-08-22 | 2017-08-22 | Compatibility processing method and device for embedding H5 page in APP |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710724725.9A CN110020276B (en) | 2017-08-22 | 2017-08-22 | Compatibility processing method and device for embedding H5 page in APP |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110020276A CN110020276A (en) | 2019-07-16 |
| CN110020276B true CN110020276B (en) | 2021-05-28 |
Family
ID=67186131
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710724725.9A Active CN110020276B (en) | 2017-08-22 | 2017-08-22 | Compatibility processing method and device for embedding H5 page in APP |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110020276B (en) |
Families Citing this family (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111427645A (en) * | 2020-03-20 | 2020-07-17 | 青岛聚好联科技有限公司 | H5-based cross-terminal adaptive display method and device |
| CN111708573B (en) * | 2020-06-05 | 2023-09-08 | 苏州瑞泰信息技术有限公司 | System for H5 adaptation has APP, weChat, nail |
| JP7490472B2 (en) * | 2020-07-06 | 2024-05-27 | キヤノン株式会社 | Information processing device, information processing method, and program |
| CN111984448B (en) * | 2020-08-14 | 2023-12-12 | 北京达佳互联信息技术有限公司 | Page calling method, device, equipment and storage medium |
| CN112905938A (en) * | 2021-02-24 | 2021-06-04 | 上海二三四五网络科技有限公司 | Control method and device for dynamically adjusting H5 page height |
| CN118778963A (en) * | 2023-04-03 | 2024-10-15 | 抖音视界有限公司 | Page processing method, compiling method, rendering method and device |
Family Cites Families (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20150309702A1 (en) * | 2014-04-07 | 2015-10-29 | Dresser, Inc. | Method and system for generating a user interface for device diagnostics of a valve assembly and implementation thereof |
| CN106557501B (en) * | 2015-09-28 | 2020-03-17 | 腾讯科技（深圳）有限公司 | Screen adaptation method and device for page module |
| CN105930464B (en) * | 2016-04-22 | 2021-07-13 | 腾讯科技（深圳）有限公司 | Web rich media cross-screen adaptation method and device |
| CN106021353A (en) * | 2016-05-09 | 2016-10-12 | Tcl集团股份有限公司 | Display adaption method and system of webpage |
| CN106776969A (en) * | 2016-12-05 | 2017-05-31 | 乐视控股（北京）有限公司 | Page adaptation method, device and electronic equipment |
-
2017
- 2017-08-22 CN CN201710724725.9A patent/CN110020276B/en active Active
Non-Patent Citations (2)
| Title |
|---|
| android之获取屏幕的宽度和高度;zsychanpin;《http://www.bbsmax.com/A/GBJrex1az0》;20170612;第1-2页 * |
| How screen size influences Chinese readability;You Wang等;《OzCHI "13:Proceedings of the 25th Australian Computer-Human Interaction Conference:Augmentation,Application,Innovation,Collaboration》;20131130;第277-280页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110020276A (en) | 2019-07-16 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110020276B (en) | Compatibility processing method and device for embedding H5 page in APP | |
| US11741183B2 (en) | Systems and methods for hosted applications | |
| CN110020323B (en) | Page switching method and system for hybrid application, computer equipment and storage medium | |
| CN108228188B (en) | View component processing method, electronic device and readable storage medium | |
| US9081757B2 (en) | Systems and methods for tracking and updating hosted applications | |
| US20110167332A1 (en) | System and Method for Generating Web Pages | |
| KR20150079867A (en) | Html5-protocol-based webpage presentation method and device | |
| CN102760139A (en) | Webpage processing method and webpage processing system | |
| CN110806868A (en) | Single-page building and loading method | |
| CN110781425B (en) | Display method, device and equipment of mobile terminal H5 page and storage medium | |
| CN104580298B (en) | File upload process method and device | |
| CN109408133B (en) | Method and equipment for starting assembly | |
| CN107918587B (en) | Debugging method and system for application program | |
| CN114385124A (en) | Independent page jumping method, device and equipment based on Vue framework | |
| CN111399836B (en) | Method and device for modifying page attribute | |
| CN113778393A (en) | Component generation method, device, computer system and computer-readable storage medium | |
| CN102831212B (en) | The composition method of page display and device | |
| CN114168875A (en) | Page program generation method and device, computer equipment and storage medium | |
| CN113282328A (en) | Application program updating method, computer device and computer storage medium | |
| US12141223B2 (en) | Systems and methods for hosted applications | |
| JP2019101537A (en) | Test script correction device and program | |
| CN110704125B (en) | Webpage loading method and device, storage medium and terminal equipment | |
| CN115439579A (en) | Webpage animation development method and device and electronic equipment | |
| CN117435182A (en) | Cross-end rendering frame construction method, rendering method device, equipment and medium | |
| CN113656017A (en) | Graphical programming object highlighting method, device, system and medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20230907 Address after: Room 503, Building A, No. 2 Taixing Road, Yongping Street, Baiyun District, Guangzhou City, Guangdong Province, 510420 Patentee after: Guangzhou Yaleheng Network Technology Co.,Ltd. Address before: 430000 East Lake Development Zone, Wuhan City, Hubei Province, No. 1 Software Park East Road 4.1 Phase B1 Building 11 Building Patentee before: WUHAN DOUYU NETWORK TECHNOLOGY Co.,Ltd. |
|
| TR01 | Transfer of patent right |