CN111966427B

CN111966427B - Implementation method for calling Java API (Java application program interface) by Android native

Info

Publication number: CN111966427B
Application number: CN202010825679.3A
Authority: CN
Inventors: 曾亮
Original assignee: Sichuan Changhong Electric Co Ltd
Current assignee: Sichuan Changhong Electric Co Ltd
Priority date: 2020-08-17
Filing date: 2020-08-17
Publication date: 2022-06-21
Anticipated expiration: 2040-08-17
Also published as: CN111966427A

Abstract

The invention discloses a method for realizing calling Java API by Android native, belonging to the technical field of computer application. The invention comprises the following steps: the Java layer calls JNI to provide an independent registration interface, and the independent registration interface stores JNI environment variables corresponding to Java layer API when the Java layer calls and calls a registration interface of a native layer in the independent registration interface; the JNI provides JNI callback functions to a native layer for registration; when a native layer program runs, calling a JNI callback function at a specific moment in the program; and calling the previously stored JNI environment variable in a JNI callback function provided by the JNI to the native layer to finish the calling of the Java layer API by the JNI. The method and the device enable the registration and callback processes of calling Java API by Android native to be completely separated, and local programs can autonomously master the callback opportunity, so that the method and the device are more practical in embedded application.

Description

Implementation method for calling Java API (Java application program interface) by Android native

Technical Field

The invention relates to the technical field of computer application, in particular to a method for realizing Java API call by Android native.

Background

The Android operating system is a Linux-based operating system and is mainly used for portable equipment. The upper layer application in the Android system is generally developed and completed based on Java, but when some services relate to local services or hardware and the like, C needs to be used for realization, and C programs run in a native layer.

JNI (Java Native Interface; Java Native Interface) provides a mechanism for Java layer and Native layer to call each other.

However, in the calling mode of the native layer to the Java layer API in the prior art, two parts are often required to be repeatedly called through JNI, or the calling of the native layer to the Java layer API needs to be triggered through the calling of the Java layer API, so that the efficiency is low, the problems of memory leakage or program crash and the like are easily caused, the independence between two modules is also reduced, and the Java layer API needs to be actively called at some specific time in the embedded development, and such solutions are not mentioned in the previous patents.

Disclosure of Invention

The invention provides a method for realizing calling of Java API by Android native, aiming at solving the technical problem.

In order to achieve the purpose, the invention adopts the following technical scheme:

a realization method for calling Java API by Android native includes the following steps:

the Java layer calls JNI to provide an independent registration interface, and when the Java layer calls the JNI, the independent registration interface stores JNI environment variables corresponding to the API of the Java layer and calls a registration interface of a native layer in the independent registration interface;

the JNI provides JNI callback functions to a native layer for registration; thus, completing the registration process from the Java layer to the native layer;

when a native layer program runs, calling a JNI callback function at a specific moment in the program;

and calling the previously stored JNI environment variable in a JNI callback function provided by the JNI to the native layer to finish the calling of the Java layer API by the JNI, so as to finish the callback from the native layer to the Java layer.

Furthermore, the JNI provides an independent registration interface, and comprises a calling interface provided by the JNI for a Java layer, the calling interface has no additional parameter, and the JNI takes the environment variable corresponding to the API of the Java layer through the default parameter of the calling interface.

Furthermore, the JNI environment variables corresponding to the Java layer API are a plurality of parameters in the JNI for marking the Java layer API.

Further, the JNI environment variables corresponding to the Java layer API are three parameters used for marking the Java layer API in the JNI, which are: java VM, JOBject object, Java API's MethodeID.

Further, the registration interface of the native layer refers to a registration interface which actually needs to register a JNI callback function in the native layer, and the registration interface needs a JNI callback function pointer as a parameter.

Furthermore, the JNI provides a JNI callback function which is a JNI callback function really registered to the native layer, and the JNI callback function calls the Java layer API by using the environment variable of the Java layer API stored during registration so as to complete the callback of the Java layer API from the native layer.

Further, the specific time is a condition that the embedded device triggers a callback in the whole program running process.

Compared with the prior art, the invention has the beneficial effects that:

according to the method, the relevant Java layer API is triggered and called through ZigBee equipment of the native layer in combination with the actual situation of embedded development, the registration and the callback are separated, and programs of the native layer and the Java layer are independent, so that the native layer can actively call back the Java layer API according to the progress of the programs.

Drawings

Fig. 1 is a flowchart in example 1 of the present application.

Fig. 2 is a flowchart of embodiment 2 of the present application.

Detailed Description

The present invention will be further described with reference to the following examples, which are intended to illustrate only some, but not all, of the embodiments of the present invention. Based on the embodiments of the present invention, other embodiments used by those skilled in the art without any creative effort belong to the protection scope of the present invention.

Example 1:

as shown in fig. 1, an implementation method for calling Java API by Android native includes the following steps:

s1, providing an independent registration interface for calling a Java layer by the JNI, storing JNI environment variables corresponding to a Java layer API when the Java layer is called by the independent registration interface, calling a registration interface of a native layer in the independent registration interface, and performing step S2;

s2, providing a JNI callback function by the JNI to register the native layer, realizing the butt joint of the native layer and the JNI, ensuring the independence of a local program, and completing the registration process from the Java layer to the native layer;

s3, when the native layer program runs, calling JNI callback functions at a specific moment in the program, and performing step S4;

and S4, calling the previously stored JNI environment variable in a JNI callback function provided by the JNI to the native layer to finish calling the Java layer API by the JNI, so as to finish the callback from the native layer to the Java layer.

The JNI provides an independent registration interface, namely a calling interface provided by the JNI part for a Java layer, the calling interface has no additional parameter, but the JNI can take the environment variable corresponding to the API of the Java layer through the default parameter of the calling interface, so that the Java part can control the initiative of the registration function, and the running safety of the program is ensured by calling back after registration.

In this embodiment, the environment variables are multiple parameters used for marking a Java layer API in the JNI, and preferably, the JNI may locate the API of the Java environment by using three parameters; respectively as follows: java VM, JOBject object, Java API's MethodeID.

The registration interface of the native layer is a registration interface which actually needs to register a JNI callback function on the native layer, the registration interface needs a JNI callback function pointer as a parameter, and the Java layer does not have the concept of the JNI callback function pointer, so that the whole callback function registration from the Java layer to the native layer is completed by adding registration step by taking the JNI as a middle part.

The JNI callback function provided by the JNI is a JNI callback function which is really registered to a native layer, the JNI callback function used by the native layer is the function, the JNI callback function calls a Java layer API by using the environment variable of the Java layer API which is saved during registration, and then the callback of the Java layer API from the native layer is completed.

The specific moment is the condition that the embedded device triggers callback in the whole program running process, and generally, the conditions include online, offline, status report and the like.

Example 2:

fig. 2 shows a flowchart of an implementation method for calling Java API by Android native according to the present invention, in this embodiment, registration and callback are separated, and callback to Java API is triggered by an on-line device message received at the bottom layer, as shown in fig. 2, the method includes the following steps:

s100, calling a local interface packaged by the JNI by the Java layer during running, providing a registration function from the Java layer to the JNI part, and storing related information such as environment variables of a JNI callback function;

s200, registering a native layer registration interface through a JNI callback function provided by a JNI layer to realize the butt joint of the native layer and the JNI, and actively calling the JNI callback function when the equipment is on line;

s300, when a native layer runs and equipment online information is processed, actively calling a JNI callback function to realize active callback from the native layer to the JNI;

s400, when the JNI callback function of the JNI is called, the JNI environment variables stored during registration can be used in the function, and the online JNI callback function of the Java layer can be called back through the environment variables, so that the active callback from a native layer to a Java layer API is achieved.

The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents and improvements made within the spirit and principle of the present invention are intended to be included within the scope of the present invention.

Claims

1. An implementation method for calling Java API by Android native is characterized by comprising the following steps:

the JNI environment variable saved before being called in a JNI callback function provided by the JNI to the native layer is called, the calling of the JNI to a Java layer API is completed, and the callback from the native layer to the Java layer is completed; the JNI provides an independent registration interface and comprises a calling interface provided by the JNI for a Java layer, the calling interface has no additional parameter, and the JNI takes the environment variable corresponding to the API of the Java layer through the default parameter of the calling interface.

2. The method for realizing Android native calling Java API as claimed in claim 1, wherein JNI environment variables corresponding to the Java layer API are a plurality of parameters in JNI for marking the Java layer API.

3. The method for realizing Android native calling Java API as claimed in claim 2, wherein JNI environment variables corresponding to the Java layer API are three parameters in JNI for marking the Java layer API, which are respectively: JavaVM, jobject object, MethodID of Java API.

4. The method for implementing the Android native calling Java API as claimed in claim 1, wherein the registration interface of the native layer is a registration interface which actually needs to register a JNI callback function on the native layer, and the registration interface needs a JNI callback function pointer as a parameter.

5. The method for realizing Android native calling Java API as claimed in claim 1, wherein the JNI provides JNI callback function as JNI callback function really registered to native layer, the JNI callback function uses saved environment variables of Java layer API when registering to call Java layer API, and then finishes callback to Java layer API from native layer.

6. The method for implementing the Android native calling Java API, according to claim 1, wherein the specific time is a condition that the embedded device triggers a callback in the whole program running process.