WO2016155388A1

WO2016155388A1 - Method and device for installing and running application

Info

Publication number: WO2016155388A1
Application number: PCT/CN2015/099591
Authority: WO
Inventors: 许澎湃; 郑相振
Original assignee: 北京奇虎科技有限公司; 奇智软件（北京）有限公司
Priority date: 2015-03-31
Filing date: 2015-12-29
Publication date: 2016-10-06
Also published as: CN104714828B; CN104714828A

Abstract

The present invention provides a method and device for installing and running an application. The method for installing an application comprises: determining, according to demands, multiple types of functions needing to be implemented, wherein the multiple types of functions comprise a major function and auxiliary functions; generating a major application for the major function and generating independent plug-ins for the various auxiliary functions; and installing the major application, wherein the major application is capable of calling different plug-ins according to demands so as to implement different auxiliary functions. By using the present invention, a major application can be independent from plug-ins of auxiliary applications, thereby reducing the size of an installation package, increasing the installation speed and reducing the occupation of the system space.

Description

Application installation, operation method and device

Technical field

The present invention relates to the field of Internet applications, and in particular, to an application installation method and apparatus, and an application operation method and apparatus.

Background technique

Android (Android) system has become one of the most commonly used operating systems for smart terminals due to its openness and compatibility. The organizational structure of the Android system can be easily plugged and functionalized independently because of its good inter-component and inter-application communication mechanisms. However, these mechanisms are limited to installed applications.

Currently, the traditional plug-in technology in the Android system stipulates that each plug-in needs to be installed in the user's operating system as a stand-alone application. However, if each plug-in needs to be installed before it can be used, as the user's demand increases and the network itself develops, the operating system needs to install more and more plug-ins. As the plug-in grows, the number of applications will gradually increase, taking up a large amount of Resources can easily cause the operating system to run slowly or even overload.

Summary of the invention

In view of the above problems, the present invention has been made in order to provide an application mounting method, an application operating method, and a corresponding apparatus that overcome the above problems or at least partially solve the above problems.

Based on an aspect of the present invention, an embodiment of the present invention provides an application installation method, including:

Determining a plurality of types of functions to be implemented according to requirements, wherein the plurality of types of functions include a primary function and an auxiliary function;

Generating a main application for the main function, and generating a separate plug-in for various auxiliary functions;

The main application is installed, wherein the main application can call different plugins according to requirements to implement different auxiliary functions.

According to another aspect of the present invention, an embodiment of the present invention further provides an application running method, including:

Opening a main application having a main function, wherein the main application can call a plug-in having an auxiliary function other than the main function;

Selecting, in the interface of the main application, a plug-in identifier corresponding to the auxiliary function according to requirements;

The plug-in corresponding to the selected plug-in identifier is invoked by the main application to implement a corresponding auxiliary function.

According to still another aspect of the present invention, an embodiment of the present invention further provides an application installation apparatus, including:

a function determining module, configured to determine, according to requirements, a plurality of types of functions to be implemented, wherein the plurality of types of functions include a primary function and an auxiliary function;

a classification configuration module, configured to generate a main application for the main function, and generate a separate plug-in for each auxiliary function;

The installation module is adapted to install the main application, wherein the main application can call different plugins according to requirements to implement different auxiliary functions.

According to still another aspect of the present invention, an embodiment of the present invention further provides an application running device, including:

a startup module, configured to open a main application having a main function, wherein the main application can invoke a plug-in having an auxiliary function other than the main function;

a selection module, configured to select, according to requirements, a plug-in identifier corresponding to the auxiliary function in an interface of the main application;

The calling module is adapted to use the plug-in corresponding to the selected plug-in identifier by the main application to implement a corresponding auxiliary function.

According to still another aspect of the present invention, a computer program is provided, comprising computer readable code, when the computer readable code is run on a computing device, causing the computing device to perform any of the above described application installation methods, And/or, any of the above application execution methods.

According to still another aspect of the present invention, a computer readable medium is provided, wherein the computer program described above is stored.

In the embodiment of the present invention, the functions corresponding to the requirements are divided into two categories, one is a main function implemented by the main application, and the other is an auxiliary function implemented by the plug-in. In the embodiment of the present invention, only the main application needs to be installed. If other auxiliary functions are needed, different plug-ins can be called in real time according to requirements by the main application to implement different auxiliary functions. That is, in the embodiment of the present invention, only the main application needs to be installed in an operating system in the form of a separate application, and the remaining plug-ins need not be installed to be used. In the implementation, the main application can implement the corresponding function by calling the plug-in through a certain communication method. In addition, the embodiments of the present invention divide the functions corresponding to the requirements, so that the requirements can be developed in a distributed manner, and each auxiliary function is implemented by a plug-in function, which can be directly used as a plug-in for other products, and further improves the practicability of the plug-in. . In addition, during the installation process of the main application, only the main application is installed, and the corresponding installation package only needs to contain the code and resources necessary for the application, which greatly reduces the application installation data package and can speed up the application installation data package. The download process prevents the user from giving up the download by seeing the application too much, or giving up the download halfway because the download is too slow, which improves the user experience. Further, since the plug-in is separated from the main application, the plug-in can be dynamically added, updated, and deleted according to the control command, and the system space can be fully utilized. And it is independent of the update process of the main application, and the update process of each plug-in is independent, thus making the update process more independent, and does not interfere with the update of other plug-ins or main applications.

The above description is only an overview of the technical solutions of the present invention, and the above-described and other objects, features and advantages of the present invention can be more clearly understood. Specific embodiments of the invention are set forth below.

DRAWINGS

Various other advantages and benefits will become apparent to those skilled in the art from a The drawings are only for the purpose of illustrating the preferred embodiments and are not to be construed as limiting. Throughout the drawings, the same reference numerals are used to refer to the same parts. In the drawing:

1 shows a process flow diagram of an application installation method in accordance with one embodiment of the present invention;

2 is a schematic diagram showing a specific example of an architecture between a main application and a plug-in according to an embodiment of the present invention;

FIG. 3 is a schematic diagram showing an interface of a plug-in display according to an embodiment of the present invention; FIG.

4 shows a process flow diagram of an application mode of operation in accordance with one embodiment of the present invention;

FIG. 5 is a schematic diagram showing a main application calling a plurality of plugins according to an embodiment of the present invention; FIG.

6 is a schematic diagram showing a flow of implementing a plugin according to an embodiment of the present invention;

FIG. 7 is a schematic structural view of an application mounting device according to an embodiment of the present invention; FIG.

FIG. 8 is a schematic view showing another structure of an application mounting device according to an embodiment of the present invention; FIG.

FIG. 9 is a schematic structural view of an application running device according to an embodiment of the present invention; FIG.

Figure 10 is a schematic block diagram of a computing device for performing an application installation method and/or an application execution method in accordance with the present invention;

Fig. 11 schematically shows a storage unit for holding or carrying program code implementing an application installation method and/or an application execution method according to the present invention.

detailed description

The invention is further described below in conjunction with the drawings and specific embodiments.

To solve the above technical problem, an embodiment of the present invention provides a new application installation method. FIG. 1 shows a process flow diagram of an application installation method in accordance with one embodiment of the present invention. Referring to FIG. 1, the application installation method includes at least steps S102 to S106:

Step S102: Determine, according to requirements, a plurality of types of functions to be implemented, where the plurality of types of functions include a primary function and an auxiliary function;

Step S104, generating a main application as a main function, and generating a separate plug-in for each auxiliary function;

Step S106: Install a main application, wherein the main application can call different plugins according to requirements to implement different auxiliary functions.

It should be noted that the plug-in mentioned in the embodiment of the present invention is actually an independent application (apk), which internally includes resources and codes, and related android component definitions.

In the embodiment of the present invention, the functions corresponding to the requirements are divided into two categories, one is a main function implemented by the main application, and the other is an auxiliary function implemented by the plug-in. In the embodiment of the present invention, only the main application needs to be installed. If other auxiliary functions are needed, different plug-ins can be called in real time according to requirements by the main application to implement different auxiliary functions. That is, in the embodiment of the present invention, only the main application needs to be installed in an operating system in the form of a separate application, and the remaining plug-ins need not be installed to be used. In the implementation, the main application can implement the corresponding function by calling the plug-in through a certain communication method. In addition, the embodiments of the present invention divide the functions corresponding to the requirements, so that the requirements can be developed in a distributed manner, and each auxiliary function is implemented by a plug-in function, which can be directly used as a plug-in for other products, and further improves the practicability of the plug-in. . In addition, during the installation process of the main application, only the main application is installed, and the corresponding installation package only needs to contain the code and resources necessary for the application, which greatly reduces the application installation data package and can speed up the application installation data package. The download process prevents the user from giving up the download by seeing the application too much, or giving up the download halfway because the download is too slow, which improves the user experience. Further, since the plug-in is separated from the main application, the plug-in can be dynamically added, updated, and deleted according to the control command, and the system space can be fully utilized. And its The update process of the main application is independent, and the update process of each plug-in is independent, thus making the update process more independent, and does not interfere with the update of other plug-ins or main applications.

In the embodiment of the present invention, after the step S106 is performed, that is, after the main application installation ends, the plug-in may be selectively distinguished from the main application installation manner, for example, each of the auxiliary functions may be displayed in the foreground. Plugins, or you can silently load plugins with accessibility in the background. After plugging in the auxiliary functions, the main application only needs to install the code and resources necessary to run its application. Other functions can dynamically download the silent installation after the main application is installed, so that the application data package can be greatly reduced. The purpose of slimming is to increase the download volume of the application, so that the application can be more widely accepted by users.

Further, after plugging in the accessibility features, the main app will have a full localization experience (eg music, video, fiction, news, scan code, etc.). 2 shows a schematic diagram of a specific example of an architecture between a main application and a plug-in according to an embodiment of the present invention. Referring to FIG. 2, the main application is a search app, and the corresponding auxiliary functions include novels, music, movies, news, skins, and the like. Each auxiliary function exists in a separate plug-in form, and the search app can implement the dynamics of the plug-in through specific calls. load. FIG. 3 shows an interface diagram of a plug-in display in accordance with one embodiment of the present invention. Referring to FIG. 3, in the search application, various auxiliary functions such as a title, news, video, novel, picture, map, application, music, and the like can be dynamically loaded. For example, when a user searches for a novel (including keywords related to a novel, such as a book title, an author, etc.), the search app can invoke the novel plug-in to transform into a novel app with functions such as a reader, a bookshelf, a library, and the like. The presentation form of the plug-in in the main application interface includes at least one of the following: a card; a pop-up window; and a scrolling screen.

Due to the independence of the plug-in, the update of each plug-in is also independent. It is not necessary to update the main application to update the resources of each plug-in. For example, the skin of the app can be dynamically switched through the plugin. Each skin theme can be dynamically loaded and updated as a standalone plugin. The skin library does not need to update the main app. It can flexibly produce various star versions, holiday versions, and even users. Customize skins, share skins, and more.

It should be noted that, by using the application installation method provided by the embodiment of the present invention, the plug-in may be stored in a different storage space separately from the main application, and the plug-in may be separately stored in the expansion space (for example, an expansion card, an SD card, a TF card), and Dynamic loading, deletion, or updating can be implemented in the extended space. Among them, the commands for adding and deleting plug-ins are remotely controlled by the cloud, which further ensures the flexibility of the plug-ins.

Among them, each plug-in with auxiliary functions is loaded, including two parts, one is to load the plug-in code, and the other is to load the plug-in resource. In the embodiment of the present invention, the plug-in code of each plug-in is loaded by the class loader of the main application, and the plug-in code of each plug-in is loaded into the memory, and the plug-in independent class loader is generated for each plug-in. Subsequently, each plugin resource is loaded correspondingly using the class loader of each plugin.

Usually, an app can only have one resource object (Resource) and a class loader (ClassLoader) that loads the app code, so the resources and code used throughout the app are the main app. If you want to call the resources and code inside the plugin without limiting the original code structure and logic of the plugin, you must replace the main application's resource object and class loader (mResource, mClassLoader) with the plugin. Resources and class loaders, so plugins can use their own resources and code directly.

In order for the main app to call up the plugin, you need to simulate the environment in which an app runs to provide the plugin to run, so each The plug-in code and resources of the plug-in are used to simulate the plug-in runtime environment when the plug-in is called; and, after the plug-in is loaded, the plug-in manager uniformly names and manages the plug-in.

Based on the same inventive concept, an embodiment of the present invention further provides an application running method, which is applied to an application installed by using the above application installation method. 4 shows a process flow diagram of an application mode of operation in accordance with one embodiment of the present invention. Referring to FIG. 4, the application running method at least includes:

Step S402, the main application having the main function is enabled, wherein the main application can invoke a plug-in having other auxiliary functions besides the main function;

Step S404, selecting, according to requirements, a plug-in identifier corresponding to the auxiliary function in an interface of the main application;

Step S406: The plug-in corresponding to the selected plug-in identifier is used by the main application to implement the corresponding auxiliary function.

In the embodiment of the present invention, the functions corresponding to the requirements are divided into two categories, one is a main function implemented by the main application, and the other is an auxiliary function implemented by the plug-in. In the embodiment of the present invention, only the main application needs to be installed in an operating system in the form of a separate application, and the remaining plug-ins need not be installed to be used. In the implementation, the main application can implement the corresponding function by calling the plug-in through a certain communication method. In addition, the embodiments of the present invention divide the functions corresponding to the requirements, so that the requirements can be developed in a distributed manner, and each auxiliary function is implemented by a plug-in function, which can be directly used as a plug-in for other products, and further improves the practicability of the plug-in. . Further, since the plug-in is separated from the main application, the plug-in can be dynamically added, updated, and deleted according to the control command, and the system space can be fully utilized. And it is independent of the update process of the main application, and the update process of each plug-in is independent, thus making the update process more independent, and does not interfere with the update of other plug-ins or main applications.

The plugin is actually a standalone application. It contains resources and code and related android component definitions. To make the main app call up the plugin, you need to simulate the environment in which the app is running and provide it to the plugin. The key points include: plugin code. And resource loading, plugin resource injection, component hosting, and proxying. In addition, in order for the plugin to maintain the original structure and code logic, we need to handle their specific calls: such as this, super call, system component property simulation (launch_mode, intent-filter, etc.).

First, call the plugin with the main application. Most of the components in Android need to be registered in the Androidmanifest.xml of the apk to be called normally by the system (such as Activity, Service, etc.), but the plug-in in the embodiment of the present invention is not installed, and its component is not to the system. Registered, the app can't be called like a traditional component. To use the components in the plugin, you must solve this problem. To solve this problem, the embodiment of the present invention adopts a processing method for establishing a managed plug-in component in a main application, wherein the managed plug-in component can simulate a non-independent plug-in generated when the same auxiliary function is implemented and embedded in the main application is generated. event. When any event is detected, the managed plug-in component is triggered to forward the event to the event handler function of the dependent plug-in for processing.

Take Activity as an example. When the plugin is an active Activity, the managed plugin component is a proxy activity, which can simulate the Activity life cycle and the Activity event. When the Activity event occurs, the proxy activity is passed through the reflection call to pass the Activity event to the handler corresponding to the plugin Activity event for processing. That is, define a dedicated proxy Activity (ProxyActivity) in the main app, the Activity is specifically used to proxy the plug-in Activity, simulate the life cycle of the plug-in Activity (onCreate, onStart, etc.) and various events, plug-ins The Activity is created as an ordinary Java object, and the event is passed to the handler of the plugin Activity through a reflection call. The process is transparent to the plugin, and it still implements the logic of the Activity as usual.

ProxyActivity is not a real Activity. It does not have a plugin class loader and resources. The proxy activity can only solve the event that the simulation system initiates actively and the component passively receives. When the plugin activity uses the methods provided by the system such as this or super, Such as setContentView, etc., there will inevitably be problems.

In order to solve this problem, the embodiment of the present invention defines a very simple plugin implementation specification: all activities used in the plugin must inherit a specific PluginActivity from the plugin sdk. In the case that the plugin architecture is good, and most of the same types of activities have a unified parent class, you only need to replace the parent class of these parent classes with PluginActivity. PluginActivity will rewrite the key methods of the system, and forward the calls of the subclass directly to ProxyActiviy. In this way, the more critical methods of the plugin Activity using this or super call will be handled by ProxyActivity, just like it is a real Activity. same.

Normally, an app can only have one resource object and a class loader that loads the app code, so the resources and code used throughout the app are both the main app. If you want to call the resources and code in the plugin without limiting the original code structure and logic of the plugin, you must force the plugin's resources and class loader into the context of the main application calling each plugin. In the main application to call each plugin.

Specifically, when the main application invokes a plugin, the resource object and the class loader of the context of the main application are replaced by the reflection with the resource object and the class loader of the plugin; the resource object and the class loader of the plugin are respectively loaded by the plugin. Resources and code to perform the plugin's accessibility features. When a plugin is called, it is generally a component of a plugin (Activity, Service, etc.). As mentioned above, the present invention is a component of the main application calling plugin, and the plugin is provided to the main application. Context, if the plugin is used directly, it must be wrong. Therefore, this embodiment uses the reflection to replace the resource object and the class loader (mResource, mClassLoader) and other objects in the context with the resources and classes of the plugin. The loader, so that the plugin can use its own resources and code directly.

Since the main application has an interaction relationship with a plurality of plugins at the same time, the main application communicates with each plugin by setting a plugin interface on each plugin to implement a call to each plugin. For example, the plugin component provides a plugin interface (IPlugin) to the plugin to help the plugin communicate with the host. The key methods are onLoad(), onCommand(), onLoad() when the plugin is loaded. The plugin can perform some initialization work in the function. onCommand() is called when the plugin receives the command. The plugin can be in the function. Implement the processing of commands.

When the main application calls multiple plugins at the same time, when any one of the plugins issues a command, the plugin manager receives the command and distributes the command to all plugins managed by the plugin manager, wherein the plugin interested in the command processes it and generates The result of the response; the plugin manager receives the response to the command and returns it to the plugin that issued the command. That is, a unified specification can be defined in the plugin. When the plugin issues a command, the plugin manager distributes the command to all the plugins. The plugin only needs to process the commands of interest in the interface class response (onCommand). The command is passed using the system's Intent class encapsulation, which ensures that there is no dependency between the plugins and avoids the dependency of the plugin code. FIG. 5 shows a schematic diagram of a main application invoking a plurality of plugins in accordance with one embodiment of the present invention.

According to the above description, the embodiments of the present invention can enable plug-in functions of applications, such as application cards and application modules. Blocks, application skins, etc. can be plug-in independent, so that application development can be distributed synchronously, increasing the value of existing products, and solving the problem of large application size, as well as some small updates also need to update the entire app. Problems, improve user experience and shorten user processes. specifically,

1. Plug-in resources and code dynamic loading solve the problem of plug-in dynamic update, so the plug-in does not need to be included in the installation package of the main app.

2, component proxy and hosting, solve the problem of component definition in the plug-in, reduce the coupling between the plug-in and the host.

3, plug-in resources and class loader injection, to ensure the original logic and resources of the plug-in, so that the plug-in can be run as a plug-in without major changes.

4, the plug-in this, super call processing, to ensure that the plug-in code runs intact.

5, the plug-in implementation of each other, you can make the plug-ins have no dependencies, and can be adjusted each other.

6. The implementation of the plugin interface provides a mechanism for the plugin to communicate with the host.

FIG. 6 shows a schematic diagram of a plug-in implementation flow according to an embodiment of the present invention. Referring to Figure 6, the plugin manager manages the plugin, performs preprocessing such as initialization operations and preloading. This process is independent and asynchronous with the startup process of the main app. When the main app is initialized, the plugin call is initiated through the app function interface, and the required plugin is called to the plugin manager. The plugin then launches and loads and displays the new plugin feature interface on the app's function interface.

Based on the same inventive concept, an embodiment of the present invention further provides an application installation device. Figure 7 is a block diagram showing the construction of an application mounting device in accordance with one embodiment of the present invention. Referring to Figure 7, the device includes at least:

The function determining module 710 is adapted to determine a plurality of types of functions to be implemented according to requirements, wherein the plurality of types of functions include a primary function and an auxiliary function;

The classification configuration module 720 is coupled to the function determination module 710, is adapted to generate a main application for the main function, and generates a separate plug-in for each auxiliary function;

The installation module 730 is coupled to the classification configuration module 720 and is adapted to install a main application, wherein the main application can call different plug-ins according to requirements to implement different auxiliary functions.

FIG. 8 shows another schematic structural view of an application mounting apparatus according to an embodiment of the present invention. In a preferred embodiment, referring to FIG. 7, the application installation device may further include:

The plug-in loading module 740 is respectively coupled to the configuration module 720 and the installation module 730, and is adapted to display the plug-ins with auxiliary functions in the foreground after the installation of the main application is finished; or to silently load the plug-ins with auxiliary functions in the background. .

In a preferred embodiment, the plug-in loading module 740 is further configured to:

Load the plugin code of each plugin with the class loader of the main application;

Loading the plugin code of each plugin into the memory, and generating a separate class loader for the plugin for each plugin;

Each plugin resource is loaded correspondingly by the class loader of each plugin.

In a preferred embodiment,

The plugin code and resources of each plugin are loaded to simulate the plugin runtime environment when the plugin is called;

After the plug-in is loaded, the plug-in manager uninitifies and manages the plug-ins.

Based on the same inventive concept, an embodiment of the present invention further provides an application running device. FIG. 9 is a block diagram showing the structure of an application running device according to an embodiment of the present invention. Referring to Figure 9, the device includes at least:

The startup module 910 is adapted to enable a main application having a main function, wherein the main application can invoke a plug-in having an auxiliary function other than the main function;

The selection module 920 is coupled to the startup module 910, and is adapted to select a plug-in identifier corresponding to the auxiliary function according to requirements in an interface of the main application;

The calling module 930 is coupled to the selection module 920, and is adapted to use the plug-in corresponding to the selected plug-in identifier by the main application to implement the corresponding auxiliary function.

In a preferred embodiment, the calling module 930 is further configured to:

Establishing a managed plugin component in the main application, wherein the managed plugin component can simulate an event generated when a non-independent plugin that implements the same auxiliary function and is embedded in the main application is called;

When any event is detected, the managed plug-in component is triggered to forward the event to the event handler function of the dependent plug-in for processing.

In a preferred embodiment, when the plugin is an active activity,

The managed plug-in component is a proxy activity, which can simulate the Activity life cycle and Activity event;

When the Activity event occurs, the proxy activity is passed through the reflection call to pass the Activity event to the handler corresponding to the plugin Activity event for processing.

In a preferred embodiment, the hosted plugin component is implemented by the following steps:

The parent class of the same type of activity in the unified plugin architecture;

Replace the unified parent class with a specific PluginActivity;

When a subclass is called, the call to the subclass is forwarded by the PluginActivity to the managed plugin component.

In a preferred embodiment, the hosted plugin component is transparent relative to its corresponding plugin.

In a preferred embodiment, the calling module 930 is further configured to:

The resource objects and class loaders of each plug-in are forcibly injected into the context used by the main application to call each plug-in for the main application to call each plug-in.

In a preferred embodiment, the calling module 930 is further configured to:

When the main application calls a plugin, the resource object and the class loader of the context of the main application are replaced by the reflection with the resource object and the class loader of the plugin;

The resource object and code of the plugin are respectively loaded by the resource object and the class loader of the plugin, and the auxiliary function of the plugin is executed.

With the method and device provided by the embodiments of the present invention, the following technical features can be achieved:

In the embodiment of the present invention, the functions corresponding to the requirements are divided into two categories, one is a main function implemented by the main application, and the other is an auxiliary function implemented by the plug-in. In the embodiment of the present invention, only the main application needs to be installed. If other auxiliary functions are needed, different plug-ins can be called in real time according to requirements by the main application to implement different auxiliary functions. That is, in the embodiment of the present invention, only the main application needs to be installed in an operating system in the form of a separate application, and the remaining plug-ins need not be installed to be used. In the implementation, the main application can realize the phase by calling the plug-in through a certain communication method. The function should be. In addition, the embodiments of the present invention divide the functions corresponding to the requirements, so that the requirements can be developed in a distributed manner, and each auxiliary function is implemented by a plug-in function, which can be directly used as a plug-in for other products, and further improves the practicability of the plug-in. . In addition, during the installation process of the main application, only the main application is installed, and the corresponding installation package only needs to contain the code and resources necessary for the application, which greatly reduces the application installation data package and can speed up the application installation data package. The download process prevents the user from giving up the download by seeing the application too much, or giving up the download halfway because the download is too slow, which improves the user experience. Further, since the plug-in is separated from the main application, the plug-in can be dynamically added, updated, and deleted according to the control command, and the system space can be fully utilized. And it is independent of the update process of the main application, and the update process of each plug-in is independent, thus making the update process more independent, and does not interfere with the update of other plug-ins or main applications.

In the description provided herein, numerous specific details are set forth. However, it is understood that the embodiments of the invention may be practiced without these specific details. In some instances, well-known methods, structures, and techniques are not shown in detail so as not to obscure the understanding of the description.

Similarly, the various features of the invention are sometimes grouped together into a single embodiment, in the above description of the exemplary embodiments of the invention, Figure, or a description of it. However, the method disclosed is not to be interpreted as reflecting the intention that the claimed invention requires more features than those recited in the claims. Rather, as the following claims reflect, inventive aspects reside in less than all features of the single embodiments disclosed herein. Therefore, the claims following the specific embodiments are hereby explicitly incorporated into the embodiments, and each of the claims as a separate embodiment of the invention.

Those skilled in the art will appreciate that the modules in the devices of the embodiments can be adaptively changed and placed in one or more devices different from the embodiment. The modules or units or components of the embodiments may be combined into one module or unit or component, and further they may be divided into a plurality of sub-modules or sub-units or sub-components. In addition to such features and/or at least some of the processes or units being mutually exclusive, any combination of the features disclosed in the specification, including the accompanying claims, the abstract and the drawings, and any methods so disclosed, or All processes or units of the device are combined. Each feature disclosed in this specification (including the accompanying claims, the abstract and the drawings) may be replaced by alternative features that provide the same, equivalent or similar purpose.

In addition, those skilled in the art will appreciate that, although some embodiments described herein include certain features that are included in other embodiments and not in other features, combinations of features of different embodiments are intended to be within the scope of the present invention. Different embodiments are formed and formed. For example, in the following claims, any one of the claimed embodiments can be used in any combination.

The various component embodiments of the present invention may be implemented in hardware, or in a software module running on one or more processors, or in a combination thereof. Those skilled in the art will appreciate that a microprocessor or digital signal processor (DSP) may be used in practice to implement some or all of the functionality of some or all of the application mounting devices, application operating devices, in accordance with embodiments of the present invention. . The invention may also be embodied as a device or device program (eg, a computer program and a computer) for performing some or all of the methods described herein. Program product). Such a program implementing the invention may be stored on a computer readable medium or may be in the form of one or more signals. Such signals may be downloaded from an Internet website, provided on a carrier signal, or provided in any other form.

For example, Figure 10 illustrates a computing device that can implement an application installation method and/or an application operation method in accordance with the present invention. The computing device conventionally includes a processor 1010 and a computer program product or computer readable medium in the form of a memory 1020. The memory 1020 may be an electronic memory such as a flash memory, an EEPROM (Electrically Erasable Programmable Read Only Memory), an EPROM, a hard disk, or a ROM. The memory 1020 has a memory space 1030 for executing program code 1031 of any of the above method steps. For example, storage space 1030 for program code may include various program code 1031 for implementing various steps in the above methods, respectively. The program code can be read from or written to one or more computer program products. These computer program products include program code carriers such as hard disks, compact disks (CDs), memory cards or floppy disks. Such a computer program product is typically a portable or fixed storage unit as described with reference to FIG. The storage unit may have storage segments, storage spaces, and the like that are similarly arranged to memory 1020 in the computing device of FIG. The program code can be compressed, for example, in an appropriate form. Typically, the storage unit includes computer readable code 1031', ie, code that can be read by, for example, a processor such as 1010, which when executed by a computing device causes the computing device to perform each of the methods described above step.

"an embodiment," or "an embodiment," or "an embodiment," In addition, it is noted that the phrase "in one embodiment" is not necessarily referring to the same embodiment.

It is to be noted that the above-described embodiments are illustrative of the invention and are not intended to be limiting, and that the invention may be devised without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as a limitation. The word "comprising" does not exclude the presence of the elements or steps that are not recited in the claims. The word "a" or "an" The invention can be implemented by means of hardware comprising several distinct elements and by means of a suitably programmed computer. In the unit claims enumerating several means, several of these means can be embodied by the same hardware item. The use of the words first, second, and third does not indicate any order. These words can be interpreted as names.

In addition, it should be noted that the language used in the specification has been selected for the purpose of readability and teaching, and is not intended to be construed or limited. Therefore, many modifications and changes will be apparent to those skilled in the art without departing from the scope of the invention. The disclosure of the present invention is intended to be illustrative, and not restrictive, and the scope of the invention is defined by the appended claims.

Claims

An application installation method, including:

Determining a plurality of types of functions to be implemented according to requirements, wherein the plurality of types of functions include a primary function and an auxiliary function;

Generating a main application for the main function, and generating a separate plug-in for various auxiliary functions;

The main application is installed, wherein the main application can call different plugins according to requirements to implement different auxiliary functions.
The method of claim 1, wherein after the main application installation ends, the method further comprises:

Displaying plug-ins with accessibility features in the foreground; or

Silently load plugins with accessibility in the background.
The method according to claim 2, wherein said loading each plug-in having an auxiliary function comprises:

Loading the plugin code of each plugin by using the class loader of the main application;

Loading the plug-in code of each plug-in into the memory, and generating a plug-in independent class loader for each plug-in;

Each plugin resource is loaded correspondingly by the class loader of each plugin.
The method of claim 3, wherein

The plugin code and resources of each plugin are loaded to simulate the plugin runtime environment when the plugin is called;

After the plug-in is loaded, the plug-in manager uninitifies and manages the plug-ins.
An application running method, including:

Opening a main application having a main function, wherein the main application can call a plug-in having an auxiliary function other than the main function;

Selecting, in the interface of the main application, a plug-in identifier corresponding to the auxiliary function according to requirements;

The plug-in corresponding to the selected plug-in identifier is invoked by the main application to implement a corresponding auxiliary function.
The method of claim 5, wherein the plugging the plugin with the main application comprises:

Establishing a hosted plug-in component in the main application, wherein the hosted plug-in component is capable of simulating an event generated when a non-independent plug-in that implements the same auxiliary function and is embedded in the main application is called;

When any event is detected to occur, the hosted plugin component is triggered to transfer the event that occurred to the event handler function provided by the dependent plugin for processing.
The method of claim 6, wherein when the plugin is an active activity,

The managed plug-in component is a proxy activity, which can simulate an Activity life cycle and an Activity event;

When the Activity event occurs, the proxy activity passes the Activity event to the handler corresponding to the plugin Activity event for processing by the reflection call.
The method of claim 7 wherein said hosted plugin component is implemented by the following steps:

The parent class of the same type of activity in the unified plugin architecture;

Replace the unified parent class with a specific PluginActivity;

When the subclass is called, the call to the subclass is forwarded by the PluginActivity to the managed plugin component.
Method according to any of claims 6 to 8, wherein the hosted plugin component corresponds to its counterpart The plugin is transparent.
The method according to any one of claims 5 to 9, wherein the calling the plugin by using the main application further comprises:

The resource objects and class loaders of each plug-in are forcibly injected into the context used by the main application to call each plug-in for the main application to call each plug-in.
The method of claim 10, wherein the plugging the plugin with the main application comprises:

When the main application calls a plugin, the resource object and the class loader of the context of the main application are replaced by the reflection with the resource object and the class loader of the plugin;

The resource object and code of the plugin are respectively loaded by the resource object and the class loader of the plugin, and the auxiliary function of the plugin is executed.
The method according to any one of claims 5 to 11, wherein the calling the plugin by using the main application comprises:

The main application communicates with each plug-in by setting a plug-in interface on each plug-in to implement a call to each plug-in.
The method according to any one of claims 5 to 11, further comprising:

When the main application calls multiple plugins at the same time,

When any one of the plugins issues a command, the plugin manager receives the command and distributes the command to all plugins managed by the plugin manager, wherein the plugin interested in the command processes the plugin, Produce a response result;

The plugin manager receives the response to the command and returns it to the plugin that issued the command.
The method of claim 13 wherein said command uses a system's Intent class encapsulation during delivery.
The method according to any one of claims 5 to 14, wherein the number or type of plug-ins can be added or deleted according to requirements during the running of the main application.
The method of claim 15 wherein the commands to add or delete plugins are remotely controlled by the cloud.
The method according to any one of claims 1 to 16, wherein the presentation form of the plugin in the main application interface comprises at least one of the following:

card;

Pop-ups;

Scrolling.
The method according to any one of claims 1 to 17, wherein when the main application is a search application,

Accessibility features include at least one of the following:

Fiction;

Scan code;

music;

Video

news;

skin.
An application mounting device comprising:

a function determining module, configured to determine, according to requirements, a plurality of types of functions to be implemented, wherein the plurality of types of functions include a primary function and an auxiliary function;

a classification configuration module, configured to generate a main application for the main function, and generate a separate plug-in for each auxiliary function;

The installation module is adapted to install the main application, wherein the main application can call different plugins according to requirements to implement different auxiliary functions.
The apparatus of claim 19, further comprising:

The plug-in loading module is adapted to display the plug-ins with auxiliary functions in the foreground after the installation of the main application ends, or to silently load the plug-ins with auxiliary functions in the background.
The device of claim 20, wherein the plug-in loading module is further configured to:

Loading the plugin code of each plugin by using the class loader of the main application;

Loading the plug-in code of each plug-in into the memory, and generating a plug-in independent class loader for each plug-in;

Each plugin resource is loaded correspondingly by the class loader of each plugin.
The device according to claim 21, wherein

The plugin code and resources of each plugin are loaded to simulate the plugin runtime environment when the plugin is called;

After the plug-in is loaded, the plug-in manager uninitifies and manages the plug-ins.
An application running device includes:

a startup module, configured to open a main application having a main function, wherein the main application can invoke a plug-in having an auxiliary function other than the main function;

a selection module, configured to select, according to requirements, a plug-in identifier corresponding to the auxiliary function in an interface of the main application;

The calling module is adapted to use the plug-in corresponding to the selected plug-in identifier by the main application to implement a corresponding auxiliary function.
The apparatus of claim 23, wherein the calling module is further configured to:

Establishing a hosted plug-in component in the main application, wherein the hosted plug-in component is capable of simulating an event generated when a non-independent plug-in that implements the same auxiliary function and is embedded in the main application is called;

When any event is detected to occur, the hosted plugin component is triggered to transfer the event that occurred to the event handler function provided by the dependent plugin for processing.
The apparatus according to claim 24, wherein when said plugin is an active activity,

The managed plug-in component is a proxy activity, which can simulate an Activity life cycle and an Activity event;

When the Activity event occurs, the proxy activity passes the Activity event to the handler corresponding to the plugin Activity event for processing by the reflection call.
The apparatus of claim 25, wherein the hosted plugin component is implemented by the following steps:

The parent class of the same type of activity in the unified plugin architecture;

Replace the unified parent class with a specific PluginActivity;

When the subclass is called, the call to the subclass is forwarded by the PluginActivity to the managed plugin component.
A device according to any of claims 24 to 26, wherein the hosted plugin component is transparent with respect to its corresponding plugin.
The apparatus according to any one of claims 23 to 27, wherein the calling module is further configured to:

The resource objects and class loaders of each plug-in are forcibly injected into the context used by the main application to call each plug-in for the main application to call each plug-in.
The apparatus of claim 28, wherein the calling module is further configured to:

When the main application calls a plugin, the resource object and the class loader of the context of the main application are replaced by the reflection with the resource object and the class loader of the plugin;

The resource object and code of the plugin are respectively loaded by the resource object and the class loader of the plugin, and the auxiliary function of the plugin is executed.
A computer program comprising computer readable code, when said computer readable code is run on a computing device, causing said computing device to perform an application installation method according to any one of claims 1-4, and/ Or the application operation method according to any one of claims 5-18.
A computer readable medium storing the computer program of claim 30.