WO2021190469A1

WO2021190469A1 - Terminal apparatus, and control method for calling application program interface therefor

Info

Publication number: WO2021190469A1
Application number: PCT/CN2021/082260
Authority: WO
Inventors: 关安杰
Original assignee: 广州华多网络科技有限公司
Priority date: 2020-03-24
Filing date: 2021-03-23
Publication date: 2021-09-30
Also published as: CN111338828B; CN111338828A

Abstract

A terminal apparatus and control method for calling application program interface therefor. The method comprises the following steps: an application program receiving, after a service component thereof is activated, binding communication of a client process by means of the service component; the application program creating, in response to an interface creation request initiated by the client process on the basis of calling an interface class, an instance object of a corresponding implementation class, wherein interface registration information corresponding to the implementation class is pre-registered in an interface library by the application program; and the application program calling and executing, in response to an interface calling request initiated by the client process for calling a built-in method of the instance object, the built-in method of the instance object to generate and feed back resulting data to the client process, wherein the request comprises property information determined according to the interface registration information in the interface library for executing the built-in method. The present invention simplifies development steps related to implementing a communication interface during an application program development process, and provides a simple, convenient, and efficient cross-process communication solution.

Description

Terminal equipment and its application program interface calling control method

This application claims the priority of a Chinese patent application filed with the Chinese Patent Office on March 24, 2020, the application number is 202010212433.9, and the invention title is "terminal equipment and its application program interface call control method", the entire content of which is incorporated by reference In this application.

Technical field

The invention relates to the application development technology of the Android operating system, in particular to an application program interface call control method, and also to its corresponding terminal equipment.

Background technique

In the process of developing Android applications, we will begin to introduce multi-process communication technology into the existing technology system according to different business scales and scenarios. The use of multi-process communication technology can break through the limitation of the application's allocable system resources (the allocation of Android system resources is based on the process as the basic unit), so that the available resources of the application can be doubled, and business needs such as application keep-alive can be achieved, but it has increased For the technical system of multi-process communication, we need to deal with the problem of data transmission in multi-process communication, which will greatly increase the technical complexity of development.

The Android official itself provides a variety of technologies to solve multi-process communication. We usually use AIDL to achieve inter-process communication. AIDL is one of the IPC (Inter-Process Communication) methods in Android, and is an abbreviation of Android Interface definition language (Android interface definition language). Although AIDL's indicators are more in line with actual needs, the processing process is complicated and the development cost is high.

Generally using AIDL to develop an interface method that supports multi-process communication, we need to do the following: 1. Create an aidl file and define the interface class in the aidl file; 2. If the parameter of the interface class method contains a custom type, you also need Define another aidl file for this type; 3. A Service class needs to be created to provide information communication services for the process providing services; 4. A Binder class is defined to implement the interface class defined in aidl, and the functional logic is implemented in the implementation class; 5. The Service class returns the object of the Binder class in step 4 to the Client program through the onBind interface; 6. The Client program needs to connect to the Service class of the Server program, obtain the proxy object of the Binder class in the onServiceConnected method, and call the Binder class through the proxy object Interface methods to obtain the functions provided by the Binder class; 7, the Client program needs to maintain its connection with the Service class, because the Service class is the carrier of its communication and interaction.

According to the above-mentioned interface method of using AIDL to develop multi-process communication, a cross-process interface can be created. The key to the problem is that in general, each interface class that provides IPC services needs to be operated again according to the above steps. It can be seen that now Although some technologies support ipc communication, their development steps are complex and cumbersome, and their scalability is poor, leading to high development costs. This is particularly unfavorable for the development of projects that require joint operation.

Summary of the invention

The primary purpose of the present invention is to provide an application program interface call control method for improving application program development efficiency.

Correspondingly, as another object of the present invention, a terminal device compatible with it is also provided based on the method of the previous object.

In order to meet the primary purpose of the present invention, the present invention provides an application program interface call control method, which includes the following steps:

After the service component pre-registered to the operating system of this application is started, the service component accepts the binding communication with the client process of the same application or a different application through the application;

This application creates an instance object of the implementation class corresponding to the interface class in response to the interface creation request initiated by the client process based on calling the interface class; the interface registration information corresponding to the implementation class is pre-registered to the interface by this application In the library, it is set in a one-to-one correspondence with the interface class;

This application responds to an interface call request for invoking the built-in method of the instance object initiated by the client process, and the request includes the attribute information for executing the built-in method determined according to the interface registration information of the interface library , Call and execute the built-in method of the instance object according to the attribute information to generate result data and feed it back to the client process.

In some embodiments, the method further includes the following steps:

Perform a version update of the application program. After the updated application program runs, re-register the interface library to increase or decrease the number of interfaces registered in the interface library.

Preferably, the interface registration information in the interface library includes:

Class table information that characterizes the corresponding relationship between the interface identifier of the interface, the implementation class, and the interface class, so as to determine the one-to-one correspondence between the interface class and the implementation class according to the interface identifier;

Method table information that characterizes the relationship between the implementation class and its built-in methods and the call operation information of these built-in methods, so as to execute method calls;

The instance table information that characterizes the correspondence between the implementation class instance objects that are providing services to the client process and the object identifiers with unique characteristics, so as to implement the invocation of the instance objects.

Specifically, the attribute information includes the interface identifier or object identifier corresponding to the implementation class to which the built-in method belongs and the invocation operation information of the built-in method, and the invocation operation information includes the method identifier and operation of the built-in method. Parameters and return value types.

Correspondingly, when the application program responds to an interface creation request, it queries the class table information to determine the corresponding implementation class according to the interface identifier specified by the request, so as to create an instance object of the implementation class for it;

When this application program responds to an interface call request, according to the attribute information provided by the request, the built-in method is determined by querying the method table information to call it.

In some embodiments, the service component of the application program is bound to multiple client processes in parallel, and the application program is suitable for starting one or more of the client processes.

Preferably, the application program and the program to which the client process belongs shall comply with a predetermined agreement, the attribute information is encapsulated and unencapsulated in the first format, and the result data is encapsulated and unencapsulated in the second format.

Further, the performance of the application in the memory and the client process construct functional modules corresponding to the functions according to mutual agreements, both of which include a parsing module and a transceiver module, wherein the parsing module is responsible for executing the first format and the first format. The functions related to the second format are realized, and the transceiver module is used to perform communication transmission related to the first format and the second format.

Preferably, the application program constructs an interface management module for uniformly executing the client process and the application program's own access to the interface library.

Further, the client process is responsible for maintaining the communication state with the service process to ensure the stability of the cross-process communication between the client process and the service process.

In some embodiments, the method further includes the following steps:

After the client process is unbound with the service component of the application, the instance table information generated by the call of the client process is cleared.

In order to meet other objectives of the present invention, a terminal device provided by the present invention includes a central processing unit and a memory, and the central processing unit is used to call and run a computer program stored in the memory to execute the above-mentioned The application program interface calls the steps of the control method.

Compared with the prior art, the present invention has the following advantages:

First of all, the method of the present invention uses the interface library to store and manage the implementation classes of the application program, and register its built-in implementation classes in the interface library in advance when the application program is running, and then be called by the client process. In this process, through The interface identifier is associated with the interface class of the client process and the implementation class of the application, as well as the memory resources such as instance objects and proxy objects of the implementation class. It plays a role in centralized scheduling and management of calls between processes, making the application (Expressed as a service process) The interface call between the client process is more flexible and efficient. For the method level of the class, the interface library also configures storage and management mechanisms for it, so that the relevant attribute information required for the operation of the built-in method of the instance object can be interoperated across processes by querying the interface library. Therefore, the client process can communicate with each other through its The proxy object can pass parameters and call the built-in methods of the instance object of the service process. Therefore, the setting of the interface library and its protocol analysis mechanism makes it possible to communicate efficiently across processes.

Secondly, the improvement of cross-process communication efficiency is reflected in the development process, especially in the development process of the Android operating system, which can greatly improve the efficiency of program development. In Android, the implementation of the present invention makes it unnecessary to perform a completely consistent interface configuration process for a new interface based on AIDL when calling interfaces between different processes. For the development steps of the process communication interface, on the basis of the present invention, developers only need to create an API interface class and its implementation class for the cross-process communication interface, instead of repeating other well-known steps. During the program, the API interface will be registered in the interface library, and the functions corresponding to other known steps are automatically implemented by the method of the present invention in a program process. Therefore, after the application that implements the present invention is upgraded, if the relevant cross-process communication interface is added or deleted in the upgraded version, it will be reflected in the change of the interface registration information of the interface library. It can be seen that the present invention can greatly improve the efficiency of program development, help release development capabilities, and comprehensively reduce project development costs.

Furthermore, because the service process of the present invention is equipped with service components, its interface calling mechanism can provide services for multiple client processes in parallel, regardless of whether these client processes belong to this application or other applications, which is a joint development Projects such as login module, authorization module, payment module, filter module, etc. provide a convenient basis for technical implementation. Whether it is the application program or the client process of a different application program, as long as it complies with the protocol regulated by the method of the present invention, it also has the ability to interact with the application program of the present invention, so as to realize the resource connection with the application program. Call each other and share memory resources with the service process represented by this application. This basic technology is also conducive to ensuring the survival of service processes or client processes in memory, the mechanism of binding each other through service components, scheduling activities that implement class interfaces, and making it possible for processes to wake up each other, ensuring The activity of each process in the memory, to prevent each process from being terminated during the memory cleaning process, and even one process can be used to restart another process, so that these processes are always running in the system.

Furthermore, the service process realizes the ability of centralized maintenance and service of the interface, and the client process can simplify the development. One or more client processes, regardless of whether these processes belong to the same application or different programs, can be provided by the service process to provide interface services. For terminal programs related to joint development projects that focus on realizing some core functions, or for scenarios that require extended plug-ins, it is more efficient.

In addition, the present invention adopts a protocol analysis mechanism for the intermediate process data between the service process and the client process. Specifically, the first format is adopted at the call level and the second format is adopted at the result level. Develop some analysis modules with concentrated functions and configure them in the client process and service process, so as to facilitate the modular development of the analysis and packaging functions corresponding to different formats, and further improve the development efficiency while ensuring the security of communication between different processes.

The additional aspects and advantages of the present invention will be partly given in the following description, which will become obvious from the following description, or be understood through the practice of the present invention.

Description of the drawings

The above and/or additional aspects and advantages of the present invention will become obvious and easy to understand from the following description of the embodiments in conjunction with the accompanying drawings, in which:

FIG. 1 is a schematic diagram of the realization structure of the client process and the service process in the principle on which the present invention is implemented;

FIG. 2 is a schematic flowchart of an application program interface calling control method in a typical embodiment of the present invention;

FIG. 3 is a schematic flowchart of a cross-process communication method in a typical embodiment of the present invention;

Fig. 4 is a schematic flow diagram of specific steps of step S23 in the cross-process communication method of the present invention.

Detailed ways

The embodiments of the present invention are described in detail below. Examples of the embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals indicate the same or similar elements or elements with the same or similar functions. The embodiments described below with reference to the drawings are exemplary, and are only used to explain the present invention, but cannot be construed as limiting the present invention.

Those skilled in the art can understand that, unless specifically stated, the singular forms "a", "an", "said" and "the" used herein may also include plural forms. It should be further understood that the term "comprising" used in the specification of the present invention refers to the presence of the described features, integers, steps, operations, elements and/or components, but does not exclude the presence or addition of one or more other features, Integers, steps, operations, elements, components, and/or groups of them. It should be understood that when we refer to an element as being "connected" or "coupled" to another element, it can be directly connected or coupled to the other element, or intervening elements may also be present. In addition, “connected” or “coupled” used herein may include wireless connection or wireless coupling. The term "and/or" as used herein includes all or any unit and all combinations of one or more associated listed items.

Those skilled in the art can understand that, unless otherwise defined, all terms (including technical terms and scientific terms) used herein have the same meaning as those commonly understood by those of ordinary skill in the art to which the present invention belongs. It should also be understood that terms such as those defined in general dictionaries should be understood to have a meaning consistent with the meaning in the context of the prior art, and unless specifically defined as here, they will not be idealized or overly Explain the formal meaning.

Those skilled in the art can understand that the "client", "terminal", and "terminal device" used herein include both wireless signal receiver devices, which only have wireless signal receiver devices without transmitting capabilities, and include A device for receiving and transmitting hardware, which has a device capable of receiving and transmitting hardware for two-way communication on a two-way communication link. Such devices may include: cellular or other communication devices such as personal computers, tablet computers, which have single-line displays or multi-line displays or cellular or other communication devices without multi-line displays; PCS (Personal Communications Service, personal communication) System), which can combine voice, data processing, fax and/or data communication capabilities; PDA (Personal Digital Assistant), which can include radio frequency receivers, pagers, Internet/Intranet access, web browsers, and notes Notebook, calendar, and/or GPS (Global Positioning System) receiver; conventional laptop and/or palmtop computer or other equipment, which has and/or includes a conventional laptop and/or radio frequency receiver Palm-size computer or other equipment. The "client", "terminal", and "terminal device" used here may be portable, transportable, installed in vehicles (air, sea and/or land), or suitable and/or configured to be locally Operate, and/or in a distributed form, operate in any other location on the earth and/or space. The "client", "terminal", and "terminal device" used here can also be communication terminals, internet terminals, music/video playback terminals, such as PDA, MID (Mobile Internet Device, mobile Internet device) and/or Mobile phones with music/video playback functions can also be devices such as smart TVs and set-top boxes.

The hardware referred to by the names "terminal equipment" and "mobile terminal" in the present invention is essentially a device with the equivalent capabilities of a personal computer, which has a central processing unit (including arithmetic unit and controller), memory, and input The hardware devices of the necessary components disclosed by the Von Neumann principle, such as equipment and output devices, have computer programs stored in their memory, and the central processing unit transfers the programs stored in the external memory into the memory to run, executes the instructions in the programs, and The input and output devices interact to complete specific functions.

The main implementation principles of the present invention are first disclosed below in conjunction with the accompanying drawings:

The application program of the present invention runs in the form of a computer program in a terminal device such as a mobile terminal such as a mobile phone, a tablet, etc. The terminal device runs Android or a forward compatible Android (for example, the "Hongmeng" recently developed by Huawei-Harmony OS) operating system. The application program is scheduled to run in the memory by the central processing unit to implement the relevant method of the present invention.

According to the inherent mechanism of the operating system, each application program will run in a virtual machine of the system. Of course, the operating system also supports a multi-process architecture. Therefore, the same application program may include multiple processes, for example, a process that provides service functions is run by registering a service component on the basis of the main process.

Please refer to Figure 1. After the application in which the relevant method implemented by the present invention is running in the memory, two types of processes associated with the relevant method of the present invention will be allowed to exist in the memory, one is the service that serves as the main body of the application. Process 2, the other type is client process 1 that belongs to this application or belongs to other applications but can interact with the service process 2 to implement interface calls.

A protocol mechanism is established between the service process 2 and the client process 1, and the two have complied with the relevant development agreement in advance. Therefore, in scenarios where the data format is required, it includes encapsulation and decapsulation (analysis) in a specific data format. This kind of agreement exists between each other, so the data encapsulated by the other party can be recognized by each other, and the content transmitted by the other party can be restored correctly. That is to say, between the client process 1 and the service process 2, the data format encapsulated by one party can be correctly parsed by the other party in accordance with the pre-agreement. The agreement between service process 2 and client process 1 defines two formats, the first is the request format, and the second is the result format. The request format is used to encapsulate and decapsulate various requests initiated by the client process 1. The data involved is mainly the interface identifier and method identifier (and attribute information such as method operating parameters and return value types) obtained after the client process parses the interface class annotations. The object identifier carried by the proxy object, etc., and the result format is used to encapsulate and decapsulate various result data generated by the execution of the service process 2. The return value after the method is called and executed. The request format is usually encapsulated by the client process 1 and parsed by the service process 2, and the result data is usually encapsulated by the service process 2 and parsed by the client process 1. For this reason, it will be revealed below that both the client process 1 and the service process 2 will construct specialized functional modules, namely, the parsing modules 13, 23 to implement the encapsulation and decapsulation functions related to these data formats.

The service process 2 is responsible for the registration of the interface and subsequently receives the interface creation and invocation request of the client process 1, and provides the interface creation and invocation service for the client process 1. In order to maintain its service function, the service process 2 needs to register a service component 20 with the system, thereby realizing background operation. The service process 2 mainly includes a business module 21, an execution module 22, a parsing module 23, a transceiver module 24, and the service component 20, and maintains an interface library 25 by performing registration after startup. The business module 21 is responsible for the interface implementation class The registration function; its service component 20 is mainly provided to the client process 1 for binding, so as to ensure the communication between the service process 2 and the client process 1; on the one hand, the transceiver module 24 is responsible for receiving various requests from the client process 1, On the other hand, it is responsible for feeding back various result data to the client process 1, through its two-way service function to meet the communication transmission between the service process 2 and the client process 1. Its analysis module 23 is mainly used to parse out the client process 1 in the first format (Request format) encapsulated various requests, and encapsulate various result data in the second format (result format) to send to the client process 1 through its transceiver module 24; its execution module 22 is mainly responsible for the response when the client process 1 requests an interface call The creation of the realization class and the execution function of the built-in method of the realization class.

The client process 1 is mainly responsible for interacting with the service process 2, serving the interface creation and invocation requirements of its business module 11, and maintaining the request process of interface creation and invocation. After the client process 1 is started, it seeks to bind with the service component 20 of the service process 2, and is responsible for maintaining the bound connection state. If the service process 2 is not started, the client process 1 can even be responsible for calling the service component 20 running the service process 2 to facilitate subsequent calls to related interfaces by itself. Corresponding to service process 2, in addition to its own business module 11, client process 1 also has a transceiver module 14 and analysis module 13 corresponding to service process 2. The transceiver module 14 is responsible for receiving various types of service process 2. The result data, on the other hand, is responsible for issuing various requests initiated by its own business module 11 to the service process 2; its parsing module 13 is mainly used to parse out the interface identifier from the programming annotations of the interface to be called by its business module 11 and use the first One format encapsulates it into an interface creation request, and is further used to parse the attribute information from the programming annotations of the implementation class built-in method to be called by its business module 11 and encapsulate it into an interface call request in the first format, so that it can be followed by the customer The transceiving module 14 of process 1 sends these requests to the service process 2; the parsing module 13 analyzes various result data from the service process 2 in reverse, including the interface creation request and the result data corresponding to the interface call request for feedback Business module 11 for client process 1.

It should be noted that in Android and its compatible systems, there is an IPC mechanism in itself, which allows interfaces to interact across processes. When developing, define a Binder class to realize the interface class defined in advance by AIDL, and realize the functional logic in the realization class. After the service component 20 of the service process 2 runs, the client process 1 connects to it, obtains the proxy object of the Binder class in the onServiceConnected method, and calls the interface method of the Binder class through the proxy object to obtain the functions provided by the Binder class. At the same time, the client process 1 is responsible for maintaining the connection state between itself and the service component 20. The realization of the present invention is also based on this underlying mechanism, and the effective use of this mechanism is realized through the relevant steps of the present invention, which should be understood by those skilled in the art.

The interface library 3 of the present invention can realize the unified execution of the client process 1 and the service process 2 to access the interface library 3 by constructing a functionally relatively independent interface management module. Of course, this is a logical requirement. In fact, the interface management module can generally be constructed by the service process 2, or the service process 2 and the client process 1 can each construct their own required functions, and the implementation method is flexible. The interface library 3 maintained by the interface management module is logically mainly maintained by the service process 2 for use by the client process 1, but in an interactive manner, both the service process 2 and the client process 1 will access the interface library 3 in order to implement relevant protocol analysis mechanism.

As mentioned above, the interface library 3 is mainly used to record relevant data related to the interface, and its manifestation can be flexibly implemented by those skilled in the art. The interface library 3 is mainly used to store the interface registration information formed by the registration of the service process 2 and the interface registration information related to the instance objects generated during the interaction between the service process 2 and the client process 1. For example, the interface registration information can be constructed as the following tables: class table, method table, and instance table.

The class table is used to store expression class table information. The class table information is used to characterize the corresponding relationship between the interface identifier of the interface and the implementation class and interface class. Through this corresponding relationship, the client process 1 can query and determine the relevant interface identifier according to the interface class to be called by its business module 11, and the service process 2 The relevant implementation classes can be determined according to the parsed interface identification query, and they correspond to each other and can be uniquely determined.

The method table is used to store expression method table information. The method table information is used to characterize the relationship between the implementation class and its built-in methods, and the call operation information of these built-in methods. The characterization of the relationship between the implementation class and its built-in methods can be achieved by establishing a unique correspondence relationship between the call operation information of the built-in method in the method table information and the interface identifier. The invoking operation information is the relevant information determined by the service process 2 for each built-in method when the implementation class is registered, including the method identifier assigned to the built-in method, the operating parameters required for the operation of the method, and the method The defined return value type. Those skilled in the art can understand that after the client process 1 clarifies the built-in method of a certain implementation class specified by its business module 11, it can query the interface registration information in the interface library 3, specifically the method table, to obtain the method Table information, more clearly, obtain the method ID related to the built-in method. Then, the client process 1 merges the operating parameters and return value types provided by the service module 11 corresponding to the built-in method, and transmits these invocation operating information to the service process 2. After the service process 2 parses out the calling operation information transmitted from the client process 1, and obtains the method identifier therein, it can query the interface library 25 based on the method identifier to determine the built-in method in the specific instance object for execution.

The instance table is used to store the information of the expression instance table. The instance table information is used to characterize the information related to the implementation class instance objects that are providing services for the client process 1. Specifically, each instance object can be assigned a corresponding object identifier, and the proxy object can also carry the identifier. In this way, The instance object is further associated with the proxy object, and the instance object can also be determined through the object identifier to be called. Of course, other direct or indirect identifiers can also be given, and even further associated with the interface identifiers of related implementation classes. In short, as long as it is sufficient to ensure the uniqueness of subsequent calls to the instance object through the proxy object. Those skilled in the art should be able to implement such things flexibly.

Interface registration information refers to the information related to the creation and invocation of the interface used to implement this method, including all kinds of information obtained by the service process 2 by parsing the programming annotations of the implementation class when it is started, and the running process of the service process 2 Instance information maintained in. The business module 21 of the service process 2 will provide the implementation class of the API interface of the service, call the method of registering the service class to register, and the method of registering the service class internally calls the interface management module. After receiving the registration request, it obtains the relevant information of the registered implementation class. , Whether the parsing class is annotated with the interface identifier of the implementation class according to the use of the protocol, and when there is an interface identifier, it is stored as interface registration information for invocation. Then, analyze whether the related built-in methods of this class use the annotations of the protocol of the present invention, and use the standard annotations related to the built-in method as the interface identification, method identification, operating parameters, return value type, etc. Part of the registration information is stored in the method table. The service process 2 completes the registration of the interface through this process, forms the basic data of the interface registration information, and provides a key foundation for subsequent cross-process interface calls.

Based on the interface registration information, when the client process 1 actually calls the built-in method of the instance object, it is implemented through the proxy object of the instance object. Therefore, the proxy object of the client process 1 needs to call the analysis mechanism of the client process 1 , Query the interface library 3, generally the method table information in it, determine the interface identifier or object identifier corresponding to the built-in method and its calling operation information, and form the attribute information required to run the built-in method, so as to finally provide it to the service process 2 Reverse analysis and use it to ensure that the built-in method of the instance object can be effectively invoked and executed by the service process 2. It needs to be pointed out that whether the attribute is used to indicate the specific instance object by the interface identifier or the object identifier depends on the specific realization of the proxy object. Although the following principles of the present invention disclose a situation in which the object identifier is used for realization, the original A person of ordinary skill in the art should also understand that the same effect can also be achieved through the interface identification, as long as it is ensured that there is a one-to-one correspondence with the proxy object and the instance object and that each process agrees with each other.

The proxy object referred to here is implemented using Java proxy technology. Those skilled in the art can use Java proxy technology to map the instance object of the corresponding implementation class created by the service process 2 in response to the interface creation request on the client process. The corresponding proxy object. The proxy object is generated by the response of the interface creation request. The service process 2 allocates the corresponding object identifier after the instance object is generated, and provides the object identifier to the client process to generate the proxy object. The proxy object also carries the object. Object ID.

Corresponding to the link of the interface creation request, the business module 11 of the client process 1 initiates a request service for a certain interface class, and the client process 1 responds with a request service method. The method for requesting service uses an analysis mechanism to query the interface library 3 to determine the corresponding interface identifier of the interface class, encapsulate it into request format data, and transmit it to the service process 2. The service process 2 parses the request format data after receiving it, and uses the interface identifier to query the interface registration information in the interface library 3, determines the corresponding implementation class, creates its instance object, and can generate a unique object identifier for the object at the same time , The corresponding relationship between the object identifier and the object is stored as instance table information, so the proxy object generated by the subsequent client process 1 should naturally carry the object identifier, so that the subsequent proxy object only needs to pass its object identifier to the service process 2, and the service Process 2 can determine the corresponding instance object based on its uniqueness. After the client process 1 generates the proxy object, it is returned to the service module 11 of the client process 1 for further method calls.

Corresponding to the link of the interface call request, the business module 11 of the client process 1 obtains the proxy object corresponding to its interface creation request, and further initiates an interface call request to call the relevant built-in method of the instance object pointed to by the proxy object. In response to the interface call request, the client process 1 invokes the analysis mechanism to obtain the method identifier, operating parameters, return value type, and object identifier related to the built-in method, and uses these information to form attribute information, which is formatted and encapsulated and sent to the service process 2. The service process 2 calls the analysis mechanism to parse out the specific information in the attribute information. The service process then calls and executes the built-in method. According to the object identifier, the instance object to be called can be determined, and the specific internal information can be determined according to the method identifier. Build a method, and then pass related operating parameters to the built-in method, and run as the passed parameters of the built-in method. After the built-in method runs, a result that meets the return value type is obtained. Then, the service process 2 can encapsulate the related result data in the second format and return it to the client process 1. After the proxy object in the client process 1 obtains the corresponding analysis of the data call analysis mechanism, it returns to the service module 11 of the client process 1 to complete the response to its interface call request.

It can be seen that no matter what the link, when the client process 1 and the service process 2 are parsed or encapsulated using the pre-protocol analysis mechanism, they need to cooperate with the use of the interface registration information in the interface library 3 to make the relevant format The data has a clear purpose.

Generally, after the client process 1 and the service component 20 of the service process 2 are unbound, a step of clearing memory can also be performed. By performing this step, the interface management module clears the related objects in the instance table of the interface library 3 . On the other hand, for the purpose of program keep-alive, the client process 1 and the service process 2 can also start or wake up each other one-way or each other according to preset rules, such as timing and trigger conditions, so that both parties can Live in the memory, avoid being cleaned up by the operating system or the memory cleaning program of third-party security software.

From the above disclosure of the principle of the present invention, it can be seen that through the agreement between the client process 1 and the service process 2, the steps of AIDL defining the cross-process interface are reused through the interface library 3, which can greatly reduce the repetitive development involving cross-process interface development. Rate, providing a solid technical foundation for high-end applications of cross-process communication.

Reflected in simplifying the development process and improving development efficiency, in the development process of an application that uses the principles of the present invention, if it is necessary to extend the cross-process communication interface, only the interface class and its corresponding implementation class need to be created, which is an interface class And its corresponding implementation classes repeat the development of the underlying communication. When this change is reflected in different application versions of the application, it can be known that after the updated new version of the application, the service module 21 of the service process 2 re-registers all implementation classes with the interface library 3, and the interface in the interface library 3 The total will increase or decrease accordingly. If the developer expands the interface and adds the interface class and its implementation class, the total number of interfaces in the interface library 3 will increase accordingly. If the developer deletes the interface, the interface class and its implementation class are correspondingly reduced, then the interface library The total number of interfaces in 3 is reduced accordingly. In short, there is no need to use AIDL for more repetitive development, which is also reflected in the avoidance of unnecessary AIDL definition files.

On the basis of understanding the implementation principle of the present invention described above, the following will examine various performances of the present invention from different perspectives of the implementation principle of the present invention.

Please refer to FIG. 2, at the level of the application program expressed by the principle of the present invention, it is embodied as a typical embodiment of the present invention. In this embodiment, the application program interface call control method of the present invention is implemented in the form of a computer program, and the application program of the present invention is provided. After the application program is installed and run in the operating system, the execution includes the following steps:

In step S11, after the service component 20 pre-registered to the operating system of the application is started, the service component 20 accepts the binding communication of the client process 1 belonging to the same application or a different application with the application.

Taking the Android system as an example, this application can declare a service component 20 in its installation configuration file Androidmanifest.xml file. After the service component 20 is started by the system, the application will play the role of service process 2 in the memory. The service component 20 can communicate and interact with other client processes 1. The client process 1 can be either the process where the service component of the application is located, or other applications, especially the client process 1 that is displayed when the application is running for some joint development projects that have agreed on a protocol scheme.

According to the principles of the Android operating system, generally speaking, an application-related process will run in an independent virtual machine, but it is also allowed to exist in the same application to implement a multi-process architecture. For example, this application can declare service components The way to achieve multi-process architecture. From this, it can be understood that client process 1 and service process 2 can run in the same virtual machine or different virtual machines in parallel. When client process 1 does not belong to this application, it means that client process 1 and service process 2 belong to different Memory virtual machine, but due to the realization of the present invention, the development of the interface call between them becomes more convenient.

After the service component 20 is started, the client process 1 can be bound to it. According to the above-mentioned principle of the present invention, the client process 1 is also responsible for maintaining the connection state between it and the service component in order to determine the stable connection between the client process 1 and the application. After the client process 1 and the service process 2 are bound, the subsequent functions related to the interface call can be further completed.

Step S12: In response to the interface creation request initiated by the client process 1 based on calling the interface class, the application creates an instance object of the implementation class corresponding to the interface class; the interface registration information corresponding to the implementation class is used by the application It is registered in the interface library 3 in advance, and is set in a one-to-one correspondence with the interface class.

As mentioned above, the client process 1 of the present invention will initiate an interface creation request to the application according to the needs of its own business module 11 to use related interfaces.

In the client process 1, when its service module 11 runs to define or call an instruction of a related interface class, an interface call will occur. Here, the service module 11 first needs the system to create a related interface for it. The client process 1 then inquires the class table information in the interface library 3 according to the pre-protocol parsing mechanism, that is, calls its parsing module 13, and determines the interface identifier uniquely corresponding to the interface to be created based on the class table information, and uses the first format to pair The query result is encapsulated, encapsulated into the requested format data, and sent to the application.

Therefore, the transceiver module 24 of the service process 2 of this application will receive the request through the service component and pass it to the parsing module 23 for parsing. The parsing module 23 can decapsulate the request format data to obtain the interface identifier, and then call its execution module 22 After determining the corresponding implementation class from the class table information of the interface library 3 according to the interface identifier, the execution module 22 executes the creation of an instance object of the implementation class. As mentioned above, this application has pre-registered the interface registration information related to the implementation class in the interface library 3. According to the corresponding relationship between the implementation class and the interface identifier, it is possible to avoid incorrectly calling the implementation class.

After the instance object is created, it is given an object identifier with unique characteristics. The one-to-one correspondence between the object identifier and the instance object will also be updated to the interface library 3 by this application, and the object identifier will also be used as The result data is encapsulated into result format data in the second format by the parsing module 23 of the service process 2 of this application, and then fed back to the client process 1 via the transceiver module 24. After receiving the result format data, the transceiving module 14 of the client process 1 passes it to the parsing module 13 of the client process 1 to parse the object identification, and then uses Java proxy technology to create a proxy object of the instance object, which naturally carries the object Logo. Thus, when the service module 11 of the client process 1 initiates a call to the instance object through the proxy object, the proxy object can communicate with the service process 2 based on its own object identifier, so that the service process 2 can correctly call the relevant instance object.

After the instance object is created, its related information is stored in the instance table of the interface library 3 as the instance table information to provide services. If the client process 1 and the service component 20 of the service process 2 are unbound, the instance table information will become the remaining redundant information. Therefore, a parallel step can be set up to implement the cleanup of the redundant information, specifically After the client process 1 and the service process 2 are unbound, the redundant information in the interface library 3 is deleted. This step can theoretically be implemented in the service process 2 in order to centrally manage the memory, or it can be set in the client process 1, which is implemented by the client process 1 before it determines to unbind.

On the basis of successfully creating the instance object, the application program can further provide the client process 1 with a call service for the built-in method of the instance object.

Step S13: The application program responds to the interface call request for calling the built-in method of the instance object initiated by the client process 1, and the request includes the interface registration information determined according to the interface library 3 for executing the internal method. According to the attribute information of the method, the built-in method of the instance object is invoked and executed according to the attribute information to generate result data and fed back to the client process 1.

After the client process 1 successfully establishes the proxy object of the instance object, it returns to its service module 11 for further calls. The service module 11 of the client process 1 will then initiate an interface call request to a built-in method of the instance object through the proxy object. With reference to the foregoing disclosure of the principle of the present invention, once the business module 11 initiates such a request, the proxy object can combine the calling operation information obtained by querying the method table information in the interface library 3, and combine the object identifier carried by itself, the internal After the method identification of the built-in method, the operating parameters (data) of the built-in method passed by the business module 11, and the return value type of the built-in method and other attribute information, the parsing module 13 is encapsulated into the interface call request in the requested format, The transceiver module 14 sends to the application program.

The transceiver module 24 of the application program receives the interface call request transmitted by the proxy object, calls the analysis module 23 to analyze the attribute information therein, and then calls the execution module 22 to execute the call to the built-in method. The execution module 22 queries the interface library 3, the corresponding instance object can be determined from the instance table according to the object identifier in the attribute information, and the built-in method of the corresponding instance object can be determined from the method table according to the method identifier, and then Pass the operating parameter data in the attribute information to the target built-in method in the target instance object, call and execute it, so that the target built-in method returns result data that meets the return value type specification. The result data obtained by running the built-in method is encapsulated by the parsing module 23 of the application program into a result format and then sent back to the proxy object of the client process 1. The proxy object parses the result data in reverse and returns it to the business module 11. The service module 11 then obtains the invoking operation result of the built-in method of the instance object generated by the implementation class corresponding to the invoking interface class, and completes the entire process of invoking the interface.

In some embodiments, the return value type does not need to be added as attribute information. On the one hand, it is not necessary to record the item in the method table information of the interface library 3, and on the other hand, there is no need to interact with the client process 1 and the service process 2. If this item is used in the process, those skilled in the art should be aware of this alternative.

In some embodiments, as mentioned above, this application can independently build an interface management module to centrally manage access to the interface library 3, and provide a calling interface for the modules that need to access the interface library 3 for call execution. , This can improve memory efficiency.

The implementation of this exemplary embodiment helps to provide an application program with a cross-process service function at the application program level, and facilitates the access of other applications, thereby facilitating the development of joint program projects.

Further, after the application program embodied in this exemplary embodiment is installed on a mobile device such as a mobile terminal or a tablet, it can be embodied as another embodiment of the present invention, and this embodiment is embodied as a terminal device provided by the present invention. It includes a central processing unit and a memory, and the central processing unit is used to call and run a computer program stored in the memory to execute each specific step of the application program interface call control method as described above.

Please refer to FIG. 3, at the process level expressed by the principle of the present invention, it is embodied as another typical embodiment of the present invention. In this embodiment, a cross-process communication method of the present invention includes the following steps:

In step S21, the client process 1 queries the interface library 3 pre-registered with the interface registration information by the service process 2 to obtain the interface identifier of the interface class according to the invocation of the interface class by its service module 11, and encapsulates the interface class according to the pre-protocol request format. Service process 2 initiates an interface creation request.

As described in the principle of the present invention and other embodiments, the interface library 3 has been pre-configured by the service process 2, and the service process 2 has registered class table information and method table information with the interface library 3, and is in the process of interacting with the client process 1. The information of the maintenance instance table is also updated. Therefore, the client process 1 can directly use the interface registration information of the interface library 3 in this step. In addition, the client process 1 and the service process 2 also implement their respective internal functional modules according to the principles of the present invention.

The business module 11 of the client process 1 first initiates a call to a specific interface class. According to the call to the interface class, the client process 1 uses its parsing module 13 to query the interface registration information of the interface library 3, specifically through the interface The class table in library 3 is queried to obtain the interface identifier corresponding to the interface class. Then, the parsing module 13 complies with the agreement with the service process 2 and encapsulates the interface identifier into a request format to form an interface creation request, which is sent to the service process 2 via the transceiver module 14 of the client process 1.

Step S22, the service process 2 receives the interface creation request, parses the request, uses the interface identifier therein to execute the creation operation of the corresponding implementation class, generates an instance object of the implementation class, and reversely encapsulates the backward client process in the pre-contracted result format 1 Feedback the result data generated by the creation operation;

After the service process 2 receives the interface creation request via its transceiver module 24, its parsing module 23 parses out the interface identifier therein, and then its execution module 22 queries the interface library 3 to determine the implementation class corresponding to the interface identifier After that, the action of creating an instance object of the implementation class is performed.

After the implementation object is created, an object identifier is assigned to the instance object, and the object identifier can be used by the client process 1. After the service process 2 constructs the instance object, it encapsulates the object identifier of the instance object into the result data according to the second format of the pre-protocol, and returns it to the client process 1 through its transceiver module 24.

In step S23, the client process 1 receives the result data, parses it into a proxy object of the instance object according to the protocol, and returns it to the business module 11 of the client process 1, so that the business module 11 can call the proxy object. Implement calling the instance object.

After the client process 1 receives the result data through its transceiving module 14, it will be handed over to its parsing module 13 to parse out the object identifier therein, and use Java proxy technology to construct a proxy object for the instance object pointed to by the object identifier. The proxy object carries the object identifier, and then returns the proxy object to the service module 11 of the client process 1 for the next method call. The service module 11 can call the instance object by calling the proxy object.

Please refer to Figure 4, in addition to following a method that can be understood by those skilled in the art, the business module 11 uses proxy objects to implement calls to its corresponding instance objects. In a further optimized embodiment, the client process 1 can follow the following specific steps Cooperate with service process 2 to call the proxy object to further implement the call to the built-in method of the instance object it points to:

In step S231, the service module 11 of the client process 1 initiates an interface call request for calling the method of the proxy object.

When the business module 11 of the client process 1 needs to call the built-in method of the interface class of the corresponding proxy object, it initiates the interface call request, and expects the returned result by calling the proxy object. For the acquisition, the proxy object is responsible for the execution of the intermediate process.

Step S232: The proxy object queries the interface library 3 to determine the corresponding attribute information of the method, forms the attribute information into a pre-protocol request format, and sends it to the service process 2.

As mentioned above, the proxy object can combine the calling operation information obtained by querying the method table information in the interface library 3, and combine the object ID it carries, the method ID of the built-in method, and the built-in information passed by the business module 11. The operating parameters (data) of the method and the attribute information such as the return value type of the built-in method are encapsulated by the calling analysis module 13 into an interface calling request in the request format, and then sent to the service process 2 via the transceiver module 14.

In step S233, the service process 2 receives and queries the interface library 3 to parse out the attribute information, and calls the corresponding implementation class object to execute the corresponding method therein.

The transceiver module 24 of the service process 2 receives the interface call request transmitted by the proxy object, calls the analysis module 23 to analyze the attribute information therein, and then calls the execution module 22 to execute the call to the target method. The execution module 22 queries the interface library 3, the corresponding instance object can be determined from the instance table according to the object identifier in the attribute information, and the built-in method of the corresponding instance object can be determined from the method table according to the method identifier, and then Pass the operating parameter data in the attribute information to the target built-in method in the target instance object, call and execute it, so that the target method returns result data that meets the return value type specification.

In step S234, the service process 2 feeds back the result data after the execution of the method to the client process 1 in a pre-agreeed result format.

The result data obtained by the service process 2 calling the running target method is encapsulated into the result format by the parsing module 23 of the service process 2, and then sent back to the proxy object of the client process 1 through the transceiver module 24 of the service process 2 for internal transmission by the client process 1. Used by its business module 11.

In step S235, the client process 1 receives the result data, analyzes and restores it, and returns it to its service module 11.

After the client process 1 receives the result data returned by the service process 2 to the proxy object through its transceiving module 14, the proxy object calls the parsing module 13 to parse the result data in reverse, and returns the parsed result data directly to the business module 11. Then, the service module 11 obtains the calling operation result of the built-in method of the instance object generated by the implementation class corresponding to the calling interface class, and completes the whole process of calling the interface.

Similarly, in some embodiments, the return value type does not need to be added as attribute information. On the one hand, it is not necessary to record the item in the method table information of the interface library 3, and on the other hand, it does not need to be added in the client process 1. This item is used in the process of process 2 interaction, and those skilled in the art should be aware of this alternative.

The implementation of this exemplary embodiment provides a bottom-level implementation scheme for cross-process communication, so that the principles of the present invention can be applied to the bottom layer, and solve the technical obstacles in cross-process communication.

In the same way, after the application program embodied in this exemplary embodiment is further installed on a mobile device such as a mobile terminal or a tablet, it can be embodied as another embodiment of the present invention, and this embodiment is embodied as a method provided by the present invention. The terminal device includes a central processing unit and a memory, and the central processing unit is used to invoke and run a computer program stored in the memory to execute the steps of the aforementioned cross-process communication method.

In summary, the present invention simplifies the development steps involved in the realization of communication interfaces in the application program development process, and provides a simpler and more efficient cross-process communication solution for jointly developed program projects.

Those skilled in the art can understand that the present invention includes equipment for performing one or more of the operations and methods described in the present invention. These devices may be specially designed and manufactured for the required purpose, or may also include known devices in general-purpose computers. These devices have computer programs stored in their memory, which are selectively activated or reconfigured. Such a computer program may be stored in a device (for example, a computer) readable medium or in any type of medium suitable for storing electronic instructions and respectively coupled to a bus. The computer readable medium includes, but is not limited to, any Types of disks (including floppy disks, hard disks, optical disks, CD-ROMs, and magneto-optical disks), ROM (Read-Only Memory), RAM (Random Access Memory), EPROM (Erasable Programmable Read-Only Memory) , Erasable Programmable Read-Only Memory), EEPROM (Electrically Erasable Programmable Read-Only Memory), flash memory, magnetic card or optical card. That is, the readable medium includes any medium that stores or transmits information in a readable form by a device (for example, a computer).

Those skilled in the art can understand that computer program instructions can be used to implement each block in these structural diagrams and/or block diagrams and/or flow diagrams and combinations of blocks in these structural diagrams and/or block diagrams and/or flow diagrams. . Those skilled in the art can understand that these computer program instructions can be provided to processors of general-purpose computers, professional computers, or other programmable data processing methods for implementation, so that the computer or other programmable data processing method processors can execute this The structure diagram and/or block diagram and/or flow diagram of the disclosure of the invention are specified in the block or multiple blocks.

Those skilled in the art can understand that the various operations, methods, and steps, measures, and solutions in the process that have been discussed in the present invention can be alternated, changed, combined, or deleted. Further, the various operations, methods, and other steps, measures, and solutions in the process that have been discussed in the present invention can also be alternated, changed, rearranged, decomposed, combined, or deleted. Further, the steps, measures, and schemes in the various operations, methods, and procedures disclosed in the present invention in the prior art can also be alternated, changed, rearranged, decomposed, combined or deleted.

The above are only part of the embodiments of the present invention. It should be pointed out that for those of ordinary skill in the art, without departing from the principle of the present invention, several improvements and modifications can be made, and these improvements and modifications are also It should be regarded as the protection scope of the present invention.

Claims

An application program interface call control method, characterized in that the method includes the following steps:

After the service component pre-registered to the operating system of this application is started, the service component accepts the binding communication with the client process of the same application or a different application through the application;

This application creates an instance object of the implementation class corresponding to the interface class in response to the interface creation request initiated by the client process based on calling the interface class; the interface registration information corresponding to the implementation class is pre-registered to the interface by this application In the library, it is set in a one-to-one correspondence with the interface class;

This application responds to an interface call request for invoking the built-in method of the instance object initiated by the client process, and the request includes the attribute information for executing the built-in method determined according to the interface registration information of the interface library , Call and execute the built-in method of the instance object according to the attribute information to generate result data and feed it back to the client process.
The method according to claim 1, wherein the method further comprises the following steps:

Perform a version update of the application program. After the updated application program runs, re-register the interface library to increase or decrease the number of interfaces registered in the interface library.
The method according to claim 1, wherein the interface registration information in the interface library comprises:

Class table information that characterizes the corresponding relationship between the interface identifier of the interface, the implementation class, and the interface class, so as to determine the one-to-one correspondence between the interface class and the implementation class according to the interface identifier;

Method table information that characterizes the relationship between the implementation class and its built-in methods and the call operation information of these built-in methods, so as to execute method calls;

The instance table information that characterizes the correspondence between the implementation class instance objects that are providing services to the client process and the object identifiers with unique characteristics, so as to implement the invocation of the instance objects.
The method according to claim 3, wherein the attribute information includes the interface identifier or object identifier corresponding to the implementation class to which the built-in method belongs and the invocation operation information of the built-in method, and the invocation operation information includes The method identifier, operating parameters, and return value type of the built-in method.
The method according to claim 3 or 4, characterized in that:

When this application responds to an interface creation request, it queries the class table information to determine the corresponding implementation class according to the interface identifier specified by the request, so as to create an instance object of the implementation class for it;

When this application program responds to an interface call request, according to the attribute information provided by the request, the built-in method is determined by querying the method table information to call it.
The method according to claim 1, wherein the service component of the application program is bound to a plurality of the client processes in parallel, and the application program is suitable for starting one or more of the client processes .
The method according to claim 1, wherein the application program and the program to which the client process belongs complies with a predetermined agreement, the attribute information is encapsulated and decapsulated in a first format, and the attribute information is encapsulated and decapsulated in a second format. The result data described.
The method according to claim 7, wherein the performance of the application in the memory and the client process construct functional modules corresponding to each other according to the mutual agreement, and both include a parsing module and a transceiver module, wherein, The parsing module is responsible for implementing the functional implementation related to the first format and the second format, and the transceiver module is used to perform the transmission of data related to the first format and the second format.
The method according to claim 1, wherein the application program constructs an interface management module for uniformly executing the client process and the application program's own access to the interface library.
The method according to claim 1, wherein the client process is responsible for maintaining the communication state with the service process to ensure the stability of cross-process communication between the client process and the service process.
The method according to claim 1, characterized in that it further comprises the following steps:

After the client process is unbound with the service component of the application, the instance table information generated by the call of the client process is cleared.
A terminal device, comprising a central processing unit and a memory, wherein the central processing unit is used to call and run a computer program stored in the memory to execute the application program according to any one of claims 1 to 11 The steps for the interface to call the control method.