CN111897555A - Dynamic updating method, device and system of client and terminal equipment - Google Patents
Dynamic updating method, device and system of client and terminal equipment Download PDFInfo
- Publication number
- CN111897555A CN111897555A CN201910372463.3A CN201910372463A CN111897555A CN 111897555 A CN111897555 A CN 111897555A CN 201910372463 A CN201910372463 A CN 201910372463A CN 111897555 A CN111897555 A CN 111897555A
- Authority
- CN
- China
- Prior art keywords
- client
- source code
- file
- repair
- code file
- 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 73
- 230000008439 repair process Effects 0.000 claims description 117
- 238000006243 chemical reaction Methods 0.000 claims description 22
- 230000008569 process Effects 0.000 claims description 6
- 230000001360 synchronised effect Effects 0.000 claims description 6
- 230000000694 effects Effects 0.000 claims description 5
- 238000010586 diagram Methods 0.000 description 19
- 238000012545 processing Methods 0.000 description 11
- 238000004891 communication Methods 0.000 description 10
- 230000006870 function Effects 0.000 description 8
- 238000010200 validation analysis Methods 0.000 description 7
- 238000004590 computer program Methods 0.000 description 5
- 230000005540 biological transmission Effects 0.000 description 4
- 230000004044 response Effects 0.000 description 4
- 230000009286 beneficial effect Effects 0.000 description 3
- 230000003993 interaction Effects 0.000 description 3
- 238000013461 design Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 239000000835 fiber Substances 0.000 description 2
- 239000004973 liquid crystal related substance Substances 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000001902 propagating effect Effects 0.000 description 2
- RYGMFSIKBFXOCR-UHFFFAOYSA-N Copper Chemical compound [Cu] RYGMFSIKBFXOCR-UHFFFAOYSA-N 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 229910052802 copper Inorganic materials 0.000 description 1
- 239000010949 copper Substances 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000014509 gene expression Effects 0.000 description 1
- 230000010365 information processing Effects 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000013507 mapping Methods 0.000 description 1
- 238000003672 processing method Methods 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 230000002441 reversible effect Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Information Transfer Between Computers (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a dynamic update method, a device, a system and a terminal device of a client, wherein the method is implemented by the terminal device, and the method comprises the following steps: acquiring a source code file of a patch of the client; converting the source code file into an executable file; and calling the executable file to run the client.
Description
Technical Field
The present invention relates to the field of repair update technologies for clients, and in particular, to a dynamic update method for a client, a dynamic update apparatus for a client, a terminal device, a dynamic update system for a client, and a computer-readable storage medium.
Background
A Client (Client) is also called a Client, and refers to a program corresponding to a server and providing local services to clients.
After a client is released, it will often need repair updates to the client in order to solve some online problems or to wish to modify some online code logic. A common repair update method is to release a new version of the client to cover an old version, and this method has the problems of low update efficiency and long period, and also requires a user to perform manual installation operation. In view of the above, a scheme for dynamically updating a client by patching is proposed at present, but in the existing dynamic updating scheme, patch files need to be compiled into executable files at one end of a server and then issued to a terminal device for updating the client, which not only increases the management flow for updating the client and is not beneficial to timely repairing the online problem, but also has the problem that the patch files are unreadable, is not beneficial to error checking and modifying the patch files, and invisibly increases the probability of errors of the patch files.
Disclosure of Invention
It is an object of embodiments of the present invention to provide a new dynamic update scheme for a client.
According to a first aspect of the present invention, there is provided a dynamic update method for a client, which is implemented by a terminal device, the method including:
acquiring a source code file of a patch of the client;
converting the source code file into an executable file;
and calling the executable file to operate the client.
Optionally, the source code file is a source code file written in js language, a source code file written in Lua language, or a source code file written in xml language.
Optionally, the executable file is a dex file.
Optionally, the obtaining a source code file of a patch of the client includes:
and responding to a set event, and acquiring a source code file of the patch of the client.
Optionally, the method further comprises:
providing a setting entrance for setting the setting event;
acquiring an event input through the setting entrance;
updating the set event includes the entered event.
Optionally, the invoking the executable file to run the client includes:
searching a repair object registered for the client;
and calling the executable file corresponding to the repaired object to run the client.
Optionally, the invoking the executable file corresponding to the repair object to run the client includes:
when the client runs to the repair object, detecting whether the executable file corresponding to the repair object exists locally;
and under the condition that the executable file corresponding to the repair object is detected, calling the detected executable file to execute the corresponding repair object.
Optionally, the invoking the executable file corresponding to the repair object to run the client further includes:
when the client runs to the repair object, judging whether the repair opportunity of the registered repair object allows repair in the current running;
and under the condition that the repair is allowed in the current operation, the operation of detecting whether the executable file corresponding to the repair object exists locally is executed again.
Optionally, the invoking the executable file corresponding to the repair object to run the client further includes:
under the condition that the executable file corresponding to the repair object is not detected, if the repair time when the repair object is registered is synchronous and waiting to take effect, then detecting whether the source code file corresponding to the repair object is in the process of conversion;
and under the condition that the source code file corresponding to the repair object is detected to be converted, waiting for the detected source code file to finish the conversion, and calling the executable file obtained by conversion to execute the corresponding repair object after the conversion is finished.
Optionally, the repair object comprises a class method of a java class.
According to the second aspect of the present invention, there is also provided a dynamic update apparatus for a client, including:
the file acquisition module is used for acquiring a source code file of the patch of the client;
the file conversion module is used for converting the source code file into an executable file; and the number of the first and second groups,
and the operation management module is used for calling the executable file to operate the client.
According to a third aspect of the present invention, there is also provided a terminal device, which includes the dynamic update apparatus according to the second aspect of the present invention; or, the terminal device includes:
a memory for storing executable instructions;
a processor for performing the method according to the first aspect of the invention under the control of the executable instructions.
According to a fourth aspect of the present invention, there is also provided a dynamic update system of a client, comprising a server and the terminal device according to the third aspect of the present invention, the terminal device installing the client, wherein:
the server is used for providing a source code file of the patch of the client;
and the terminal equipment is used for acquiring the source code file from the server.
According to a fifth aspect of the present invention, there is also provided a computer readable storage medium storing executable instructions which, when executed by a processor, perform the method according to the first aspect of the present invention.
The method has the advantages that the patch file in the embodiment of the invention is issued by adopting the source code file, so that the source code can be directly read at the server, technicians can directly obtain the logic of the patch code without checking the corresponding logic by means of decompilation and the like, and the error rate of the patch file can be effectively reduced; in addition, the source code file is directly issued, the management flow for updating the client can be simplified, and the online problem can be timely repaired.
Other features of the present invention and advantages thereof will become apparent from the following detailed description of exemplary embodiments thereof, which proceeds with reference to the accompanying drawings.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description, serve to explain the principles of the invention.
FIG. 1 is a schematic diagram of a dynamic update system according to an embodiment of the present invention;
FIG. 2 is a schematic flow chart diagram of a dynamic update method according to an embodiment of the present invention;
FIG. 3 is a schematic flow chart diagram of a dynamic update method according to another embodiment of the present invention;
FIG. 4 is a schematic diagram of a set entry page according to an embodiment of the invention;
FIG. 5 is a schematic interaction flow diagram for implementing a dynamic update method according to an embodiment of the present invention;
FIG. 6 is a functional block diagram of a dynamic update apparatus according to an embodiment of the present invention;
fig. 7 is a functional block diagram of a terminal device according to an embodiment of the present invention.
Detailed Description
Various exemplary embodiments of the present invention will now be described in detail with reference to the accompanying drawings. It should be noted that: the relative arrangement of the components and steps, the numerical expressions and numerical values set forth in these embodiments do not limit the scope of the present invention unless specifically stated otherwise.
The following description of at least one exemplary embodiment is merely illustrative in nature and is in no way intended to limit the invention, its application, or uses.
Techniques, methods, and apparatus known to those of ordinary skill in the relevant art may not be discussed in detail but are intended to be part of the specification where appropriate.
In all examples shown and discussed herein, any particular value should be construed as merely illustrative, and not limiting. Thus, other examples of the exemplary embodiments may have different values.
It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, further discussion thereof is not required in subsequent figures.
< hardware configuration >
After the client is released, in order to solve some online problems or hope to modify some online code logics, the client will often need to be repaired, an embodiment of the present invention provides a dynamic update method for dynamically updating the client, and fig. 1 is a schematic view of a composition structure of a dynamic update system capable of implementing the dynamic update method according to the embodiment of the present invention.
As shown in fig. 1, the dynamic update system 1000 of the present embodiment includes a server 1100 and a terminal device 1200, and the server 1100 and the terminal device 1200 are communicatively connected via a network 1300.
The server 1100 may be, for example, a blade server, a rack server, a cloud server cluster, and the like, which is not limited herein.
The server 1100 may be as shown in FIG. 1, including a processor 1110, a memory 1120, an interface device 1130, a communication device 1140, a display device 1150, and an input device 1160.
The processor 1110 may be, for example, a central processing unit CPU. The memory 1120 includes, for example, a ROM (read only memory), a RAM (random access memory), a nonvolatile memory such as a hard disk, and the like. The interface device 1130 includes, for example, a USB interface, a serial interface, and the like. The communication device 1140 is capable of wired or wireless communication, for example. The display device 1150 is, for example, a liquid crystal display panel. Input devices 1160 may include, for example, a touch screen, a keyboard, and the like.
Although shown as multiple devices of server 1100 in fig. 1, the present invention may relate to only some of the devices, e.g., server 1100 may relate to only memory 1120, processor 1110, communications 1140, etc.
In this embodiment, the memory 1120 of the server 1100 is configured to store instructions, which are used to control the processor 1110 to operate to perform operations supporting the dynamic update method according to any embodiment of the present invention, for example, receiving and saving a source code file of an uploaded patch of the client, and sending the source code file to the terminal device 1200, so that the terminal device 1200 can execute the dynamic update method according to any embodiment of the present invention. The skilled person can design the instructions according to the disclosed solution. How the instructions control the operation of the processor is well known in the art and will not be described in detail herein.
The terminal device 1200 may be a mobile terminal or a fixed terminal, and is not limited herein, and may be, for example, a smart phone, a portable computer, a desktop computer, a tablet computer, and the like. As shown in fig. 1, the terminal apparatus 1200 may include a processor 1210, a memory 1220, an interface device 1230, a communication device 1240, a display device 1250, an input device 1260, a speaker 1270, a microphone 1280, and the like.
The processor 1210 may be a central processing unit CPU, a microprocessor MCU, or the like. The memory 1220 includes, for example, a ROM (read only memory), a RAM (random access memory), a nonvolatile memory such as a hard disk, and the like. The interface device 1230 includes, for example, a USB interface, a headphone interface, and the like. The communication device 1240 can perform wired or wireless communication, for example. The display device 1250 is, for example, a liquid crystal display, a touch display, or the like. The input device 1260 may include, for example, a touch screen, a keyboard, and the like. A user can output/input voice information through the speaker 1270 and the microphone 1280.
Although a plurality of devices of the terminal apparatus 1200 are shown in fig. 1, the present invention may only relate to some of the devices, for example, the terminal apparatus 1200 only relates to the memory 1220, the processor 1210, the communication device 1240 and the like.
In this embodiment, the memory 1220 of the terminal device 1200 is used for storing instructions for controlling the processor 1210 to operate to perform the dynamic update method according to any embodiment of the present invention. The skilled person can design the instructions according to the disclosed solution. How the instructions control the operation of the processor is well known in the art and will not be described in detail herein.
The communication network 1300 may be a wireless network or a wired network, and may be a local area network or a wide area network. The terminal apparatus 1200 can communicate with the server 1100 through the communication network 1300.
In one embodiment, the terminal device 1200 is installed with a client, the server 1100 is configured to provide a source code file of a patch of the client, and the terminal device 1200 is configured to obtain the source code file from the server 1100 and execute a dynamic update method according to any embodiment of the present invention to implement dynamic update of the client.
The dynamic update system 1000 shown in FIG. 1 is merely illustrative and is in no way intended to limit the present invention, its application, or uses. For example, although fig. 1 shows only one server 1100 and one terminal apparatus 1200, it is not meant to limit the respective numbers, and multiple servers 1100 and/or multiple terminal apparatuses 1200 may be included in the dynamic update system 1000.
< method examples >
Fig. 2 is a schematic flow chart of a dynamic update method according to an embodiment of the present invention, where the dynamic update method of the present embodiment is implemented by a terminal device installed with a client, for example, the terminal device 1200 in fig. 1.
As shown in fig. 2, the dynamic update method in the present embodiment includes the following steps S2100 to S2300.
In step S2100, a source code file of a patch of the client is obtained.
The client is also called a client, and is a program for providing local services to the client. For example, the client may be a web browser, an email client when receiving and sending an email, or an instant messaging client, and the like, which is not limited herein.
The patch of the client may be understood as: an applet written to fix a client to solve a problem exposed by the client during use.
In one example, the client is, for example, an android (android id) client.
In one example, the source code file may be a source code file written in a scripting language, for example, the source code file is written in a js language, or a source code file written in a Lua language, etc. In this example, since the scripting language is a lightweight language and has good interpretability, writing the source code file by using the scripting language can effectively reduce the size of the file and improve the readability of the source code file.
In another example, the source code file may be a source code file written in a markup language, for example, the source code file is a source code file written in an xml language, and the like. In this example, since the markup language is also a lightweight language and has good interpretability, writing the source code file using the markup language can also effectively reduce the file size and improve the readability of the source code file.
In an example, the source code file may be actively issued to the terminal device by a server, for example, the server 1100 in fig. 1, so that the terminal device obtains the source code file according to the step S2100.
In another example, the obtaining of the source code file of the patch of the client in step S2100 may include: and responding to the set event, and acquiring a source code file of the patch of the client.
The set event may include any one or more of a set time interval, a received update notification sent by the server, a client restart, and a terminal device restart.
In this example, the terminal device may send a request for obtaining the source code file to the server in response to the set time, so that the server issues the source code file to the terminal device according to the request, so that the terminal device obtains the source code file.
In step S2200, the source code file obtained in step S2100 is converted into an executable file.
Taking the client as an android client as an example, the executable file is an executable file that can run on an android virtual machine, for example, the executable file is a dex file.
For example, the source code file is a source code file written in js language, that is, a js file, and in this step S2200, the terminal device may call a converter for converting the js file into a dex file, and convert the source code file into an executable file.
For another example, the source code file is a source code file written in the Lua language, that is, a Lua file, and in step S2200, the terminal device may call a converter for converting the Lua file into a dex file, so as to convert the source code file into an executable file.
For another example, the source code file is a source code file written in xml language, that is, an xml file, and in step S2200, the terminal device may call a converter for converting the xml file into a dex file, so as to convert the source code file into an executable file.
In an embodiment, after obtaining the executable file according to the step S2200 by the terminal device, the terminal device may record a mapping relationship between the executable file and the source code file of the patch, for example, record a source code file version of the executable file, so as to facilitate management of the patch file and the patch file version.
Step S2300, the executable file obtained in step S2200 is called, and the corresponding client is run.
According to the step S2300, the corresponding client is operated by calling the executable file of the patch, so that the client can be dynamically updated by the patch.
After the source code file is converted into the executable file according to the above step S2200, the executable file may be loaded to the memory for the step S2300 to call.
In an example, the step S2300 of calling the executable file to run the client may include the following steps S2310 to S2320:
in step S2310, a repair object registered for the client is searched.
According to the step S2310, a designer of the client may register a repair object that may need to be changed after the client is developed in advance, where the repair object may include a class method of java class, that is, a function method in the java class. The repaired object will have a record to be instrumented for modification after registration.
The search performed according to step S2310 may be a search performed in the client operation.
The lookup performed according to step S2310 may also be a lookup performed in client initialization.
In the example, the repair object which may need to be changed is registered during development, so that the whole class of the client does not need to be loaded and replaced during the later repair of the client, and the method of each class does not need to be inserted, so that the performance of the client is not affected by the dynamic update of the client.
Step S2320, the executable file of the repair object is called to run the client.
In an example, the invoking of the executable file of the repair object in step S2320 to run the client may include S2321 to S2321:
step S2321, when the client runs to the repair object, it is detected whether there is an executable file corresponding to the repair object locally.
In step S2321, "when the client runs to the repair object" may be understood as that the repair object is to be called to run the client.
Step S2322, when the executable file corresponding to the repair object is detected, the detected executable file is called to execute the corresponding repair object.
In this example, each time the client runs to the registered repair object, the terminal device detects whether the client locally has an executable file corresponding to the repair object according to step S2321, so that, in the case of having the executable file corresponding to the repair object, the terminal device invokes the detected executable file to execute the corresponding repair object, and abandons the original execution content, thereby implementing dynamic update on the client.
In this example, if the executable file corresponding to the repair object is not detected, the corresponding repair object may be executed according to the original execution content.
In this example, if the repair timing of each repair object is registered when the repair object is registered, or referred to as a repair priority, in the case where an executable file corresponding to the repair object is not detected, further processing can be performed according to the repair timing of the repair object.
The above repair timing may include, for example, real-time validation, next startup validation, synchronous wait validation, and the like.
The real-time validation is the validation priority of the main application in this example, and for the repair object whose validation priority is real-time validation, when the client runs to the repair object, if the executable file corresponding to the repair object is detected, the executable file is called to execute the repair object.
For the repair object whose effective priority is synchronous waiting for effectiveness, when the client runs to the repair object, if it is detected that there is a source code file corresponding to the patch of the repair object and the source code file is being converted into an executable file according to the step S2200 above, but the whole conversion and loading process is not completed, then it is necessary to synchronously wait for the source code file to complete conversion and then call the source code file. The effective priority is generally applied to a repair object which has a large influence on the whole service link and does not belong to the application main thread.
The next startup effect is mainly performed for some set special scenes, for example, a service flow that a patch needs to be repaired is located in the middle of the whole call link, if the modified patch logic is forcibly applied at this time, some service interaction or content errors may be caused, and to avoid this, the effective priority of the corresponding repaired object may be set to be the next startup effect. For the restoration object whose restoration time is valid for the next start, the restoration object can be searched and processed in the initialization stage of the client.
When further processing is performed according to the repair opportunity of the repair object, the step S2320 above calls the executable file corresponding to the repair object to run the client, and the method may further include the following steps S2323 to S2324:
step S2323, if the executable file corresponding to the repair object is not detected, and the repair timing at which the repair object is registered is synchronous waiting to be validated, then it is detected whether there is a source code file corresponding to the repair object that is undergoing the conversion according to step S2200.
Step S2324, in a case that it is detected that there is a source code file corresponding to the repair object that is performing the conversion, waiting for the detected source code file to complete the conversion, and after the conversion is completed, calling the executable file obtained by the conversion to execute the corresponding repair object.
In this example, if a repair object whose repair opportunity is valid for the next time of starting is registered, the invoking an executable file corresponding to the repair object in step S2320 to run the client may further include: when the client runs to the repair object, judging whether the repair opportunity of the registered repair object allows repair in the current running; and if the repair is allowed in the current operation, the operation of detecting whether the executable file corresponding to the repair object exists locally in step S2321 is executed again.
According to the steps S2100 to S2300, for the patch file of the client, the dynamic update method of the embodiment issues the source code file of the patch to the terminal device, so that the source code of the patch file is directly readable at the server, and a technician can directly obtain the logic of the patch code without looking up the corresponding logic through means such as decompilation, so that the error rate of the patch file can be effectively reduced.
According to the steps S2100 to S2300, for the patch file of the client, the dynamic update method of the embodiment directly issues the source code file of the patch to the terminal device, which can simplify the management process for updating the client and is beneficial to timely repairing the online problem.
According to the steps S2100 to S2300, for the code logic which only needs to slightly change the repaired object, according to the embodiment, the client can be updated only by compiling correct calling codes by using the languages such as js and the like and issuing the calling codes to the terminal equipment, so that the using process is simple and quick, and the quick effect of the repaired code logic is facilitated.
Fig. 3 is a flowchart illustrating a dynamic update method according to another embodiment of the invention. The method of the present embodiment is implemented by a terminal device, such as terminal device 1200 in fig. 1.
As shown in fig. 3, the dynamic update method of this embodiment may further include the following steps:
step S3100, in response to the setting event, acquiring a source code file of the patch of the client.
The set event may include any one or more of a set time interval, a received update notification sent by the server, a client restart, and a terminal device restart.
In this embodiment, the terminal device may send a request for acquiring the source code file to the server in response to the set time, so that the server issues the source code file to the terminal device according to the request, so that the terminal device acquires the source code file.
In step S3200, the source code file obtained in step S3100 is converted into an executable file.
In step S3300, the executable file obtained in step S2200 is called, and the corresponding client is run.
Steps S3100 to S3200 respectively correspond to steps S2100 to S2300 of the above embodiment, and the relevant explanation and optional implementation manner of each step S3100 may refer to the description of the corresponding step in the above embodiment, and are not repeated herein.
The dynamic update method of the present embodiment further includes the following steps S3400 to S3600:
in step S3400, a setting entry for setting the above setting event is provided.
The setting entry may be a drop-down list, a text entry box, etc., and is not limited herein.
As shown in fig. 4, for the client installed on the terminal device, a setting entry for performing update of the client may be provided in the setting thereof, and when the user clicks the update setting, an event of a desired setting may be input.
In step S3500, an event input through the setting entry is acquired.
For example, an event selected through the setting entry is acquired.
In step S3600, the update setting event includes the input event.
In step S3600, the stored setting event may be replaced with an input event, or the input event may be added.
In this embodiment, steps S3400 to S3600 may be executed by the assistant thread, and after the setting event is updated, another thread executing step S3100 is notified, so that the another thread may obtain the source code file of the patch of the client from the server according to the latest setting event.
According to the dynamic updating method of the embodiment, a user or a tester can set a setting event according to needs, so that dynamic updating test and personalized setting are facilitated.
< example >
FIG. 5 illustrates an interaction flow diagram for implementing a dynamic update method according to an embodiment of the invention by the dynamic update system 1000 shown in FIG. 1.
In this example, the dynamic update system 1000 implementing the dynamic update method may include:
in step S1-1, the server 1100 receives and saves the source code file of the uploaded patch of the client.
The source code file is for example a js file.
The source code file may be uploaded to an operator server of the client by a designer of the client.
The server 1100 transmits the source code file to the terminal apparatus 1200 at step S1-2.
In this step, the server 1100 may actively issue the source code file of the patch to the terminal device 1200 when obtaining a new patch. The server 1100 may also provide the source code file to the terminal apparatus 1200 based on a request of the terminal apparatus 1200.
Step S2-1 the terminal apparatus 1200 acquires the source code file of the patch of the client provided by the server 1100.
In step S2-2, the terminal apparatus 1200 converts the source code file into an executable file.
In this step, the terminal device 1200 may call a converter that converts a js file into a dex file, for example, and convert the js file into the dex file.
In step S2-3, the terminal device 1200 calls the converted executable file to run the client.
< apparatus embodiment >
Fig. 6 shows a schematic block diagram of a dynamic update apparatus according to an embodiment of the present invention.
As shown in fig. 6, the dynamic update apparatus 6000 of this embodiment may include a file acquiring module 6100, a file converting module 6200, and an operation managing module 6300.
The file acquiring module 6100 may be used to acquire a source code file of a patch of a client.
The source code file can be a source code file written by js language, a source code file written by Lua language or a source code file written by xml language.
The file conversion module 6200 may be used to convert the source code file into an executable file.
The executable file may be a dex file capable of running on an android virtual machine.
The operation management module 6300 may be configured to call the executable file to operate the client.
In one embodiment, the file acquiring module 6100 may be configured to acquire a source code file of a patch of a client in response to a set event.
In one embodiment, the dynamic update apparatus 6000 may further include a setting module, the setting module being configured to: providing a setting entrance for setting the setting event; acquiring an event input through the setting entrance; and updating the set event to include the input event.
In one embodiment, the operation management module 6300 may be configured to: searching a repair object registered for the client; and calling the executable file corresponding to the repair object to run the client.
The repair object may comprise, for example, a class method of the java class.
In one embodiment, the operation management module 6300 may be further configured to: when the client runs to the repair object, detecting whether an executable file corresponding to the repair object exists locally; and under the condition that the executable file corresponding to the repair object is detected, calling the detected executable file to execute the corresponding repair object.
In one embodiment, the operation management module 6300 may further be configured to: under the condition that the executable file corresponding to the repair object is not detected, if the repair time when the repair object is registered is synchronous and waiting to be effective, then detecting whether a source code file corresponding to the repair object is converted by the file conversion module 6200; and, in case it is detected that there is a source code file corresponding to the repair object being converted by the file conversion module 6200, waiting for the file conversion module 6200 to complete the conversion of the detected source code file, and calling the converted executable file to execute the corresponding repair object.
In one embodiment, the operation management module 6300 may further be configured to: when the client runs to the repair object, judging whether the repair opportunity of the registered repair object allows repair in the current running; and under the condition that the repair is allowed in the current operation, detecting whether the executable file corresponding to the repair object exists locally or not.
< apparatus embodiment >
This embodiment provides a terminal device, and as shown in fig. 7, this terminal device 7000 may include the dynamic update apparatus 6000 according to any embodiment of this application.
In another embodiment, the terminal device 7000 may comprise a memory for storing executable commands and a processor for performing the dynamic update method according to any of the embodiments of the present invention under control of the executable commands stored in the memory.
The terminal device 7000 can be, for example, the terminal device 1200 in fig. 1.
< media examples >
The present embodiments provide a computer-readable storage medium having executable instructions stored thereon. When executed by the executor, the executable instruction executes the dynamic update method according to any embodiment of the present invention, as described in the method embodiment.
Each embodiment in this specification is described in a progressive manner, and the same and similar parts among the embodiments may be referred to each other, each embodiment focuses on explaining differences from other embodiments, and the embodiments may be used alone or in combination with each other as needed, for example, a person skilled in the art may combine any two or more method embodiments as needed to implement the information processing method of the present invention, and the method is not limited herein.
The present invention may be a system, method and/or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions embodied therewith for causing a processor to implement various aspects of the present invention.
The computer readable storage medium may be a tangible device that can hold and store the instructions for use by the instruction execution device. The computer readable storage medium may be, for example, but not limited to, an electronic memory device, a magnetic memory device, an optical memory device, an electromagnetic memory device, a semiconductor memory device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), a Static Random Access Memory (SRAM), a portable compact disc read-only memory (CD-ROM), a Digital Versatile Disc (DVD), a memory stick, a floppy disk, a mechanical coding device, such as punch cards or in-groove projection structures having instructions stored thereon, and any suitable combination of the foregoing. Computer-readable storage media as used herein is not to be construed as transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., optical pulses through a fiber optic cable), or electrical signals transmitted through electrical wires.
The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to a respective computing/processing device, or to an external computer or external storage device via a network, such as the internet, a local area network, a wide area network, and/or a wireless network. The network may include copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. The network adapter card or network interface in each computing/processing device receives computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in the respective computing/processing device.
The computer program instructions for carrying out operations of the present invention may be assembler instructions, Instruction Set Architecture (ISA) instructions, machine-related instructions, microcode, firmware instructions, state setting data, or source or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider). In some embodiments, aspects of the present invention are implemented by personalizing an electronic circuit, such as a programmable logic circuit, a Field Programmable Gate Array (FPGA), or a Programmable Logic Array (PLA), with state information of computer-readable program instructions, which can execute the computer-readable program instructions.
Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer-readable program instructions.
These computer-readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer-readable program instructions may also be stored in a computer-readable storage medium that can direct a computer, programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer-readable medium storing the instructions comprises an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer, other programmable apparatus or other devices implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions. It is well known to those skilled in the art that implementation by hardware, implementation by software, and implementation by a combination of software and hardware are equivalent.
Having described embodiments of the present invention, the foregoing description is intended to be exemplary, not exhaustive, and not limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen in order to best explain the principles of the embodiments, the practical application, or improvements made to the technology in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein. The scope of the invention is defined by the appended claims.
Claims (14)
1. A dynamic update method for a client, implemented by a terminal device, the method comprising:
acquiring a source code file of a patch of the client;
converting the source code file into an executable file;
and calling the executable file to operate the client.
2. The method of claim 1, wherein the source code file is a js language written source code file, a Lua language written source code file, or an xml language written source code file.
3. The method of claim 1, wherein the executable file is a dex file.
4. The method of claim 1, wherein the obtaining a source code file of a patch of the client comprises:
and responding to a set event, and acquiring a source code file of the patch of the client.
5. The method of claim 4, wherein the method further comprises:
providing a setting entrance for setting the setting event;
acquiring an event input through the setting entrance;
updating the set event includes the entered event.
6. The method of any of claims 1-5, wherein the invoking the executable file to run the client comprises:
searching a repair object registered for the client;
and calling the executable file corresponding to the repaired object to run the client.
7. The method of claim 6, wherein said invoking the executable file corresponding to the repair object runs the client, comprising:
when the client runs to the repair object, detecting whether the executable file corresponding to the repair object exists locally;
and under the condition that the executable file corresponding to the repair object is detected, calling the detected executable file to execute the corresponding repair object.
8. The method of claim 7, wherein the invoking the executable file corresponding to the repair object runs the client, further comprising:
when the client runs to the repair object, judging whether the repair opportunity of the registered repair object allows repair in the current running;
and under the condition that the repair is allowed in the current operation, the operation of detecting whether the executable file corresponding to the repair object exists locally is executed again.
9. The method of claim 7, wherein the invoking the executable file corresponding to the repair object runs the client, further comprising:
under the condition that the executable file corresponding to the repair object is not detected, if the repair time when the repair object is registered is synchronous and waiting to take effect, then detecting whether the source code file corresponding to the repair object is in the process of conversion;
and under the condition that the source code file corresponding to the repair object is detected to be converted, waiting for the detected source code file to finish the conversion, and calling the executable file obtained by conversion to execute the corresponding repair object after the conversion is finished.
10. The method of claim 6, wherein the repair object comprises a java-like class method.
11. A dynamic update apparatus of a client, comprising:
the file acquisition module is used for acquiring a source code file of the patch of the client;
the file conversion module is used for converting the source code file into an executable file; and the number of the first and second groups,
and the operation management module is used for calling the executable file to operate the client.
12. A terminal device comprising the dynamic update apparatus of claim 11; or, the terminal device includes:
a memory for storing executable instructions;
a processor for performing the method of any one of claims 1 to 10 under the control of the executable instructions.
13. A dynamic update system of a client, comprising a server and the terminal device of claim 12, the terminal device installing the client, wherein:
the server is used for providing a source code file of the patch of the client;
and the terminal equipment is used for acquiring the source code file from the server.
14. A computer-readable storage medium storing executable instructions that, when executed by a processor, perform the method of any one of claims 1-10.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910372463.3A CN111897555B (en) | 2019-05-06 | 2019-05-06 | Dynamic updating method, device and system of client and terminal equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910372463.3A CN111897555B (en) | 2019-05-06 | 2019-05-06 | Dynamic updating method, device and system of client and terminal equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111897555A true CN111897555A (en) | 2020-11-06 |
| CN111897555B CN111897555B (en) | 2024-06-07 |
Family
ID=73169525
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910372463.3A Active CN111897555B (en) | 2019-05-06 | 2019-05-06 | Dynamic updating method, device and system of client and terminal equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111897555B (en) |
Citations (18)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20020144238A1 (en) * | 2001-01-23 | 2002-10-03 | Hanson David R. | Method and apparatus for facilitating execution of applications accepting local path and URL specified file parameters |
| US20040088679A1 (en) * | 2002-11-01 | 2004-05-06 | Grala Darius A. | Software development system for editable executables |
| US20070067437A1 (en) * | 2005-09-19 | 2007-03-22 | Eugene Sindambiwe | Generation of customized client proxies |
| US20070261047A1 (en) * | 2006-05-03 | 2007-11-08 | Microsoft Corporation | Differentiated Installable Packages |
| TW200943185A (en) * | 2008-04-11 | 2009-10-16 | Hon Hai Prec Ind Co Ltd | System and method for updating version of the executable file |
| CN103207779A (en) * | 2012-01-16 | 2013-07-17 | 国际商业机器公司 | Apparatus And Method Useful For Source Code Patches |
| WO2016101503A1 (en) * | 2014-12-24 | 2016-06-30 | 中兴通讯股份有限公司 | Hot patching realization method and apparatus |
| CN106873967A (en) * | 2016-12-28 | 2017-06-20 | 北京五八信息技术有限公司 | The method and apparatus of bug on a kind of reparation APP lines |
| CN106897095A (en) * | 2017-02-24 | 2017-06-27 | 网易（杭州）网络有限公司 | The multiple method of application program hot repair, device and readable storage medium storing program for executing |
| CN107346252A (en) * | 2016-05-07 | 2017-11-14 | 腾讯科技（深圳）有限公司 | Using update method and device |
| CN107368330A (en) * | 2017-05-26 | 2017-11-21 | 阿里巴巴集团控股有限公司 | Client patch restorative procedure, device and system |
| CN107632826A (en) * | 2016-07-14 | 2018-01-26 | 腾讯科技（深圳）有限公司 | The Compilation Method and client of a kind of source code |
| CN108399080A (en) * | 2018-03-05 | 2018-08-14 | 深圳市华讯方舟软件信息有限公司 | A kind of hot update methods of Android App |
| CN108399318A (en) * | 2018-01-31 | 2018-08-14 | 北京顶象技术有限公司 | The generation method of executable file executes method and electronic equipment |
| CN108694049A (en) * | 2017-02-23 | 2018-10-23 | 阿里巴巴集团控股有限公司 | A kind of method and apparatus of update software |
| CN108829431A (en) * | 2018-06-27 | 2018-11-16 | 杭州贝购科技有限公司 | Update method, device, equipment and the storage medium of iOS application program |
| CN109445807A (en) * | 2017-08-28 | 2019-03-08 | 腾讯科技（深圳）有限公司 | Realize the method, apparatus and computer readable storage medium of application program update |
| CN109614109A (en) * | 2018-11-16 | 2019-04-12 | 中国银行股份有限公司 | Using dispositions method, device and system |
-
2019
- 2019-05-06 CN CN201910372463.3A patent/CN111897555B/en active Active
Patent Citations (18)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20020144238A1 (en) * | 2001-01-23 | 2002-10-03 | Hanson David R. | Method and apparatus for facilitating execution of applications accepting local path and URL specified file parameters |
| US20040088679A1 (en) * | 2002-11-01 | 2004-05-06 | Grala Darius A. | Software development system for editable executables |
| US20070067437A1 (en) * | 2005-09-19 | 2007-03-22 | Eugene Sindambiwe | Generation of customized client proxies |
| US20070261047A1 (en) * | 2006-05-03 | 2007-11-08 | Microsoft Corporation | Differentiated Installable Packages |
| TW200943185A (en) * | 2008-04-11 | 2009-10-16 | Hon Hai Prec Ind Co Ltd | System and method for updating version of the executable file |
| CN103207779A (en) * | 2012-01-16 | 2013-07-17 | 国际商业机器公司 | Apparatus And Method Useful For Source Code Patches |
| WO2016101503A1 (en) * | 2014-12-24 | 2016-06-30 | 中兴通讯股份有限公司 | Hot patching realization method and apparatus |
| CN107346252A (en) * | 2016-05-07 | 2017-11-14 | 腾讯科技（深圳）有限公司 | Using update method and device |
| CN107632826A (en) * | 2016-07-14 | 2018-01-26 | 腾讯科技（深圳）有限公司 | The Compilation Method and client of a kind of source code |
| CN106873967A (en) * | 2016-12-28 | 2017-06-20 | 北京五八信息技术有限公司 | The method and apparatus of bug on a kind of reparation APP lines |
| CN108694049A (en) * | 2017-02-23 | 2018-10-23 | 阿里巴巴集团控股有限公司 | A kind of method and apparatus of update software |
| CN106897095A (en) * | 2017-02-24 | 2017-06-27 | 网易（杭州）网络有限公司 | The multiple method of application program hot repair, device and readable storage medium storing program for executing |
| CN107368330A (en) * | 2017-05-26 | 2017-11-21 | 阿里巴巴集团控股有限公司 | Client patch restorative procedure, device and system |
| CN109445807A (en) * | 2017-08-28 | 2019-03-08 | 腾讯科技（深圳）有限公司 | Realize the method, apparatus and computer readable storage medium of application program update |
| CN108399318A (en) * | 2018-01-31 | 2018-08-14 | 北京顶象技术有限公司 | The generation method of executable file executes method and electronic equipment |
| CN108399080A (en) * | 2018-03-05 | 2018-08-14 | 深圳市华讯方舟软件信息有限公司 | A kind of hot update methods of Android App |
| CN108829431A (en) * | 2018-06-27 | 2018-11-16 | 杭州贝购科技有限公司 | Update method, device, equipment and the storage medium of iOS application program |
| CN109614109A (en) * | 2018-11-16 | 2019-04-12 | 中国银行股份有限公司 | Using dispositions method, device and system |
Non-Patent Citations (1)
| Title |
|---|
| 周冲;: "基于服务器/客户端的补丁管理***设计与实现", 微计算机应用, no. 06, pages 55 - 59 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111897555B (en) | 2024-06-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8533691B2 (en) | Managing non-common features for program code translation | |
| CN105718313A (en) | Application operation method and device | |
| CN104536890A (en) | Testing system, method and device | |
| CN111708557B (en) | Method, device and storage medium for updating configuration file | |
| CN106911500B (en) | Physical machine configuration method and device and physical machine | |
| CN111708753A (en) | Method, device and equipment for evaluating database migration and computer storage medium | |
| CN112114789B (en) | Service development method and equipment | |
| US20190082050A1 (en) | Data structure driven interactive voice response (ivr) framework | |
| CN110221840B (en) | Function implementation method and device of application program, equipment and storage medium | |
| CN112835568A (en) | Project construction method and device | |
| CN113709243A (en) | Equipment remote control method and device, electronic equipment and storage medium | |
| CN113986270A (en) | Distributed application deployment method and device, storage medium and electronic equipment | |
| CN113468067A (en) | Application program debugging method and device, electronic equipment and computer readable medium | |
| KR20130014203A (en) | Multi operating system flatform in smart devices | |
| CN110795328A (en) | Interface testing method and device | |
| CN105227597A (en) | A kind of method, Apparatus and system obtaining terminal equipment screen-picture | |
| CN111124874B (en) | Method for debugging webpage, debugging server and main control equipment | |
| CN101710277B (en) | Script processing method, device of embedded browser | |
| CN111897555B (en) | Dynamic updating method, device and system of client and terminal equipment | |
| CN111414154A (en) | Method and device for front-end development, electronic equipment and storage medium | |
| CN111435328A (en) | Application testing method and device, electronic equipment and readable storage medium | |
| CN110599112A (en) | Method and device for developing and maintaining network page | |
| CN113656050B (en) | Method and apparatus for generating version number | |
| CN114168463A (en) | Method and device for switching project environment, storage medium and electronic equipment | |
| CN114745313A (en) | Terminal remote testing method and device, electronic equipment and readable 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 |