CN107967155B - Method, device, server and medium for realizing program operation based on Hook shared library - Google Patents
Method, device, server and medium for realizing program operation based on Hook shared library Download PDFInfo
- Publication number
- CN107967155B CN107967155B CN201610908886.9A CN201610908886A CN107967155B CN 107967155 B CN107967155 B CN 107967155B CN 201610908886 A CN201610908886 A CN 201610908886A CN 107967155 B CN107967155 B CN 107967155B
- Authority
- CN
- China
- Prior art keywords
- shared library
- implementation
- function
- interface
- updated
- 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
Abstract
The invention discloses a method for realizing program operation based on a Hook shared library, which comprises the steps that an executable program searches for a derived symbol in an interface shared library so as to call an interface function in the interface shared library; and the interface function calls the realization function in the realization shared library through the symbolic link so as to realize the corresponding function. The invention also provides a device and a server for realizing program operation based on the Hook shared library. The method, the device and the server for realizing the program operation based on the Hook shared library can dynamically update the program when the program operates (without restarting) without modifying the existing program, and can improve the program updating efficiency.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a method, a device, a server and a medium for realizing program operation based on a Hook shared library.
Background
With the advance of computer and network technologies, more and more programs need to be updated continuously to meet the needs of users.
The existing program directly calls the function in the shared library during running, so the shared library needs to be replaced to realize the updating of the program, and the executable program needs to be restarted when the shared library is directly replaced, thereby causing low updating efficiency.
Disclosure of Invention
In view of this, the present invention provides a method for implementing program running based on a Hook shared library, which can dynamically update a program during program running (without restarting) without modifying an existing program, and can improve program updating efficiency.
The invention provides a method for realizing program operation based on a Hook shared library, which comprises the steps that an executable program searches for a derived symbol in an interface shared library so as to call an interface function in the interface shared library; and the interface function calls the realization function in the realization shared library through the symbolic link so as to realize the corresponding function.
The invention also provides a device for realizing the program operation based on the Hook shared library, which comprises an execution module, an interface shared library and a shared library; the execution module is used for searching for a derived symbol in the interface shared library so as to call an interface function in the interface shared library; the interface shared library is used for calling the realization function in the realization shared library through symbolic link so as to realize corresponding functions.
The invention also provides a server which comprises the device for realizing the program operation based on the Hook shared library.
The method, the device and the server for realizing the program operation based on the Hook shared library call the realization function which can be freely rewritten in the shared library through the interface function positioned in the interface shared library, can not modify the existing program, can dynamically update the program when the program runs (without restarting), and can improve the program updating efficiency.
In order to make the aforementioned and other objects, features and advantages of the invention comprehensible, preferred embodiments accompanied with figures are described in detail below.
Drawings
Fig. 1 shows a block diagram of a user terminal;
FIG. 2 shows a block diagram of a server;
fig. 3 is a flowchart of a method for implementing program running based on a Hook shared library according to a first embodiment of the present invention;
fig. 4 is a flowchart of a method for implementing program running based on a Hook shared library according to a second embodiment of the present invention;
fig. 5 is a flowchart of a method for implementing program running based on a Hook shared library according to a third embodiment of the present invention;
fig. 6 is a structural diagram of a Hook API-based proxy implementation apparatus according to a fourth embodiment of the present invention;
fig. 7 is a block diagram of a server according to a fifth embodiment of the present invention.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
The method for realizing program operation based on the Hook shared library provided by the embodiments of the present invention can be applied to the user terminal shown in fig. 1 or the server shown in fig. 2. The user terminal includes Computer terminal devices such as a Personal Computer (PC), an all-in-one machine, a laptop portable Computer, and a vehicle-mounted terminal, and mobile terminal devices such as a smart phone, a tablet PC, an electronic book reader, and an MP3 player (Moving Picture Experts Group Audio Layer III, motion Picture Experts compression standard Audio Layer III), an MP4(Moving Picture Experts Group Audio Layer IV, motion Picture Experts compression standard Audio Layer 4), and the like.
Fig. 1 shows a block diagram of a user terminal. As shown in FIG. 1, the user terminal 10 includes a memory 102, a memory controller 104, one or more processors (only one shown) 106, a peripheral interface 108, a radio frequency module 110, a location module 112, a camera module 114, an audio module 116, a screen 118, and a key module 120, as shown in FIG. 1. These components communicate with each other via one or more communication buses/signal lines 122.
It will be appreciated that the configuration shown in fig. 1 is merely illustrative and that the user terminal 10 may include more or fewer components than shown in fig. 1 or may have a different configuration than shown in fig. 1. The components shown in fig. 1 may be implemented in hardware, software, or a combination thereof.
The memory 102 may be configured to store software programs and modules, such as program instructions/modules corresponding to the method and apparatus for implementing program execution based on the Hook shared library in the embodiment of the present invention, and the processor 106 executes various functional applications and data processing by executing the software programs and modules stored in the memory 102, that is, implementing the above-mentioned method for implementing program execution based on the Hook shared library.
The memory 102 may include high speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 102 may further include memory located remotely from the processor 106, which may be connected to the user terminal 10 via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof. Access to the memory 102 by the processor 106, and possibly other components, may be under the control of the memory controller 104.
In some embodiments, the peripheral interface 108, the processor 106, and the memory controller 104 may be implemented in a single chip. In other examples, they may be implemented separately from the individual chips.
The rf module 110 is used for receiving and transmitting electromagnetic waves, and implementing interconversion between the electromagnetic waves and electrical signals, so as to communicate with a communication network or other devices. The rf module 110 may include various existing circuit elements for performing these functions, such as an antenna, an rf transceiver, a digital signal processor, an encryption/decryption chip, a Subscriber Identity Module (SIM) card, memory, and so forth. The rf module 110 may communicate with various networks such as the internet, an intranet, a wireless network, or with other devices via a wireless network. The wireless network may comprise a cellular telephone network, a wireless local area network, or a metropolitan area network. The Wireless network may use various Communication standards, protocols, and technologies, including, but not limited to, Global System for Mobile Communication (GSM), Enhanced Mobile Communication (Enhanced Data GSM Environment, EDGE), wideband Code division multiple Access (W-CDMA), Code Division Multiple Access (CDMA), Time Division Multiple Access (TDMA), bluetooth, Wireless Fidelity (Wireless Fidelity, Wi-Fi) (e.g., IEEE802.11 a, IEEE802.11 b, IEEE802.1 g, and/or IEEE802.11 n), Voice over internet protocol (VoIP), VoIP, world wide Interoperability, Access, Max, and any other suitable protocol for short message Communication, and may even include those protocols that have not yet been developed.
The positioning module 112 is used for acquiring the current position of the user terminal 10. Examples of the positioning module 112 include, but are not limited to, a global positioning satellite system (GPS), a wireless local area network-based positioning technology, or a mobile communication network-based positioning technology.
The camera module 114 is used to take a picture or video. The pictures or videos taken may be stored in the memory 102 and transmitted through the radio frequency module 110.
The screen 118 provides an output interface between the user terminal 10 and the user. In particular, screen 118 displays video output to the user, the content of which may include text, graphics, video, and any combination thereof. Some of the output results are for some of the user interface objects. It is understood that the screen 118 may also include a touch screen. The touch screen provides both an output and an input interface between the user terminal 10 and the user. In addition to displaying video output to users, touch screens also receive user input, such as user clicks, swipes, and other gesture operations, so that user interface objects respond to these user input. The technique of detecting user input may be based on resistive, capacitive, or any other possible touch detection technique. Specific examples of touch screen display units include, but are not limited to, liquid crystal displays or light emitting polymer displays.
The key module 120 also provides an interface for user input to the user terminal 10, and the user may press different keys to cause the user terminal 10 to perform different functions.
Fig. 2 shows a block diagram of a server. As shown in fig. 2, the server includes: memory 201, processor 202, and network module 203.
It will be appreciated that the configuration shown in fig. 2 is merely illustrative and that the server may include more or fewer components than shown in fig. 2 or may have a different configuration than shown in fig. 2. The components shown in fig. 2 may be implemented in hardware, software, or a combination thereof.
The memory 201 may be configured to store software programs and modules, such as program instructions/modules corresponding to the method and apparatus for implementing program execution based on the Hook-shared library in the embodiment of the present invention, and the processor 202 executes various functional applications and data processing by executing the software programs and modules stored in the memory 201, that is, implementing the method for implementing program execution based on the Hook-shared library in the embodiment of the present invention. Memory 201 may include high speed random access memory and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, memory 201 may further include memory located remotely from processor 202, which may be connected to a server over a network. Further, the software programs and modules may further include: an operating system 221 and a service module 222. The operating system 221, which may be LINUX, UNIX, WINDOWS, for example, may include various software components and/or drivers for managing system tasks (e.g., memory management, storage device control, power management, etc.), and may communicate with various hardware or software components to provide an operating environment for other software components. The service module 222 runs on the basis of the operating system 221, and monitors a request from the network through the network service of the operating system 221, completes corresponding data processing according to the request, and returns a processing result to the client. That is, the service module 222 is used to provide network services to clients.
The network module 203 is used for receiving and transmitting network signals. The network signal may include a wireless signal or a wired signal. In one example, the network signal is a wired network signal. At this time, the network module 203 may include a processor, a random access memory, a converter, a crystal oscillator, and the like.
First embodiment
Fig. 3 is a flowchart of a method for implementing program execution based on a Hook shared library according to a first embodiment of the present invention. As shown in fig. 3, the method for implementing program operation based on the Hook shared library includes the following steps:
step S31: the executable program searches for the derived symbol in the interface shared library to call an interface function in the interface shared library; and
step S32: the interface function calls the realization function in the realization shared library through the symbolic link so as to realize the corresponding function.
The symbolic link is also called a soft link, and is a special file containing a path name of another file.
The implementation function may be customized by the service, that is, the function of the implementation function may also be customized according to the service.
Preferably, the method for implementing program running based on the Hook shared library may further include: and compiling the updated implementation function to the implementation shared library so that the interface function can call the updated implementation function through symbolic link.
The method for realizing the program operation based on the Hook shared library calls the realization function which can be freely rewritten in the realization shared library through the interface function positioned in the interface shared library, can dynamically update the program when the program operates (without restarting) without modifying the existing program, and can improve the program updating efficiency.
Second embodiment
Fig. 4 is a flowchart of a method for implementing program execution based on a Hook shared library according to a second embodiment of the present invention. As shown in fig. 4, the method for implementing program operation based on the Hook shared library includes the following steps:
step S41: the executable program searches for the derived symbol in the interface shared library to call an interface function in the interface shared library;
step S42: monitoring whether the shared library is loaded or not;
if the shared library is loaded, the process proceeds to step S43: judging whether the shared library is updated;
if the shared library is updated, the process proceeds to step S44: loading a shared library;
step S45: calling an implementation function in an implementation shared library;
if the shared library is not updated, the process proceeds to step S45: calling an implementation function in an implementation shared library;
if the shared library is not loaded, the process proceeds to step S44: and loading to realize the shared library.
Preferably, the method for implementing program running based on the Hook shared library may further include: and compiling the updated implementation function to the implementation shared library so that the interface function can call the updated implementation function through symbolic link.
The method for realizing the program operation based on the Hook shared library calls the realization function which can be freely rewritten in the realization shared library through the interface function positioned in the interface shared library, automatically loads the realization shared library when realizing the update of the shared library so as to call a new realization function, thereby realizing the dynamic update of the program without modifying the existing program and during the program operation (without restarting), without manual operation, and further improving the program update efficiency.
Third embodiment
Fig. 5 is a flowchart of a method for implementing program execution based on a Hook shared library according to a third embodiment of the present invention. As shown in fig. 5, the method for implementing program operation based on the Hook shared library includes the following steps:
step S51: writing the interface shared library into an environment variable;
step S52: the executable program searches for the derived symbol in the interface shared library to call an interface function in the interface shared library;
if the corresponding operating system of the executable program is Linux, the interface shared library can be written into the LD _ load environment variable.
Step S53: the interface function calls the realization function in the realization shared library through the symbolic link so as to realize the corresponding function.
Preferably, the method for implementing program running based on the Hook shared library may further include: and compiling the updated implementation function to the implementation shared library so that the interface function can call the updated implementation function through symbolic link.
The method for realizing the program operation based on the Hook shared library calls the realization function which can be freely rewritten in the realization shared library through the interface function positioned in the interface shared library, thereby realizing the dynamic program updating without modifying the existing program and during the program operation (without restarting), without manual operation, and further improving the program updating efficiency.
Fourth embodiment
Fig. 6 is a structural diagram of a Hook API-based proxy implementation apparatus according to a fourth embodiment of the present invention. As shown in fig. 6, the apparatus 60 for implementing program operation based on the Hook shared library includes an execution module 601, an interface shared library 602, and an implementation shared library 603.
The execution module 601 is configured to search the derived symbol in the interface shared library 602 to call an interface function in the interface shared library 602;
the interface shared library 602 is used to call the implementation function in the implementation shared library 603 through symbolic link to implement the corresponding function.
Preferably, the apparatus for implementing program execution based on the Hook shared library further includes an updating module, configured to compile an updated implementation function into the implementation shared library 603.
Specifically, the interface shared library 602 may include a first call unit, a second call unit, and a third call unit. The first calling unit is configured to call an implementation function in the implementation shared library 603 after the implementation shared library 603 is loaded when the implementation shared library 603 is not loaded. The second calling unit is configured to call an implementation function in the implementation shared library 603 after the implementation shared library 603 is loaded when the implementation shared library 603 is updated. The third calling unit is used for calling the implementation function in the implementation shared library 603 when the implementation shared library 603 is loaded and not updated.
Preferably, the apparatus for implementing program execution based on the Hook shared library further comprises a writing module, configured to write the interface shared library 602 into the environment variable. When the operating system corresponding to the execution program in the execution module 601 is Linux, the interface shared library 602 may be written in the LD _ load environment variable.
The device for realizing the program operation based on the Hook shared library can not only not modify the existing program, but also dynamically update the program when the program operates (without restarting), and can improve the program updating efficiency.
Fifth embodiment
Fig. 7 is a block diagram of a server according to a fifth embodiment of the present invention. As shown in fig. 7, the server includes a means 60 for implementing program execution based on the Hook shared library as shown in fig. 6. Preferably, the interface sharing library and the implementation sharing library are both located locally on the server, although the interface sharing library or the implementation sharing library may also be located remotely. The specific structure of the server shown in fig. 7 can also refer to fig. 2, and is not described herein again.
The method, the device and the server for realizing the program operation based on the Hook shared library call the realization function which can be freely rewritten in the shared library through the interface function positioned in the interface shared library, can not modify the existing program, can dynamically update the program when the program runs (without restarting), and can improve the program updating efficiency.
It should be noted that, in the present specification, the embodiments are all described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments may be referred to each other. For the device-like embodiment, since it is basically similar to the method embodiment, the description is simple, and for the relevant points, reference may be made to the partial description of the method embodiment.
It is noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.
It will be understood by those skilled in the art that all or part of the steps for implementing the above embodiments may be implemented by hardware, or may be implemented by a program instructing relevant hardware, and the program may be stored in a computer-readable storage medium, and the storage medium may be a read-only memory, a magnetic disk or an optical disk.
Although the present invention has been described with reference to the preferred embodiments, it should be understood that various changes, substitutions and alterations can be made herein without departing from the spirit and scope of the invention as defined by the appended claims.
Claims (9)
1. A method for realizing program operation based on a Hook shared library is characterized by comprising the following steps:
searching a derived symbol in an interface shared library by an executable program, calling an interface function in the interface shared library based on the derived symbol, and monitoring whether the shared library is loaded or not;
if the realization shared library is loaded and the realization shared library is updated, loading the updated realization shared library, and calling a realization function in the updated realization shared library through the interface function based on the symbolic link to realize the function of the realization function;
when the implementation function in the implementation shared library is updated through free rewriting, compiling the updated implementation function to the updated implementation shared library so as to realize the implementation of the shared library
And when the executable program calls the implementation function again, calling the updated implementation function through the interface function based on the symbolic link.
2. The method for enabling the execution of a program based on a Hook shared library of claim 1, wherein the method further comprises:
if the shared library is loaded, judging whether the shared library is updated;
if the realization shared library is not updated, calling a realization function in the realization shared library;
and if the realization shared library is not loaded, calling a realization function in the realization shared library after the realization shared library is loaded.
3. The method for implementing program running based on the Hook shared library according to claim 1, wherein the operating system corresponding to the executable program is Linux; the executable program searches for a derived symbol in an interface shared library, and the step of calling an interface function in the interface shared library based on the derived symbol further comprises:
and writing the interface sharing library into an LD _ PRELOAD environment variable.
4. The device for realizing the program operation based on the Hook shared library is characterized by comprising an execution module, an interface shared library, an implementation shared library and an updating module;
the execution module is used for searching a derived symbol in an interface shared library by an executable program, calling an interface function in the interface shared library based on the derived symbol and monitoring whether the shared library is loaded or not;
if the implementation shared library is loaded and the implementation shared library is updated, loading the updated implementation shared library, wherein the interface shared library is used for calling an implementation function in the updated implementation shared library through the interface function based on the symbolic link so as to realize the function of the implementation function;
the updating module is configured to compile the updated implementation function to the updated implementation shared library when the implementation function in the implementation shared library is updated by free rewriting, so that when the executable program calls the implementation function again, the interface function calls the updated implementation function based on the symbolic link.
5. The apparatus for implementing program execution based on Hook shared library of claim 4, wherein the interface shared library comprises:
the first calling unit is used for calling the implementation function in the implementation shared library after the implementation shared library is loaded when the implementation shared library is not loaded;
the second calling unit is used for calling the implementation function in the implementation shared library after the implementation shared library is loaded when the implementation shared library is updated; and
and the third calling unit is used for calling the implementation function in the implementation shared library when the implementation shared library is loaded and is not updated.
6. The apparatus for enabling program execution based on a Hook shared library of claim 4, wherein the apparatus further comprises:
and the writing module is used for writing the interface shared library into the environment variable.
7. A server, characterized in that, the server includes the device for realizing the program operation based on the Hook shared library of any claim 4 to 6.
8. The server of claim 7, wherein the interface share library and the implementation share library are both local to the server.
9. A computer-readable storage medium, characterized by storing executable instructions, which when executed, implement a method for implementing the running of a program based on a Hook shared library according to any one of claims 1 to 3.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610908886.9A CN107967155B (en) | 2016-10-18 | 2016-10-18 | Method, device, server and medium for realizing program operation based on Hook shared library |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610908886.9A CN107967155B (en) | 2016-10-18 | 2016-10-18 | Method, device, server and medium for realizing program operation based on Hook shared library |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN107967155A CN107967155A (en) | 2018-04-27 |
| CN107967155B true CN107967155B (en) | 2022-01-07 |
Family
ID=61996785
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201610908886.9A Active CN107967155B (en) | 2016-10-18 | 2016-10-18 | Method, device, server and medium for realizing program operation based on Hook shared library |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107967155B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111694747B (en) * | 2020-06-17 | 2023-03-28 | 抖音视界有限公司 | Thread detection method, device, equipment and computer readable medium |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7703081B1 (en) * | 2005-09-22 | 2010-04-20 | Symantec Corporation | Fast system call hooking on x86-64 bit windows XP platforms |
| CN103885808A (en) * | 2014-04-08 | 2014-06-25 | 北京奇虎科技有限公司 | Hotfix processing method and device |
| CN104217164A (en) * | 2014-09-11 | 2014-12-17 | 工业和信息化部电子第五研究所 | Method and device for detecting malicious software of intelligent mobile terminal |
| CN104267956A (en) * | 2014-09-28 | 2015-01-07 | 深圳光启创新技术有限公司 | Method and module for controlling hardware device in operating system |
| CN105956474A (en) * | 2016-05-17 | 2016-09-21 | 武汉虹旭信息技术有限责任公司 | Abnormal behavior detection system of Android platform software |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104504341B (en) * | 2015-01-21 | 2018-01-23 | 联想(北京)有限公司 | A kind of Loopholes of OS restorative procedure and device |
-
2016
- 2016-10-18 CN CN201610908886.9A patent/CN107967155B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7703081B1 (en) * | 2005-09-22 | 2010-04-20 | Symantec Corporation | Fast system call hooking on x86-64 bit windows XP platforms |
| CN103885808A (en) * | 2014-04-08 | 2014-06-25 | 北京奇虎科技有限公司 | Hotfix processing method and device |
| CN104217164A (en) * | 2014-09-11 | 2014-12-17 | 工业和信息化部电子第五研究所 | Method and device for detecting malicious software of intelligent mobile terminal |
| CN104267956A (en) * | 2014-09-28 | 2015-01-07 | 深圳光启创新技术有限公司 | Method and module for controlling hardware device in operating system |
| CN105956474A (en) * | 2016-05-17 | 2016-09-21 | 武汉虹旭信息技术有限责任公司 | Abnormal behavior detection system of Android platform software |
Also Published As
| Publication number | Publication date |
|---|---|
| CN107967155A (en) | 2018-04-27 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10206074B2 (en) | Remote access to a mobile communication device over a wireless local area network (WLAN) | |
| CN105763723B (en) | Mobile terminal and method for upgrading system | |
| CN112291764B (en) | Content connection system | |
| US9008633B2 (en) | Methods to determine availability of user based on mobile phone status | |
| US10853437B2 (en) | Method and apparatus for invoking application programming interface | |
| CN104965848B (en) | A kind of front end resource loading method and device | |
| CN106657528B (en) | Incoming call management method and device | |
| CN105260301A (en) | Visual effect comparison test device of user interfaces and realization method of visual effect comparison test device of user interfaces | |
| CN111580879A (en) | Applet running method and device, electronic equipment and computer storage medium | |
| CN106681749B (en) | Local code patch updating method and device based on android platform | |
| EP3367646B1 (en) | Method for detecting proximity of object and electronic device using the same | |
| US20150160827A1 (en) | Method of interface control and electronic device thereof | |
| CN104657181A (en) | Method and device for mounting application program | |
| CN103607431B (en) | Mobile terminal resource processing method, device and equipment | |
| CN103713943A (en) | Native terminal operating system based application function realization method and device | |
| CN107463372B (en) | Data-driven page updating method and device | |
| CN112805988B (en) | Call control method and device, computer readable storage medium and electronic equipment | |
| US20150200641A1 (en) | Method for providing audio and electronic device adapted to the same | |
| CN107967155B (en) | Method, device, server and medium for realizing program operation based on Hook shared library | |
| CN112748970B (en) | Message display method and terminal equipment | |
| WO2016169426A1 (en) | Video playing method and device | |
| AU2014200195B2 (en) | Method and apparatus for executing application program in electronic device | |
| CN105320707B (en) | Hot word prompting method and device based on instant messaging | |
| WO2020103073A1 (en) | Method and device for processing audio resources, computer readable storage medium and electronic device | |
| CN110989987A (en) | Portal webpage generation method, portal webpage generation device, client, server and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |