CN116431193A

CN116431193A - Program patch package packaging method and device, storage medium and electronic equipment

Info

Publication number: CN116431193A
Application number: CN202310556673.4A
Authority: CN
Inventors: 韩安波
Original assignee: Netease Hangzhou Network Co Ltd
Current assignee: Netease Hangzhou Network Co Ltd
Priority date: 2023-05-15
Filing date: 2023-05-15
Publication date: 2023-07-14

Abstract

The embodiment of the application discloses a program patch package packaging method, a program patch package packaging device, a storage medium and electronic equipment, wherein the method comprises the following steps: comparing the full file list of the current version of the program with the full file list of the reference version, determining a difference file, wherein the reference version is the previous version of the current version; acquiring current version patch package version information corresponding to a current version of a program, and acquiring a full file list of all version patches of the program from an original version to the current version; and packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain the patch package. The difference files between adjacent versions and the full file list of all version patch packages are packaged into the patch packages, so that when the client updates a program according to the patch packages, the files to be updated, which need to be updated, can be determined through the full file list of all version patch packages, and then the files to be updated are updated.

Description

Program patch package packaging method and device, storage medium and electronic equipment

Technical Field

The present invention relates to the field of computers, and in particular, to a method and an apparatus for packaging a program patch package, a computer readable storage medium, and an electronic device.

Background

In recent years, with the development and popularization of computer equipment technology, more and more applications such as: instant messaging applications, car calling applications, game applications, and the like.

In the prior art, taking a game application program as an example, when content updating is performed on the game application program, two modes of hot updating and patch (patch) updating are generally adopted, wherein the hot updating is a common updating mechanism, but usually, the hot updating is only used as an auxiliary means of patch to update codes, quickly repair game bugs or update game data. Patch can then update resources, code, and even engines, with more complete functionality. Updates to game-like applications should support both patch and hot updates.

In the research and practice process of the prior art, the inventor of the present application finds that in the update of the application program, the prior art generally uses a full-scale patch mode to update, and the full-scale patch uses all game resources as patches, but the full-scale patch is generally used for micro-terminals or application programs with low resource amount, and for non-micro-terminals or application programs with high resource amount, if the full-scale patch is continuously used, users need to download a large amount of resources each time, which is time-consuming.

Disclosure of Invention

The embodiment of the application provides a method and a device for packaging a program patch package, which can update non-micro-end or application programs with large resource amount without using full-amount patch, and reduce downloading time.

In order to solve the technical problems, the embodiment of the application provides the following technical scheme:

a packing method of a program patch package is applied to a server and comprises the following steps:

comparing a full file list of a current version of a program with a full file list of a reference version, and determining a difference file, wherein the reference version is the previous version of the current version;

acquiring current version patch package version information corresponding to a current version of a program, and acquiring a full file list of all version patches of the program from an original version to the current version;

and packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages.

An updating method based on a program patch package is applied to a client and is characterized by comprising the following steps:

comparing the current version patch version information in the patch with the client patch version information of the program in the client;

if the current version patch package version information is different from the client patch package version information, downloading the patch package;

Determining a target full file list based on the program inclusion file of the client and the full file list of all version patch packages in the patch packages;

determining a full file list of the client based on the program inclusion file of the client and the file of the client patch package of the client;

comparing the full file list of the client with the target full file list to determine a file to be updated;

and downloading the file to be updated from the server, and updating the program of the client.

A packaging device of a program patch package, applied to a server, comprising:

the first comparison module is used for comparing the full file list of the current version of the program with the full file list of the reference version, and determining a difference file, wherein the reference version is the previous version of the current version;

the system comprises an acquisition module, a storage module and a storage module, wherein the acquisition module is used for acquiring current version patch package version information corresponding to a current version of a program and acquiring a full file list of all version patches of the program from an original version to the current version;

and the first packing module is used for packing the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages.

An updating device based on a program patch package, applied to a client, comprising:

the second comparison module is used for comparing the current version patch version information in the patch with the client patch version information of the program in the client;

the downloading module is used for downloading the patch package if the current version patch package version information is different from the client patch package version information;

the first determining module is used for determining a target full file list based on the program inclusion file of the client and the full file list of all version patch packages in the patch packages;

the second determining module is used for determining a full file list of the client based on the program inclusion file of the client and the file of the client patch package of the client;

the third comparison module is used for comparing the full file list of the client with the full file list of the target to determine a file to be updated;

and the updating module is used for downloading the file to be updated from the server and updating the program of the client.

A computer readable storage medium storing a plurality of instructions adapted to be loaded by a processor to perform the steps of the method of packaging a program patch package described above.

An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the steps in the method of packaging a program patch package as described above when the program is executed by the processor.

The method comprises the steps of determining a difference file by comparing a full file list of a current version of a program with a full file list of a reference version, wherein the reference version is the previous version of the current version; acquiring current version patch package version information corresponding to a current version of a program, and acquiring a full file list of all version patches of the program from an original version to the current version; and packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages. Therefore, the difference files between adjacent versions and the full file list of all version patch packages are packaged into the patch packages, so that when the client updates a program according to the patch packages, the files to be updated, which need to be updated, can be determined through the full file list of all version patch packages, and then the files to be updated are updated. Avoiding using a full amount of tabs, users need to download a lot of resources each time they download a tab, which is time consuming.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the description of the embodiments will be briefly introduced below, it being obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.

Fig. 1a is a system schematic diagram of a method for packaging a program patch package according to an embodiment of the present application.

Fig. 1b is a flowchart of a method for packaging a program patch package according to an embodiment of the present application.

Fig. 1c is a schematic diagram of program version update according to an embodiment of the present application.

Fig. 1d is a schematic flow chart of patch package packaging according to an embodiment of the present application.

Fig. 1e is a schematic diagram of an update flow based on a program patch package according to an embodiment of the present application.

Fig. 2a is a schematic structural diagram of a packaging device for a program patch package according to an embodiment of the present application.

Fig. 2b is a schematic structural diagram of an update device based on a program patch package according to an embodiment of the present application.

Fig. 3 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application. It will be apparent that the described embodiments are only some, but not all, of the embodiments of the present application. All other embodiments, which can be made by those skilled in the art based on the embodiments herein without making any inventive effort, are intended to be within the scope of the present application.

Referring to fig. 1a, fig. 1a is a schematic system diagram of a method for packaging a program patch package according to an embodiment of the present application, where the system may include at least one client 1000, at least one electronic device 2000, at least one database 3000, and a network 4000. The client 1000 may be a mobile phone, a computer, a personal digital assistant, or other devices, the electronic device 2000 may be connected to the client 1000 through the network 4000, and the electronic device 2000 may be used to provide resources such as a patch package, a program package file, and the like required for program update to the client 1000. The network 4000 may be a wireless network or a wired network, such as a Wireless Local Area Network (WLAN), a Local Area Network (LAN), a cellular network, a 2G network, a 3G network, a 4G network, a 5G network, etc. In addition, the system may include a database 3000, where the database 3000 may be used to store resources such as control records generated by a user manipulating a program within the client 1000.

The embodiment of the application provides a method for packaging a program patch package, which can be executed by the electronic device 2000. As shown in fig. 1a, the electronic device 2000 compares the full file list of the current version of the program with the full file list of the reference version, and determines a difference file, where the reference version is the previous version of the current version; acquiring current version patch package version information corresponding to a current version of a program, and acquiring a full file list of all version patches of the program from an original version to the current version; and packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages.

It should be noted that, the system schematic diagram of the method for packaging a program patch package shown in fig. 1a is only an example, and the packaging system and the scenario of the program patch package described in the embodiments of the present application are for more clearly describing the technical solution of the embodiments of the present application, and do not constitute a limitation to the technical solution provided by the embodiments of the present application, and as one of ordinary skill in the art can know, along with the evolution of the packaging system of the program patch package and the appearance of a new service scenario, the technical solution provided by the embodiments of the present application is equally applicable to similar technical problems.

In this embodiment, description will be made from the viewpoint of a packaging apparatus of a program patch package, which may be integrated in an electronic device having a storage unit and a microprocessor mounted thereon and having arithmetic capability.

Referring to fig. 1b, fig. 1b is a flowchart illustrating a method for packaging a program patch package according to an embodiment of the present application. The packing method of the program patch package comprises the following steps:

in step 101, the full file list of the current version of the program and the full file list of the reference version, which is the previous version of the current version, are compared to determine the difference file.

The update time of each version update of the program is that a developer manually compiles the program in the server, and in order to ensure that the program in the client can adapt to the compilation of the developer, the program in the client needs to be updated by using a patch.

Specifically, when a patch (patch package) is manufactured for the current version update of the client, the full file list of the current version (i.e., the latest version) in the server is compared with the full file list of the reference version (i.e., the previous version of the current version), so that the change of the original file of the reference version and the newly added file of the developer in the manual compiling process are determined, and the files are difference files.

In some embodiments, the program is a game program, and after the step of comparing the full file list of the current version of the program with the full file list of the reference version, the step of determining the difference file further includes:

(1) Determining a static resource file and a dynamic resource file in the game program;

(2) Determining the files except the static resource file and the dynamic resource file in the full file list of the current version as redundant resource files;

(3) And clearing redundant resource files in the difference files to obtain the difference files after redundant processing.

For the size limitation of the file package body and the patch package by different platforms, for example, the first package of the android platform is generally not more than 2GB and the platform is 12 GB), the patch package also has the corresponding size limitation, so in order to avoid that the patch package cannot pass through the platform, the resource file to be packaged needs to be optimized before the patch package is packaged.

Specifically, for a game program, game resources in the game program are generally divided into two types, namely, static resources and dynamic resources, wherein the static resources generally comprise scenes, materials, shader files (shaders), audio and video, user graphical interfaces (UIs), fonts, configuration files and the like. Dynamic resources generally include: monsters, props, vehicles, firearms, and associated special effects, etc. that are placed by the planner through an editor or form. Therefore, the optimization mode is to determine files except the static resource file and the dynamic resource file in the difference file as redundant resource files, and clear the redundant resource files from the difference file to obtain the difference file after redundant processing.

In some embodiments, after the step of removing the redundant resource file in the difference file to obtain the difference file after the redundancy processing, the method further includes:

(1) Determining a dependent resource file that depends on the difference file;

(2) Determining whether the dependent resource file is in a full file list of a historical version patch package, wherein the full file list of the historical version patch package is a full file list except for a full file list of a current version patch package in the full file list of all version patch packages;

(3) And if the dependent resource file is not in the full file list of the historical version patch package, packaging the dependent resource file into the patch package.

The resource redundancy may cause resource deficiency, so that a dependency needs to be calculated for each difference file, a dependent resource file is determined, the dependent resource file is also packaged into a patch package, and because the dependent resource file does not belong to a newly added file (difference file) of version update, whether the dependent resource file exists in a full file list of a historical version patch package or not needs to be checked, and if the dependent resource file is not in the full file list of the historical version patch package, the dependent resource file needs to be packaged into the patch package together.

In some embodiments, the step of determining the static resource file and the dynamic resource file in the game program includes:

(1.1) acquiring a scene resource file of the game program, and determining a scene dependent resource file on which the scene resource file depends;

(1.2) determining resource files within the whitelist, the scenario resource files, and the scenario-dependent resource files as static resource files in the game program;

(1.3) determining a directly dependent resource file, a table resource file, and an editor resource file that the game program editor depends on;

(1.4) determining the direct-dependent resource file, the table resource file, and the editor resource file as dynamic resource files in the game program.

The determining modes of the static resource file and the dynamic resource file are respectively as follows: for static resource files, some necessary but relatively scattered resources used by the game program, such as materials, shapers, audios and videos, ui, fonts and configuration files are collected to form a white list, and because the scene resources required by the game program are also determined, the scene contains static model, materials, special effects and other resources. Therefore, the game resource dependence needs to be calculated, and the scene, the scene dependence set and the white list form a static part of the game resource.

For dynamic resource files, the dynamic resources of the game program are typically released by form filling or various editors. To achieve dynamic resource collection, the code specification requires that the resource paths cannot be hard coded or spliced within the game, and all game usage resources should be entered by form filling. Form input resources can be obtained by scanning the form. The editor is more complex than the form. The content formats output by the editors may vary, so that it is necessary to provide an editor to obtain a unified interface, and mask the differences in details of the editors. In an embodiment of the present application, 3 interfaces are provided: and obtaining direct resource dependence, obtaining other editing types and editor indexes, obtaining dependence tables and indexes, and realizing interface functions by corresponding editor authors. Forms and forms, editors and editors, there may be dependencies between editors and forms that can be calculated using breadth-first traversal algorithms, with form resources + editor resources + interdependent resources constituting a dynamic portion of game resources.

Specifically, the directly dependent resource file is a direct resource which is not a table and is not dependent on an editor by an editor class, the table resource file is a table resource which is dependent on an editor, and the editor resource file is an editor resource which is dependent on an editor.

In step 102, current version patch package version information corresponding to a current version of a program is obtained, and a full file list of all version patches of the program from an original version to the current version is obtained.

Each time the update of the version releases the patch package, the current version patch package version is the last version of the patch package released by 1. For example, the last release patch package version is 2, the current version patch package version is 3, and the current version patch package version information is used to record the version number of the current version patch package, for example, 3.

Specifically, a full file list of all version patches of all versions released during the program from the first version (i.e., original version) of the most original release to the latest current version is also acquired.

For example, the original version is 1, the current version is 3, then the full file list of all version patches is set of patch 1 from original version 1 to version 2, and patch 2 from version 2 to current version 3. I.e. patch 1+ patch 2.

In step 103, the difference file, the current version patch package version information and the full file list of all the version patch packages are packaged to obtain patch packages.

And packaging the difference file, the current version patch package version information and the full file list of all the version patches to obtain the patches required by updating the program from the reference version to the current version.

In some embodiments, before the step of packaging the difference file, the current version patch version information, and the full file list of all version patches to obtain a patch, the method further includes:

according to a pre-configured blacklist and a white list, removing files with file names belonging to the blacklist from the difference files to obtain target difference files, and obtaining designated files with the file names belonging to the white list;

the step of packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages comprises the following steps:

and packaging the target difference file, the designated file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages.

In the game development, some accidents may exist, resources are wrong or a problem occurs in the issued patch due to the bug of the patch, once the problem occurs, the internal test is good, the problem occurs in the formally issued patch, bad influence is caused, players are very likely to run off, and the effort paid by marketing popularization and diversion is not excessive. The strong bag body is a solution of course, but the bag body is always replaced at will to increase the burden of downloading waiting of a player, so that the confidence and the tolerance of the player to the game are easily eliminated. Therefore, a black-and-white list function is designed as a patch pocket bottom, and if accidents happen, the issued patch can be saved, and the patch can be subsequently repaired on the basis of the task pocket.

The difference file is modified by using a black-and-white list, the white list can add the part which is not in the difference file to the current patch, and the black list can directionally reject the file part in the difference file. The black-and-white lists can be multiple, the sequence of the black-and-white lists does not affect the final result, but various black-and-white lists are processed during encoding, and the sequence is considered to be a complicated operation, so that errors are likely to happen slightly carelessly. The encapsulation may handle either blacklists or whitelists, or any combination of the two. With this function, the fault tolerance of the patch is greatly improved.

For example, when the last version is updated and there is a bug caused by the file a and the file B is missing, the file a may be written into a blacklist and the file B may be written into a whitelist when the patch package is packaged, so that the file a is removed from the difference file by using the blacklist function (because the last version of the file a causes the bug, the developer repairs the file a, and the file a must be the difference file when the comparison version determines the difference file at this time), and the file B is added into the difference file.

(1) Acquiring a inclusion file list of each version of the program;

(2) Sequencing the inclusion file lists according to the version sequence to obtain sequenced inclusion file lists;

(3) Sequentially comparing inclusion file lists of two adjacent versions to determine deleted resource files deleted by each version;

(4) And if the target deleted resource file meeting the preset packaging condition exists in the deleted resource file, packaging the target deleted resource file into the patch package.

Referring to fig. 1c, fig. 1c is a schematic diagram of program version updating according to an embodiment of the present application. According to the patch package packaging method of the embodiment of the application, as shown in fig. 1c, in the development process, a first package 1 is released when a version x1 is released, and the first patch is based on the version x2 and the version x1. With the game development, version x3 issues the nth patch, 3 operations are performed between the n+1th patch: file a was deleted at version x4, added back at version x6, and package m was published at version x 5. At this time, package m downloads and applies patch n+1, and if file A is not in the patch, file A is missing.

Based on the above problems, when the patch package is packaged, the method acquires the inclusion file list of each version of the program, sorts the inclusion file lists according to the version sequence, obtains the sorted inclusion file lists, sequentially compares the inclusion file lists of two adjacent versions, determines the deleted resource file of each version, and packages the target deleted resource file of which the deleted resource file meets the preset packaging condition into the patch package.

In some embodiments, if the target deleted resource file satisfying the preset packaging condition exists in the deleted resource files, the step of packaging the target deleted resource file into the patch package includes:

if the deleted resource file exists in the full file list which is deleted when the package body is released and is not in the historical version patch package and the target deleted resource file exists in the full file list of the current version of the program, the target deleted resource file is packaged into the patch package.

The method comprises the steps that a preset packing condition is 1, and a file is deleted in a release package version; 2. files are not in the history patch; 3. files meeting the above 3 conditions are lost after the release package patch is finished in the current version library, so that the target deleted resource files meeting the preset packaging conditions are required to be packaged into the patch package.

Specifically, a Patch debug (Patch debug) mechanism is also an indispensable content in the Patch scheme. One of the most common problems is that before a patch is formally put out, it is necessary to test the patch to be issued, and the test passes the issue. If the operation is not standard, a lot of manpower and material resources are spent on repairing the wrong patch. It is common practice to redirect the web site of a patch download version file to the web site of the version file to be published, and the patch debug mechanism provides this functionality. In addition, the patch debug also comprises common functions such as modifying package version, modifying the version of the target patch, and the like. If a plurality of incremental patches are downloaded, which patch may have problems needs to be checked, the patches can be emptied, and the patch checking problems are performed one by controlling the patch target version mode. The Debug mechanism greatly facilitates the development and bug positioning of the patch, and is a very practical function in the whole scheme.

The embodiment of the application also provides an updating method based on the program patch package, which is applied to the client and is characterized by comprising the following steps:

(1) Comparing the current version patch version information in the patch with the client patch version information of the program in the client;

(2) If the current version patch package version information is different from the client patch package version information, downloading the patch package;

(3) Determining a target full file list based on the program inclusion file of the client and the full file list of all version patch packages in the patch packages;

(4) Determining a full file list of the client based on the program inclusion file of the client and the file of the client patch package of the client;

(5) Comparing the full file list of the client with the target full file list to determine a file to be updated;

(6) And downloading the file to be updated from the server, and updating the program of the client.

After the program is started each time, the triggering updating mechanism of the client updating program analyzes the latest patch package from the server corresponding to the program, extracts the current version patch package version information in the patch package, compares the current version patch package version information with the client patch package version information of the program in the client, if the comparison is consistent, the client is indicated to have updated the latest version before the client, the client directly enters the program, if the comparison is inconsistent, the client is indicated to need to update, and therefore the whole patch package needs to be downloaded to the client.

Specifically, because version information of programs on different clients are different, the clients need to determine a target full-text file list based on the program package files of the clients and full-text file lists of all version patch packages in the patch packages; determining a client full file list based on the program inclusion file of the client and the file of the client patch package of the client; comparing the full file list of the client with the target full file list to determine a file to be updated; after determining a file to be updated, which is required to be updated, of a program, downloading the file to be updated from a server, and updating the program of a client.

If the file to be updated belongs to the difference file part of the patch package, the file to be updated in the difference file is directly used for updating, and downloading from a server is not needed.

In some embodiments, the step of downloading the patch package includes:

(1) Setting a plurality of downloading starting positions and downloading ending positions for downloading the patch package according to a preset downloading data amount in a downloading website of the patch package;

(2) Downloading part of the patch packages according to the adjacent downloading starting positions and the downloading ending positions to obtain a plurality of part of patch packages;

(3) And merging the plurality of partial patch packages to obtain the patch package.

In order to avoid network anomaly that may cause failure in downloading the entire patch package and waste network traffic, the present application proposes a block downloading scheme, in which a plurality of downloading start positions and downloading end positions are set for the patch package according to a preset downloading data amount (for example, 5 MB). Since the patch package is not a discrete single file, but is composed of a plurality of files, the download start position and the download end position corresponding to each preset download data amount on the patch package can be determined according to the preset download data amount, so that a plurality of download start positions and download end positions are set on the patch package. Downloading part of the patch packages according to the adjacent downloading starting positions and downloading ending positions, namely partitioning the patch packages to obtain a plurality of part of patch packages; and merging the plurality of partial patch packages to obtain the patch package.

Specifically, when all the blocks (partial patch packages) are downloaded, merging is carried out according to the offset of the blocks in the original downloaded file, and md5 verification is carried out after merging, and if verification is passed, the patch file is completely downloaded. If an abnormality occurs, the patch needs to be downloaded again, and the local blocks do not need to be downloaded again, but only the blocks which are not completed yet need to be downloaded.

In some embodiments, the step of merging the plurality of partial patches to obtain the patch includes:

(1.1) determining a downloading starting position and a downloading ending position corresponding to each part of patch package;

and (1.2) combining a plurality of partial patch packages according to a plurality of download starting positions and download ending positions for downloading the patch packages set in the download website of the patch packages to obtain the patch packages.

The method for combining the plurality of partial patches includes the steps of determining a downloading starting position and a downloading ending position corresponding to each partial patch, and combining the plurality of partial patches according to the plurality of downloading starting positions and the plurality of downloading ending positions for downloading the patches in a downloading website of the patch to obtain the patch.

In some embodiments, before the step of comparing the current version patch version information in the patch package with the client patch version information of the program in the client, the method further includes:

(1) When the client does not start the program, detecting whether a client patch package of the client needs to be subjected to hot update;

(2) If the client patch package needs to be subjected to hot updating, the client patch package is subjected to hot updating, and the client patch package subjected to hot updating is obtained;

(3) When the client starts the program, detecting whether the client patch package subjected to the hot update needs to be self-updated or not;

(4) If so, self-updating the client patch package after the hot updating is carried out, and the self-updated client patch package is obtained.

Wherein, if the patch cannot be self-updated, the modification of the patch requires the next start to be effective, which is unacceptable for code real-time. The patch code may be updated in a hot-better manner, but once a hot-better is issued, the hot-better needs to be present all the time, otherwise no hot-better clients download the patch to report errors. And the heat is more suitable for the lightweight update of the patch, if the patch has large updates or iterations, it is also a painful matter to write the hot more code. Therefore, a patch hot update scheme is proposed in which a patch self-update and a patch hot are more combined. So-called patch self-update, a hot update is performed before the patch starts, and then if the patch code has an update, the self-update of the patch is performed first. The self-update of the patch is light and is not shared with the patch code updated by the following resources, and if the self-update of the patch has problems, the self-update is solved by using the hot update.

Specifically, because the hot update needs to close the program and restart the program, in order to avoid time waste, when the client does not start the program, it is preferentially detected whether the client patch package of the client needs to be hot updated; if the client patch package needs to be subjected to hot updating, the client patch package is subjected to hot updating, so that the client patch package subjected to hot updating is obtained, the user is ensured not to be subjected to hot updating after opening the program, and the process of restarting the program is avoided. When the client starts the program, detecting whether the client patch package subjected to the hot update needs to be self-updated or not; if so, self-updating the client patch package after the hot updating is carried out, and the self-updated client patch package is obtained.

In some embodiments, redundant elimination may be performed on the program resource in the client, where the elimination mode is the same as the elimination mode for the patch, and details are not described here. And because the situation that resource deficiency can occur in the rejection, possible reasons for the resource deficiency are as follows: 1. a resource dependency miss; 2. iterating a table or an editor, and disabling the resource scanning; 3. a lack of resources in the white list, etc. Therefore, the missing resource is traced to the source, and the missing resource gradually converges until the missing resource is absent. The missing resources may be logged inside the engine and then the list of missing resources is obtained by scanning the log. And filtering the missing resources, wherein the filtering does exist but does not enter the missing resources inside the package, and obtaining an effective missing resource list. If the missing resource is missing because of resource dependence, then complementing the resource dependence; if the missing resources are from a form or editor, then the form or editor resource collection is completed.

As can be seen from the foregoing, in the embodiment of the present application, the difference file is determined by comparing the full-text file list of the current version of the program with the full-text file list of the reference version, where the reference version is the previous version of the current version; acquiring current version patch package version information corresponding to a current version of a program, and acquiring a full file list of all version patches of the program from an original version to the current version; and packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages. Therefore, the difference files between adjacent versions and the full file list of all version patch packages are packaged into the patch packages, so that when the client updates a program according to the patch packages, the files to be updated, which need to be updated, can be determined through the full file list of all version patch packages, and then the files to be updated are updated. Avoiding using a full amount of tabs, users need to download a lot of resources each time they download a tab, which is time consuming.

Fig. 1d is a schematic flow chart of the patch package packaging according to the embodiment of the present application, as shown in fig. 1 d. The full file list of the version is calculated, different resources are packaged, the map is compressed, and tasks of animation compression can be parallel by using a distributed mode. The father task initiates and obtains the execution result of the subtask, and the generation and release speeds of the patch can be greatly accelerated by using the distributed parallelism.

Specifically, aiming at the android platform, the multi-section sub-packaging function is realized. Depending on game play, we divide the game resources into different phases: initializing to a login stage, a face pinching and novice stage, a world stage and other playing stages. The method comprises the steps of initializing to login, putting resources used in 2 stages of face pinching and novice into a first package, and then downloading the world and other playing subcontracts respectively. The first packet has a size limitation, the size of the resources in the first 2 stages is likely to exceed the limitation, if the size exceeds the standard, the resource adjustment is needed, and the exceeding part of the resources are moved to the next 2 sub-packets. This requires us to be able to distinguish which resources are needed for the first packet and which are not. From the above redundant resource elimination, game resources can be divided into two parts, namely static resources and dynamic resources, and the dynamic resources can be controlled by planning a filling table. The form or editor data of the filled form is planned, and the filled form part is extracted, otherwise, the filled form part is extracted by default.

The previous patch scheme is fully applicable to multi-segment packaging, as multi-segment packaging can be considered part of the bag body. However, if considered long-term, as games are developed and operated, the patch is larger and larger, and the purpose of multi-segment subcontracting is to let the player quickly enter into the game experience of new hand, and decide whether to experience the following game content according to the new hand experience. If the player had downloaded less inclusion resources in the early stages, but had to download a large number of latches, our final objective was not achieved, although this problem would be exposed later in the game operation.

Therefore, a multi-segment sub-package patch is provided, i.e., the patch is also divided into multiple segments, and the corresponding patch is downloaded if the user downloads the corresponding sub-package content. The novice player does not download the world and play sub-package, and does not need to download the corresponding patch. However, the multi-segment sub-packaging of the incremental resources requiring the sub-packaging cannot be performed simply because some resources belong to the depended resources, typical examples are maps, and we can find the dependent maps only through models or special effects, which belong to the dynamic resources at the time of sub-packaging. The correct practice is to run the sub-packaging process once again, and then to cross the patch resources for each sub-packaging, so as to sub-package the patch resources in this way.

Fig. 1e is a schematic diagram of an update flow based on a program patch package according to an embodiment of the present application, as shown in fig. 1 e. Before updating the patch package, detecting whether the patch package is subjected to hot update or not, if so, performing hot update, after hot update, checking whether the patch package is subjected to self-update, if so, downloading a version file to perform patch package self-update, after self-update, detecting whether the package body version of the program is too old, and if so, prompting to download a new package body; if not, determining whether the program bag body is the latest bag body. If not, judging whether the local patch package is the patch package of the latest version. If not, downloading the Bao Quanwen piece list of the patches, acquiring the files to be updated which need to be downloaded based on comparison, downloading part of the patch packages in a block downloading mode, merging the part of the patch packages to obtain patch packages, writing the patch packages into the patch package version files, and finishing updating.

In order to facilitate better implementation of the method for packaging the program patch package provided by the embodiment of the application, the embodiment of the application also provides a device based on the method for packaging the program patch package, which is applied to a server. The meaning of the nouns is the same as that in the above packing method of the program patch package, and specific implementation details can refer to the description in the method embodiment.

Referring to fig. 2a, fig. 2a is a schematic structural diagram of a packaging apparatus for a program patch package according to an embodiment of the present application, where the packaging apparatus for a program patch package may include a first comparing module 201, an obtaining module 202, a first packaging module 203, and so on.

A first comparison module 201, configured to compare a full file list of a current version of a program with a full file list of a reference version, and determine a difference file, where the reference version is a previous version of the current version;

an obtaining module 202, configured to obtain current version patch package version information corresponding to a current version of a program, and obtain a full file list of all version patches of the program from an original version to the current version;

and the first packing module 203 is configured to pack the difference file, the current version patch package version information, and the full file list of all the version patch packages to obtain patch packages.

In some embodiments, the packaging device of the program patch package further includes:

the rejecting module is used for rejecting files with file names belonging to the blacklist from the difference files according to a preset blacklist and a preset whitelist to obtain target difference files, and acquiring designated files with the file names belonging to the whitelist;

the first packing module 203 includes:

and the first packing sub-module is used for packing the target difference file, the appointed file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages.

In some embodiments, the program is a game program, and the packaging device of the program patch package further includes:

the first receiving module is used for determining static resource files and dynamic resource files in the game program;

a third determining module, configured to determine, as a redundant resource file, a file in the full file list of the current version that is divided into the static resource file and the dynamic resource file;

and the clearing module is used for clearing redundant resource files in the difference files to obtain the difference files after redundant processing.

a fourth determining module for determining dependent resource files that depend on the difference file;

a fifth determining module, configured to determine whether the dependent resource file is in a full file list of a historical version patch package, where the full file list of the historical version patch package is a full file list of all version patch packages except the full file list of the current version patch package;

and the second packaging module is used for packaging the dependent resource file into the patch package if the dependent resource file is not in the full file list of the historical version patch package.

In some embodiments, the fourth determination module includes:

a first determining submodule, configured to obtain a scenario resource file of the game program, and determine a scenario dependent resource file on which the scenario resource file depends;

a second determining submodule, configured to determine a resource file in a whitelist, the scene resource file, and the scene-dependent resource file as static resource files in the game program;

a third determination submodule for determining a direct-dependent resource file, a form resource file and an editor resource file which are relied on by the game program editor;

And a fourth determining sub-module, configured to determine the directly dependent resource file, the table resource file, and the editor resource file as dynamic resource files in the game program.

the first acquisition module is used for acquiring a inclusion file list of each version of the program;

the ordering module is used for ordering the inclusion file lists according to the version sequence to obtain ordered inclusion file lists;

the comparison module is used for sequentially comparing the inclusion file lists of two adjacent versions and determining deleted resource files deleted by each version;

and the third packaging module is used for packaging the target deleted resource file into the patch package if the target deleted resource file meeting the preset packaging condition exists in the deleted resource file.

In some embodiments, the third bagging module comprises:

and the second packing sub-module is used for packing the target deleted resource file into the patch package if the deleted resource file exists in the full file list which is deleted when the patch package is released and is not in the historical version patch package and the target deleted resource file exists in the full file list of the current version of the program.

In order to facilitate better implementation of the update method based on the program patch package provided by the embodiment of the application, the embodiment of the application also provides a device based on the update method based on the program patch package, which is applied to the client. The meaning of the nouns is the same as that in the above packing method of the program patch package, and specific implementation details can refer to the description in the method embodiment.

Referring to fig. 2b, fig. 2b is a schematic structural diagram of a program patch package-based updating apparatus according to an embodiment of the present application, where the program patch package-based updating apparatus may include a second comparing module 301, a downloading module 302, a first determining module 303, a second determining module 304, a third comparing module 305, an updating module 306, and so on.

A second comparison module 301, configured to compare the current version patch version information in the patch with the client patch version information of the program in the client;

a downloading module 302, configured to download the patch package if the current version patch package version information is different from the client patch package version information;

a first determining module 303, configured to determine a target full file list based on a program package body file of the client and full file lists of all version patch packages in the patch packages;

A second determining module 304, configured to determine a full client file list based on the program package file of the client and the file of the client patch package of the client;

a third comparison module 305, configured to compare the client full file list with the target full file list, and determine a file to be updated;

and the updating module 306 is configured to download the file to be updated from the server, and update the program of the client.

In some embodiments, the download module 302 includes:

the setting sub-module is used for setting a plurality of downloading starting positions and downloading ending positions for downloading the patch package according to the preset downloading data amount in the downloading website of the patch package;

the downloading sub-module is used for downloading part of the patch packages according to the adjacent downloading starting position and the downloading ending position to obtain a plurality of part of patch packages;

and the merging sub-module is used for merging the plurality of partial patch packages to obtain the patch packages.

In some embodiments, the combining sub-module is configured to:

determining a downloading starting position and a downloading ending position corresponding to each part of patch package;

and combining the partial patches according to a plurality of download starting positions and download ending positions for downloading the patches in the download website of the patches to obtain the patches.

In some embodiments, the updating device based on the program patch package further comprises:

the first detection module is used for detecting whether a client patch package of the client needs to be subjected to hot update or not when the client does not open the program;

the hot updating module is used for carrying out hot updating on the client patch package if hot updating is needed, so as to obtain a client patch package after hot updating;

the second detection module is used for detecting whether the client patch package subjected to the hot update needs to be self-updated or not when the client starts the program;

and the self-updating module is used for carrying out self-updating on the client patch package after the hot updating if the client patch package is needed to obtain the client patch package after the self-updating.

As can be seen from the foregoing, in the embodiment of the present application, the first comparison module 201 compares the full file list of the current version of the program with the full file list of the reference version, and determines the difference file, where the reference version is the previous version of the current version; the acquiring module 202 acquires current version patch package version information corresponding to a current version of a program and acquires a full file list of all version patches of the program from an original version to the current version; the first packing module 203 packs the difference file, the current version patch version information and the full file list of all the versions of patch packages to obtain patch packages. Therefore, the difference files between adjacent versions and the full file list of all version patch packages are packaged into the patch packages, so that when the client updates a program according to the patch packages, the files to be updated, which need to be updated, can be determined through the full file list of all version patch packages, and then the files to be updated are updated. Avoiding using a full amount of tabs, users need to download a lot of resources each time they download a tab, which is time consuming.

The specific implementation of each operation above may be referred to the previous embodiments, and will not be described herein.

Correspondingly, the embodiment of the application also provides an electronic device, as shown in fig. 3, and fig. 3 is a schematic structural diagram of the electronic device provided in the embodiment of the application. The electronic device 2000 may be a client 1000 or an electronic device 2000, the electronic device 2000 comprising a processor 401 having one or more processing cores, a memory 402 having one or more computer readable storage media, and a computer program stored on the memory 402 and executable on the processor. The processor 401 is electrically connected to the memory 402. It will be appreciated by those skilled in the art that the electronic device structure shown in the figures is not limiting of the electronic device and may include more or fewer components than shown, or may combine certain components, or a different arrangement of components.

The processor 401 is a control center of the electronic device 2000, connects various parts of the entire electronic device 2000 using various interfaces and lines, and performs various functions of the electronic device 2000 and processes data by running or loading software programs and/or modules stored in the memory 402, and calling data stored in the memory 402, thereby performing overall monitoring of the electronic device 2000.

In the embodiment of the present application, the processor 401 in the electronic device 2000 loads the instructions corresponding to the processes of one or more application programs into the memory 402 according to the following steps, and the processor 401 executes the application programs stored in the memory 402, so as to implement various functions:

comparing a full file list of a current version of a program with a full file list of a reference version, and determining a difference file, wherein the reference version is the previous version of the current version; acquiring current version patch package version information corresponding to a current version of a program, and acquiring a full file list of all version patches of the program from an original version to the current version; and packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages.

Optionally, as shown in fig. 3, the electronic device 2000 further includes: an input unit 403 and a power supply 404. The processor 401 is electrically connected to the input unit 403 and the power supply 404, respectively. Those skilled in the art will appreciate that the electronic device structure shown in fig. 3 is not limiting of the electronic device and may include more or fewer components than shown, or may combine certain components, or may be arranged in different components.

The input unit 403 may be used to receive input numbers, character information or user characteristic information (e.g., fingerprint, iris, facial information, etc.), and to generate keyboard, mouse, joystick, optical or trackball signal inputs related to user settings and function control.

The power supply 404 is used to power the various components of the electronic device 2000. Alternatively, the power supply 404 may be logically connected to the processor 401 through a power management system, so as to implement functions of managing charging, discharging, and power consumption management through the power management system. The power supply 404 may also include one or more of any of a direct current or alternating current power supply, a recharging system, a power failure detection circuit, a power converter or inverter, a power status indicator, and the like.

Although not shown in fig. 3, the electronic device 2000 may further include a camera, a sensor, a wireless fidelity module, a bluetooth module, etc., which are not described herein.

In the foregoing embodiments, the descriptions of the embodiments are emphasized, and for parts of one embodiment that are not described in detail, reference may be made to related descriptions of other embodiments.

As can be seen from the above, the electronic device provided in this embodiment may compare the full file list of the current version of the program with the full file list of the reference version, and determine the difference file, where the reference version is the previous version of the current version; acquiring current version patch package version information corresponding to a current version of a program, and acquiring a full file list of all version patches of the program from an original version to the current version; and packaging the difference file, the current version patch package version information and the full file list of all the version patch packages to obtain patch packages. Therefore, the difference files between adjacent versions and the full file list of all version patch packages are packaged into the patch packages, so that when the client updates a program according to the patch packages, the files to be updated, which need to be updated, can be determined through the full file list of all version patch packages, and then the files to be updated are updated. Avoiding using a full amount of tabs, users need to download a lot of resources each time they download a tab, which is time consuming.

Those of ordinary skill in the art will appreciate that all or a portion of the steps of the various methods of the above embodiments may be performed by instructions, or by instructions controlling associated hardware, which may be stored in a computer-readable storage medium and loaded and executed by a processor.

To this end, embodiments of the present application provide a computer readable storage medium having stored therein a plurality of computer programs that can be loaded by a processor to perform steps in any of the data analysis methods provided by embodiments of the present application. For example, the computer program may perform the steps of:

Wherein the storage medium may include: read Only Memory (ROM), random access Memory (RAM, random Access Memory), magnetic or optical disk, and the like.

The steps in the method for packaging a program patch package according to the embodiment of the present application may be performed by the computer program stored in the storage medium, so that the beneficial effects that may be achieved by any one of the data analysis methods according to the embodiment of the present application may be achieved, which are described in detail in the previous embodiments and are not described herein.

The foregoing describes in detail a method, an apparatus, a storage medium, and an electronic device for packaging a program patch package provided in the embodiments of the present application, and specific examples are applied to describe principles and implementations of the present application, where the descriptions of the foregoing embodiments are only used to help understand the method and core ideas of the present application; meanwhile, those skilled in the art will have variations in the specific embodiments and application scope in light of the ideas of the present application, and the present description should not be construed as limiting the present application in view of the above.

Claims

1. A method for packaging a program patch package, applied to a server, comprising the following steps:

2. The method for packaging a program patch package according to claim 1, further comprising, before the step of packaging the difference file, the current version patch package version information, and the full file list of all version patch packages, the step of obtaining a patch package:

3. The method of claim 2, wherein the program is a game program, and after the step of comparing the full text list of the current version of the program with the full text list of the reference version, the step of determining the difference file further comprises:

determining a static resource file and a dynamic resource file in the game program;

determining the files except the static resource file and the dynamic resource file in the full file list of the current version as redundant resource files;

and clearing redundant resource files in the difference files to obtain the difference files after redundant processing.

4. A method of packaging a program patch package as recited in claim 3, further comprising, after the step of removing redundant resource files from the difference file to obtain a redundant difference file:

determining a dependent resource file that depends on the difference file;

determining whether the dependent resource file is in a full file list of a historical version patch package, wherein the full file list of the historical version patch package is a full file list except for a full file list of a current version patch package in the full file list of all version patch packages;

And if the dependent resource file is not in the full file list of the historical version patch package, packaging the dependent resource file into the patch package.

5. A method of packaging a program patch package as recited in claim 3, wherein the step of determining static resource files and dynamic resource files in the game program comprises:

acquiring a scene resource file of the game program, and determining a scene dependent resource file on which the scene resource file depends;

determining a resource file in a white list, the scene resource file and the scene dependent resource file as static resource files in the game program;

determining a directly-dependent resource file, a table resource file and an editor resource file which are relied on by a game program editor;

and determining the direct dependent resource file, the table resource file and the editor resource file as dynamic resource files in the game program.

6. The method for packaging a program patch package according to claim 1, further comprising, before the step of packaging the difference file, the current version patch package version information, and the full file list of all version patch packages, the step of obtaining a patch package:

Acquiring a inclusion file list of each version of the program;

sequencing the inclusion file lists according to the version sequence to obtain sequenced inclusion file lists;

sequentially comparing inclusion file lists of two adjacent versions to determine deleted resource files deleted by each version;

and if the target deleted resource file meeting the preset packaging condition exists in the deleted resource file, packaging the target deleted resource file into the patch package.

7. The method for packaging a program patch package according to claim 6, wherein if a target deleted resource file satisfying a preset packaging condition exists in the deleted resource files, the step of packaging the target deleted resource file into the patch package includes:

8. An updating method based on a program patch package is applied to a client and is characterized by comprising the following steps:

9. A program patch package based updating method as in claim 8, wherein said step of downloading said patch package comprises:

setting a plurality of downloading starting positions and downloading ending positions for downloading the patch package according to a preset downloading data amount in a downloading website of the patch package;

downloading part of the patch packages according to the adjacent downloading starting positions and the downloading ending positions to obtain a plurality of part of patch packages;

and merging the plurality of partial patch packages to obtain the patch package.

10. The method for updating a program-based patch package as recited in claim 9, wherein the step of merging the plurality of partial patch packages to obtain the patch package includes:

11. A program patch package based updating method as recited in claim 8, further comprising, prior to the step of comparing current version patch package version information in the patch package with client patch package version information of programs in the client:

when the client does not start the program, detecting whether a client patch package of the client needs to be subjected to hot update;

if the client patch package needs to be subjected to hot updating, the client patch package is subjected to hot updating, and the client patch package subjected to hot updating is obtained;

when the client starts the program, detecting whether the client patch package subjected to the hot update needs to be self-updated or not;

if so, self-updating the client patch package after the hot updating is carried out, and the self-updated client patch package is obtained.

12. A program patch package packaging device applied to a server, comprising:

13. An updating device based on a program patch package, applied to a client, comprising:

14. A computer readable storage medium storing a plurality of instructions adapted to be loaded by a processor to perform the steps in the method of packaging a program patch package of any one of claims 1 to 11.

15. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, wherein the processor performs the steps in the method of packaging a program patch package as claimed in any one of claims 1 to 11 when the program is executed.