WO2018161813A1 - 一种资源加载方法及装置 - Google Patents

一种资源加载方法及装置 Download PDF

Info

Publication number
WO2018161813A1
WO2018161813A1 PCT/CN2018/077220 CN2018077220W WO2018161813A1 WO 2018161813 A1 WO2018161813 A1 WO 2018161813A1 CN 2018077220 W CN2018077220 W CN 2018077220W WO 2018161813 A1 WO2018161813 A1 WO 2018161813A1
Authority
WO
WIPO (PCT)
Prior art keywords
thread
request
event
resource
web
Prior art date
Application number
PCT/CN2018/077220
Other languages
English (en)
French (fr)
Inventor
闵洪波
朱永盛
鲁振华
林志平
蔡艳明
曾旭
Original Assignee
阿里巴巴集团控股有限公司
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by 阿里巴巴集团控股有限公司 filed Critical 阿里巴巴集团控股有限公司
Publication of WO2018161813A1 publication Critical patent/WO2018161813A1/zh
Priority to US16/557,792 priority Critical patent/US11210109B2/en

Links

Images

Classifications

    • 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
    • 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
    • G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
    • G06F9/45529—Embedded in an application, e.g. JavaScript in a Web browser
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/90—Details of database functions independent of the retrieved data types
    • G06F16/95—Retrieval from the web
    • G06F16/958—Organisation or management of web site content, e.g. publishing, maintaining pages or automatic linking
    • G06F16/986—Document structures and storage, e.g. HTML extensions
    • 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
    • G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
    • 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/46—Multiprogramming arrangements
    • G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
    • G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
    • G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
    • 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/46—Multiprogramming arrangements
    • G06F9/54—Interprogram communication
    • 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/46—Multiprogramming arrangements
    • G06F9/54—Interprogram communication
    • G06F9/542—Event management; Broadcasting; Multicasting; Notifications
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2209/00—Indexing scheme relating to G06F9/00
    • G06F2209/54—Indexing scheme relating to G06F9/54
    • G06F2209/548—Queue
    • 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/451—Execution arrangements for user interfaces

Definitions

  • the present application relates to the field of computer technologies, and in particular, to a resource loading method and apparatus.
  • HTML5 HyperText Markup Language
  • Hypertext Markup Language Hypertext Markup Language
  • Web World Wide Web
  • the web application obtains and displays the web resource through the browser, and displays the web resource in the form of a page.
  • the functionality of the browser can be implemented through the web engine.
  • the web engine includes various components, such as a rendering engine for page rendering, a browser engine for management and control, and more.
  • Node.js is a JavaScript runtime, also known as a runtime platform, that provides a variety of system-level Application Programming Interfaces (APIs) for easily building web applications that are responsive and easy to extend.
  • APIs Application Programming Interfaces
  • the embodiment of the present application provides a resource loading method and device.
  • the embodiment of the present application provides a resource loading method, including:
  • the first thread sends a resource load request to the second thread; wherein the first thread and the second thread are in the same process, and the first thread runs on the dynamic language application running platform;
  • the first thread receives an indication returned by the second thread according to the resource loading request
  • the first thread loads, according to the indication, the resource that is requested to be loaded by the resource loading request, according to the pre-loaded resource of the process, where the pre-loaded resource includes the web engine.
  • a resource loading apparatus provided by the embodiment of the present application includes: a first thread unit and a second thread unit;
  • the first thread unit is configured to:
  • the embodiment of the present application provides one or more computer readable media having instructions stored thereon, the instructions being executed by one or more processors, such that the communication device performs the above method.
  • a communication device provided by an embodiment of the present application includes: one or more processors; and one or more computer readable media having instructions stored on the readable medium, the instructions being the one or more The processor, when executed, causes the apparatus to perform the above method.
  • the process of the application is preloaded with resources, wherein the preloaded resources of the process include a web engine.
  • the first thread in the same process sends a resource load request to the second thread, where the first thread runs on the dynamic language application running platform; the first thread receives an indication returned by the second thread according to the resource loading request; The first thread loads, according to the indication, the resource that is requested to be loaded by the resource loading request, based on the module and/or resource preloaded by the process, thereby implementing the web engine and the dynamic language application running platform. Fusion.
  • FIG. 1 exemplarily shows a cloud operating system architecture 100 based on Node.js according to some embodiments
  • FIG. 2 exemplarily shows a schematic diagram of a Node.js preloaded with a web engine, according to some embodiments
  • FIG. 3 exemplarily shows a schematic diagram of an API mapping relationship of a web engine according to some embodiments
  • FIG. 4 exemplarily shows a schematic diagram of a Node.js thread and a Browser thread and related resources after preloading a web engine, according to some embodiments;
  • Figure 5a exemplarily shows a schematic diagram of a preloading process in accordance with some embodiments
  • FIG. 5b exemplarily shows a schematic diagram of a web resource loading process according to some embodiments
  • Figure 6 exemplarily shows a schematic diagram of an event loop mechanism in accordance with some embodiments
  • FIG. 7 exemplarily shows a schematic structural diagram of a resource loading device according to some embodiments.
  • Figure 8 exemplarily shows a schematic diagram of a device in accordance with some embodiments.
  • references to "an embodiment”, “an embodiment”, “an illustrative embodiment” or the like in the specification are intended to mean that the described embodiments may include specific features, structures, or characteristics, but each embodiment may or may not necessarily include a particular Feature, structure or characteristic. Moreover, such phrases are not necessarily referring to the same embodiments. Further, it is to be understood that the specific features, structures, or characteristics may be combined with other embodiments, whether explicitly described or not, in conjunction with the embodiments. In addition, it should be understood that items included in the list in the form of "at least one of A, B, and C” may represent (A); (B); (C); (A and B); (A and C) ; (B and C); or (A, B and C). Similarly, items listed in the form of "at least one of A, B or C” may represent (A); (B); (C); (A and B); (A and C); (B and C) or (A, B and C).
  • the disclosed embodiments can be implemented in hardware, firmware, software, or any combination thereof.
  • the disclosed embodiments can also be implemented as instructions carried or stored by one or more transitory or non-transitory machine readable (eg, computer readable) storage media, which can be read by one or more processors And execution.
  • a machine-readable storage medium may be embodied in any storage device, mechanism or other physical structure for storing or transmitting information in a machine readable form (eg, a volatile or nonvolatile memory, media disk or other medium). ).
  • the operating system is used to provide the user application with the basic capabilities of the operating system, which can be implemented based on the dynamic language application runtime platform, thereby providing an operating environment for the dynamic language application.
  • Node.js is the running environment or running platform of JavaScript.
  • dynamic language is a language category in computer programming language. It is a kind of language that can dynamically change type and structure at runtime. Functions and attributes can be added, modified and deleted at runtime. For example, JavaScript, Python, Ruby, etc. are all dynamic languages. Dynamic languages do not need to be compiled to run. They need to be supported by the runtime environment at runtime. This environment is called the runtime environment and contains all the elements needed for dynamic language operations, such as Java virtual machines, JavaScript engines, and so on.
  • Node.js is the JavaScript runtime environment and is the web application framework for the JavaScript engine built on Chrome. That is, the operating system provides the basic capabilities of the operating system to user applications based on Node.js.
  • Node.js includes a variety of modules that can be packaged by code that implements specific functions, such as code that implements operating system-level service functions, such as packaged as component forms, such as those implemented in these modules.
  • GPS Global Positioning System
  • the interfaces of these modules are exposed to the application layer.
  • Applications in the application layer (such as web applications) can implement these modules by calling the interfaces of these modules, parsing the code in the module through the JavaScript engine, and executing the methods provided by these modules. The function.
  • the loading of the web resource is implemented by the browser, and the browser implements the web resource loading based on the web engine.
  • the traditional HTML5 browser has two types of threads in the web engine: the Browser thread (browser thread) and the Render thread (the rendering thread).
  • the Browser thread is the main thread, which can provide service and management capabilities for the rendering of each Web page;
  • the Render thread is a sub-thread, which can perform page rendering and execute JavaScript code based on the Web engine.
  • the Browser thread can create one or more Render threads. For example, in the process of loading a web page, the Browser thread creates a Render thread, and the Render thread renders the Web page. If multiple web pages need to be loaded, the Browser thread creates multiple Render threads, and each Render thread renders a Web page.
  • FIG. 1 exemplarily shows an operating system architecture 100.
  • the architecture 100 includes an application layer 10, an application framework layer 20, and an operating system layer 30.
  • the application layer 10 includes one or more applications, which may include a browser.
  • the program framework layer 20 includes a dynamic language application runtime platform (such as Node.js).
  • the operating system layer 30 is mainly used to provide an operating system level code base and basic system services, such as provided system services may include device driver services, event management services, and the like.
  • the web engine in the browser is at the application layer and does not have the ability to use the system services provided by Node.js. If you need to enable the Render thread in the web engine to use the capabilities provided by Node.js, you need to start Node.js during the Render thread startup process. Considering that each time a Web page is loaded, a Render thread is started, and Node.js needs to be started once, which results in a large resource overhead and time overhead for loading the Web page.
  • the embodiment of the present application is based on the above architecture, so that the Web engine can access the capabilities provided by the Node.js, and further reduce the resource overhead and time overhead compared with the above manner.
  • the embodiments of the present application are described in detail below with reference to the accompanying drawings.
  • the dynamic language application running platform can be preloaded with various resources, including a web engine.
  • the Node.js process preloads various capabilities.
  • the term "capabilities" as used herein may also be referred to as resources. It may include the aforementioned modules (such as components) for implementing specific functions, and may also include some configuration information, such as Context, event queue, etc.
  • the capabilities pre-loaded by Node.js include at least the web engine (such as the Webview component (ie web view component) in the Android system), and may further include the capabilities provided by Node.js.
  • Node.js may include: modules in Node.js (such as components for providing specific functions or services) and/or JavaScript runtime environment related information.
  • Modules in Node.js can be encapsulated by JavaScript code that implements specific functions.
  • Each module has an interface (such as an API) that can be supplied to the application layer for application calls.
  • the JavaScript runtime environment related information may include, but is not limited to, one or more of a context of a JavaScript engine, an event loop related configuration.
  • the context is used to describe the various objects, states, and functions within the engine.
  • the context of the JavaScript engine can include interfaces (such as APIs) for modules that are preloaded by the Node.js process.
  • the event loop related configuration may specifically include the configuration of the event queue of the Node.js, such as the location of the memory area where the event queue is located, the size of the queue, etc., in order to access the Node.js event request and the web event request to the event queue.
  • preloaded capabilities may be packaged as standard modules in a dynamic language application runtime platform, as a standard module of the platform is preloaded into the platform.
  • FIG. 2 takes the platform as Node.js as an example, and exemplarily shows a schematic diagram of Node.js preloaded with a web engine.
  • the web engine is written in the c/c++ language, and Node.js supports the JavaScript language, so the API of the web engine conforming to the c/c++ standard needs to be mapped to an API that conforms to the JavaScript standard in Node.js, and The mapped API that conforms to the JavaScript standard is provided to the application layer, and the mapping relationship of the API is saved in Node.js.
  • FIG. 3 exemplarily shows a schematic diagram of an API mapping relationship of a web engine.
  • the Web engine can include a variety of components, such as Window system components (window system components), UI Elements components (user interface component components), Layout components (layout components), Event Handling components (event processing components), etc.
  • the APIs of the c/c++ standard components are mapped one by one to the corresponding APIs that conform to the JavaScript standard.
  • the ability to preload may also include, but is not limited to, one or more of the following:
  • the capabilities provided by the operating system may include: system services provided by the operating system layer, and the like. Modules for providing system services may be included in the operating system layer, which may be derived from code encapsulation for implementing specific capabilities. Each module has an interface (such as an API). In the embodiment of the present application, the preloading of the operating system capability can be implemented by adding the API of the module in the operating system layer to the context of a dynamic language engine such as a JavaScript engine.
  • User-defined capabilities ie user-defined code for implementing specific functions, can be packaged as modules, each with an interface (such as an API).
  • the pre-loading of the user-defined capability can be implemented by adding the API of the user-defined module to the context of a dynamic language engine such as a JavaScript engine.
  • a module interface (such as an API) in the JavaScript context in Node.js is added to the JavaScript context of the web engine so that, for the developer of the application, the JavaScript context of the web engine can be utilized
  • the included API is used for application development.
  • the Node.js thread can call the corresponding module through these interfaces to implement the corresponding functions, that is, the capabilities corresponding to accessing these interfaces.
  • the module interface in the uplink of Node.js can include the module interface in Node.js, it can also include the module interface provided by the operating system and the interface of the user-defined module, so that the Node.js thread can access more abundantly. .
  • the module interface in the JavaScript context of Node.js that contains the web engine's JavaScript context can also be added to the JavaScript context of Node.js.
  • the main thread in the Node.js process is called the Node.js thread, which can share the running environment of the Node.js process and the ability of the Node.js process to be preloaded. That is, the Node.js thread can access the various capabilities preloaded by the Node.js process. Since the Node.js process preloads the web engine, the Node.js thread can implement the functionality provided by the web engine based on the web engine, such as page rendering.
  • FIG. 4 exemplarily shows a schematic diagram of a Node.js thread and a browser thread (Browser thread) and related resources after preloading the web engine.
  • the application process includes a Node.js thread and a Brower thread, and the Node.js thread and the Browser thread can communicate with each other.
  • the Node.js thread handles events based on the event loop mechanism of Node.js.
  • the Node.js thread can implement web resource loading operations based on the web engine.
  • the Node.js thread can implement page loading by calling the page load method provided by the web engine.
  • the Node.js thread can call the corresponding module (component) based on the API in the JavaScript context in the web engine.
  • the JavaScript engine parses the called module, obtains the interface provided by the operating system layer to the JavaScript engine, and invokes the capabilities provided by the operating system layer (such as device capabilities, network services, power management, etc.) based on the interface.
  • Page load operation For the application process shown in Figure 4, the Node.js thread is the main thread, and the Browser thread is the child thread. That is, the Browser thread can be created by the Node.js thread, and communication between them can be based on the inter-thread communication mechanism. .
  • the application process communicates with other processes (such as processes corresponding to network service modules at the operating system layer in the figure) based on an Inter-Process Communication (IPC) mechanism.
  • IPC Inter-Process Communication
  • the Node.js thread may call the module 1 (network module) in FIG. 4 to execute a page acquisition method.
  • the network service provided by the operating system layer may be invoked based on an interface provided by the operating system layer. Get the requested page.
  • the Node.js thread may call module 2 (capability acquisition module) in FIG. 4 to perform an acquisition method of device capabilities (such as device information such as display screen size) and determine a display mode according to the device capability, in the execution of the method.
  • the device capability provided by the operating system layer may be invoked based on an interface provided by the operating system layer to obtain device capability information.
  • FIG. 5a exemplarily shows a preloading process provided by an embodiment of the present application.
  • the process is started (eg, a Node.js process is started after receiving an event that opens a page in a browser window).
  • the process performs an initialization process.
  • the process preloads the network module, the system module, the rendering engine, and the like.
  • This process can be a Node.js process.
  • the first thread is created.
  • the first thread creates a Web component object by calling a method of creating a new object provided by the Web engine, and starts the Web component object to create a second thread. Thereafter, the first thread can load the page in the browser window by calling the resource loading method provided by the object based on the web component object.
  • the first thread may be a Node.js thread
  • the second thread may be a Browser thread.
  • FIG. 5b exemplarily shows a resource loading process provided by an embodiment of the present application.
  • the web event request such as the user sends an HTML request through the browser to request to open a web page
  • the user's operation triggers generating a web event request
  • the resource loading process loads the requested web page, and the resource loading process may include acquisition of resources, rendering of the page, and the like.
  • the first thread sends a resource loading request to the second thread, and receives an indication returned by the second thread according to the resource loading request, and according to the indication, the resource pre-loaded based on the process in which the first thread is located, the resource
  • the resource requested to be loaded by the load request is loaded.
  • the second thread is mainly used to implement the management and control function to instruct the first thread to invoke the system module required by the resource loading process to implement the resource loading process; the resource acquisition and page rendering operations are performed by the first thread.
  • the first thread can perform the corresponding task by calling a preloaded module, such as a network module, a system module, or the like. It should be noted that each time the first thread obtains the web event request, the first thread can respond to the event request according to the preloaded module.
  • the indication sent by the second thread to the first thread may include control information about resource loading (such as a control instruction), or indication information of a resource that the resource loading operation needs to use (such as an API to be called), or resource loading.
  • Required system information may include one of the following control information to control a webpage loading operation of the first thread: start loading control information of the webpage, and stop loading control information of the webpage, Load the information on the previous or next page.
  • the indication sent by the second thread to the first thread may carry an API provided by the system module, so that the first thread may use the API to call a function of the related system module to implement, for example, adding and subtracting a volume, dynamically acquiring a device battery. Situation, real-time access to geographic location or device vibration.
  • the indication sent by the second thread to the first thread may also include system information (ie, the second thread passes the system information to the first thread), and the system information is available to the first thread, for example, the system information may include Media Access Control (MAC) address, device ID, user account information, and so on.
  • MAC Media Access Control
  • the web page loading process may include: the Node.js thread acquires the HTML document requested by the web event request based on the network module; parses the obtained HTML document, and converts the label in the HTML document into a document object model (Document Object Model) , DOM) DOM node in the tree, get the DOM tree structure; parse the Cascading Style Sheets (CSS) file, parse the obtained information and the instructions visible in the HTML document (such as ⁇ b> ⁇ /b>, etc.) Used to build a render tree (Render tree) consisting mainly of rectangles containing colors, widths and heights, which are displayed sequentially on the screen; the Node.js thread performs the layout process based on the Render tree. Each node traverses the Render tree on the corresponding coordinates on the screen and its overlay and reflow conditions, and draws each node using the UI backend layer.
  • a render tree consisting mainly of rectangles containing colors, widths and heights
  • the Node.js thread can execute the method using resources preloaded in Node.js.
  • the Node.js thread can load the requested resource by calling the method provided by the corresponding module based on the interface of the module in the JavaScript context of the web engine.
  • the interface in the JavaScript context of the Web engine can include the interface of the original module in Node.js, it can also include the interface of the module in the operating system layer and the interface of the user-defined module, thus integrating various capabilities into the Web. In the engine.
  • the Node.js thread may load the requested loaded web resource based on the JavaScript engine in Node.js initialized during the Node.js startup process without reinitializing the JavaScript. engine.
  • the Node.js thread may call the corresponding module according to an interface provided by the Web engine for the module for resource loading; the JavaScript engine preloaded by the Node.js process parses the module to obtain an operation invoked by the module.
  • the module interface in the system; the corresponding module in the operating system is called according to the module interface obtained by the parsing.
  • the event loop of the web engine is independent of the event loop of Node.js.
  • the web engine is preloaded into the dynamic language application running platform (such as Node.js), so the events of the web engine and the events of the platform may be cycled based on the event queue.
  • the event loop is in a wait state and blocks, and when an event occurs (such as when the web engine has an event), the event loops up.
  • the event loop can be awakened asynchronously, and the events of the web engine are stored in the event queue.
  • This event queue usually uses a first-in, first-out mechanism.
  • FIG. 6 exemplarily shows an event loop mechanism of an embodiment of the present application, taking Node.js as an example.
  • Node.js event requests and web event requests are stored in the event queue in the order in which they occur.
  • the web event request is involved in the event loop as a whole. For example, you can store web engine events as a subqueue.
  • the scheduling policy may also specify that if the sub-queue corresponding to the web engine is currently read, the response may be based on a preset processing capability (for example, a request to take out K event requests at a time, and the value of K may be Set), the corresponding number of event requests in the sub-queue are fetched, and the Handler of the web event request processes the fetched web event request, and returns to the event loop after responding to the event request.
  • a preset processing capability for example, a request to take out K event requests at a time, and the value of K may be Set
  • the Node.js process is preloaded with resources, and the pre-loaded resources of the Node.js process include a web engine.
  • the Node.js thread in the same Node.js process sends a resource load request to the browser thread, wherein the Node.js thread is a main thread, and the browser thread is a child thread; the Node.js thread receives the The browser thread is loaded according to the resource loading request, and the Node.js thread loads the resource requested by the resource loading request according to the resource preloaded by the Node.js process according to the indication, Thereby the integration of the web engine and Node.js is realized.
  • the embodiment of the present application can integrate the Web engine into the Node.js under the premise of ensuring the cross-platform application of the Web engine, so that it can access the capabilities provided by the Node.js, and provides the possibility of providing more flexible and rich applications.
  • the above embodiments of the present application are applicable to mobile terminals such as mobile phones, smart wearable devices, in-vehicle devices, personal digital assistants (PDAs), and the like.
  • the main thread of the Node.js can implement page rendering based on the Web engine, so that the page rendering operation can use the capability that the main thread of the Node.js can access.
  • the integration of Node.js and Web engine is realized.
  • the embodiment of the present application further provides a resource loading device, which can implement the resource loading process described in the foregoing embodiment.
  • FIG. 7 exemplarily shows a schematic structural diagram of a resource loading apparatus provided by an embodiment of the present application.
  • the apparatus may include: a first thread unit 701 and a second thread unit 702, the first thread unit 701 and the second thread unit 702 belong to the same process unit, and the first thread unit runs on a dynamic language application running platform.
  • the device may further include an event scheduling unit 703.
  • the first thread unit 701 is configured to: send a resource loading request to the second thread unit, receive an indication returned by the second thread unit 702 according to the resource loading request; and, according to the indication, preload based on the process unit And the resource loaded by the resource loading request is loaded; wherein the pre-loaded module of the process unit includes a web engine.
  • the event queue corresponding to the process includes a subqueue corresponding to the web engine, where the subqueue includes a web event request.
  • the event scheduling unit 703 is configured to: obtain an event request to be processed from the event queue, and if the sub-queue is obtained, obtain a web event request in the sub-queue in chronological order, and obtain the obtained Web An event request is sent to the first thread unit.
  • the first thread unit 701 is specifically configured to: after receiving the web event request, send a resource loading request to the second thread unit 702.
  • the event queue corresponding to the process further includes a dynamic language application running platform event request.
  • the event scheduling unit 703 is further configured to: after the web event request processing in the sub-queue is completed, return to the event queue, and obtain a dynamic language application running platform event request to be processed; or, the setting in the sub-queue After a certain number of web event request processing is completed, return to the event queue and obtain a dynamic language application runtime platform event request to be processed.
  • the process unit is specifically configured to: perform preloading of resources when starting, where the preloaded resources include the web engine, and a module provided by a dynamic language application running platform, a module provided by an operating system, One or more combinations of custom modules; wherein the modules are obtained by encapsulating code that implements a particular function.
  • the process unit is specifically configured to: perform preloading of resources when starting, where the preloaded resources include an interface including a module provided by a web engine in a dynamic language context, and an interface of the module preloaded by the process.
  • the module preloaded by the process includes: one of a module provided by a dynamic language application running platform, a module provided by an operating system, and a customized module.
  • the first thread unit 701 is specifically configured to: invoke, according to an interface provided by the web engine, a corresponding module, where the called module is used to load the requested loaded resource; and the dynamic language engine preloaded by the process
  • the module is parsed to obtain a module interface in the operating system called by the module; the corresponding module in the operating system is called according to the parsed module interface.
  • the first thread unit is specifically configured to: send a resource loading request to the second thread according to the web page access request, where the resource loading request is used to request loading the resource of the requested web page.
  • the first thread unit is a main thread unit in a process
  • the second thread unit is a child thread unit in a process.
  • the dynamic language application running platform is Node.js
  • the first thread unit is a Node.js thread unit
  • the second thread unit is a browser thread unit.
  • the embodiment of the present application further provides an apparatus 800, which can implement the process described in the foregoing embodiment.
  • FIG. 8 exemplarily illustrates an example apparatus 800 in accordance with various embodiments.
  • Apparatus 800 can include one or more processors 802, system control logic 801 coupled to at least one processor 802, non-volatile memory (NMV)/memory 804 coupled to system control logic 801, network interface 806 Coupled to system control logic 801.
  • NMV non-volatile memory
  • Processor 802 can include one or more single core processors or multi-core processors.
  • Processor 802 can include any general purpose processor or combination of special purpose processors (eg, image processors, application processor baseband processors, etc.).
  • System control logic 801 in one embodiment may include any suitable interface controller to provide any suitable interface to at least one of processors 802 and/or to any suitable communication in communication with system control logic 801. Any suitable interface to the device or component.
  • System control logic 801 in one embodiment may include one or more memory controllers to provide an interface to system memory 803.
  • System memory 803 is used to load and store data and/or instructions.
  • corresponding device 800 in one embodiment, system memory 803 can include any suitable volatile memory.
  • NVM/memory 804 can include one or more tangible, non-transitory computer readable media for storing data and/or instructions.
  • NVM/memory 804 can include any suitable non-volatile storage device, such as one or more hard disk devices (HDDs), one or more compact disks (CDs), and/or one or more Digital versatile disk (DVD).
  • HDDs hard disk devices
  • CDs compact disks
  • DVD Digital versatile disk
  • the NVM/memory 804 can include storage resources that are physically part of the device that the system is installed on or can be accessed, but is not necessarily part of the device.
  • NVM/memory 804 can be accessed by the network via network interface 806.
  • System memory 803 and NVM/memory 804 may each include a copy of temporary or persistent instructions 810.
  • the instructions 810 can include instructions that, when executed by at least one of the processors 802, cause the apparatus 800 to implement one or a combination of the methods described in Figures 5a, 5b.
  • instructions 810 or hardware, firmware, and/or software components may additionally/alternatively be placed in system control logic 801, network interface 806, and/or processor 802.
  • Network interface 806 can include a receiver to provide device 800 with a wireless interface to communicate with one or more networks and/or any suitable device.
  • Network interface 806 can include any suitable hardware and/or firmware.
  • Network interface 806 can include multiple antennas to provide a multiple input multiple output wireless interface.
  • network interface 806 can include a network adapter, a wireless network adapter, a telephone modem, and/or a wireless modem.
  • At least one of the processors 802 can be packaged with logic for one or more controllers of system control logic. In one embodiment, at least one of the processors may be packaged with logic for one or more controllers of system control logic to form a system level package. In one embodiment, at least one of the processors can be integrated on the same die as the logic of one or more controllers for system control logic. In one embodiment, at least one of the processors can be integrated on the same die as the logic of one or more controllers for system control logic to form a system chip.
  • Device 800 can further include input/output device 805.
  • Input/output device 805 can include a user interface intended to enable a user to interact with device 800, can include a peripheral component interface designed to enable peripheral components to interact with the system, and/or can include sensors for determining environmental conditions And/or location information about the device 800.

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)
  • Multimedia (AREA)
  • Data Mining & Analysis (AREA)
  • Stored Programmes (AREA)
  • Information Transfer Between Computers (AREA)

Abstract

本申请公开了一种资源加载方法及装置，应用于计算机技术领域。本申请中，第一线程向第二线程发送资源加载请求，其中，所述第一线程和所述第二线程位于同一进程，所述第一线程运行于动态语言应用运行平台；所述第一线程接收所述第二线程根据所述资源加载请求返回的指示；所述第一线程根据所述指示，基于所述进程预加载的资源，对所述资源加载请求所请求加载的资源进行加载，其中，所述进程预加载的模块中包括Web引擎。采用本申请可实现Web引擎与Node.js的融合。

Description

一种资源加载方法及装置
本申请要求2017年03月08日递交的申请号为201710137173.1、发明名称为“一种资源加载方法及装置”的中国专利申请的优先权，其全部内容通过引用结合在本申请中。
技术领域
本申请涉及计算机技术领域，尤其涉及一种资源加载方法及装置。
背景技术
随着移动互联网的快速发展与HTML5(HTML是HyperText Markup Language的英文缩写，即超文本标记语言)技术的逐步成熟，万维网(Web)应用已经成为移动端跨平台应用开发的热门解决方案。
Web应用通过浏览器获取和显示Web资源，以页面形式显示Web资源。浏览器的功能可通过Web引擎实现。Web引擎包含了各种组件，比如用于实现页面渲染的渲染引擎、用于进行管理和控制的浏览器引擎等。
Node.js是JavaScript运行环境(runtime)，也称运行平台，提供了多种***级的应用程序编程接口(Application Programming Interface，API)，用于方便地搭建响应速度快、易于扩展的网络应用。
发明内容
本申请实施例提供一种资源加载方法及装置。
本申请实施例提供了一种资源加载方法，包括：
第一线程向第二线程发送资源加载请求；其中，所述第一线程和所述第二线程位于同一进程，所述第一线程运行于动态语言应用运行平台；
所述第一线程接收所述第二线程根据所述资源加载请求返回的指示；
所述第一线程根据所述指示，基于所述进程预加载的资源，对所述资源加载请求所请求加载的资源进行加载，其中，所述进程预加载的资源中包括Web引擎。
本申请实施例提供的一种资源加载装置，包括：第一线程单元和第二线程单元；
所述第一线程单元，用于：
向所述第二线程单元发送资源加载请求；其中，所述第一线程单元和所述第二线程单元属于同一进程单元，所述第一线程单元运行于动态语言应用运行平台；
接收所述第二线程单元根据所述资源加载请求返回的指示；以及，
根据所述指示，基于所述进程单元预加载的资源，对所述资源加载请求所请求加载的资源进行加载；其中，所述进程单元预加载的模块中包括Web引擎。
本申请实施例提供的一个或多个计算机可读介质，所述可读介质上存储有指令，所述指令被一个或多个处理器执行时，使得通信设备执行上述方法。
本申请实施例提供的一种通信设备，包括：一个或多个处理器；以及，一个或多个计算机可读介质，所述可读介质上存储有指令，所述指令被所述一个或多个处理器执行时，使得所述装置执行上述方法。
本申请的上述实施例中，应用程序的进程预加载有资源，其中，所述进程预加载的资源中包括Web引擎。同一进程中的第一线程向第二线程发送资源加载请求，所述第一线程运行于动态语言应用运行平台；所述第一线程接收所述第二线程根据所述资源加载请求返回的指示；所述第一线程根据所述指示，基于所述进程预加载的模块和/或资源，对所述资源加载请求所请求加载的资源进行加载，从而实现了Web引擎与所述动态语言应用运行平台的融合。
附图说明
本申请的实施例通过示例而非限制的方式示出在所附附图中，类似的附图标记表示类似的元素。
图1根据一些实施例示例性地示出了基于Node.js的云操作***架构100；
图2根据一些实施例示例性地示出了预加载有Web引擎的Node.js的示意图；
图3根据一些实施例示例性地示出了Web引擎的API映射关系示意图；
图4根据一些实施例示例性地示出了预加载Web引擎后Node.js线程和Browser线程及相关资源的示意图；
图5a根据一些实施例示例性地示出了预加载流程示意图；
图5b根据一些实施例示例性地示出了Web资源加载流程示意图；
图6根据一些实施例示例性地示出了事件循环机制示意图；
图7根据一些实施例示例性地示出了资源加载装置的结构示意图；
图8根据一些实施例示例性地示出了一种装置示意图。
具体实施方式
虽然本申请的概念易于进行各种修改和替代形式，但是其具体实施例已经通过附图中的示例示出并且将在本文中详细描述。然而，应当理解，没有意图将本申请的概念限制为所公开的特定形式，而是相反，意图是覆盖与本申请以及所附权利要求一致的所有修改、等同物和替代物。
说明书中对“一个实施例”、“实施例”、“说明性实施例”等的引用，指示所描述的实施例可包括特定特征、结构或特性，但是每个实施例可以或可以不必包括特定特征、结构或特性。此外，这样的短语不一定指的是相同的实施例。进一步地，认为在本领域技术人员的知识范围内，当结合实施例描述特定特征、结构或特性时，结合无论是否明确描述的其它实施例影响这样的特征，结构或特性。另外，应当理解，以“A，B和C中的至少一个”的形式包括在列表中的项目可以表示(A)；(B)；(C)；(A和B)；(A和C)；(B和C)；或(A，B和C)。类似地，以“A，B或C中的至少一个”的形式列出的项目可以表示(A)；(B)；(C)；(A和B)；(A和C)；(B和C)或(A，B和C)。
在一些情况下，所公开的实施例可以在硬件、固件、软件或其任何组合中实现。所公开的实施例还可以被实现为由一个或多个暂时性或非暂时性机器可读(例如，计算机可读)存储介质携带或存储的指令，其可以由一个或多个处理器读取和执行。机器可读存储介质可以体现为用于以机器可读形式(例如，易失性或非易失性存储器、介质盘或其他介质)存储或传输信息的任何存储设备，机制或其他物理结构的设备)。
在附图中，一些结构或方法特征可以以特定布置和/或顺序示出。然而，应当理解，可能不需要这样的具体布置和/或排序。相反，在一些实施例中，这些特征可以以与说明性附图中所示不同的方式和/或顺序来布置。另外，在特定图中包括结构或方法特征并不意味着暗示这种特征在所有实施例中都是需要的，并且在一些实施例中可以不包括或可以与其他特征组合。
操作***用于向用户应用提供操作***的基础能力，可基于动态语言应用运行平台实现，从而为动态语言应用提供运行环境。其中，Node.js即为JavaScript的运行环境或运行平台。
其中，动态语言是计算机编程语言中的一个语言类别，是一类在运行时可以动态地改变类型、结构的语言，在运行时函数和属性可以被增加、修改和删除。例如JavaScript、Python、Ruby等都属于动态语言。动态语言不需要编译即可运行，在运行时需要运行环境的支撑，这个环境叫做运行时环境，它包含动态语言运行所需要的所有要素，例如Java 虚拟机、JavaScript引擎等。
以云操作***(云OS)中的Host***为例，它可基于Node.js实现。Node.js是JavaScript的运行环境，是建立在Chrome上的JavaScript引擎的Web应用程序框架，也就是说，操作***基于Node.js向用户应用提供操作***的基础能力。Node.js中包括多种模块，这些模块可通过将用于实现特定功能的代码(比如实现操作***级服务功能的代码)进行封装得到，比如可封装为组件形式，例如这些模块中可包括实现全球定位***(Global Positioning System，简称GPS)定位功能的组件、实现电源管理功能的组件等。这些模块的接口被暴露给应用层，应用层中的应用程序(比如Web应用)可通过调用这些模块的接口，通过JavaScript引擎解析模块中的代码，执行这些模块提供的方法，从而实现这些模块提供的功能。
对于Web应用来说，Web资源的加载(比如Web页面的获取、渲染等操作)由浏览器实现，浏览器则基于Web引擎(web engine)实现Web资源加载。目前，传统的HTML5浏览器，其Web引擎中的线程包括两种类型：Browser线程(浏览器线程)和Render线程(渲染线程)。其中，Browser线程为主线程，可为各个Web页面的渲染提供服务和管理能力；Render线程为子线程，可基于Web引擎进行页面渲染以及执行JavaScript代码。Browser线程可创建一个或多个Render线程。比如，在加载一个Web页面的过程中，Browser线程创建一个Render线程，由该Render线程对该Web页面进行渲染。如果需要加载多个Web页面，则Browser线程创建多个Render线程，每个Render线程对一个Web页面进行渲染。
图1示例性地示出了一种操作***架构100。架构100包括应用层10、应用框架层20和操作***层30。应用层10中包括一个或多个应用，其中可包括浏览器。程序框架层20包括动态语言应用运行平台(比如Node.js)。操作***层30主要用于提供操作***级别的代码库以及基本的***服务，比如提供的***服务可包括设备驱动服务、事件管理服务等。
浏览器中的Web引擎处于应用层，不具备使用Node.js提供的***服务的能力。如果需要使Web引擎中的渲染(Render)线程能够使用Node.js提供的能力，则需要在Render线程启动过程中启动Node.js。考虑到每加载一个Web页面就会启动一个Render线程，也就需要启动一次Node.js，因此导致加载Web页面的资源开销和时间开销较大。
如何将Web引擎与Node.js融合，将Web引擎作为***服务的一部分，使基于HTML请求的web页面访问处理过程能够使用***提供的各种能力，是目前业界面临的问题。
本申请实施例基于上述架构，使Web引擎可以访问到Node.js提供的能力，进一步地与上述方式相比还可以减少资源开销和时间开销。下面结合附图对本申请实施例进行详细描述。
本申请实施例中，动态语言应用运行平台启动时可预加载各种资源，其中包括Web引擎。
以动态语言应用运行平台为Node.js为例，Node.js启动过程中，Node.js进程被创建。Node.js进程预加载各种能力，这里所说的“能力”也可称为资源，可包括前述所描述的用于实现特定功能的模块(比如组件)，还可以包括一些配置信息等，比如上下文、事件队列等。Node.js所预加载的能力中至少包括Web引擎(比如Android***中的Webview组件(即web视图组件))，进一步还可包括Node.js提供的能力。其中，Node.js提供的能力可包括：Node.js中的模块(比如用于提供特定功能或服务的组件)和/或JavaScript运行环境相关信息。Node.js中的模块可通过对用于实现特定功能的JavaScript代码封装得到。每个模块均具有接口(比如API)，可提供给应用层供应用程序调用。JavaScript运行环境相关信息可包括但不限于JavaScript引擎的上下文、事件循环相关配置中的一种或多种。其中，上下文用于描述引擎内部的各种对象、状态和功能。JavaScript引擎的上下文中可包括由Node.js进程所预加载的模块的接口(如API)。事件循环相关配置具体可包括Node.js的事件队列的配置，比如事件队列所在的内存区域位置、队列大小等，以便向该事件队列中存取Node.js事件请求和Web事件请求。
在一些实施例中，可将预加载的能力(比如Web引擎)封装为动态语言应用运行平台中的标准模块，作为该平台的一个标准模块预加载到该平台中。图2以该平台为Node.js为例，示例性地示出了预加载有Web引擎的Node.js的示意图。
在一些实施例中，Web引擎由c/c++语言编写，而Node.js支持JavaScript语言，因此需要将Web引擎的符合c/c++标准的API映射为Node.js中符合JavaScript标准的API，并将映射得到的符合JavaScript标准的API提供给应用层，Node.js中保存该API的映射关系。图3示例性地示出了Web引擎的API映射关系示意图。其中，Web引擎中可包括多种组件，比如Window system组件(窗口***组件)、UI Elements组件(用户界面部件组件)、Layout组件(布局组件)、Event Handling组件(事件处理组件)等，这些符合c/c++标准的组件的API被一一映射为对应的符合JavaScript标准的API。
在一些实施例中，进一步地，预加载的能力还可包括但不限于以下中的一种或多种组合：
Figure PCTCN2018077220-appb-000001
操作***提供的能力
操作***提供的能力可包括：操作***层提供的***服务等。操作***层中可包括用于提供***服务的模块，这些模块可由用于实现特定能力的代码封装得到。每个模块均具有接口(比如API)。本申请实施例中，可通过将操作***层中的模块的API添加到动态语言引擎(比如JavaScript引擎)的上下文中，实现对操作***能力的预加载。
Figure PCTCN2018077220-appb-000002
用户自定义的能力
用户自定义的能力，即用户自定义的用于实现特定功能的代码，可被封装为模块，每个模块均具有接口(如API)。本申请实施例中，可通过将用户自定义的模块的API添加到动态语言引擎(比如JavaScript引擎)的上下文中，实现对用户自定义能力的预加载。
在一些实施例中，Node.js中的JavaScript上下文中的模块接口(比如API)被添加到Web引擎的JavaScript上下文中，这样，对于应用程序的开发者来说，可利用Web引擎的JavaScript上下文中包含的API进行应用程序开发，当该应用程序运行时，Node.js线程可通过这些接口调用相应的模块实现相应的功能，即访问这些接口对应的能力。由于Node.js的上行文中的模块接口可包括Node.js中的模块接口，还可包括操作***提供的模块接口以及用户自定义的模块的接口，从而使得Node.js线程能够访问的能力更加丰富。Node.js的JavaScript上下文中包含有Web引擎的JavaScript上下文中的模块接口也可被添加到Node.js的JavaScript上下文中。
Node.js进程中的主线程称为Node.js线程，它可以共享Node.js进程的运行环境以及Node.js进程预加载的能力。也就是说，Node.js线程可以访问Node.js进程所预加载的各种能力。由于Node.js进程预加载了Web引擎，因此，Node.js线程可以基于Web引擎实现Web引擎所提供的功能，比如页面渲染功能。
图4示例性地示出了预加载Web引擎后Node.js线程和浏览器线程(Browser线程)及相关资源的示意图。如图所示，应用进程中包括Node.js线程和Brower线程，Node.js线程和Browser线程之间可以通信。Node.js线程基于Node.js的事件循环机制进行事件的处理。Node.js线程可基于Web引擎实现Web资源加载的操作。作为一个例子，Node.js线程可通过调用Web引擎提供的页面加载方法，实现页面加载。在页面加载方法的执行过程中，Node.js线程可基于Web引擎中的JavaScript上下文中的API，调用相应的模块(组件)。JavaScript引擎对被调用的模块进行解析，获得操作***层提供给JavaScript引擎的接口，并基于该接口调用操作***层提供的能力(比如图中的设备能力、网络服 务、电源管理等)，以实现页面加载操作。对于图4中所示的应用进程来说，其中的Node.js线程为主线程，Browser线程为子线程，即Browser线程可由Node.js线程创建得到，它们之间可基于线程间通信机制进行通信。该应用进程与其他进程(比如图中位于操作***层的网络服务模块对应的进程)之间基于进程间通信(Inter-Process Communication，IPC)机制进行通信。
比如，Node.js线程可调用图4中的模块1(网络模块)以执行页面获取方法，在该方法的执行过程中，可基于操作***层提供的接口调用操作***层提供的网络服务，以获取所请求的页面。再比如，Node.js线程可调用图4中的模块2(能力获取模块)以执行设备能力(比如显示屏幕大小等设备信息)的获取方法以及根据该设备能力确定显示模式，在该方法的执行过程中，可基于操作***层提供的接口调用操作***层提供的设备能力，以获取设备能力信息。
图5a示例性地示出了本申请实施例提供的预加载流程。如图所示，在S510中，进程启动(比如接收到在浏览器窗口中打开一个页面的事件后启动一个Node.js进程)。在S511～S514中，该进程执行初始化过程，在该过程中，该进程预加载网络模块、***模块、渲染引擎等模块，具体预加载过程可参见前述实施例的描述。该进程可以是Node.js进程。
进一步地，在S511～S514中，第一线程被创建。第一线程通过调用Web引擎提供的新建对象的方法创建Web组件对象，并启动该Web组件对象，创建第二线程。此后第一线程即可基于该Web组件对象，通过调用该对象提供的资源加载方法，在浏览器窗口中加载页面。其中，第一线程可以是Node.js线程，第二线程可以是Browser线程。
图5b示例性地示出了本申请实施例提供的资源加载流程。如图所示，在S520～S523中，当第一线程获得Web事件请求后(比如用户通过浏览器发送HTML请求，以请求打开一个web页面，则用户的上述操作触发生成web事件请求)，执行资源加载过程，以加载所请求的web页面，该资源加载过程可包括资源的获取以及页面的渲染等。在该资源加载过程中，第一线程向第二线程发送资源加载请求，接收第二线程根据该资源加载请求返回的指示，根据该指示，基于第一线程所在的进程预加载的资源，对资源加载请求所请求加载的资源进行加载。该过程中，第二线程主要用于实现管理和控制功能可指示第一线程调用资源加载过程所需的***模块，以实现该资源加载过程；资源获取以及页面渲染等操作由第一线程执行。第一线程可通过调用预加载的模块，比如网络模块、***模块等，执行相应的任务。需要说明的是，第一线程每次获得Web事件请求后，可 根据预加载的模块对该事件请求进行响应。
上述过程中，第二线程向第一线程发送的指示可包括有关资源加载的控制信息(比如控制指令)，或者资源加载操作需要使用的资源的指示信息(比如需要调用的API)，或者资源加载所需的***信息。作为一个例子，第二线程可以向第一线程发送的指示中可包括以下控制信息中的一种，以控制第一线程的网页加载操作：开始加载网页的控制信息、停止加载网页的控制信息，加载上一页或下一页的信息。作为另一个例子，第二线程向第一线程发送的指示中可携带***模块提供的API，使得第一线程可以利用该API调用相关***模块的函数，以实现诸如加减音量、动态获取设备电池情况、实时获取地理位置或设备震动等功能。再例如，第二线程向第一线程发送的指示也可以包括***信息(即第第二线程将***信息传递给第一线程)，该***信息可供第一线程使用，比如该***信息可包括设备的媒体接入控制(Media Access Control，MAC)地址、设备标识，用户账户信息等。
作为一个例子，web页面加载过程可包括：Node.js线程基于网络模块获取Web事件请求所请求的HTML文档；解析获得到的HTML文档，将HTML文档中的标签转换为文档对象模型(Document Object Model，DOM)树中的DOM节点，得到DOM树结构；解析层叠样式表(Cascading Style Sheets，简称CSS)文件，解析得到的信息与HTML文档中可见的指令(如<b></b>等)被用来构建渲染树(Render树)，这棵树主要由一些包含颜色和宽高等属性组成的矩形组成，它们将依次按顺序显示在屏幕上；Node.js线程根据Render树执行布局过程，确定每个节点在屏幕上对应的坐标及其覆盖和回流情况等，遍历该Render树，使用UI后端层绘制每个节点。
在一些实施例中，在S521中，Node.js线程可使用Node.js中预加载的资源执行该方法。比如，Node.js线程可基于Web引擎的JavaScript上下文中模块的接口，通过调用对应模块提供的方法，加载所请求的资源。由于Web引擎的JavaScript上下文中的接口，可包括Node.js中原有的模块的接口，还可包括操作***层中的模块的接口以及用户自定义的模块的接口，从而将各种能力融合在Web引擎中。
在另一些实施例中，在S521中，Node.js线程可基于在Node.js启动过程中初始化的Node.js中的JavaScript引擎，对所请求加载的Web资源进行加载，而无需再次初始化该JavaScript引擎。具体地，Node.js线程可根据Web引擎提供的用于资源加载的模块的接口，调用相应的模块；通过Node.js进程预加载的JavaScript引擎对该模块进行解析，得到该模块所调用的操作***中的模块接口；根据解析得到的模块接口调用操作***中的 相应模块。
Node.js和Web引擎均采用事件循环(Event loop)机制。现有技术中，Web引擎的事件循环与Node.js的事件循环彼此独立。本申请实施例中，Web引擎被预加载到动态语言应用运行平台(如Node.js)中，因此Web引擎的事件与该平台的事件可基于事件队列进行事件循环。在没有事件发生的情况下，事件循环处于等待状态并阻塞，当有事件发生时(比如Web引擎有事件发生时)，会将事件循环唤醒。比如，当Web引擎有事件发生时，可通过异步方式唤醒事件循环，该Web引擎的事件被存储于事件队列。该事件队列通常采用先进先出的机制。
图6以Node.js为例，示例性地示出了本申请实施例的事件循环机制。如图所示，Node.js事件请求和Web事件请求按照发生的先后顺序被存储在事件队列中。在本申请实施例中，将Web事件请求作为一个整体参与事件循环。比如可以将Web引擎事件存储为一个子队列。Node.js线程从事件队列中读取事件进行响应时，如果当前读取到的是该子队列，根据调度策略的规定，将该子队列中的全部事件请求取出，Web引擎事件关联的处理程序(Handler)会处理该子队列中的所有事件请求，在全部响应完成后，返回到事件循环，从事件队列继续读取其他的事件请求进行响应，实现了将Web引擎中的事件处理融入到了Node的事件循环中。在另外的例子中，调度策略也可以规定：如果当前读取到的是Web引擎对应的子队列，则根据预设的处理能力(比如规定一次取出K个事件请求进行响应，K的取值可设置)，将该子队列中的相应数量的事件请求取出，Web事件请求的处理程序(Handler)会处理所取出的Web事件请求，在响应这些事件请求后，返回到事件循环。
通过以上描述可以看出，本申请的上述实施例中，Node.js进程预加载有资源，其中，所述Node.js进程预加载的资源中包括Web引擎。同一Node.js进程中的Node.js线程向浏览器线程发送资源加载请求，其中，所述Node.js线程为主线程，所述浏览器线程为子线程；所述Node.js线程接收所述浏览器线程根据所述资源加载请求返回的指示；所述Node.js线程根据所述指示，基于所述Node.js进程预加载的资源，对所述资源加载请求所请求加载的资源进行加载，从而实现了Web引擎与Node.js的融合。
由于Web引擎的通用性，因此具有较好的跨平台能力。本申请实施例可在保证Web引擎跨平台应用的前提下，将其融入Node.js，使其能够访问Node.js提供的能力，为提供功能更加灵活和丰富的应用提供了可能性。
本申请的上述实施例可应用于移动终端，比如手机、智能穿戴设备、车载设备、个 人数字助理(Personal Digital Assistant，PDA)等。以应用于基于云操作***的手机为例，采用本申请实施例，可由Node.js的主线程基于Web引擎实现页面渲染，从而使得页面渲染操作可使用Node.js主线程所能访问的能力，实现了Node.js与Web引擎的融合。
基于相同的技术构思，本申请实施例还提供了一种资源加载装置，可实现前述实施例描述的资源加载流程。
图7示例性地示出了本申请实施例提供的资源加载装置的结构示意图。该装置可包括：第一线程单元701和第二线程单元702，第一线程单元701和所述第二线程单元702属于同一进程单元，所述第一线程单元运行于动态语言应用运行平台。进一步地，还装置还可包括事件调度单元703。
第一线程单元701用于：向所述第二线程单元发送资源加载请求，接收第二线程单元702根据所述资源加载请求返回的指示；以及，根据所述指示，基于所述进程单元预加载的资源，对所述资源加载请求所请求加载的资源进行加载；其中，所述进程单元预加载的模块中包括Web引擎。
可选地，所述进程对应的事件队列中包括所述Web引擎对应的子队列，所述子队列中包括Web事件请求。事件调度单元703用于：从所述事件队列中获取待处理的事件请求，若获取到所述子队列，则按照时间先后顺序获取所述子队列中的Web事件请求，并将获取到的Web事件请求发送给所述第一线程单元。第一线程单元701具体用于：接收到Web事件请求后向所述第二线程单元702发送资源加载请求。
可选地，所述进程对应的事件队列中还包括动态语言应用运行平台事件请求。事件调度单元703还用于：所述子队列中的Web事件请求处理完成后，返回到所述事件队列，并获取待处理的动态语言应用运行平台事件请求；或者，所述子队列中的设定数量的Web事件请求处理完成后，返回到所述事件队列，并获取待处理的动态语言应用运行平台事件请求。
可选地，所述进程单元具体用于：启动时进行资源的预加载，所预加载的资源中包括所述Web引擎，以及包括动态语言应用运行平台所提供的模块、操作***提供的模块、自定义的模块中的一种或多种组合；其中，所述模块通过对实现特定功能的代码进行封装得到。
可选地，所述进程单元具体用于：启动时进行资源的预加载，所预加载的资源中包括动态语言上下文中包括Web引擎提供的模块的接口，以及所述进程预加载的模块的接口，所述进程预加载的模块包括：动态语言应用运行平台所提供的模块、操作***提供 的模块、自定义的模块中的一种或多种组合。
可选地，第一线程单元701具体用于：根据所述Web引擎提供的接口，调用相应的模块，被调用的模块用于加载所请求加载的资源；通过所述进程预加载的动态语言引擎对该模块进行解析，得到该模块所调用的操作***中的模块接口；根据解析得到的模块接口调用操作***中的相应模块。
可选地，所述第一线程单元具体用于：根据web页面访问请求，向第二线程发送资源加载请求，所述资源加载请求用于请求加载所请求的web页面的资源。
可选地，所述第一线程单元为所在进程中的主线程单元，所述第二线程单元为所在进程中的子线程单元。
可选地，所述动态语言应用运行平台为Node.js，所述第一线程单元为Node.js线程单元，所述第二线程单元为浏览器线程单元。
基于相同的技术构思，本申请实施例还提供了一种装置800，该装置800可实现前述实施例描述的流程。
图8示例性地示出了根据各种实施例的示例装置800。装置800可包括一个或多个处理器802，***控制逻辑801耦合于至少一个处理器802，非易失性存储器(non-volatile memory，NMV)/存储器804耦合于***控制逻辑801，网络接口806耦合于***控制逻辑801。
处理器802可包括一个或多个单核处理器或多核处理器。处理器802可包括任何一般用途处理器或专用处理器(如图像处理器、应用处理器基带处理器等)的组合。
一个实施例中的***控制逻辑801，可包括任何适当的接口控制器，以提供到处理器802中的至少一个的任何合适的接口，和/或提供到与***控制逻辑801通信的任何合适的设备或组件的任何合适的接口。
一个实施例中的***控制逻辑801，可包括一个或多个内存控制器，以提供到***内存803的接口。***内存803用来加载以及存储数据和/或指令。例如，对应装置800，在一个实施例中，***内存803可包括任何合适的易失性存储器。
NVM/存储器804可包括一个或多个有形的非暂时的计算机可读介质，用于存储数据和/或指令。例如，NVM/存储器804可包括任何合适的非易失性存储装置，如一个或多个硬盘(hard disk device，HDD)，一个或多个光盘(compact disk，CD)，和/或一个或多个数字通用盘(digital versatile disk，DVD)。
NVM/存储器804可包括存储资源，该存储资源物理上是该***所安装的或者可以被 访问的设备的一部分，但不一定是设备的一部分。例如，NVM/存储器804可经由网络接口806被网络访问。
***内存803以及NVM/存储器804可分别包括临时的或持久的指令810的副本。指令810可包括当由处理器802中的至少一个执行时导致装置800实现图5a、图5b描述的方法之一或组合的指令。各实施例中，指令810或硬件、固件，和/或软件组件可另外地/可替换地被置于***控制逻辑801，网络接口806和/或处理器802。
网络接口806可包括一个接收器来为装置800提供无线接口来与一个或多个网络和/或任何合适的设备进行通信。网络接口806可包括任何合适的硬件和/或固件。网络接口806可包括多个天线来提供多输入多输出无线接口。在一个实施例中，网络接口806可包括一个网络适配器、一个无线网络适配器、一个电话调制解调器，和/或无线调制解调器。
在一个实施例中，处理器802中的至少一个可以与用于***控制逻辑的一个或多个控制器的逻辑一起封装。在一个实施例中，处理器中的至少一个可以与用于***控制逻辑的一个或多个控制器的逻辑一起封装以形成***级封装。在一个实施例中，处理器中的至少一个可以与用于***控制逻辑的一个或多个控制器的逻辑集成在相同的管芯上。在一个实施例中，处理器中的至少一个可以与用于***控制逻辑的一个或多个控制器的逻辑集成在相同的管芯上以形成***芯片。
装置800可进一步包括输入/输出装置805。输入/输出装置805可包括用户接口旨在使用户与装置800进行交互，可包括***组件接口，其被设计为使得***组件能够与***交互，和/或，可包括传感器，旨在确定环境条件和/或有关装置800的位置信息。

Claims (18)

  1. 一种资源加载方法，其特征在于，包括：
    第一线程向第二线程发送资源加载请求；其中，所述第一线程和所述第二线程位于同一进程，所述第一线程运行于动态语言应用运行平台；
    所述第一线程接收所述第二线程根据所述资源加载请求返回的指示；
    所述第一线程根据所述指示，基于所述进程预加载的资源，对所述资源加载请求所请求加载的资源进行加载，其中，所述进程预加载的资源中包括Web引擎。
  2. 如权利要求1所述的方法，其特征在于，所述进程对应的事件队列中包括所述Web引擎对应的子队列，所述子队列中包括Web事件请求；
    所述第一线程向所述第二线程发送资源加载请求，包括：
    所述第一线程从所述事件队列中获取待处理的事件请求；
    若获取到所述子队列，则按照时间先后顺序获取所述子队列中的Web事件请求，并在获取到Web事件请求后向所述第二线程发送资源加载请求。
  3. 如权利要求2所述的方法，其特征在于，所述进程对应的事件队列中还包括动态语言应用运行平台事件请求；
    所述方法还包括：
    所述子队列中的Web事件请求处理完成后，返回到所述事件队列，并获取待处理的动态语言应用运行平台事件请求；或者，
    所述子队列中的设定数量的Web事件请求处理完成后，返回到所述事件队列，并获取待处理的动态语言应用运行平台事件请求。
  4. 如权利要求1所述的方法，其特征在于，还包括：
    所述进程启动时进行资源的预加载，所预加载的资源中包括所述Web引擎，以及包括动态语言应用运行平台所提供的模块、操作***提供的模块、自定义的模块中的一种或多种组合；其中，所述模块通过对实现特定功能的代码进行封装得到。
  5. 如权利要求1所述的方法，其特征在于，所述对所述资源加载请求所请求加载的资源进行加载，包括：
    根据所述Web引擎提供的接口调用相应的模块，被调用的模块用于加载所请求加载的资源；
    通过所述进程预加载的动态语言引擎对该模块进行解析，得到该模块所调用的操作***中的模块接口；
    根据解析得到的模块接口调用操作***中的相应模块。
  6. 如权利要求1至5任一项所述的方法，其特征在于，所述第一线程向第二线程发送资源加载请求，包括：
    所述第一线程根据web页面访问请求，向第二线程发送资源加载请求，所述资源加载请求用于请求加载所请求的web页面的资源。
  7. 如权利要求1至5中任一项所述的方法，其特征在于，所述第一线程为所在进程中的主线程，所述第二线程为所在进程中的子线程。
  8. 如权利要求1至5中任一项所述的方法，其特征在于，所述动态语言应用运行平台为Node.js，所述第一线程为Node.js线程，所述第二线程为浏览器线程。
  9. 一种资源加载装置，其特征在于，包括：第一线程单元和第二线程单元；
    所述第一线程单元，用于：
    向所述第二线程单元发送资源加载请求；其中，所述第一线程单元和所述第二线程单元属于同一进程单元，所述第一线程单元运行于动态语言应用运行平台；
    接收所述第二线程单元根据所述资源加载请求返回的指示；以及，
    根据所述指示，基于所述进程单元预加载的资源，对所述资源加载请求所请求加载的资源进行加载；其中，所述进程单元预加载的模块中包括Web引擎。
  10. 如权利要求9所述的装置，其特征在于，所述进程对应的事件队列中包括所述Web引擎对应的子队列，所述子队列中包括Web事件请求；
    还包括：事件调度单元，所述事件调度单元用于：
    从所述事件队列中获取待处理的事件请求；
    若获取到所述子队列，则按照时间先后顺序获取所述子队列中的Web事件请求，并将获取到的Web事件请求发送给所述第一线程单元；
    所述第一线程单元具体用于：接收到Web事件请求后向所述第二线程单元发送资源加载请求。
  11. 如权利要求10所述的装置，其特征在于，所述进程对应的事件队列中还包括动态语言应用运行平台事件请求；
    所述事件调度单元还用于：
    所述子队列中的Web事件请求处理完成后，返回到所述事件队列，并获取待处理的动态语言应用运行平台事件请求；或者，
    所述子队列中的设定数量的Web事件请求处理完成后，返回到所述事件队列，并 获取待处理的动态语言应用运行平台事件请求。
  12. 如权利要求9所述的装置，其特征在于，所述进程单元具体用于：
    启动时进行资源的预加载，所预加载的资源中包括所述Web引擎，以及包括动态语言应用运行平台所提供的模块、操作***提供的模块、自定义的模块中的一种或多种组合；其中，所述模块通过对实现特定功能的代码进行封装得到。
  13. 如权利要求9所述的装置，其特征在于，所述第一线程单元具体用于：
    根据所述Web引擎提供的接口调用相应的模块，被调用的模块用于加载所请求加载的资源；
    通过所述进程预加载的动态语言引擎对该模块进行解析，得到该模块所调用的操作***中的模块接口；
    根据解析得到的模块接口调用操作***中的相应模块。
  14. 如权利要求9至13任一项所述的装置，其特征在于，所述第一线程单元具体用于：根据web页面访问请求，向第二线程发送资源加载请求，所述资源加载请求用于请求加载所请求的web页面的资源。
  15. 如权利要求9至13中任一项所述的装置，其特征在于，所述第一线程单元为所在进程中的主线程单元，所述第二线程单元为所在进程中的子线程单元。
  16. 如权利要求9至13中任一项所述的装置，其特征在于，所述动态语言应用运行平台为Node.js，所述第一线程单元为Node.js线程单元，所述第二线程单元为浏览器线程单元。
  17. 一个或多个计算机可读介质，所述可读介质上存储有指令，所述指令被一个或多个处理器执行时，使得通信设备执行如权利要求1至8中任一项所述的方法。
  18. 一种通信设备，其特征在于，包括：
    一个或多个处理器；以及
    一个或多个计算机可读介质，所述可读介质上存储有指令，所述指令被所述一个或多个处理器执行时，使得所述设备执行如权利要求1至8中任一项所述的方法。
PCT/CN2018/077220 2017-03-08 2018-02-26 一种资源加载方法及装置 WO2018161813A1 (zh)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US16/557,792 US11210109B2 (en) 2017-03-08 2019-08-30 Method and system for loading resources

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
CN201710137173.1A CN108572965B (zh) 2017-03-08 2017-03-08 一种资源加载方法及装置
CN201710137173.1 2017-03-08

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US16/557,792 Continuation-In-Part US11210109B2 (en) 2017-03-08 2019-08-30 Method and system for loading resources

Publications (1)

Publication Number Publication Date
WO2018161813A1 true WO2018161813A1 (zh) 2018-09-13

Family

ID=63448060

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/CN2018/077220 WO2018161813A1 (zh) 2017-03-08 2018-02-26 一种资源加载方法及装置

Country Status (4)

Country Link
US (1) US11210109B2 (zh)
CN (1) CN108572965B (zh)
TW (1) TW201833768A (zh)
WO (1) WO2018161813A1 (zh)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN111159615A (zh) * 2019-12-31 2020-05-15 北大方正集团有限公司 网页处理方法和装置
CN111756831A (zh) * 2020-06-22 2020-10-09 北京达佳互联信息技术有限公司 服务器预加载方法、装置、服务器及存储介质

Families Citing this family (14)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN108614722B (zh) 2018-05-10 2020-09-08 上海瑾盛通信科技有限公司 应用程序预加载方法、装置、存储介质及终端
CN108595228B (zh) 2018-05-10 2021-03-12 Oppo广东移动通信有限公司 应用程序预测模型建立方法、装置、存储介质及移动终端
CN108595227A (zh) 2018-05-10 2018-09-28 Oppo广东移动通信有限公司 应用程序预加载方法、装置、存储介质及移动终端
CN108710513B (zh) 2018-05-15 2020-07-21 Oppo广东移动通信有限公司 应用程序启动方法、装置、存储介质及终端
CN108762843B (zh) * 2018-05-29 2020-05-05 Oppo广东移动通信有限公司 应用程序的预加载方法、装置、存储介质及智能终端
CN108804157A (zh) 2018-06-05 2018-11-13 Oppo广东移动通信有限公司 应用程序预加载方法、装置、存储介质及终端
US20200186623A1 (en) * 2018-12-11 2020-06-11 Microsoft Technology Licensing, Llc Performant retrieval and presentation of content
US11176204B2 (en) * 2018-12-13 2021-11-16 Business Objects Software Limited Application runtime for cloud-based analytics engine
CN111382381B (zh) * 2018-12-28 2023-07-11 北京字节跳动网络技术有限公司 一种用户数据共享方法、装置、移动终端及存储介质
CN110083416B (zh) * 2019-03-25 2021-10-15 华为技术有限公司 一种资源加载的方法和装置
CN110471757B (zh) * 2019-03-29 2023-04-14 重庆长安汽车股份有限公司 一种车载智能天线***的软件架构及汽车
CN112825538B (zh) * 2019-11-20 2022-04-12 Oppo（重庆）智能科技有限公司 一种应用启动方法、装置、终端设备及存储介质
CN111309421B (zh) * 2020-02-11 2021-05-14 腾讯科技（深圳）有限公司 界面资源的加载方法、装置、终端及存储介质
CN114428922A (zh) * 2022-01-24 2022-05-03 中国工商银行股份有限公司 页面加载方法、装置、终端设备及存储介质

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN105607895A (zh) * 2014-11-21 2016-05-25 阿里巴巴集团控股有限公司 一种基于应用程序编程接口的应用程序的运行方法和装置
CN105701246A (zh) * 2015-11-25 2016-06-22 青岛海信电器股份有限公司 一种基于web应用的终端信息的加载方法与装置
CN105893446A (zh) * 2015-02-18 2016-08-24 奥多比公司 用于基于用户行为预测的智能web参考预加载的方法
CN105912689A (zh) * 2016-04-20 2016-08-31 郑州悉知信息科技股份有限公司 一种网站显示方法、装置及***

Family Cites Families (12)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6807570B1 (en) * 1997-01-21 2004-10-19 International Business Machines Corporation Pre-loading of web pages corresponding to designated links in HTML
US6988140B2 (en) * 2001-02-23 2006-01-17 Sun Microsystems, Inc. Mechanism for servicing connections by disassociating processing resources from idle connections and monitoring the idle connections for activity
US20090024986A1 (en) 2007-07-19 2009-01-22 Microsoft Corporation Runtime code modification
US8572682B2 (en) 2009-12-21 2013-10-29 Sap Ag System and method of accessing data objects in a dynamic language environment
US20120167122A1 (en) * 2010-12-27 2012-06-28 Nokia Corporation Method and apparatus for pre-initializing application rendering processes
US8910185B2 (en) * 2011-10-28 2014-12-09 International Business Machines Corporation Message queuing application access to specific API services through a generic API interface integrating a message queue
US9171348B2 (en) * 2012-01-23 2015-10-27 Google Inc. Rendering content on computing systems
CN103593238A (zh) * 2012-08-16 2014-02-19 腾讯科技（深圳）有限公司 控制应用程序编程接口调用的方法及装置
US9565233B1 (en) * 2013-08-09 2017-02-07 Google Inc. Preloading content for requesting applications
US9330074B2 (en) * 2013-10-31 2016-05-03 Google Inc. Style sheet speculative preloading
CN104683294B (zh) * 2013-11-27 2019-01-18 阿里巴巴集团控股有限公司 一种数据处理方法和***
US9569191B2 (en) 2014-09-10 2017-02-14 Soundspectrum, Inc. Dynamic programming platform for implementing bulk data operators in a multithreaded environment

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN105607895A (zh) * 2014-11-21 2016-05-25 阿里巴巴集团控股有限公司 一种基于应用程序编程接口的应用程序的运行方法和装置
CN105893446A (zh) * 2015-02-18 2016-08-24 奥多比公司 用于基于用户行为预测的智能web参考预加载的方法
CN105701246A (zh) * 2015-11-25 2016-06-22 青岛海信电器股份有限公司 一种基于web应用的终端信息的加载方法与装置
CN105912689A (zh) * 2016-04-20 2016-08-31 郑州悉知信息科技股份有限公司 一种网站显示方法、装置及***

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN111159615A (zh) * 2019-12-31 2020-05-15 北大方正集团有限公司 网页处理方法和装置
CN111159615B (zh) * 2019-12-31 2024-01-02 新方正控股发展有限责任公司 网页处理方法和装置
CN111756831A (zh) * 2020-06-22 2020-10-09 北京达佳互联信息技术有限公司 服务器预加载方法、装置、服务器及存储介质
CN111756831B (zh) * 2020-06-22 2023-05-30 北京达佳互联信息技术有限公司 服务器预加载方法、装置、服务器及存储介质

Also Published As

Publication number Publication date
US20200057658A1 (en) 2020-02-20
CN108572965A (zh) 2018-09-25
US11210109B2 (en) 2021-12-28
TW201833768A (zh) 2018-09-16
CN108572965B (zh) 2020-03-31

Similar Documents

Publication Publication Date Title
WO2018161813A1 (zh) 一种资源加载方法及装置
WO2018161812A1 (zh) 一种用户界面渲染方法及装置
US11868785B2 (en) Application program page processing method and device
WO2016192556A1 (zh) 接口调用方法、装置及终端
US9619304B2 (en) Automatic connections between application components
US8978023B2 (en) Canonical mechanism for securely assembling features into a mobile application
US11853820B2 (en) Cross-process communication method, apparatus, and device
US9075663B2 (en) Cloud-based web workers and storages
US11042387B2 (en) Deploying cross-platform applications on mobile devices with native and web components
US8966508B2 (en) Method for executing hybrid web application and apparatus therefor
US20140208326A1 (en) File presenting method and apparatus for a smart terminal
CN110908712A (zh) 移动端跨平台的数据处理方法和设备
US20170083387A1 (en) High-performance computing framework for cloud computing environments
CN113010170A (zh) 一种基于Vue3组件的页面渲染方法、装置、介质及电子设备
CN111596916A (zh) 一种应用程序管理方法、装置、设备及计算机存储介质
CN112256421B (zh) 通信处理方法、装置、存储介质及电子设备
WO2021057390A1 (zh) 一种启动快应用的方法及相关装置
CN111008050B (zh) 页面任务执行方法、装置、终端及存储介质
CN113672445A (zh) 记录目标程序运行状态信息的方法以及电子设备
WO2022188766A1 (zh) 一种应用程序的显示方法及电子设备
CN114138507A (zh) Python程序服务化方法、装置及计算机可读存储介质

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 18763920

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 18763920

Country of ref document: EP

Kind code of ref document: A1