CN111897555B - 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
- CN111897555B CN111897555B CN201910372463.3A CN201910372463A CN111897555B CN 111897555 B CN111897555 B CN 111897555B CN 201910372463 A CN201910372463 A CN 201910372463A CN 111897555 B CN111897555 B CN 111897555B
- Authority
- CN
- China
- Prior art keywords
- client
- source code
- file
- repair object
- executable 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 67
- 230000008439 repair process Effects 0.000 claims description 114
- 238000006243 chemical reaction Methods 0.000 claims description 31
- 230000000694 effects Effects 0.000 claims description 8
- 230000008569 process Effects 0.000 claims description 8
- 230000001360 synchronised effect Effects 0.000 claims description 8
- 238000010586 diagram Methods 0.000 description 17
- 238000012545 processing Methods 0.000 description 12
- 238000004891 communication Methods 0.000 description 10
- 238000010200 validation analysis Methods 0.000 description 10
- 230000006870 function Effects 0.000 description 8
- 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
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 238000003491 array Methods 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 239000000835 fiber Substances 0.000 description 2
- 230000002452 interceptive effect Effects 0.000 description 2
- 239000004973 liquid crystal related substance Substances 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000001902 propagating effect Effects 0.000 description 2
- BOJKULTULYSRAS-OTESTREVSA-N Andrographolide Chemical compound C([C@H]1[C@]2(C)CC[C@@H](O)[C@]([C@H]2CCC1=C)(CO)C)\C=C1/[C@H](O)COC1=O BOJKULTULYSRAS-OTESTREVSA-N 0.000 description 1
- 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
- 238000005516 engineering process Methods 0.000 description 1
- 230000014509 gene expression Effects 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000010365 information processing Effects 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 230000003993 interaction Effects 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
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 updating method, a device, a system and terminal equipment of a client, wherein the method is implemented by the terminal equipment and comprises the following steps: acquiring a source code file of the 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 updating technologies of clients, and in particular, to a dynamic updating method of a client, a dynamic updating device of a client, a terminal device, a dynamic updating system of a client, and a computer readable storage medium.
Background
A Client (Client), also called a Client, refers to a program that corresponds to a server and provides local services to the Client.
After release, the client will often need repair updates to the client in order to solve some online problems, or to want to modify some online code logic. One common repair update method is to release a new version of the client to cover an old version, which has the problems of low update efficiency and long period, and further requires a user to perform manual installation operation. In this regard, a scheme of dynamically updating a client by patching is proposed at present, but in the existing dynamic updating scheme, patch files are compiled into executable files at one end of a server and then issued to a terminal device to update the client, which not only increases the management flow of updating the client, is not beneficial to timely repairing on-line problems, but also has the problem that the patch files are unreadable, is not beneficial to error-checking modification of the patch files, and increases the probability of error occurrence of the patch files in an intangible way.
Disclosure of Invention
It is an object of embodiments of the present invention to provide a new dynamic update scheme for clients.
According to a first aspect of the present invention, there is provided a method for dynamic update of a client, implemented by a terminal device, the method comprising:
acquiring a source code file of the patch of the client;
converting the source code file into an executable file;
and calling the executable file to run the client.
Optionally, the source code file is a js-written source code file, a Lua-written source code file or an xml-written source code file.
Optionally, the executable file is a dex file.
Optionally, the obtaining the source code file of the patch of the client includes:
And responding to the setting event, and acquiring a source code file of the patch of the client.
Optionally, the method further comprises:
providing a setting entry for setting the setting event;
Acquiring an event input through the setting inlet;
updating the set event includes the entered event.
Optionally, the calling the executable file to run the client includes:
searching a repair object registered for the client;
And calling the executable file corresponding to the repair object to run the client.
Optionally, the invoking the executable file corresponding to the repair object runs the client, including:
Detecting whether the executable file corresponding to the repair object exists locally or not when the client runs to the repair object;
And calling the detected executable file to execute the corresponding repair object under the condition that the executable file corresponding to the repair object is detected.
Optionally, the invoking the executable file corresponding to the repair object runs the client, and further includes:
When the client runs to the repairing object, judging whether the repairing opportunity of the registered repairing object allows repairing in the running time or not;
And under the condition that the restoration is allowed to be carried out in the current operation, executing the operation of detecting whether the executable file corresponding to the restoration object exists locally.
Optionally, the invoking the executable file corresponding to the repair object runs the client, and further includes:
If the restoration opportunity of the restoration object registered is synchronous waiting to take effect under the condition that the executable file corresponding to the restoration object is not detected, detecting whether the source code file corresponding to the restoration object exists or not to perform the conversion;
And under the condition that the source code file corresponding to the repair object is detected to be in the process of conversion, 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 includes a class method of java class.
According to a 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
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 comprising the dynamic updating apparatus according to the second aspect of the present invention; or the terminal device includes:
a memory for storing executable instructions;
A processor for executing the method according to the first aspect of the invention under 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 a 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;
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 a method according to the first aspect of the present invention.
The patch file in the embodiment of the invention adopts the source code file to issue, so that the source code is directly readable at the server side, technicians can directly know the logic of the patch code without checking the corresponding logic through decompilation and other means, and the error rate of the patch file can be effectively reduced; in addition, the source code file is directly adopted for issuing, so that the management flow for updating the client can be simplified, and the on-line problem can be repaired in time.
Other features of the present invention and its advantages will become apparent from the following detailed description of exemplary embodiments of the invention, 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 of a dynamic update method according to an embodiment of the invention;
FIG. 3 is a schematic flow chart of a dynamic update method according to another embodiment of the invention;
FIG. 4 is a schematic diagram of a setup portal page according to an embodiment of the present invention;
FIG. 5 is a schematic diagram of an interactive flow 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 schematic 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, numerical expressions and numerical values set forth in these embodiments do not limit the scope of the present invention unless it is specifically stated otherwise.
The following description of at least one exemplary embodiment is merely exemplary in nature and is in no way intended to limit the invention, its application, or uses.
Techniques, methods, and apparatus known to persons 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 specific values should be construed as merely illustrative, and not a limitation. Thus, other examples of exemplary embodiments may have different values.
It should be noted that: like reference numerals and letters denote like items in the following figures, and thus once an item is defined in one figure, no further discussion thereof is necessary in subsequent figures.
< Hardware configuration >
After a client is released, in order to solve some on-line problems or to want to modify some on-line code logic, the client will often need to be repaired.
As shown in fig. 1, the dynamic updating system 1000 of the present embodiment includes a server 1100 and a terminal device 1200, the server 1100 and the terminal device 1200 being communicatively connected through a network 1300.
The server 1100 may be, for example, a blade server, a rack server, a cloud server cluster, etc., which is not limited herein.
The server 1100 may include, as shown in fig. 1, 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, ROM (read only memory), RAM (random access memory), 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 can perform wired or wireless communication, for example. The display device 1150 is, for example, a liquid crystal display. The input device 1160 may include, for example, a touch screen, a keyboard, and the like.
Although a plurality of devices of the server 1100 are shown in fig. 1, the present invention may relate to only some of the devices, for example, the server 1100 may relate to only the memory 1120, the processor 1110, the communication device 1140, and the like.
In this embodiment, the memory 1120 of the server 1100 is configured to store instructions for controlling the processor 1110 to perform operations for supporting the dynamic update method according to any embodiment of the present invention, for example, receiving and storing a source code file of a patch of an uploaded client, and issuing the source code file to the terminal device 1200 for the terminal device 1200 to perform the dynamic update method according to any embodiment of the present invention, and so on. The skilled person can design instructions according to the disclosed solution. How the instructions control the processor to operate is well known in the art and will not be described in detail here.
The terminal device 1200 may be a mobile terminal or a fixed terminal, and is not limited thereto, and may be a smart phone, a portable computer, a desktop computer, a tablet computer, or 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 so forth.
The processor 1210 may be a central processing unit CPU, microprocessor MCU, or the like. The memory 1220 includes, for example, ROM (read only memory), RAM (random access memory), 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 may 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 relate to only some of the devices, for example, the terminal apparatus 1200 may relate to only 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 to store 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 instructions according to the disclosed solution. How the instructions control the processor to operate is well known in the art and will not be described in detail here.
The communication network 1300 may be a wireless network or a wired network, or may be a local area network or a wide area network. The terminal device 1200 may 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 used to provide a source code file of a patch of the client, and the terminal device 1200 is used to obtain the source code file from the server 1100 and perform the dynamic update method according to any embodiment of the present invention, so as 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 invention, its applications 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 a plurality of servers 1100 and/or a plurality of terminal apparatuses 1200 may be included in the dynamic update system 1000.
< Method example >
Fig. 2 is a schematic flow chart of a dynamic update method according to an embodiment of the present invention, wherein the dynamic update method of the present embodiment is implemented by a terminal device installed with a client, such as 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 a client is obtained.
The client, also called a client, is a program that provides local services to the client. For example, the client may be a web browser, an email client when receiving email, or an instant messaging client, which are not limited herein.
The patch of the client can be understood as: an applet written to fix a client to solve the problem that the client is exposed to during use.
In one example, the client is, for example, an android (Andro i d) 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 may be a source code file written in js language, or a source code file written in Lua language, or the like. In this example, since the scripting language is a lightweight language and has good interpretation, writing the source code file in the scripting language can effectively reduce the file size 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, e.g., the source code file is a source code file written in xml language, etc. In this example, since the markup language is also a lightweight language and has good interpretation, writing the source code file with the markup language can also effectively reduce the file size and improve the readability of the source code file.
In one example, the source code file may be actively issued by a server, such as the server 1100 of fig. 1, to the terminal device, so that the terminal device obtains the source code file according to the step S2100.
In another example, the obtaining the source code file of the patch of the client in step S2100 may include: and responding to the setting event, and acquiring a source code file of the patch of the client.
The setting event may include any one or more of expiration of a set time interval, receipt of an update notification sent by the server, a client restart, and a terminal device restart.
In this example, the terminal device may send a request to the server to obtain the source code file 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.
Step S2200, converting the source code file obtained via step S2100 into an executable file.
Taking a 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 step S2200, the terminal device may call a js file-to-dex file converter to convert the source code file into an executable file.
For another example, the source code file is a source code file written in Lua language, that is, a Lua file, and in the step S2200, the terminal device may call a converter for converting the Lua file into a dex file, 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 this step S2200, the terminal device may call a converter for converting the xml file into a dex file, and convert the source code file into an executable file.
In one embodiment, after the executable file is obtained by the conversion in step S2200, 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, calling the executable file obtained via step S2200, and running the corresponding client.
According to this step S2300, the corresponding client is executed by calling the executable file of the patch, and the dynamic update of the client can be performed through the patch.
After converting the source code file into the executable file according to the above step S2200, the executable file may be loaded into the memory for the call of step S2300.
In one example, the invoking the executable file running client in step S2300 may include steps S2310-S2320 as follows:
in step S2310, the repair object registered for the client is searched.
According to the step S2310, the designer of the client may register in advance a repair object that may need to be changed later when developing the client, where the repair object may include, for example, a class method of a java class, that is, a function method in the java class. After the repair object is registered, a record is recorded to perform pile inserting modification.
The search performed according to step S2310 may be a search performed in the client run.
The search performed according to step S2310 may also be a search performed in client initialization.
By registering the repair object which possibly needs to be changed during development, the whole class of the replacement client is not required to be loaded during the later repair of the client, the stake-inserting intervention is not required to be carried out on each class method of each class, and 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 one example, the invoking the executable file of the repair object in the step S2320 to run the client may include S2321 to S2321:
In step S2321, when the client runs to the repair object, it is detected whether the local has an executable file corresponding to the repair object.
In the step S2321, "when the client runs to the repair object" may be understood as that the repair object running client is about to be invoked.
In step S2322, when an executable file corresponding to the repair object is detected, the detected executable file is called to execute the corresponding repair object.
In this example, when the client runs to the registered repair object, the terminal device will detect whether the executable file corresponding to the repair object exists locally according to step S2321, so as to invoke the detected executable file to execute the corresponding repair object under the condition that the executable file corresponding to the repair object exists, and discard the original execution content, thereby implementing dynamic update of 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 a repair timing of each repair object is registered at the time of registration of the repair object, or referred to as repair priority, in the case where an executable file corresponding to the repair object is not detected, further processing may be performed according to the repair timing of the repair object.
The above repair opportunities may include, for example, real-time validation, next start validation, synchronous wait validation, etc.
The real-time validation is the validation priority of the main application in the example, and for a repair object whose validation priority is real-time validation, when the client runs to the repair object, if an executable file corresponding to the repair object is detected, the executable file is called to execute the repair object.
For a repair object with a validation priority of synchronous waiting for validation, when a client runs to the repair object, if it is detected that a source code file corresponding to a patch of the repair object exists, and the source code file is being converted into an executable file according to the above step S2200, but the whole conversion and loading process is not completed, it is necessary to wait for the source code file to be transferred after completing conversion. Such validation priorities are typically applied to repair objects where patch logic has a relatively large impact on the overall traffic link and does not belong to the application main thread.
The next time of starting to take effect mainly aims at some set special scenes, for example, the service flow to be repaired by the patch is in the middle position of the whole call link, if the modified patch logic is forcibly applied at the moment, certain service interaction or content error can be caused, and in order to avoid the situation, the effective priority of the corresponding repair object can be set as the next time of starting to take effect. For the repairing object with the repairing time being the next starting effective, searching and processing can be carried out in the initialization stage of the client.
When further processing is performed according to the repair opportunity of the repair object, the step S2320 of calling the executable file corresponding to the repair object to run the client may further include the following steps S2323 to S2324:
in step S2323, if the executable file corresponding to the repair object is not detected, if the registered repair opportunity of the repair object is synchronous waiting to be effective, it is further detected whether the source code file corresponding to the repair object exists for conversion according to step S2200.
Step S2324, when it is detected that the source code file corresponding to the repair object is in the process of performing the conversion, waiting for the detected source code file to complete the conversion, and calling the executable file obtained by conversion to execute the corresponding repair object after the conversion is completed.
In this example, if the repair object whose repair opportunity is the next repair object to be started and validated is registered, invoking the executable file corresponding to the repair object to run the client in the above step S2320 may further include: when the client runs to the repair object, judging whether the registered repair opportunity of the repair object allows repair in the running process; and if the repair is allowed in the present operation, the above operation of detecting whether the local executable file corresponding to the repair object 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 present embodiment issues the patch source code file to the terminal device, so that the patch file is directly readable by source code at the server, and a technician can directly learn the logic of the patch code without checking the corresponding logic by decompilation or other means, thereby effectively reducing the error rate of the patch file.
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 flow for the update of 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 repair object, according to the embodiment, only the js and other languages are used for writing the correct calling code and issuing the correct calling code to the terminal device, so that the updating of the client can be completed, the use process is simple and quick, and the quick effect of the repair code logic is facilitated.
Fig. 3 is a flow chart of 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.
According to the embodiment, as shown in fig. 3, the dynamic update method 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 setting event may include any one or more of expiration of a set time interval, receipt of an 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 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 S3200, the source code file obtained in step S3100 is converted into an executable file.
Step S3300, call the executable file obtained via step S2200, and run the corresponding client.
The above steps S3100 to S3200 correspond to the steps S2100 to S2300 of the above embodiments, respectively, and the explanation and the optional implementation of each step S3100 may refer to the explanation of the corresponding steps of the above embodiments, which is not repeated herein.
The dynamic updating method of the present embodiment further includes the following steps S3400 to S3600:
step S3400, a setting entry for setting the above setting event is provided.
The settings entry may be a drop down list, text entry box, etc., without limitation.
As shown in fig. 4, for a client installed on a terminal device, a setting entry for performing update of the client may be provided in its setting, and when a user clicks the update setting, an event of a desired setting may be input.
Step S3500, acquire an event input through the setting entry.
For example, an event selected through the setting entry is acquired.
In step S3600, the update setting event includes the input event.
The step S3600 may be performed by replacing the stored setting event with the input event or by adding the input event.
In this embodiment, steps S3400 to S3600 may be executed by the assist thread, and after updating the setting event, notify another thread executing step S3100, 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 the needs, so that dynamic updating test and personalized setting are convenient to conduct.
< Example >
Fig. 5 illustrates an interactive flow diagram for implementing a dynamic update method according to an embodiment of the present invention by the dynamic update system 1000 illustrated 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 for the client.
The source code file is, for example, a js file.
The source code file may be uploaded to the operator server of the client by the designer of the client.
In step S1-2, the server 1100 transmits the source code file to the terminal device 1200.
In this step, the server 1100 may actively issue the source code file of the patch to the terminal device 1200 when a new patch is obtained. The server 1100 may also provide the source code file to the terminal device 1200 based on the request of the terminal device 1200.
Step S2-1, the terminal device 1200 acquires the source code file of the patch of the client provided by the server 1100.
In step S2-2, the terminal device 1200 converts the source code file into an executable file.
In this step, the terminal apparatus 1200 is, for example, a converter that can call js file to dex file, and converts js file to dex file.
In step S2-3, the terminal device 1200 calls the converted executable file to run the client.
< Device example >
Fig. 6 shows a functional block diagram of a dynamic updating apparatus according to an embodiment of the present invention.
As shown in fig. 6, the dynamic updating apparatus 6000 of the present embodiment may include a file acquisition module 6100, a file conversion module 6200, and a run management module 6300.
The file acquisition 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 in js language, a source code file written in Lua language or a source code file written in xml language.
The file conversion module 6200 may be configured to convert a source code file into an executable file.
The executable file may be a dex file capable of running on an android virtual machine.
The run management module 6300 may be used to invoke the executable to run the client.
In one embodiment, the file acquisition module 6100 may be used to acquire a source code file of a patch of a client in response to a setup event.
In one embodiment, the dynamic updating apparatus 6000 may further include a setting module for: providing a setting entry for setting the setting event; acquiring an event input through the setting entry; and updating the setting event includes the entered event.
In one embodiment, the operation management module 6300 may be configured to: searching a repair object registered for a client; and calling the executable file corresponding to the repair object to run the client.
The repair object may include, for example, a class method of the java class.
In one embodiment, the operation management module 6300 may be further to: when a client runs to the repair object, detecting whether an executable file corresponding to the repair object exists locally; and calling the detected executable file to execute the corresponding repair object under the condition that the executable file corresponding to the repair object is detected.
In one embodiment, the operation management module 6300 may be further configured to: under the condition that the executable file corresponding to the repair object is not detected, if the registered repair time of the repair object is synchronous waiting to take effect, detecting whether the source code file corresponding to the repair object exists or not, and converting the source code file by a file conversion module 6200; and, in the case that it is detected that the source code file corresponding to the repair object is being converted by the file conversion module 6200, waiting for the file conversion module 6200 to complete conversion of the detected source code file, and calling the executable file obtained by conversion to execute the corresponding repair object.
In one embodiment, the operation management module 6300 may be further configured to: when the client runs to the repair object, judging whether the registered repair opportunity of the repair object allows repair in the running process; and under the condition that the restoration is allowed in the current operation, executing the operation of detecting whether the local executable file corresponding to the restoration object exists.
< Device example >
This embodiment provides a terminal device, as shown in fig. 7, where the terminal device 7000 may include the dynamic updating apparatus 6000 according to any embodiment of the application.
In another embodiment, the terminal device 7000 may comprise a memory for storing executable commands and a processor for performing the dynamic updating method in accordance with any embodiment of the invention under control of the executable commands stored in the memory.
The terminal device 7000 may be, for example, the terminal device 1200 in fig. 1.
< Example of Medium >
The present embodiment provides a computer-readable storage medium storing executable instructions. When the executable instructions are executed by the executor, the method for dynamically updating the data according to any embodiment of the present invention is executed, and specific reference is made to the description of the method embodiment.
In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are referred to each other, and each embodiment is mainly described as different from other embodiments, and each embodiment may be used alone or in combination with each other according to need, for example, a person skilled in the art may combine any two or more method embodiments according to need to implement the information processing method of the present invention, which 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 thereon for causing a processor to implement aspects of the present invention.
The computer readable storage medium may be a tangible device that can hold and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage 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: portable computer disks, hard disks, random Access Memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static Random Access Memory (SRAM), portable compact disk read-only memory (CD-ROM), digital Versatile Disks (DVD), memory sticks, floppy disks, mechanical coding devices, punch cards or in-groove structures such as punch cards or grooves having instructions stored thereon, and any suitable combination of the foregoing. Computer-readable storage media, as used herein, are not to be construed as transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., optical pulses through fiber optic cables), or electrical signals transmitted through 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 over 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 transmissions, wireless transmissions, routers, firewalls, switches, gateway computers and/or edge servers. The network interface 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.
Computer program instructions for carrying out operations of the present invention may be assembly 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 be executed 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 kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected 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 electronic circuitry, such as programmable logic circuitry, field Programmable Gate Arrays (FPGAs), or Programmable Logic Arrays (PLAs), with state information for computer readable program instructions, which can execute the computer readable program instructions.
Various 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 having the instructions stored therein includes 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 flowcharts 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 all equivalent.
The foregoing description of embodiments of the invention has been presented for purposes of illustration and description, and is not intended to be exhaustive or 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 various embodiments described. The terminology used herein was chosen in order to best explain the principles of the embodiments, the practical application, or the technical improvement 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 (13)
1. A method for dynamically updating a client, implemented by a terminal device, the method comprising:
acquiring a source code file of the patch of the client;
converting the source code file into an executable file;
calling the executable file to run the client;
wherein the calling the executable file to run the client comprises:
searching a repair object registered for the client;
Invoking the executable file corresponding to the repair object to run the client; and under the condition that the executable file corresponding to the repair object is not detected, if the registered repair opportunity of the repair object is synchronous and waiting to take effect, calling the executable file obtained by conversion to execute the corresponding repair object after the source code file corresponding to the repair object is detected to finish the conversion.
2. The method of claim 1, wherein the source code file is a js-written source code file, a Lua-written source code file, or an xml-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 the source code file of the patch of the client comprises:
And responding to the setting 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 entry for setting the setting event;
Acquiring an event input through the setting inlet;
updating the set event includes the entered event.
6. The method of claim 1, wherein the invoking the executable file corresponding to the repair object to run the client comprises:
Detecting whether the executable file corresponding to the repair object exists locally or not when the client runs to the repair object;
And calling the detected executable file to execute the corresponding repair object under the condition that the executable file corresponding to the repair object is detected.
7. The method of claim 6, wherein the invoking the executable file corresponding to the repair object runs the client, further comprising:
When the client runs to the repairing object, judging whether the repairing opportunity of the registered repairing object allows repairing in the running time or not;
And under the condition that the restoration is allowed to be carried out in the current operation, executing the operation of detecting whether the executable file corresponding to the restoration object exists locally.
8. The method of claim 6, wherein the invoking the executable file corresponding to the repair object runs the client, further comprising:
If the restoration opportunity of the restoration object registered is synchronous waiting to take effect under the condition that the executable file corresponding to the restoration object is not detected, detecting whether the source code file corresponding to the restoration object exists or not to perform the conversion;
And under the condition that the source code file corresponding to the repair object is detected to be in the process of conversion, 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.
9. The method of claim 1, wherein the repair object comprises a class method of a java class.
10. 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 operation management module is used for calling the executable file to operate the client;
The operation management module is used for searching a repair object registered for the client; invoking the executable file corresponding to the repair object to run the client; and under the condition that the executable file corresponding to the repair object is not detected, if the registered repair opportunity of the repair object is synchronous and waiting to take effect, calling the executable file obtained by conversion to execute the corresponding repair object after the source code file corresponding to the repair object is detected to finish the conversion.
11. A terminal device comprising the dynamic updating apparatus of claim 10; or the terminal device includes:
a memory for storing executable instructions;
A processor for performing the method according to any of claims 1-9 under control of the executable instructions.
12. A dynamic update system of a client, comprising a server and the terminal device of claim 11, the terminal device installing the client, wherein:
The server is used for providing a source code file of the patch of the client;
The terminal equipment is used for acquiring the source code file from the server.
13. A computer readable storage medium storing executable instructions which, when executed by a processor, perform the method of any one of claims 1-9.
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 CN111897555A (en) | 2020-11-06 |
| CN111897555B true 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 (14)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| 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 |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7073165B2 (en) * | 2001-01-23 | 2006-07-04 | Microsoft Corporation | Method and apparatus for facilitating execution of applications accepting local path and URL specified file parameters |
| US6904591B2 (en) * | 2002-11-01 | 2005-06-07 | Oz Development, Inc. | Software development system for editable executables |
| US8090818B2 (en) * | 2005-09-19 | 2012-01-03 | Sap Ag | Generation of customized client proxies |
| US8578363B2 (en) * | 2006-05-03 | 2013-11-05 | Microsoft Corporation | Differentiated installable packages |
-
2019
- 2019-05-06 CN CN201910372463.3A patent/CN111897555B/en active Active
Patent Citations (14)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| 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 |
|---|
| 基于服务器/客户端的补丁管理***设计与实现;周冲;;微计算机应用(06);55-59 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111897555A (en) | 2020-11-06 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108345531B (en) | Test method, device and system | |
| US8533691B2 (en) | Managing non-common features for program code translation | |
| CN110825411B (en) | Upgrading method and device for TWS (two way satellite System) earphone system and computer-readable storage medium | |
| CN111708557B (en) | Method, device and storage medium for updating configuration file | |
| CN112463634B (en) | Software testing method and device under micro-service architecture | |
| CN104536890A (en) | Testing system, method and device | |
| CN111708753A (en) | Method, device and equipment for evaluating database migration and computer storage medium | |
| US10320979B2 (en) | Data structure driven interactive voice response (IVR) framework | |
| CN113505302A (en) | Method, device and system for supporting dynamic acquisition of buried point data and electronic equipment | |
| KR20130014203A (en) | Multi operating system flatform in smart devices | |
| CN111897555B (en) | Dynamic updating method, device and system of client and terminal equipment | |
| CN110795328A (en) | Interface testing method and device | |
| CN105227597A (en) | A kind of method, Apparatus and system obtaining terminal equipment screen-picture | |
| CN111435328B (en) | Application testing method and device, electronic equipment and readable storage medium | |
| CN116938958A (en) | API information synchronization method, device, system and computer readable storage medium | |
| CN105278928A (en) | IVR external interface configuration method and IVR external interface configuration device | |
| CN111124874B (en) | Method for debugging webpage, debugging server and main control equipment | |
| CN101710277B (en) | Script processing method, device of embedded browser | |
| CN111414154A (en) | Method and device for front-end development, electronic equipment and storage medium | |
| US10311138B2 (en) | Preventing partial change set deployments in content management systems | |
| CN112905464B (en) | Application running environment data processing method and device | |
| CN113656050B (en) | Method and apparatus for generating version number | |
| CN113342553A (en) | Data acquisition method and device, electronic equipment and storage medium | |
| CN112995254B (en) | Method, equipment, system, device and component for transmitting heartbeat information | |
| CN113407229B (en) | Method and device for generating offline scripts |
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 |