CN112379952B - Method for implementing cross-process callback - Google Patents
Method for implementing cross-process callback Download PDFInfo
- Publication number
- CN112379952B CN112379952B CN202011427093.8A CN202011427093A CN112379952B CN 112379952 B CN112379952 B CN 112379952B CN 202011427093 A CN202011427093 A CN 202011427093A CN 112379952 B CN112379952 B CN 112379952B
- Authority
- CN
- China
- Prior art keywords
- event
- shared memory
- global
- callback
- cross
- 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
- 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/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4482—Procedural
-
- 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/44505—Configuring for program initiating, e.g. using registry, configuration files
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Multi Processors (AREA)
Abstract
The invention provides a method for realizing cross-process callback, which comprises the following steps: s1, creating a process A and a process B; s2, process A creates and initializes a shared memory; s3, receiving the cross-process callback, writing callback parameters into the shared memory, and writing the event type into the shared memory; s4, the process A sends a notice to the process B; s5, starting the process B, and judging whether the process B is an exit event; s6, if the event is an exit event, exiting; if not, judging whether the shared memory has unprocessed event operation; s7, if unprocessed event operation exists, acquiring an event type from the shared memory; s8, acquiring data corresponding to the event from the shared memory, processing and writing a return value into the shared memory, setting the event state to be complete, and returning to continue waiting for the global event state; and S9, the process A acquires a return value from the shared memory, and the process A is finished. The invention solves the problem that the cross-process communication and the asynchronization are difficult to carry out by using the traditional callback technology at present.
Description
Technical Field
The invention relates to the technical field of computer process callback, in particular to a cross-process callback implementation method.
Background
With the rapid development of computer technology, the complexity of software is higher and higher, in order to improve the stability of software operation, multiple functions are generally separated into separate EXE applications to improve the stability of program operation, but at the same time, because of the diversity of user interaction during interaction, some data need to send a callback to an interface layer through a service, and the interface layer needs to return to a specific service program according to the selection of a user, but it is difficult to perform cross-process communication and asynchronization by using the conventional callback technology, and therefore, it is necessary to provide a method for implementing cross-process callback to overcome the above problems.
Disclosure of Invention
The invention provides a method for realizing cross-process callback, which aims to solve the problem that cross-process communication and asynchronization are difficult to carry out by using the traditional callback technology at present.
In order to solve the technical problems, the technical scheme adopted by the invention is as follows: a method for realizing cross-process callback comprises the following steps:
s1, creating a process A, wherein the process A is a main process; creating a process B, wherein the process B is a sub-process;
s2, starting a process A, creating and initializing a shared memory by the process A, and creating a global event object;
s3, when receiving the cross-process callback from the process A, writing the callback parameters into the shared memory, and writing the event type into the shared memory;
s4, the process A sends a notification to the process B, and waits for the process B to return a global event object;
s5, starting the process B, entering a state of waiting for a global event, and judging whether the process B is an exit event or not when receiving the notification sent by the process A;
s6, if the event is an exit event, exiting and ending the process B; if not, judging whether unprocessed event operation exists in the shared memory when the process B is started for the first time;
s7, if unprocessed event operation does not exist, the process B enters a notification waiting state, and when the process B receives a notification, the event type is acquired from the shared memory; if unprocessed event operation exists, acquiring an event type from the shared memory;
s8, entering different event flows according to the event type, acquiring data corresponding to the event from the shared memory according to the event type, processing and writing a return value into the shared memory, setting the event state as complete, and returning to continue waiting for the global event state;
s9, judging whether the process A returns overtime or not, if yes, setting an error code and returning, and ending the process A; if not, the return value is obtained from the shared memory, and the process A is finished.
Further, process a is a worker thread.
Further, process B is an interface process or an auxiliary process.
Further, in step S2, the process a creates a global shared memory, and initializes the process a according to a fixed data structure.
Further, in step S2, in the initialization process, the data blocks are distinguished.
Further, in step S2, the data blocks are distinguished according to the type, logical offset, and size of the data blocks.
Further, in step S4, the process a has two ways to send a notification to the process B, one is a cross-process notification way of a Socket way capable of responding instantly; the other is a global event notification mode capable of asynchronously processing events.
Further, the step of the global event notification mode includes:
A1. the process A starts and creates a global event object, and sets the access right of the global event object as Everyone.
Further, the step of the global event notification mode further includes:
A2. starting the process B for the first time, wherein the global event object is opened successfully;
A3. and obtaining the data of the specified type from the global shared memory.
Further, the step of the global event notification mode further includes:
A4. performing corresponding processing according to the event type acquired from the global shared memory and setting a return result;
A5. process B sets the completion status of message processing.
Compared with the prior art, the invention has the following beneficial effects: the cross-process callback implementation method of the invention creates a process A and a process B; creating and initializing a shared memory; creating a global event object; the method comprises the steps of sharing a memory, performing signal management, performing shared memory management, and realizing data interaction between a process A and a process B through the shared memory. The invention has the characteristics of simplicity, rapidness, accuracy and effectiveness.
Drawings
Fig. 1 is a schematic step diagram of a method for implementing a cross-process callback according to the present invention.
Fig. 2 is a schematic diagram of a process a of a method for implementing a cross-process callback according to the present invention.
Fig. 3 is a schematic diagram of a process B of an implementation method of a cross-process callback of the present invention.
Detailed Description
The technical solutions of the present invention are further described in detail below with reference to the accompanying drawings, but the scope of the present invention is not limited to the following.
In order to make the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. All other embodiments, which can be obtained by a person skilled in the art without any inventive step based on the embodiments of the present invention, are within the scope of the present invention. Thus, the following detailed description of the embodiments of the present invention, presented in the figures, is not intended to limit the scope of the invention, as claimed, but is merely representative of selected embodiments of the invention. All other embodiments, which can be obtained by a person skilled in the art without any inventive step based on the embodiments of the present invention, are within the scope of the present invention.
The present invention will be further described with reference to the following examples, which are intended to illustrate only some, but not all, of the embodiments of the present invention. Based on the embodiments of the present invention, other embodiments used by those skilled in the art without any creative effort belong to the protection scope of the present invention.
Referring to fig. 1 to 3, an embodiment of the present invention is shown, which is for illustration purpose only and is not limited by the structure.
Example one
As shown in fig. 1, fig. 2 and fig. 3, a method for implementing a cross-process callback includes the following steps:
s1, creating a process A, wherein the process A is a main process; creating a process B, wherein the process B is a sub-process;
s2, starting a process A, creating and initializing a shared memory by the process A, and creating a global event object;
s3, when receiving the cross-process callback from the process A, writing the callback parameters into the shared memory, and writing the event type into the shared memory;
s4, the process A sends a notification to the process B, and waits for the process B to return a global event object;
s5, starting the process B, entering a global event waiting state, and judging whether the process B is an exit event or not when receiving the notification sent by the process A;
s6, if the event is an exit event, exiting and ending the process B; if not, judging whether unprocessed event operation exists in the shared memory when the process B is started for the first time;
s7, if unprocessed event operation does not exist, the process B enters a notification waiting state, and when the process B receives a notification, the event type is acquired from the shared memory; if unprocessed event operation exists, acquiring an event type from a shared memory;
s8, entering different event flows according to the event type, acquiring data corresponding to the event from the shared memory according to the event type, processing and writing a return value into the shared memory, setting the event state as complete, and returning to continue waiting for the global event state;
s9, judging whether the process A returns overtime or not, if yes, setting an error code and returning, and ending the process A; if not, the return value is obtained from the shared memory, and the process A is finished.
Process a is a worker thread.
The process B is an interface process or an auxiliary process.
In step S2, the process a creates a global shared memory and initializes the process a according to a fixed data structure.
In step S2, in the initialization process, data blocks are distinguished.
In step S2, the data blocks are distinguished according to the type, logical offset, and size of the data blocks.
In step S4, the process A has two modes to send the notice to the process B, namely a cross-process notice mode of a Socket mode capable of responding instantly; the second is a global event notification mode capable of asynchronously processing events.
The steps of the global event notification mode include:
A1. the process A starts and creates a global event object, and sets the access right of the global event object as Everyone.
A2. Starting the process B for the first time, wherein the global event object is opened successfully;
A3. and obtaining the data of the specified type from the global shared memory.
A4. Performing corresponding processing according to the event type acquired from the global shared memory and setting a return result;
A5. process B sets the completion status of message processing.
Example two
The present embodiment is a technical solution of the first embodiment.
The invention comprises a shared memory management part and a signal management part, wherein the shared memory management part comprises the following two parts:
the process A creates a global shared memory and initializes the global shared memory according to a fixed data structure, wherein the data structure is as follows:
the algorithm for creating the shared memory is as follows: the number of data blocks needed plus the size needed for each data block:
the above distinguishing of the blocks is mainly to facilitate the program to write the corresponding data into the corresponding data block when calling, so as to facilitate another process to take the data to be processed and return the setting result in the shared memory.
Copying data to a specified shared memory according to different calls, for example, a user is required to input a password in a process B, and after the process B is determined, the process A needs to know the password input by the user, and the specific steps are as follows:
a) The process A firstly receives an operation of needing a user to input a password, and the operation of needing the password is written into a previously initialized m _ NodeSize [ Mem _ CallBak ] memory segment of the shared memory by the process A;
b) The process A writes the type of the operation into a shared memory;
c) Process A informs process B;
d) After receiving the notification of the process A, the process B firstly obtains the type of the operation from the shared memory, and then obtains the data transmitted by the operation from the process A from the shared memory according to the operation type;
e) The process B interacts with the user and returns and writes the Result of the user to the m _ NodeSize [ Mem _ Result ] memory segment of the shared memory;
f) Setting a global event object by the process B, and continuously executing the process A;
g) And the process A acquires the data returned by the process B from the m _ NodeSize [ Mem _ Result ], and the process A continues to execute.
The following is a signal management section:
the cross-process notification part uses two ways: 1. a Socket mode cross-process notification mode capable of responding instantly; 2. a global event notification approach that is capable of asynchronously processing events.
a) The global event notification mode is used when software is opened for the first time, because the cross-process message transmission has an asynchronous problem, that is, the process a may have run for ten minutes, at this time, the process a already has some data that needs to be displayed or interacted, the process B is restarted at this time, the process B can judge whether there is a message that needs to be interacted according to the global event object, if so, the data is obtained from the above steps, and the steps are as follows:
the process A starts and creates a global event object, and sets the access authority of the global event object as Everyone, because the global object may need to be accessed across sessions;
b) Starting the process B for the first time, wherein the global event object is successfully opened;
c) Obtaining data of a specified type from a global shared memory;
d) Performing corresponding processing according to the event type acquired from the global shared memory and setting a return result;
e) Process B sets the completion status of message processing.
If the process A and the process B are running simultaneously, the direct communication is carried out by using a Socket mode, and the steps are as follows:
starting Socket by the process B and placing the Socket in a waiting state;
a) The process A uses Socket to inform the process B after the data of the cross-process is set to the shared memory according to the above;
b) The process B performs corresponding processing after receiving the message from the Socket, and sets the processing Result to the m _ NodeSize [ Mem _ Result ] memory segment of the shared memory;
c) Process B sets the completion status of message processing.
Sharing the memory: the module is mainly responsible for data storage of cross-process communication and storage of result return.
A global event module: the module is mainly responsible for starting the process B for the first time to judge whether data needing to be processed exists.
A network module: this module is primarily responsible for direct communication between process a and process B.
EXAMPLE III
A method for realizing cross-process callback comprises the following steps:
s1, creating a process A, wherein the process A is a main process; creating a process B, wherein the process B is a sub-process;
s2, starting a process A, creating and initializing a shared memory by the process A, and creating a global event object;
s3, when receiving the cross-process callback from the process A, writing callback parameters into the shared memory, and writing the event type into the shared memory;
s4, the process A sends a notification to the process B, and waits for the process B to return a global event object;
s5, the process B receives a notification transmitted by the process A, wherein the notification comprises a Uniform Resource Locator (URL) parameter of the process B and an application program identifier (APPID) parameter of the process A; calling the process B according to the URL parameter, and establishing an icon which is quickly called back to the process A on a display interface of the process B according to the APPID parameter; starting the process B, entering a global event waiting state, and judging whether the process B is an exit event or not when receiving the notification sent by the process A;
s6, if the event is an exit event, exiting and ending the process B; if not, judging whether unprocessed event operation exists in the shared memory when the process B is started for the first time;
s7, if unprocessed event operation does not exist, the process B enters a state of waiting for notification, and when the process B receives the notification, the event type is obtained from the shared memory; if unprocessed event operation exists, acquiring an event type from the shared memory;
s8, entering different event flows according to the event type, acquiring data corresponding to the event from the shared memory according to the event type, processing and writing a return value into the shared memory, setting the event state as complete and operating aiming at the icon, and ending the process B;
s9, generating a callback instruction when the operation aiming at the icon is detected, and calling back to the process A based on the callback instruction; the process A judges whether to return overtime, if overtime, an error code is set and returned, and the process A is ended; if not, the return value is obtained from the shared memory, and the process A is finished.
The above-described embodiments are intended to be illustrative, not limiting, of the invention, and therefore, variations of the example values or substitutions of equivalent elements are intended to be within the scope of the invention.
From the foregoing detailed description, it will be apparent to those skilled in the art that the foregoing objects and advantages of the invention have been achieved in accordance with the provisions of the patent statutes.
While preferred embodiments of the present invention have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including preferred embodiments and all such alterations and modifications as fall within the scope of the invention. The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, it should be noted that any modifications, equivalents and improvements made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (10)
1. A method for realizing cross-process callback is characterized by comprising the following steps:
s1, creating a process A, wherein the process A is a main process; creating a process B, wherein the process B is a secondary process;
s2, starting a process A, creating and initializing a shared memory by the process A, and creating a global event object;
s3, when receiving the cross-process callback from the process A, writing the callback parameters into the shared memory, and writing the event type into the shared memory;
s4, the process A sends a notification to the process B and waits for the global event object of the process B to return;
s5, starting the process B, entering a state of waiting for a global event, and judging whether the process B is an exit event or not when receiving the notification sent by the process A;
s6, if the event is an exit event, exiting and ending the process B; if not, judging whether unprocessed event operation exists in the shared memory when the process B is started for the first time;
s7, if unprocessed event operation does not exist, the process B enters a notification waiting state, and when the process B receives a notification, the event type is acquired from the shared memory; if unprocessed event operation exists, acquiring an event type from a shared memory;
s8, entering different event flows according to the event type, acquiring data corresponding to the event from the shared memory according to the event type, processing and writing a return value into the shared memory, setting the event state to be complete, and returning to continue waiting for the global event state;
s9, judging whether the process A returns overtime, if yes, setting an error code and returning, and ending the process A; if not, the return value is obtained from the shared memory, and the process A is finished.
2. The method of claim 1, wherein process a is a worker thread.
3. The method of claim 1, wherein process B is an interface process or an auxiliary process.
4. The method for implementing a cross-process callback according to claim 1, wherein in step S2, the process a creates a global shared memory and initializes the process a according to a fixed data structure.
5. The method for implementing a cross-process callback according to claim 4, wherein in step S2, during initialization, data blocks are distinguished.
6. The method of claim 5, wherein in step S2, the data blocks are distinguished according to their types, logical offsets, and sizes.
7. The method for implementing cross-process callback according to claim 1, wherein in step S4, the process a has two modes for sending notification to the process B, namely a cross-process notification mode of Socket mode capable of instant response; the second is a global event notification mode capable of asynchronously processing events.
8. The method of claim 7, wherein the step of notifying the global event comprises:
A1. the process A starts and creates a global event object, and sets the access right of the global event object as Everyone.
9. The method for implementing a cross-process callback according to claim 8, wherein the step of the global event notification mode further comprises:
A2. starting the process B for the first time, wherein the global event object is opened successfully;
A3. and obtaining the data of the specified type from the global shared memory.
10. The method for implementing a cross-process callback according to claim 9, wherein the step of the global event notification mode further comprises:
A4. performing corresponding processing according to the event type acquired from the global shared memory and setting a return result;
A5. process B sets the completion status of message processing.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011427093.8A CN112379952B (en) | 2020-12-09 | 2020-12-09 | Method for implementing cross-process callback |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011427093.8A CN112379952B (en) | 2020-12-09 | 2020-12-09 | Method for implementing cross-process callback |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112379952A CN112379952A (en) | 2021-02-19 |
| CN112379952B true CN112379952B (en) | 2023-04-07 |
Family
ID=74589760
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011427093.8A Active CN112379952B (en) | 2020-12-09 | 2020-12-09 | Method for implementing cross-process callback |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112379952B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116709609B (en) * | 2022-09-30 | 2024-05-14 | 荣耀终端有限公司 | Message delivery method, electronic device and storage medium |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102253855A (en) * | 2011-06-17 | 2011-11-23 | 北京书生国际信息技术有限公司 | Method and device for transferring shared memory |
| CN102446226A (en) * | 2012-01-16 | 2012-05-09 | 上海方正数字出版技术有限公司 | Method for achieving NoSQL key-value storage engine |
| US8510530B1 (en) * | 2010-12-09 | 2013-08-13 | Google Inc. | Memory management for programs operating asynchronously |
| WO2016082594A1 (en) * | 2014-11-26 | 2016-06-02 | 中兴通讯股份有限公司 | Data update processing method and apparatus |
| CN107229530A (en) * | 2017-06-29 | 2017-10-03 | 上海联影医疗科技有限公司 | Communication means, storage medium and computer equipment between process |
| CN108737397A (en) * | 2018-05-09 | 2018-11-02 | 烽火通信科技股份有限公司 | A kind of method for realizing data interaction between business and protocol stack in router |
| CN110569130A (en) * | 2019-07-29 | 2019-12-13 | 华为技术有限公司 | Cross-process communication method, device and equipment |
| CN111737622A (en) * | 2020-06-18 | 2020-10-02 | 上海英方软件股份有限公司 | Method and device for subscribing market information flow |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6829769B2 (en) * | 2000-10-04 | 2004-12-07 | Microsoft Corporation | High performance interprocess communication |
-
2020
- 2020-12-09 CN CN202011427093.8A patent/CN112379952B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8510530B1 (en) * | 2010-12-09 | 2013-08-13 | Google Inc. | Memory management for programs operating asynchronously |
| CN102253855A (en) * | 2011-06-17 | 2011-11-23 | 北京书生国际信息技术有限公司 | Method and device for transferring shared memory |
| CN102446226A (en) * | 2012-01-16 | 2012-05-09 | 上海方正数字出版技术有限公司 | Method for achieving NoSQL key-value storage engine |
| WO2016082594A1 (en) * | 2014-11-26 | 2016-06-02 | 中兴通讯股份有限公司 | Data update processing method and apparatus |
| CN107229530A (en) * | 2017-06-29 | 2017-10-03 | 上海联影医疗科技有限公司 | Communication means, storage medium and computer equipment between process |
| CN108737397A (en) * | 2018-05-09 | 2018-11-02 | 烽火通信科技股份有限公司 | A kind of method for realizing data interaction between business and protocol stack in router |
| CN110569130A (en) * | 2019-07-29 | 2019-12-13 | 华为技术有限公司 | Cross-process communication method, device and equipment |
| CN111737622A (en) * | 2020-06-18 | 2020-10-02 | 上海英方软件股份有限公司 | Method and device for subscribing market information flow |
Non-Patent Citations (3)
| Title |
|---|
| 王凯.面向Android系统进程间通信机制的漏洞挖掘技术研究.《万方》.2017,1-59. * |
| 郑培余,姚绍文.一种基于进程外窗口挂钩回调的软件集成方法.计算机应用.2009,(第05期),1-6. * |
| 韩旭.基于.NET WCF回调机制的进程间通信设计.《电脑知识与技术》.2010,1-5. * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112379952A (en) | 2021-02-19 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112463144B (en) | Distributed storage command line service method, system, terminal and storage medium | |
| CN109032796B (en) | Data processing method and device | |
| CN111444103A (en) | Automatic testing method for Web page and related equipment | |
| CN112379952B (en) | Method for implementing cross-process callback | |
| CN110851303B (en) | Data backup method, system and equipment | |
| CN105373563B (en) | Database switching method and device | |
| CN111294377B (en) | Dependency network request sending method, terminal device and storage medium | |
| CN114328097A (en) | File monitoring method and device, electronic equipment and storage medium | |
| CN112818336A (en) | Data access method, data access device and computer readable storage medium | |
| CN114995982A (en) | Task processing method and device and storage medium | |
| CN111708568B (en) | Modularized development decoupling method and terminal | |
| CN111147400B (en) | Method and device for command line configuration synchronization and electronic equipment | |
| CN110768855B (en) | Method and device for testing linkmzation performance | |
| CN111580940A (en) | Method and device for processing multiple inter-process processes of application program and electronic equipment | |
| CN106210031A (en) | Service execution method, device, client and server | |
| CN111679899A (en) | Task scheduling method, device, platform equipment and storage medium | |
| CN112055058A (en) | Data storage method and device and computer readable storage medium | |
| CN110928672A (en) | Task arranging method, device and equipment and storage medium | |
| CN112769824B (en) | Information transmission state updating method, terminal, device and storage medium | |
| CN111324368A (en) | Data sharing method and server | |
| CN112769753B (en) | Sharing method, device and equipment of Internet of things equipment and storage medium | |
| CN111324888B (en) | Verification method and device for application program starting, electronic equipment and storage medium | |
| CN115242972B (en) | Method and device for calling camera by application, electronic equipment and storage medium | |
| CN111476663B (en) | Data processing method and device, node equipment and storage medium | |
| CN115269269A (en) | Drill method, device, backup server, medium, server cluster and system |
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 |