CN113641401A

CN113641401A - Application data processing method and device

Info

Publication number: CN113641401A
Application number: CN202110938952.8A
Authority: CN
Inventors: 何远伦
Original assignee: Jingdong City Beijing Digital Technology Co Ltd
Current assignee: Jingdong City Beijing Digital Technology Co Ltd
Priority date: 2021-08-16
Filing date: 2021-08-16
Publication date: 2021-11-12
Anticipated expiration: 2041-08-16
Also published as: CN113641401B

Abstract

The disclosure provides a processing method and device of application data, and relates to the technical field of cloud computing and terminal application. The specific implementation mode comprises the following steps: acquiring a calling function file of a target application, wherein the calling function file comprises a calling entry of a method provided by a target channel; acquiring an application master package of a target application, wherein the calling function file and the application master package adopt the same method calling interface; merging the calling function file and the application master package to obtain merged data; and packaging the combined data, and generating a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel. The method calling interfaces between the calling function file and the application parent package are consistent, and the method provided by the channel can be called by the application comprising the merged data through merging.

Description

Application data processing method and device

Technical Field

The disclosure relates to the technical field of computers, in particular to the technical field of cloud computing and terminal application, and particularly relates to a method and a device for processing application data.

Background

With the development of internet technology, more and more application channels (such as third-party application channels) are layered endlessly. Especially for the android system, hundreds of application channels and platforms are emerging even because of the lack of a unified official application channel.

The application channel may provide a variety of functions such as payment, application login, application logout, and the like. If a new application comes online, technicians are often required to package the application from one application channel to another in order to make the application suitable for each application channel.

Disclosure of Invention

Provided are an application data processing method and device, an electronic device and a storage medium.

According to a first aspect, there is provided a method for processing application data, comprising: acquiring a calling function file of a target application, wherein the calling function file comprises a calling entry of a method provided by a target channel; acquiring an application master package of a target application, wherein the calling function file and the application master package adopt the same method calling interface; merging the calling function file and the application master package to obtain merged data; and packaging the combined data, and generating a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

According to a second aspect, there is provided an apparatus for processing application data, comprising: the system comprises an acquisition unit, a processing unit and a processing unit, wherein the acquisition unit is configured to acquire a calling function file of a target application, and the calling function file comprises a calling inlet of a method provided by a target channel; the obtaining unit is configured to obtain an application parent package of a target application, wherein the calling function file and the application parent package adopt the same method calling interface; the merging unit is configured to merge the calling function file and the application master package to obtain merged data; and the packaging unit is configured to package the merged data and generate a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

According to a third aspect, there is provided an electronic device comprising: at least one processor; and a memory communicatively coupled to the at least one processor; wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one embodiment of the method of processing application data.

According to a fourth aspect, there is provided a non-transitory computer-readable storage medium storing computer instructions for causing a computer to perform the method according to any one of the embodiments of the processing method of application data.

According to a fifth aspect, a computer program product is provided, comprising a computer program which, when executed by a processor, implements the method according to any embodiment of the method of processing application data.

According to the scheme disclosed by the invention, automatic merging and packaging of the application data capable of calling the method provided by the target channel can be realized without manual packaging operation, so that the application capable of using the target channel is obtained. Moreover, in the application, the method calling interfaces between the calling function file and the application parent package are consistent, so that even if the calling function file of the target application and the application parent package respectively and independently have respective functions, the method calling interfaces in the merged data obtained after merging are unified, and the method provided by the application channel can be called by the application comprising the merged data.

Drawings

Other features, objects and advantages of the disclosure will become more apparent upon reading of the following detailed description of non-limiting embodiments thereof, made with reference to the accompanying drawings in which:

FIG. 1 is an exemplary system architecture diagram in which some embodiments of the present disclosure may be applied;

FIG. 2 is a flow diagram of one embodiment of a method of processing application data according to the present disclosure;

FIG. 3 is a schematic diagram of an application scenario of a method of processing application data according to the present disclosure;

FIG. 4 is a flow diagram of yet another embodiment of a method of processing application data according to the present disclosure;

FIG. 5 is a schematic block diagram illustrating one embodiment of an apparatus for processing application data according to the present disclosure;

fig. 6 is a block diagram of an electronic device for implementing a processing method of application data according to an embodiment of the present disclosure.

Detailed Description

Exemplary embodiments of the present disclosure are described below with reference to the accompanying drawings, in which various details of the embodiments of the disclosure are included to assist understanding, and which are to be considered as merely exemplary. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the present disclosure. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness.

In the technical scheme of the disclosure, the collection, storage, use, processing, transmission, provision, disclosure and other processing of the personal information of the related user are all in accordance with the regulations of related laws and regulations and do not violate the good customs of the public order.

It should be noted that, in the present disclosure, the embodiments and features of the embodiments may be combined with each other without conflict. The present disclosure will be described in detail below with reference to the accompanying drawings in conjunction with embodiments.

Fig. 1 shows an exemplary system architecture 100 of an embodiment of a processing method of application data or a processing device of application data to which the present disclosure may be applied.

As shown in fig. 1, the system architecture 100 may include

terminal devices

101, 102, 103, a network 104, and a server 105. The network 104 serves as a medium for providing communication links between the

terminal devices

101, 102, 103 and the server 105. Network 104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few.

The user may use the

terminal devices

101, 102, 103 to interact with the server 105 via the network 104 to receive or send messages or the like. Various communication client applications, such as video applications, live applications, instant messaging tools, mailbox clients, social platform software, and the like, may be installed on the

terminal devices

101, 102, and 103.

Here, the

terminal apparatuses

101, 102, and 103 may be hardware or software. When the

terminal devices

101, 102, 103 are hardware, they may be various electronic devices having a display screen, including but not limited to smart phones, tablet computers, e-book readers, laptop portable computers, desktop computers, and the like. When the

terminal apparatuses

101, 102, 103 are software, they can be installed in the electronic apparatuses listed above. It may be implemented as multiple pieces of software or software modules (e.g., multiple pieces of software or software modules to provide distributed services) or as a single piece of software or software module. And is not particularly limited herein.

The server 105 may be a server providing various services, such as a background server providing support for the

terminal devices

101, 102, 103. The background server may analyze and perform other processing on the received data such as the application data, and feed back a processing result (e.g., a target package file) to the terminal device.

It should be noted that the processing method of the application data provided by the embodiment of the present disclosure may be executed by the server 105 or the

terminal devices

101, 102, and 103, and accordingly, the processing device of the application data may be disposed in the server 105 or the

terminal devices

101, 102, and 103.

It should be understood that the number of terminal devices, networks, and servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation.

With continued reference to FIG. 2, a flow 200 of one embodiment of a method of processing application data in accordance with the present disclosure is shown. The application data processing method comprises the following steps:

step 201, obtaining a calling function file of a target application, wherein the calling function file includes a calling entry of a method provided by a target channel.

In this embodiment, an execution subject (for example, a server or a terminal device shown in fig. 1) on which the processing method of the application data is executed may acquire a calling function file of the target application.

The calling function file includes a calling entry of the method provided by the target channel, that is, the terminal device can implement the method provided by the target application calling channel through the calling entry of the calling function file, and these methods are all methods performed in the Application (APP), such as payment, recharging, application login, and application exit. The calling function file can be understood as an application which cannot realize the basic running function of the application, but can realize the calling of the method provided by the channel. The basic operating function can be, for example, a chat function of a communication application. The channel may be a third party channel or a non-third party channel.

And the calling function file acquired by the execution main body is used for calling the method provided by the target channel.

The directories in the present disclosure may include a parent directory and a child directory, and specifically, the content of the directory generated in real time in the present disclosure may include the child directory, and may also include the parent directory and the child directory. The calling function file may be integrated with a channel SDK (Software Development Kit), so as to implement calling a method provided by a target channel in a target application.

Step 202, obtaining an application master package of the target application, wherein the calling function file and the application master package adopt the same method calling interface.

In this embodiment, the execution main body may obtain an application parent package of the target application. The method call interface may be used for calls in an application to methods provided by a channel. The calling function file and the application parent packet adopt the same method calling interface, so that if the execution main body combines the calling function file and the application parent packet, the method calling interfaces in the obtained combined data are uniform, and the method provided by the channel is conveniently called in the application comprising the combined data. The application parent package is used for realizing the basic operation function of the target application.

And step 203, merging the calling function file and the application master package to obtain merged data.

In this embodiment, the execution main body may call the function file and the application master package to merge, and a result of the merging is merged data.

And 204, packaging the combined data, and generating a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

In this embodiment, the execution body may perform packing on the merged data to obtain a packed result. The execution body may generate a target packaged file based on the packaging result. The target packaged file is a file that is used by the application to go online. The target package file corresponds to the target channel. For each channel, a target package file is available.

The execution agent may generate the target packaged file based on the packaged result in various ways. For example, the execution subject may directly use the packed result as the target packed file. Or, the execution body may input the packaging result into the specified model, and obtain the target packaging file output from the specified model. The specified model can obtain the target packed file through the packing result.

According to the method provided by the embodiment of the disclosure, manual packaging operation is not needed, and automatic combination and packaging of the application data capable of calling the method provided by the target channel are realized, so that the application capable of using the target channel is obtained. Moreover, in the application, the method calling interfaces between the calling function file and the application parent package are consistent, so that even if the calling function file of the target application and the application parent package respectively and independently have respective functions, the method calling interfaces in the merged data obtained after merging are unified, and the method provided by the channel can be called by the application comprising the merged data.

With continued reference to fig. 3, fig. 3 is a schematic diagram of an application scenario of the processing method of application data according to the present embodiment. In the application scenario of fig. 3, the execution subject 301 obtains a calling function file 302 of the target application, where the calling function file includes a calling entry of a method provided by the target channel. The execution main body 301 obtains an application parent package 303 of the target application, wherein the calling function file and the application parent package adopt the same method calling interface. The execution main body 301 obtains the merged calling function file and the application parent package to obtain merged data 304. The execution body 301 obtains the merged data to be packed, and generates a target packed file 305 based on the packing result, wherein the target packed file corresponds to the target channel.

With further reference to FIG. 4, a flow 400 of yet another embodiment of a method of processing application data is shown. The process 400 includes the following steps:

step 401, obtaining a calling function file of a target application, wherein the calling function file includes a calling entry of a method provided by a target channel.

Step 402, obtaining an application master package of a target application, wherein the calling function file and the application master package adopt the same method calling interface.

Step 403, generating a directory indicating to call the function file as a channel directory, and generating a directory indicating to apply the master package as a master package directory.

In this embodiment, the executing entity may generate a directory indicating the calling function file as a channel directory, that is, store the calling function file in the directory. The execution agent may also generate a parent package directory, which may indicate the application parent package. That is, the execution agent may store the calling function file in the directory.

Step 404, merging the channel catalog and the parent package catalog to obtain a merged catalog, and merging the calling function file in the channel catalog and the application parent package in the parent package catalog to obtain merged data in the merged catalog.

In this embodiment, the execution agent may merge the calling function file in the channel directory and the application parent package in the parent package directory. In practice, the execution subject may merge the channel directory and the parent package directory, and the merged result may be a merged directory. Moreover, the execution main body may also merge the calling function file and the application parent package respectively in the two directories, and the merged result may be merged data.

And 405, packaging the combined data, and generating a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

Step 401, step 402 and step 405 are the same as or similar to step 201, step 202 and step 204, respectively, and are not described herein again.

The embodiment can represent and merge files in the form of directories, thereby improving the merging efficiency.

In some optional implementations of this embodiment, the generating a directory indicating that the function file is called as the channel directory in step 403 may include: packaging the calling function file into an application program package with a specified format, wherein the application program package comprises a main configuration file; and decompressing the application program package to a channel directory indicating the calling function file.

In the present embodiment, an execution subject (for example, a server or a terminal device shown in fig. 1) on which the processing method of the application data is executed may package the calling function file into an application package of a specified format. The application package is in a specified format, such as an apk (android application package) format. In practice, the master configuration file may be a file in xml format (such as in particular Android Manifest. xml format).

The execution body may be decompressed in various ways, for example, by using a specific decompression tool (such as an apktooljar tool). Specifically, the execution subject may decompress the calling function file into the channel directory.

These implementations may generate the master configuration file by compression and check the call function file by compression.

In some optional implementations of this embodiment, the generating a directory indicating that the parent package is applied in step 403 as the parent package directory may include: packaging the application parent package into an application program package with a specified format, wherein the application program package comprises a main configuration file; the application package is decompressed to a parent package directory indicating the application parent package.

In these alternative implementations, the execution body may package the application parent package into an application package in a specified format. And decompressing the application program package to the directory of the parent package.

The application package here is in a specified format, such as APK format. In practice, the master configuration file may be a file in xml format.

The execution body may decompress in various ways, for example, using a specified decompression tool.

In some optional implementation manners of any of the embodiments, the merging the calling function file in the channel directory and the application parent package in the parent package directory to obtain merged data in the merged directory may include: newly building a target directory, and copying a main configuration file and a sub-directory file under a parent package directory to the target directory; and copying the subdirectory files under the channel directory to a target directory, wherein repeated files do not exist under the target directory.

In these alternative implementations, the executive agent may create a new target directory and copy the subdirectories and subdirectory files in the channel directory to the target directory. The execution main body can also copy the main configuration file, the sub-directory and the sub-directory file under the parent package directory to the target directory. The subdirectory file entries copied for the channel directory and the parent package directory may be the same or different. For example, the execution agent may copy all the subdirectories under the parent package directory and the files under the subdirectories to the target directory. In addition, the executing body may copy the designated subdirectories and files under the subdirectories to the channel directory, where the designated subdirectories may include a lib directory, a res directory, an assets directory, and an unknown directory.

In practice, the execution agent may ensure that duplicate files do not exist under the target directory in various ways. For example, the execution agent may directly overwrite the file to be copied if it is determined that the file already exists in the target directory when the copying is performed.

The implementation modes can realize the combination of the files under the two directories by copying the files under the parent package directory and the files under the channel directory to the target directory.

In some optional application scenarios of these implementation manners, merging the calling function file in the channel directory and the application parent package in the parent package directory to obtain merged data in the merged directory further includes: performing de-coincidence on the main configuration file under the target directory and the main configuration file under the channel directory by adopting tree form comparison; the de-coincidence result is used as a new master profile for the target directory.

In these optional application scenarios, the execution subject may adopt tree comparison to compare the master configuration file in the target directory with the master configuration file in the channel directory, and further remove duplicate, and merge the duplicate removal results, where the merged result is the above-mentioned de-coincidence result. In particular, the master configuration file may be a tree structure that facilitates tree comparison, such as in xml format.

The application scenes can realize the de-duplication combination of the main configuration files under the target directory and the channel directory through tree comparison, thereby obtaining a new main configuration file of the target directory.

Optionally, the method may further include: obtaining parameter values of channel parameters of at least one channel, wherein the channel parameters comprise at least one of the following: channel identification and channel package name; and after taking the de-registration result as the new master profile for the target directory, the method may further comprise: and assigning the channel parameters of the new main configuration file by adopting the parameter values.

In these alternative implementations, the executing entity may obtain a parameter value of a channel parameter of at least one channel, for example, directly obtain the parameter value from the present device or other electronic devices, or set the parameter value. There is a corresponding parameter value for each channel. After generating the new master configuration file, the executing agent may assign a value to the channel parameter of the new master configuration file using the obtained parameter value. The channel parameters may include a channel identification for the channel and, in addition, a channel package name for the channel.

These implementations may enable new master profile assignments to the target directory.

In some optional application scenarios of these implementations, the method further comprises: generating a resource configuration file of the target directory, wherein the resource configuration file is a file in a first format; and converting the format of the resource configuration file from the first format to a second format, wherein the resource configuration file in the second format is matched with the specified terminal operating system.

In these alternative implementations, the execution principal may generate a resource profile for the target directory. The format of the generated resource configuration file is a first format. The execution body converts the resource configuration file in the first format into the resource configuration file in the second format through format conversion (for example, format conversion is performed by using a preset model). In practice, the second format may be a file in the smali format, i.e. a file suffixed with smali. The file in the smali format is also the register language file of Dalvik. The resource configuration file in the second format is matched with the specified terminal operating system, namely can be run in the specified terminal operating system. In practice, the specified terminal operating system may be the android operating system.

The resource configuration file in the second format can be compressed by a java compression method, and then packaged into an APK file.

In particular, the resources in the resource configuration file include content that can be rendered in the application, such as controls in an application page. The resource profile may include a list of resources.

In practice, the execution main body may adopt an APPT tool to generate a resource configuration file r.java of the target directory, and then program the resource configuration file r.java into a class format file by using a java command. And finally, converting the class format file into a dex format file by using a bakamali jar tool.

These implementations may convert the resource configuration file into a format that can be run on the android system via format conversion.

In an optional implementation manner of any embodiment of the present disclosure, the packaging the merged data in the merged directory and generating the target packed file based on the packing result may include: packaging the merged directory and merged data to obtain a packaging result; packaging the merged directory and merged data into an application program package with a specified format to obtain a packaging result; and performing preset optimization operation on the signed packaging result, and generating a target packaging file according to the optimization operation result.

In these optional implementation manners, the execution main body may package the merged directory and the merged data to obtain a packaged result. In particular, it may be packaged into an application package of a specified format. And the executing body can perform signature operation on the packaging result to obtain the signed packaging result. And then, the execution body can perform preset optimization operation on the signed packaging result and generate a target packaging file according to the optimization operation result.

In practice, the execution subject may use a java compression method to pack the entire target directory into an APK file, where the APK file is the packed result. The target directory is the merged directory, and the data in the target directory is the merged data. The resource configuration file and the master configuration file of the target directory may be a resource configuration file subjected to the format conversion in the present disclosure, and a master configuration file subjected to de-duplication combination, respectively.

In practice, the execution subject may sign the packed result using a signapk. In addition, the execution body can also perform signature operation on the packaging result by calculating the MD5 value.

In practice, the execution body may perform the preset optimization operation by using various optimization tools, for example, the optimization tool may be a zipalign tool.

Specifically, the execution subject may generate the target package file according to the result of the optimization operation in various ways. For example, the execution subject may directly use the optimization operation result as the target packaging file. Or, the execution subject may input the optimization operation result into a preset model, and obtain the target package file output from the preset model. The preset model may generate a target packed file for the result of the optimization operation.

The implementation modes can ensure the safety and superiority of the target packaged file through signature and optimization processing.

In some optional implementations of any of the embodiments above, the method is applied to a server.

In these alternative implementations, the method of the present disclosure may be deployed at a server (such as the server in fig. 1). The implementation modes can accelerate the packaging speed through the strong calculation force of the server side, and the packaging efficiency is improved.

With further reference to fig. 5, as an implementation of the methods shown in the above figures, the present disclosure provides an embodiment of an apparatus for processing application data, which corresponds to the method embodiment shown in fig. 2, and which may include the same or corresponding features or effects as the method embodiment shown in fig. 2, in addition to the features described below. The device can be applied to various electronic equipment.

As shown in fig. 5, the application data processing apparatus 500 of the present embodiment includes: an acquisition unit 501, an acquisition unit 502, a merging unit 503, and a packing unit 504. The obtaining unit 501 is configured to obtain a calling function file of a target application, where the calling function file includes a calling entry of a method provided by a target channel; an obtaining unit 502 configured to obtain an application parent package of a target application, where the calling function file and the application parent package use the same method calling interface; a merging unit 503 configured to merge the calling function file and the application master package to obtain merged data; and the packaging unit is configured to package the merged data and generate a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

In this embodiment, specific processing of the obtaining unit 501, the obtaining unit 502, the combining unit 503, and the packing unit 504 of the application data processing apparatus 500 and technical effects thereof may refer to related descriptions of step 201, step 202, step 203, and step 204 in the corresponding embodiment of fig. 2, which are not described herein again.

In some optional implementations of this embodiment, the apparatus further includes: a generating unit configured to generate a directory indicating to call the function file as a channel directory, and generate a directory indicating to apply the parent package as a parent package directory; and the merging unit is further configured to merge the calling function file and the application parent package to obtain merged data as follows: and merging the channel catalog and the parent package catalog to obtain a merged catalog, and merging the calling function file under the channel catalog and the application parent package under the parent package catalog to obtain merged data under the merged catalog.

In some optional implementations of the embodiment, the obtaining unit is further configured to generate the directory indicating the calling function file as the channel directory as follows: packaging the calling function file into an application program package with a specified format, wherein the application program package comprises a main configuration file; and decompressing the application program package to a channel directory indicating the calling function file.

In some optional implementations of the embodiment, the generating unit is further configured to perform generating the directory indicating the application parent package as the parent package directory as follows: packaging the application parent package into an application program package with a specified format, wherein the application program package comprises a main configuration file; the application package is decompressed to a parent package directory indicating the application parent package.

In some optional implementation manners of this embodiment, the merging unit is further configured to merge the calling function file in the channel directory and the application parent package in the parent package directory to obtain merged data in the merged directory as follows: newly building a target directory, and copying a main configuration file and a sub-directory file under a parent package directory to the target directory; and copying the subdirectory files under the channel directory to a target directory, wherein repeated files do not exist under the target directory.

In some optional implementation manners of this embodiment, the merging unit is further configured to merge the calling function file in the channel directory and the application parent package in the parent package directory to obtain merged data in the merged directory as follows: performing de-coincidence on the main configuration file under the target directory and the main configuration file under the channel directory by adopting tree form comparison; the de-coincidence result is used as a new master profile for the target directory.

In some optional implementations of this embodiment, the apparatus further includes: a value obtaining unit configured to obtain parameter values of channel parameters of at least one channel, wherein the channel parameters include at least one of: channel identification and channel package name; and the apparatus further comprises: and the assignment module is configured to assign the channel parameters of the new main configuration file by adopting the parameter values after the de-coincidence result is used as the new main configuration file of the target directory.

In some optional implementations of this embodiment, the apparatus further includes: the generating unit is configured to generate a resource configuration file of the target directory, wherein the resource configuration file is a file in a first format; and the conversion unit is configured to convert the format of the resource configuration file from a first format to a second format, wherein the resource configuration file in the second format is matched with the specified terminal operating system.

In some optional implementations of this embodiment, the packing unit is further configured to perform packing of the merged data in the merged directory as follows, and generate the target packed file based on the packing result: packaging the merged directory and merged data into an application program package with a specified format to obtain a packaging result; performing signature operation on the packaging result to obtain a signed packaging result; and performing preset optimization operation on the signed packaging result, and generating a target packaging file according to the optimization operation result.

In some optional implementations of this embodiment, the apparatus is applied to a server.

The present disclosure also provides an electronic device, a readable storage medium, and a computer program product according to embodiments of the present disclosure.

As shown in fig. 6, is a block diagram of an electronic device of a processing method of application data according to an embodiment of the present disclosure. Electronic devices are intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. The electronic device may also represent various forms of mobile devices, such as personal digital processing, cellular phones, smart phones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions, are meant to be examples only, and are not meant to limit implementations of the disclosure described and/or claimed herein.

As shown in fig. 6, the electronic apparatus includes: one or more processors 601, memory 602, and interfaces for connecting the various components, including a high-speed interface and a low-speed interface. The various components are interconnected using different buses and may be mounted on a common motherboard or in other manners as desired. The processor may process instructions for execution within the electronic device, including instructions stored in or on the memory to display graphical information of a GUI on an external input/output apparatus (such as a display device coupled to the interface). In other embodiments, multiple processors and/or multiple buses may be used, along with multiple memories and multiple memories, as desired. Also, multiple electronic devices may be connected, with each device providing portions of the necessary operations (e.g., as a server array, a group of blade servers, or a multi-processor system). In fig. 6, one processor 601 is taken as an example.

The memory 602 is a non-transitory computer readable storage medium provided by the present disclosure. Wherein the memory stores instructions executable by the at least one processor to cause the at least one processor to perform the method of processing application data provided by the present disclosure. The non-transitory computer-readable storage medium of the present disclosure stores computer instructions for causing a computer to execute the processing method of application data provided by the present disclosure.

The memory 602, which is a non-transitory computer-readable storage medium, may be used to store non-transitory software programs, non-transitory computer-executable programs, and modules, such as program instructions/modules corresponding to the processing method of application data in the embodiment of the present disclosure (for example, the obtaining unit 501, the obtaining unit 502, the merging unit 503, and the packing unit 504 shown in fig. 5). The processor 601 executes various functional applications of the server and data processing, i.e., implements the processing method of the application data in the above method embodiments, by running non-transitory software programs, instructions, and modules stored in the memory 602.

The memory 602 may include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function; the storage data area may store data created according to use of the processing electronics of the application data, and the like. Further, the memory 602 may include high speed random access memory, and may also include non-transitory memory, such as at least one magnetic disk storage device, flash memory device, or other non-transitory solid state storage device. In some embodiments, the memory 602 optionally includes memory located remotely from the processor 601, and these remote memories may be connected over a network to processing electronics that apply the data. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The electronic device applying the data processing method may further include: an input device 603 and an output device 604. The processor 601, the memory 602, the input device 603 and the output device 604 may be connected by a bus or other means, and fig. 6 illustrates the connection by a bus as an example.

The input device 603 may receive input numeric or character information and generate key signal inputs related to user settings and function control of the processing electronics applying the data, such as a touch screen, keypad, mouse, track pad, touch pad, pointer stick, one or more mouse buttons, track ball, joystick, etc. input devices. The output devices 604 may include a display device, auxiliary lighting devices (e.g., LEDs), and tactile feedback devices (e.g., vibrating motors), among others. The display device may include, but is not limited to, a Liquid Crystal Display (LCD), a Light Emitting Diode (LED) display, and a plasma display. In some implementations, the display device can be a touch screen.

Various implementations of the systems and techniques described here can be realized in digital electronic circuitry, integrated circuitry, application specific ASICs (application specific integrated circuits), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include: implemented in one or more computer programs that are executable and/or interpretable on a programmable system including at least one programmable processor, which may be special or general purpose, receiving data and instructions from, and transmitting data and instructions to, a storage system, at least one input device, and at least one output device.

These computer programs (also known as programs, software applications, or code) include machine instructions for a programmable processor, and may be implemented using high-level procedural and/or object-oriented programming languages, and/or assembly/machine languages. As used herein, the terms "machine-readable medium" and "computer-readable medium" refer to any computer program product, apparatus, and/or device (e.g., magnetic discs, optical disks, memory, Programmable Logic Devices (PLDs)) used to provide machine instructions and/or data to a programmable processor, including a machine-readable medium that receives machine instructions as a machine-readable signal. The term "machine-readable signal" refers to any signal used to provide machine instructions and/or data to a programmable processor.

To provide for interaction with a user, the systems and techniques described here can be implemented on a computer having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to a user; and a keyboard and a pointing device (e.g., a mouse or a trackball) by which a user can provide input to the computer. Other kinds of devices may also be used to provide for interaction with a user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including acoustic, speech, or tactile input.

The systems and techniques described here can be implemented in a computing system that includes a back-end component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with an implementation of the systems and techniques described here), or any combination of such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: local Area Networks (LANs), Wide Area Networks (WANs), and the Internet.

The computer system may include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. The Server can be a cloud Server, also called a cloud computing Server or a cloud host, and is a host product in a cloud computing service system, so as to solve the defects of high management difficulty and weak service expansibility in the traditional physical host and VPS service ("Virtual Private Server", or simply "VPS"). The server may also be a server of a distributed system, or a server incorporating a blockchain.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, 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.

The units described in the embodiments of the present disclosure may be implemented by software or hardware. The described units may also be provided in a processor, and may be described as: a processor includes an acquisition unit, an obtaining unit, a merging unit, and a packing unit. The names of these units do not in some cases constitute a limitation on the unit itself, and for example, the acquiring unit may also be described as a "unit that acquires a calling function file of a target application".

As another aspect, the present disclosure also provides a computer-readable medium, which may be contained in the apparatus described in the above embodiments; or may be present separately and not assembled into the device. The computer readable medium carries one or more programs which, when executed by the apparatus, cause the apparatus to: acquiring a calling function file of a target application, wherein the calling function file comprises a calling entry of a method provided by a target channel; acquiring an application master package of a target application, wherein the calling function file and the application master package adopt the same method calling interface; merging the calling function file and the application master package to obtain merged data; and packaging the combined data, and generating a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

The foregoing description is only exemplary of the preferred embodiments of the disclosure and is illustrative of the principles of the technology employed. It will be appreciated by those skilled in the art that the scope of the invention in the present disclosure is not limited to the specific combination of the above-mentioned features, but also encompasses other embodiments in which any combination of the above-mentioned features or their equivalents is possible without departing from the inventive concept as defined above. For example, the above features and (but not limited to) the features disclosed in this disclosure having similar functions are replaced with each other to form the technical solution.

Claims

1. A method of processing application data, the method comprising:

acquiring a calling function file of a target application, wherein the calling function file comprises a calling entry of a method provided by a target channel;

acquiring an application parent package of the target application, wherein the calling function file and the application parent package adopt the same method calling interface;

merging the calling function file and the application master package to obtain merged data;

and packaging the merged data, and generating a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

2. The method of claim 1, wherein the method further comprises:

generating a directory indicating the calling function file as a channel directory, and generating a directory indicating the application parent package as a parent package directory; and

the merging the calling function file and the application parent package to obtain merged data includes:

merging the channel catalog and the parent package catalog to obtain a merged catalog, merging the calling function file under the channel catalog and the application parent package under the parent package catalog to obtain merged data under the merged catalog.

3. The method of claim 2, wherein the generating a directory indicating the calling function file as a channel directory comprises:

packaging the calling function file into an application program package with a specified format, wherein the application program package comprises a main configuration file;

and decompressing the application program package to a channel directory indicating the calling function file.

4. The method of claim 3, wherein the generating a directory indicating the application parent package as a parent package directory comprises:

packaging the application parent package into an application program package with a specified format, wherein the application program package comprises a main configuration file;

and decompressing the application program package to a mother package directory indicating the application mother package.

5. The method of claim 4, wherein the merging the calling function file in the channel directory and the application parent package in the parent package directory to obtain merged data in the merged directory comprises:

newly building a target directory, and copying a main configuration file and a sub-directory file under the parent package directory to the target directory;

and copying the subdirectory files under the channel directory to the target directory, wherein no repeated files exist under the target directory.

6. The method of claim 5, wherein the merging the calling function file in the channel directory and the application parent package in the parent package directory to obtain merged data in the merged directory further comprises:

performing de-coincidence on the main configuration file under the target directory and the main configuration file under the channel directory by adopting tree form comparison;

and taking the de-coincidence result as a new main configuration file of the target directory.

7. The method of claim 6, wherein the method further comprises:

obtaining parameter values of channel parameters of at least one channel, wherein the channel parameters comprise at least one of the following: channel identification and channel package name; and

after the de-duplication and resulting new master profile for the target directory, the method further comprises:

and assigning a value to the channel parameter of the new main configuration file by adopting the parameter value.

8. The method of claim 5, wherein the method further comprises:

generating a resource configuration file of the target directory, wherein the resource configuration file is a file in a first format;

and converting the format of the resource configuration file from the first format to a second format, wherein the resource configuration file in the second format is matched with a specified terminal operating system.

9. The method of claim 1, wherein the packaging the merged data under the merged directory and generating the target packaged file based on the packaging result comprises:

packaging the merged directory and merged data into an application program package with a specified format to obtain a packaging result;

performing signature operation on the packaging result to obtain a signed packaging result;

and performing preset optimization operation on the signed packaging result, and generating the target packaging file according to the optimization operation result.

10. The method of claim 1, wherein the method is applied to a server.

11. An apparatus for processing application data, the apparatus comprising:

the system comprises an acquisition unit, a processing unit and a processing unit, wherein the acquisition unit is configured to acquire a calling function file of a target application, and the calling function file comprises a calling inlet of a method provided by a target channel;

the obtaining unit is configured to obtain an application parent package of the target application, wherein the calling function file and the application parent package adopt the same method calling interface;

the merging unit is configured to merge the calling function file and the application master package to obtain merged data;

and the packaging unit is configured to package the merged data and generate a target packaging file based on a packaging result, wherein the target packaging file corresponds to the target channel.

12. An electronic device, comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-10.

13. A non-transitory computer readable storage medium having stored thereon computer instructions for causing the computer to perform the method of any one of claims 1-10.