AndroidJNI 基础使用

最新推荐文章于 2024-04-15 17:21:43 发布
最新推荐文章于 2024-04-15 17:21:43 发布
阅读量405 收藏
点赞数 1
分类专栏： Android 文章标签： java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_33585352/article/details/120184538
版权

本文主要说明了在Android应用程序中,怎么使用jni交互.
包括:回调接口,获取对象,不同线程汇总怎么使用JNIEnv *env等实例.

简单的理解一下概念

在jni中,用jfieldID和jmethodID来表示Java类的成员变量和成员函数.

比如:我们的jni侧要获取java对象中的某个String. java代码精简如下:

class InstanceFieldAccess { 
     private String text; 
  
     private native void accessField(); 
     public static void main(String args[]) { 
         InstanceFieldAccess ifa = new InstanceFieldAccess(); 
         ifa.text = "abcdefg"; 
         ifa.accessField(); 
         System.out.println("Java output"); 
         System.out.println("  ifa.text = \"" + ifa.text + "\""); 
     } 
     static { 
         System.loadLibrary("InstanceFieldAccess"); 
     } 
 }

c++代码精简如下:

JNIEXPORT void JNICALL  Java_InstanceFieldAccess_accessField(JNIEnv *env, jobject obj) 
 { 
     jfieldID fid;   //字段id,在jni中对应着java的类成员变量
     jstring jstr;   //jstring类型,对应的java中的String
     const char *str; 
  
     //第一步,我们获取类对象,因为是非静态方法所以是object
     jclass cls = (*env)->GetObjectClass(env, obj); 
     printf("C output:\n"); 
  
     //第二步,通过jni函数表,获取类对象里面的成员变量.
     fid = (*env)->GetFieldID(env, cls, "text", "Ljava/lang/String;"); 
     if (fid == NULL) { 
         return; //如果是空的,那就是没有找到,返回. 
     } 
     
     //第三步,找到了字段id,那么就开始读取值.因为字符串是个特殊的对象,所以这里使用GetObjectField读取.
     jstr = (*env)->GetObjectField(env, obj, fid); 
    //第四步,读取到了String值因为 Java 默认使用 Unicode 编码,而 C/C++ 默认使用 UTF 编码,所以在本地代码中操作字符串的时候,必
	//须使用合适的 JNI 函数把 jstring 转换成 C 风格的字符串
     str = (*env)->GetStringUTFChars(env, jstr, NULL); 
     if (str == NULL) { 
         return; //调用完 GetStringUTFChars 之后不要忘记安全检查,因为 JVM 需要为新诞生的字符串分配内存空间,当内存
				//空间不够分配的时候,会导致调用失败,失败后 GetStringUTFChars 会返回 NULL,并抛出一个OutOfMemoryError 异常
     } 
     printf("  c.s = \"%s\"\n", str); 
    //在调用 GetStringUTFChars 函数从 JVM 内部获取一个字符串之后,JVM 内部会分配一块新的内存,用于存
	//储源字符串的拷贝,以便本地代码访问和修改。即然有内存分配,用完之后就可以马上释放了.
     (*env)->ReleaseStringUTFChars(env, jstr, str); 
  
     //通过调用 NewStringUTF 函数,会构建一个新的 java.lang.String 字符串对象。这个新创建的字符串会自动转换成Java支持的Unicode编码 
     jstr = (*env)->NewStringUTF(env, "123"); 
     if (jstr == NULL) { 
         return; /* out of memory */ 
     } 
    //通过jni函数表,给java对象的变量赋值
     (*env)->SetObjectField(env, obj, fid, jstr); 
}
//打印
/**
C output:
   c.s = "abc"
Java output:
   ifa.text = "123"
*/

Android的java文件怎么写

public interface IWifiStaServiceService {
    // methods
    public ActivateOutput activate();
    public AddApOutput addAp(WifiConfiguration wifiConfiguration);
    public ConnectOutput connect(WifiConfiguration wifiConfiguration);
    public DeactivateOutput deactivate();
    public DisconnectOutput disconnect();
    public ForgetOutput forget(WifiApID wifiApID);
    public GetApListOutput getApList();
    public GetConfiguredApListOutput getConfiguredApList();
    public GetConnectedApOutput getConnectedAp();
    public GetConnectionInfoOutput getConnectionInfo();
    public GetMacAddressOutput getMacAddress();
    public IsActivatedOutput isActivated();
    public ScanOutput scan();
    public UpdateApOutput updateAp(WifiConfiguration wifiConfiguration);

    // fields
}

public class WifiStaServiceServiceStub {
    public static final String LOG_TAG = "WifiStaServiceServiceStub";

    public static final String INSTANCE_NAME_1 = "WifiStaService_Provider/WifiStaService_ProviderRootSwc/WifiStaService1";

    private static final int METHOD_ACTIVATE = 0;
    private static final int METHOD_ADDAP = 1;
    private static final int METHOD_CONNECT = 2;
    private static final int METHOD_DEACTIVATE = 3;
    private static final int METHOD_DISCONNECT = 4;
    private static final int METHOD_FORGET = 5;
    private static final int METHOD_GETAPLIST = 6;
    private static final int METHOD_GETCONFIGUREDAPLIST = 7;
    private static final int METHOD_GETCONNECTEDAP = 8;
    private static final int METHOD_GETCONNECTIONINFO = 9;
    private static final int METHOD_GETMACADDRESS = 10;
    private static final int METHOD_ISACTIVATED = 11;
    private static final int METHOD_SCAN = 12;
    private static final int METHOD_UPDATEAP = 13;

    private static IWifiStaServiceService mService;
	//我们这里定义的都是静态类型的native方法,注意cpp里面对应的头文件
    private static native void native_init(String ap_env);
    private static native void native_setup(Object object, String instance);
    private static native void native_finalize();
    private static native void native_sendService();
    private static native void native_stopSendService();

    private static native void native_notifyRssiChanged(byte[] data);
    private static native void native_notifyScanFinished(byte[] data);
    private static native void native_notifyStaConnChanged(byte[] data);
    private static native void native_notifyStationChanged(byte[] data);

    static {
        try {
            System.loadLibrary("wifistaservice");
            Log.d(LOG_TAG, "load wifistaservice");
        } catch (Exception ex) {
            Log.e(LOG_TAG, "System.loadLibrary Exception " + ex);
        } catch (Error err) {
            Log.e(LOG_TAG, "System.loadLibrary Error " + err);
        }
    }
	//构造方法里面调用了2个native方法
    public WifiStaServiceServiceStub(IWifiStaServiceService service, String instance, String ap_env) {
        Log.d(LOG_TAG, "new WifiStaServiceServiceStub");
        native_init(ap_env);//参数只传递了一个String
        mService = service;
        native_setup(new WeakReference<WifiStaServiceServiceStub>(this), instance);//参数传递了一个软引用的对象和一个String
    }

    protected void finalize() {
        native_finalize();
    }

    public void sendService() {
        native_sendService();
    }

    public void stopSendService() {
        native_stopSendService();
    }

    public void notifyRssiChanged(WifiAp rssiChanged) {
        Log.d(LOG_TAG, "native_notifyRssiChanged");
        native_notifyRssiChanged(rssiChanged.toByteArray());
    }

    public void notifyScanFinished(WifiApList scanFinished) {
        Log.d(LOG_TAG, "native_notifyScanFinished");
        native_notifyScanFinished(scanFinished.toByteArray());
    }

    public void notifyStaConnChanged(WifiAp staConnChanged) {
        Log.d(LOG_TAG, "native_notifyStaConnChanged");
        native_notifyStaConnChanged(staConnChanged.toByteArray());
    }

    public void notifyStationChanged(int stationChanged) {
        Log.d(LOG_TAG, "native_notifyStationChanged");
        WifiStaServiceProto.ProtoUint8 proto_stationChanged = new WifiStaServiceProto.ProtoUint8();
        proto_stationChanged.value = stationChanged;
        native_notifyStationChanged(proto_stationChanged.toByteArray(proto_stationChanged));
    }

    //静态的java方法,这个方法会在native侧调用.注意关注三个参数
    private static byte[] postEventFromNative(Object Control_ref, int what, byte[] obj) {
        //获取类对象
        final WifiStaServiceServiceStub serviceimpl = (WifiStaServiceServiceStub)((WeakReference)Control_ref).get();
		//因为是从jni那边从来的,也就验证了底层有没有拿到这个对象
        if (serviceimpl == null) {
            Log.e(LOG_TAG, "postEventFromNative error : service is null");
            return null;
        }

        Log.d(LOG_TAG, "postEventFromNative what= " + what + " obj= " + obj);
        switch (what) {
        case METHOD_ACTIVATE:
            ActivateOutput ret_activate = mService.activate();
            if (ret_activate != null) {
                return ret_activate.toByteArray();
            }
            break;
        case METHOD_ADDAP:
            if (obj != null) {
                try {
                    WifiStaServiceProto.AddApInput in_addAp = WifiStaServiceProto.AddApInput.parseFrom(obj);
                    AddApOutput ret_addAp = mService.addAp(WifiConfiguration.fromByteArray(WifiStaServiceProto.WifiConfiguration.toByteArray(in_addAp.wifiConfiguration)));
                    if (ret_addAp != null) {
                        Log.d(LOG_TAG, "AddApOutput is not null ");
                        return ret_addAp.toByteArray();
                    } else {
                        Log.d(LOG_TAG, "AddApOutput is null ");
                    }
                } catch (com.google.protobuf.nano.InvalidProtocolBufferNanoException e) {
                    Log.d(LOG_TAG, e.toString());
                }
            }
            break;
        case METHOD_CONNECT:
            if (obj != null) {
                try {
                    WifiStaServiceProto.ConnectInput in_connect = WifiStaServiceProto.ConnectInput.parseFrom(obj);
                    ConnectOutput ret_connect = mService.connect(WifiConfiguration.fromByteArray(WifiStaServiceProto.WifiConfiguration.toByteArray(in_connect.wifiConfiguration)));
                    if (ret_connect != null) {
                        Log.d(LOG_TAG, "ConnectOutput is not null ");
                        return ret_connect.toByteArray();
                    } else {
                        Log.d(LOG_TAG, "ConnectOutput is null ");
                    }
                } catch (com.google.protobuf.nano.InvalidProtocolBufferNanoException e) {
                    Log.d(LOG_TAG, e.toString());
                }
            }
            break;
        default:
            break;
        }

        return null;
    }
}

jni头文件的定义

头文件定义了java代码对应的native方法,以及一个回调类.主要是用来回调java侧代码的postEventFromNative方法.

#ifndef _Included_com_yf_soa_wifistaservice_WifiStaServiceNativeListener
#define _Included_com_yf_soa_wifistaservice_WifiStaServiceNativeListener
#include <jni.h>
#include "WifiStaServiceNativeListener.h"
#include "wifistaservice/wifistaservice_skeleton.h"
#ifdef __cplusplus
extern "C" {
#endif

namespace yf {
namespace soa {

struct fields_t {
    jfieldID context;
    jmethodID post_event;//方法 ID(因为一个类中会存在多个方法,需要一个唯一标识来确定调用类中的哪个方法)
};

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub 对应java代码的类对象包名
 * Method:    native_init                                         java类对象方法native名  
 * Signature: ()V                                                 方法和参数签名   
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1init
(JNIEnv *, jclass, jstring);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_setup
 * Signature: (Ljava/lang/Object;)V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1setup
(JNIEnv *, jclass, jobject, jstring);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_finalize
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1finalize
(JNIEnv *, jclass);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_offerService
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1offerService
(JNIEnv *, jclass);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_stopOfferService
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1stopOfferService
(JNIEnv *, jclass);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_notifyRssiChanged
 * Signature: (Lcom/yf/soa/wifistaservice/WifiAp;)V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1notifyRssiChanged
(JNIEnv *, jclass, jbyteArray);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_notifyScanFinished
 * Signature: (Lcom/yf/soa/wifistaservice/WifiApList;)V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1notifyScanFinished
(JNIEnv *, jclass, jbyteArray);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_notifyStaConnChanged
 * Signature: (Lcom/yf/soa/wifistaservice/WifiAp;)V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1notifyStaConnChanged
(JNIEnv *, jclass, jbyteArray);

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_notifyStationChanged
 * Signature: (Lcom/yf/soa/wifistaservice/StationState_ref;)V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1notifyStationChanged
(JNIEnv *, jclass, jbyteArray);

class WifiStaServiceNativeListenerImpl: public WifiStaServiceNativeListener {
public:
    //参数包含jni指针,和2个object对象
    WifiStaServiceNativeListenerImpl(JNIEnv* env, jobject thiz, jobject weak_thiz);
    ~WifiStaServiceNativeListenerImpl();

    virtual void syncDetachCurrentThread();
    virtual jbyteArray notify(JNIEnv *env, int msg, const jbyteArray obj);//通知

private://定义两个全局对象
    jclass mClass;//从classpath路径下搜索ClassMethod这个类,并返回该类的Class对象
    jobject mObject;//类的实例
};

class WifiStaServiceNative : public yf::platform::WifiStaServiceSkeleton {
public:
    virtual ~WifiStaServiceNative();

    static WifiStaServiceNative& instantiate() {
        static WifiStaServiceNative elmn; 
        return elmn;
    }
    //注册listener对象
    virtual void registerListener(const std::shared_ptr<WifiStaServiceNativeListener> listener);
    virtual sovpap::core::Future<nm_wifistaservice::internal::methods::Activate::Output> Activate();
    virtual sovpap::core::Future<nm_wifistaservice::internal::methods::AddAp::Output> AddAp(const DataTypes::WifiConfiguration& wifiConfiguration);
    virtual sovpap::core::Future<nm_wifistaservice::internal::methods::Connect::Output> Connect(const DataTypes::WifiConfiguration& wifiConfiguration);
    void notifyRssiChanged(const DataTypes::WifiAp& rssiChanged);
    void notifyScanFinished(const DataTypes::WifiApList& scanFinished);
    void notifyStaConnChanged(const DataTypes::WifiAp& staConnChanged);
    void notifyStationChanged(const DataTypes::StationState_ref& stationChanged);


private:
    explicit WifiStaServiceNative();
    WifiStaServiceNative& operator = (const WifiStaServiceNative&)=delete;
    std::shared_ptr<WifiStaServiceNativeListener> m_listener;
    enum notifyType {
        METHOD_ACTIVATE,
        METHOD_ADDAP,
        METHOD_CONNECT
    };
};

}  // namespace soa
}  // namespace yf

#ifdef __cplusplus
}
#endif
#endif  // _Included_com_yf_soa_wifistaservice_WifiStaServiceNativeListener

看一下另一个回调函数的头文件

#ifndef WIFISTASERVICENATIVELISTENER_H
#define WIFISTASERVICENATIVELISTENER_H
#include <jni.h>
using namespace  android;
#ifndef __cplusplus
#   error ERROR: This file requires C++ compilation (use a .cpp suffix)
#endif


namespace yf {
namespace soa {

class WifiStaServiceNativeListener
{
public:
    virtual void syncDetachCurrentThread() = 0;
    virtual jbyteArray notify(JNIEnv *env, int msg, const jbyteArray obj) = 0;
    virtual ~WifiStaServiceNativeListener(){};
};

}  // namespace soa
}  // namespace yf

#endif  // WIFISTASERVICENATIVELISTENER_H

再理解几个概念

JavaVM是虚拟机在JNI中的表示，一个JVM中只有一个JavaVM对象，这个对象是线程共享的。

通过JNIEnv我们可以获取一个Java虚拟机对象，其函数如下：

jint GetJavaVM(JNIEnv *env, JavaVM **vm);

  • vm：用来存放获得的虚拟机的指针的指针。
  • return：成功返回0，失败返回其他。

AttachCurrentThread 链接到虚拟机

JNIEnv指针仅在创建它的线程有效。如果我们需要在其他线程访问JVM，那么必须先调用AttachCurrentThread将当前线程与JVM进行关联，然后才能获得JNIEnv对象。当然，我们在必要时需要调用DetachCurrentThread来解除链接。

jint AttachCurrentThread(JavaVM* vm , JNIEnv** env , JavaVMAttachArgs* args);

  • vm：虚拟机对象指针。
  • env：用来保存得到的JNIEnv的指针。
  • args：链接参数，参数结构体如下所示。
  • return：链接成功返回0，连接失败返回其他。

仔细看看jni的实现文件

#include <jni.h>
#include <android/log.h>
#include <utils/Log.h>
#include <utils/Mutex.h>
#include "WifiStaServiceServiceJni.h"
#include <WifiStaServiceDataTransfer.h>
#include "ara/core/promise.h"
#include "ara/core/initialization.h"

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "WifiStaServiceServiceJni"

#ifdef __cplusplus
extern "C" {
#endif

namespace yf {
namespace soa {

std::string g_instance_name;
static fields_t fields;
static pthread_key_t sThreadKey;
static JavaVM* javaVM;
static android::Mutex sJNIEnvLock;

jobject g_WifiStaServiceServiceStubClass;

static JNIEnv *getJNIEnv() {
    android::Mutex::Autolock l(sJNIEnvLock);//加锁,防止多线程获取不同步
    ALOGD("[%s:%d][%s]", __FUNCTION__, __LINE__, __FILE__);
    if (javaVM == NULL) {
        ALOGE("[%s:%d][%s] Java VM is NULL", __FUNCTION__, __LINE__, __FILE__);
        return NULL;
    }
    JNIEnv *envnow = NULL;
    int status = javaVM->GetEnv((void **)&envnow, JNI_VERSION_1_6);
    ALOGD("[%s:%d][%s] GetEnv::status = [%d]", __FUNCTION__, __LINE__, __FILE__, status);
    if (status == JNI_EDETACHED) {
        if( 0 <= javaVM->AttachCurrentThread(&envnow, NULL)) {
            ALOGD("[%s:%d][%s] AttachCurrentThread::status = [%d]", __FUNCTION__, __LINE__, __FILE__, status);
            /**
             * use that key with pthread_setspecific to store JNIEnv in thead-local-storage.
             * In that, it'll be passed into your destructor as the argument.
             *
             */
            if (NULL == pthread_getspecific(sThreadKey)) {
                pthread_setspecific(sThreadKey, &envnow);
            }
        }
    }
    return envnow;
}

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_init
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1init
(JNIEnv * env, jclass clazz, jstring ap_env) {
    ALOGD("=================== JNI call native_init ========================");
	//从classpath路径下搜索ClassMethod这个类,并返回该类的Class对象
    jclass jcls = env->FindClass("com/yf/soa/wifistaservice/WifiStaServiceServiceStub");
    //调用 NewGlobalRef 基于局部引用创建,会阻GC回收所引用的对象。可以跨方法、跨线程使用。JVM不会自
	//动释放,必须调用DeleteGlobalRef手动释放。 (*env)->DeleteGlobalRef(env,g_cls_string)
    g_WifiStaServiceServiceStubClass = env->NewGlobalRef(jcls);
	//将方法id保存在结构体中的jmethodid中
    fields.post_event = env->GetStaticMethodID(jcls, "postEventFromNative", "(Ljava/lang/Object;I[B)[B");
    //获取全局的javavm
    env->GetJavaVM(&javaVM);
    if (fields.post_event == NULL) {
       ALOGD("JNI_native_init fields.post_event is null");
       return;
    }
    if (getenv("AA_CONFIG_FILES_PATH")) {
        ALOGD("env already setted, AA_CONFIG_FILES_PATH: %s", getenv("AA_CONFIG_FILES_PATH"));
    } else {
        if (ap_env) {
            const char *jap_env = env->GetStringUTFChars(ap_env, NULL);
            if (0 != setenv("AA_CONFIG_FILES_PATH", jap_env, 1)) {
                ALOGE("setenv error ");
            }
            if (!ara::core::Initialize().HasValue()) {
                ALOGE("ara::core::init error ");
                ara::core::Abort("ara::core::Initialize() failed for Service, calling abort...");
            }
        } else {
            ALOGE("native_init without ap env set up");
        }
    }
}

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_setup
 * Signature: (Ljava/lang/Object;)V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1setup
(JNIEnv *env, jclass clazz, jobject weak_this, jstring instance) {
    ALOGD("=================== JNI call native_setup ========================");
    //新建监听器对象
    std::shared_ptr<WifiStaServiceNativeListenerImpl> listener = std::make_shared<WifiStaServiceNativeListenerImpl>(env, clazz, weak_this);
    ALOGD("=================== JNI call native_setup new WifiStaServiceNativeListenerImpl ok========================");
    g_instance_name = std::string(env->GetStringUTFChars(instance, NULL));
    //注册监听回调,这样就能收到其他库的回调监听了.
    WifiStaServiceNative::instantiate().registerListener(listener);
}

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_finalize
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1finalize
(JNIEnv * env, jclass clazz) {
    ALOGD("=================== JNI call native_finalize ========================");
}

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_offerService
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1sendService
(JNIEnv *, jclass) {
    ALOGD("=================== JNI call native_offerService ========================");
    WifiStaServiceNative::instantiate().OfferService();
}

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_stopOfferService
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1stopSendService
(JNIEnv *, jclass) {
    ALOGD("=================== JNI call native_stopOfferService ========================");
    WifiStaServiceNative::instantiate().StopOfferService();
}

/*
 * Class:     com_yf_soa_wifistaservice_WifiStaServiceServiceStub
 * Method:    native_notifyRssiChanged
 * Signature: (Lcom/yf/soa/wifistaservice/WifiAp;)V
 * 通知wifi信号的方法,java侧会将数据传到jni侧.
 */
JNIEXPORT void JNICALL Java_com_yf_soa_wifistaservice_WifiStaServiceServiceStub_native_1notifyRssiChanged
(JNIEnv *env, jclass clazz, jbyteArray jrssichanged) {
    ALOGD("=================== JNI call native_notifyRssiChanged ========================");
    DataTypes::WifiAp arxml_rssiChanged;
    DataTransfer::WifiAp transfer_rssichanged;
    ::com::yf::soa::wifistaservice::WifiAp proto_rssichanged;
    if (jrssichanged) {
        //下面的逻辑就是通过byte数组,然后通过google的protobuf转换传给其他的需要者
        jbyte *data = env->GetByteArrayElements(jrssichanged, 0);
        int data_len = env->GetArrayLength(jrssichanged);
        proto_rssichanged.ParseFromArray(data, data_len);
        env->ReleaseByteArrayElements(jrssichanged, data, 0);
        transfer_rssichanged.fromProto(proto_rssichanged).toArxml(arxml_rssiChanged);
    }

    WifiStaServiceNative::instantiate().notifyRssiChanged(arxml_rssiChanged);
}
//实现WifiStaServiceNativeListenerImpl类,构造函数
WifiStaServiceNativeListenerImpl::WifiStaServiceNativeListenerImpl(JNIEnv* env, jobject thiz, jobject weak_thiz) {
    ALOGD("WifiStaServiceNativeListenerImpl::WifiStaServiceNativeListenerImpl");
    //这个地方我们看到是一个本地的jclass,主要是用来判断是否为空.由上面的native_setup函数传参
    //thiz是代表静态的native_setup方法.weak_thiz代表java侧的接口IWifiStaServiceService
    jclass clazz = env->GetObjectClass(thiz);

    if (clazz == NULL) {
        return;
    }
    //获取在init函数保存的全局passclassload 路径对象
    mClass = (jclass)g_WifiStaServiceServiceStubClass;
    //保存全局的java侧对象的类实例
    mObject  = env->NewGlobalRef(weak_thiz);
}
//析构函数做一些释放的操作,比如我们保存的一些全局引用
WifiStaServiceNativeListenerImpl::~WifiStaServiceNativeListenerImpl() {
    ALOGD("WifiStaServiceNativeListenerImpl::~WifiStaServiceNativeListenerImpl");
    JNIEnv *env = getJNIEnv();
    if (NULL == env) {
        return;
    }
    env->DeleteGlobalRef(mObject);
    env->DeleteGlobalRef(mClass);

    syncDetachCurrentThread();
}
//注册回调后,在notify会收到其他c++程序发来的消息,这个消息我们需要转发到java侧.看看怎么做.
jbyteArray WifiStaServiceNativeListenerImpl::notify(JNIEnv* env, int msg, const jbyteArray obj) {
    ALOGD("WifiStaServiceNativeListenerImpl::notify");
    //具体的数据,这里是字节数组
    jbyteArray retobj = nullptr;
    if (NULL == env) {
        ALOGW("ERROR: JNIEnv is NULL LINE");
        return retobj;
    }
	//如果说在native_init里面保存的java方法postEventFromNative id号是空的,那就是有问题,直接return 
    if (NULL == fields.post_event) {
        ALOGW("notify fields.post_event is NULL");
        return retobj;
    }
    ALOGW("notify msg %d", msg);
    //没有问题的话,就调用java的postEventFromNative方法进行回调.首先Java postEventFromNative方法是个静态static的,
    //所以调用CallStaticObjectMethod
    //1.mClass是代表这个java的类对象路径com/yf/soa/wifistaservice/WifiStaServiceServiceStub
    //2.fields.post_event是保存着对象WifiStaServiceServiceStub里面postEventFromNative对象id
    //3.mObject是实例化WifiStaServiceServiceStub类
    //4.msg是消息type
    //5.obj每个消息type都会有自己的数据
    //6.java侧通过postEventFromNative方法返回的数据,jni侧获取到
    retobj = (jbyteArray)env->CallStaticObjectMethod(mClass, fields.post_event, mObject, msg, obj);

    return retobj;
}

void WifiStaServiceNativeListenerImpl::syncDetachCurrentThread() {
    // ALOGD("syncDetachCurrentThread");
    // android::Mutex::Autolock l(sJNIEnvLock);
    // javaVM->DetachCurrentThread();
}

WifiStaServiceNative::WifiStaServiceNative()
: yf::platform::WifiStaServiceSkeleton(ara::core::InstanceSpecifier(ara::core::StringView(g_instance_name.c_str(), g_instance_name.size())))
{
    ALOGD("WifiStaServiceNative::WifiStaServiceNative");
}

WifiStaServiceNative::~WifiStaServiceNative() {
    ALOGD("WifiStaServiceNative::~WifiStaServiceNative");
}

void WifiStaServiceNative::registerListener(const std::shared_ptr<WifiStaServiceNativeListener> listener) {
    ALOGD("WifiStaServiceNative::registerListener");
    m_listener = listener;
}

sovpap::core::Future<nm_wifistaservice::internal::methods::Activate::Output> WifiStaServiceNative::Activate() {
    ara::core::Promise<nm_wifistaservice::internal::methods::Activate::Output> prom;
    DataTransfer::ActivateOutput dataTransferOutput;
    ::com::yf::soa::wifistaservice::ActivateOutput protoOutput;
    nm_wifistaservice::internal::methods::Activate::Output arxmlOutput;
    //获取jni函数表,可用于多线程
    JNIEnv *env = getJNIEnv();
	//不同的type,调用notify函数获取java侧返回的数据
    jbyteArray jOutput = m_listener->notify(env, METHOD_ACTIVATE, nullptr);

    if (jOutput) {
        jbyte *data = env->GetByteArrayElements(jOutput, 0);
        int data_len = env->GetArrayLength(jOutput);
        protoOutput.ParseFromArray(data, data_len);
        env->ReleaseByteArrayElements(jOutput, data, 0);
        dataTransferOutput.fromProto(protoOutput).toArxml(arxmlOutput);
    } else {
        ALOGE("%s notify ret obj is null", __FUNCTION__);
    }
    m_listener->syncDetachCurrentThread();
    prom.set_value(std::move(arxmlOutput));
    return prom.get_future();
}

sovpap::core::Future<nm_wifistaservice::internal::methods::AddAp::Output> WifiStaServiceNative::AddAp(const DataTypes::WifiConfiguration& wifiConfiguration) {
    ara::core::Promise<nm_wifistaservice::internal::methods::AddAp::Output> prom;
    DataTransfer::AddApInput dataTransferInput;
    DataTransfer::AddApOutput dataTransferOutput;
    ::com::yf::soa::wifistaservice::AddApInput protoInput;
    ::com::yf::soa::wifistaservice::AddApOutput protoOutput;
    nm_wifistaservice::internal::methods::AddAp::Input arxmlInput;
    nm_wifistaservice::internal::methods::AddAp::Output arxmlOutput;
    JNIEnv *env = getJNIEnv();
    arxmlInput.WifiConfiguration = wifiConfiguration;
    dataTransferInput.fromArxml(arxmlInput).toProto(protoInput);
    jbyteArray jInput = env->NewByteArray(protoInput.ByteSize());
    jbyte *pInput = env->GetByteArrayElements(jInput, NULL);
    protoInput.SerializeToArray(pInput, protoInput.ByteSize());
    env->ReleaseByteArrayElements(jInput, pInput, 0);

    jbyteArray jOutput = m_listener->notify(env, METHOD_ADDAP, jInput);

    if (jOutput) {
        jbyte *data = env->GetByteArrayElements(jOutput, 0);
        int data_len = env->GetArrayLength(jOutput);
        protoOutput.ParseFromArray(data, data_len);
        env->ReleaseByteArrayElements(jOutput, data, 0);
        dataTransferOutput.fromProto(protoOutput).toArxml(arxmlOutput);
    } else {
        ALOGE("%s notify ret obj is null", __FUNCTION__);
    }
    m_listener->syncDetachCurrentThread();
    prom.set_value(std::move(arxmlOutput));
    return prom.get_future();
}

void WifiStaServiceNative::notifyRssiChanged(const DataTypes::WifiAp& _rssiChanged) {
    RssiChanged.Send(_rssiChanged);
}

void WifiStaServiceNative::notifyScanFinished(const DataTypes::WifiApList& _scanFinished) {
    ScanFinished.Send(_scanFinished);
}

void WifiStaServiceNative::notifyStaConnChanged(const DataTypes::WifiAp& _staConnChanged) {
    StaConnChanged.Send(_staConnChanged);
}

void WifiStaServiceNative::notifyStationChanged(const DataTypes::StationState_ref& _stationChanged) {
    StationChanged.Send(_stationChanged);
}

}  // namespace soa
}  // namespace yf
#ifdef __cplusplus
}
#endif

总结一下

访问和修改实例变量操作步聚:

• 调用 GetObjectClass 函数获取实例对象的 Class 引用
• 调用 GetFieldID 函数获取 Class 引用中某个实例变量的 ID
• 调用 GetXXXField 函数获取变量的值,需要传入实例变量所属对象和变量 ID
• 调用 SetXXXField 函数修改变量的值,需要传入实例变量所属对象、变量 ID 和变量的值

访问和修改静态变量操作步聚:

• 调用 FindClass 函数获取类的 Class 引用
• 调用 GetStaticFieldID 函数获取 Class 引用中某个静态变量 ID
• 调用 GetStaticXXXField 函数获取静态变量的值,需要传入变量所属 Class 的引用和变量 ID
• 调用 SetStaticXXXField 函数设置静态变量的值,需要传入变量所属 Class 的引用、变量 ID和变量的
值

访问和修改实例变量操作步聚:

• 调用 GetObjectClass 函数获取实例对象的 Class 引用
• 调用 GetFieldID 函数获取 Class 引用中某个实例变量的 ID
• 调用 GetXXXField 函数获取变量的值,需要传入实例变量所属对象和变量 ID
• 调用 SetXXXField 函数修改变量的值,需要传入实例变量所属对象、变量 ID 和变量的值

访问和修改静态变量操作步聚:

• 调用 FindClass 函数获取类的 Class 引用
• 调用 GetStaticFieldID 函数获取 Class 引用中某个静态变量 ID
• 调用 GetStaticXXXField 函数获取静态变量的值,需要传入变量所属 Class 的引用和变量 ID
• 调用 SetStaticXXXField 函数设置静态变量的值,需要传入变量所属 Class 的引用、变量 ID和变量的
值

紫色的路
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android JNI基础-利用JNI实现JAVA调用C++代码
05-02
Android JNI基础-利用JNI实现JAVA调用C++代码
理解Android编译命令
三杯五岳
05-03 2500
工欲善其事，必先利其器，对于想要深入学习Android源码，必须先掌握Android编译命令. 一、引言 关于Android Build系统，这个话题很早就打算整理下，迟迟没有下笔，决定跟大家分享下。先看下面几条指令，相信编译过Android源码的人都再熟悉不过的。 source /opt/android1204_17.conf source setenv.sh lunch m
安卓libc setenv函数内存泄漏
cf125313的专栏
06-27 416
安卓 libc 内存泄漏
安卓开发进阶之快速上手JNI 其一初窥门径
最新发布
qq_37256866的博客
04-15 1084
快速上手JNI
Android存储系统解析
~山之歌~
11-30 2177
目 录 存储框架概述2 $一、framework篇2 一、前期布置和准备3 1、onStart()4 2、onBootPhase(int phase)6 二、消息的接收8 三、消息的发送12 四、StorageManager14 $二、VOLD篇14 一、NetlinkManager17 二...
Android系统启动--init启动zygote进程的过程--Android 12
lvyaer_1122的博客
04-29 1194
Android设备的启动必须经历3个阶段，即Boot Loader、Linux Kernel和Android系统服务。init是Linux系统中用户空间的第一个进程，pid = 1。init进程将通过解析init.rc来启动其他关键的系统服务进程——zygote、systemserver、servicemanager。
Java单元测试动态修改环境变量
shirukai
04-01 2712
Java单元测试动态修改环境变量 今天再写单元测试的时候，遇到一个比较有趣的事情，程序需要读取一个环境变量，而这个变量又是动态生成的，所以在执行单元测试之前要进行环境变量的配置。目前总结了两种方案可以实现动态修改环境变量，修改后的环境变量仅对当前进程生效，即仅在当前Java进程中调用System.getenv(name)生效，分别是通过反射修改Runtime中保存环境变量的Map、和通过JNI的方式调用系统的setenv方法。下面将分别对两种方案进行实现。 1 通过反射修改Runtime中保存环境变量的Ma
android下设置uboot环境变量
qq_27840681的博客
12-25 1790
Uboot环境变量的作用在不改变源码、不用重新编译的情况下，可以使我们通过设置环境变量的值来改变uboot的一些设置，如bootdelay时间、机器码的值等等。
android jni基础知识 具体实例
10-25
在Android工程中，JNI的使用通常包括以下步骤： 1. **创建本地方法声明**：在Java类中，你需要声明一个native方法，这个方法将在C代码中实现。例如： ```java public class MainActivity extends ...
Android JNI-NDK与JNI基础.pptx
11-02
Android NDK和JNI是Android开发中的重要工具，它们为开发者提供了使用C和C++编写原生代码的能力。NDK（Native Develop Kit）是一组工具，允许开发者在Android应用中集成C和C++代码，尤其适用于需要高性能计算或者...
AndroidJNI.rar_Android jni_android
09-23
本资料"AndroidJNI.rar_Android jni_android"可能包含一个简单的示例项目——HelloWorld，用于教学如何在Android应用中使用JNI。 首先，我们来理解JNI的基本概念。JNI是一套接口，使得Java虚拟机（JVM）能够调用...
putenv与setenv的区别
05-24
putenv可以使用程序中已定义，且值形如"name=value"的字符串变量作为函数的实参。此时，系统将不再为该环境变量分配内存，
HDroidGUI:Harbor的Android GUI框架
06-11
图形用户界面 Harbor的Android GUI框架 ###HDroidGUI发行版的结构： buildall.bat, buildall.sh - 整个框架交叉编译的命令脚本，bat - 如果你在 Windows 下执行，sh - 如果在 Linux 下。 clear.bat, clear.sh - 用于删除编译结果的命令脚本。 comp.bat、comp.sh - 用于编译“Java”的命令脚本 - 框架代码。 ndkBuild.bat、ndkbuild.sh - 用于编译“C”和“Harbour”的命令脚本 - 框架代码。 setenv.bat, setenv.sh - 用于设置环境变量以编译框架的命令脚本，您需要对其进行编辑 - 设置适合您系统的路径。 jni/Android.mk、jni/Application.mk - 用于构建框架“本机”部分的动态库（“so”）
Android JNI 进程保活
07-16
一、JNI基础 1. JNI接口：JNI定义了一套接口，使得Java代码可以调用C/C++函数，反之亦然。Java层通过`System.loadLibrary()`加载本地库，然后通过`native`关键字定义的函数来调用C/C++代码。 2. `JNI_OnLoad`：当...
android java配置环境变量,Android在Java中设置（获取）环境变量
weixin_39553352的博客
02-13 275
I have experimented little with Android OS and I tried to call System.getenv() to get environmental variables. It works e.g. for $PATH, but I was not able to define own variable, which can be accessib...
OpenSSL实践-Android下的编译和使用
热门推荐
跨链技术践行者
03-20 1万+
1. 概述 openssl可以编译成ARM下面的二进制代码（动态库或者静态库），方便APP使用，APP在使用的时候，需要使用JNI来进行调用。 官方WIKI有写如何为android编译openssl，地址是：https://wiki.openssl.org/index.php/Android 因此也是参考这篇文章实现的。 编译不太复杂，基本步骤如下： 下载NDK 下载openssl源码...
android 配置启动参数,Android系统启动之配置文件解析
weixin_31040629的博客
05-26 707
以下代码基于Android 7.0分析简介我们知道在Android系统启动的时候会创建Init进程，在Init进程的main()入口函数中会解析系统配置文件进行服务进程的创建和启动。解析Init.rc配置文件[->system/core/init/init.cpp]int main(int argc, char** argv) {...//这里将Action的function_map_替换为...
android获取所有env,Amlogic 905平台Env环境在Android系统各层获取和设置
weixin_36297381的博客
05-28 797
需要在各层如：bootloader、kernel、framework、system-app获取uboot的Env需要如下步骤以905平台设置控制台日志等级为例将Env环境变量预置并且作为bootargs(传递给内核的启动参数)--- a/uboot-repo/bl33/board/amlogic/configs/g12a_u202_v1.h+++ b/uboot-repo/bl33/board/a...
Android ——JNI基本了解与使用
qq_35231506的博客
05-16 1612
JNI （Java Native Interface，Java本地接口）是一种编程框架，使得Java虚拟机中的Java程序可以调用本地应用/或库，也可以被其他程序调用。本地程序一般是用其它语言（C、C++或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序。Android NDK开发之JNI基础Android JNI详解JNI入门到精通: 用Java和C/C++打造高性能应用ANDROID STUDIO 创建一个JNI工程创建JNI基础工程并运行JNI基本知识（一）JNI编程原理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值