Android NDK开发 Java与C互相调用实例详解

最新推荐文章于 2021-05-23 14:51:22 发布
转载 最新推荐文章于 2021-05-23 14:51:22 发布 · 1k 阅读 · 0

本文详细介绍了如何使用NDK实现Java与C/C++之间的数据互调，包括整数、字符串、字节数组的传递过程。通过构建一个回调机制，使得数据可以在不同语言环境中无缝传输。

http://abc20899.iteye.com/blog/1861121

一、概述

      对于大部分应用开发者来说可能都不怎么接触到NDK，但如果涉及到硬件操作的话就不得不使用NDK了。使用NDK还有另一个原因，就是C/C++的效率比较高，因此我们可以把一些耗时的操作放在NDK中实现。

      关于java与c/c++的互相调用，网上有一大堆的文章介绍。但仔细观察可以发现，基本都是讲在java中调用一个本地方法，然后由该本地方法直接返回一个参数给java（例如，在java中定义的本地方法为private int callJNI(int i)）。但在大多数时候要求的并不是由开发者在java层主动去调JNI中的函数来返回想要的数据，而是由JNI主动去调java中的函数。举个最简单的例子，Android中的Camera，图像数据由内核一直往上传到java层，然而这些数据的传递并不需要开发者每一次主动去调用来JNI中的函数来获取，而是由JNI主动传给用java中方法，这类似于Linux驱动机制中的异步通知。


二、要求

      用NDK实现Java与C/C++互调，实现int，string，byte[]这三种类型的互相传递。


三、实现

      下面的实现中，每次java调用JNI中的某个函数时，最后会在该函数里回调java中相应的方法而不是直接返回一个参数。可能你会觉得这不还是每次都是由开发者来主动调用吗，其实这只是为了讲解而已，在实际应用中，回调java中的方法应该由某个事件（非java层）来触发。

      新建工程MyCallback，修改main.xml文件，在里面添加3个Button，分别对应3种类型的调用和3个TextView分别显示由JNI回调java时传给java的数据。完整的main.xml文件如下：
新建工程MyCallback，修改main.xml文件，在里面添加3个Button，分别对应3种类型的调用和3个TextView分别显示由JNI回调java时传给java的数据。完整的main.xml文件如下：

Java代码 复制代码 收藏代码
  1. <?xml version="1.0" encoding="utf-8"?> 
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
  3.      android:layout_width="fill_parent" 
  4.      android:layout_height="fill_parent" 
  5.      android:orientation="vertical" > 
  6.   
  7.      <Button  
  8.          android:id="@+id/intbutton" 
  9.          android:layout_width="fill_parent" 
  10.          android:layout_height="wrap_content" 
  11.          android:text="传给JNI一个整数1" 
  12.          />  
  13.       
  14.      <TextView 
  15.          android:id="@+id/inttextview" 
  16.          android:layout_width="fill_parent" 
  17.          android:layout_height="wrap_content" 
  18.          android:text="接收到的整数："  
  19.          /> 
  20.       
  21.      <Button  
  22.          android:id="@+id/stringbutton" 
  23.          android:layout_width="fill_parent" 
  24.          android:layout_height="wrap_content" 
  25.          android:text="传给JNI一个字符A" 
  26.          />  
  27.       
  28.      <TextView 
  29.          android:id="@+id/stringtextview" 
  30.          android:layout_width="fill_parent" 
  31.          android:layout_height="wrap_content" 
  32.          android:text="接收到的字符："  
  33.          /> 
  34.       
  35.      <Button  
  36.          android:id="@+id/arraybutton" 
  37.          android:layout_width="fill_parent" 
  38.          android:layout_height="wrap_content" 
  39.          android:text="传给JNI一个数组12345" 
  40.          />  
  41.       
  42.      <TextView 
  43.          android:id="@+id/arraytextview" 
  44.          android:layout_width="fill_parent" 
  45.          android:layout_height="wrap_content" 
  46.          android:text="接收到的数组："  
  47.          /> 
  48.       
  49.   
  50. </LinearLayout>  
<?xml version="1.0" encoding="utf-8"?>
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="fill_parent"
     android:layout_height="fill_parent"
     android:orientation="vertical" >
 
     <Button 
         android:id="@+id/intbutton"
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:text="传给JNI一个整数1"
         /> 
     
     <TextView
         android:id="@+id/inttextview"
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:text="接收到的整数：" 
         />
     
     <Button 
         android:id="@+id/stringbutton"
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:text="传给JNI一个字符A"
         /> 
     
     <TextView
         android:id="@+id/stringtextview"
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:text="接收到的字符：" 
         />
     
     <Button 
         android:id="@+id/arraybutton"
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:text="传给JNI一个数组12345"
         /> 
     
     <TextView
         android:id="@+id/arraytextview"
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:text="接收到的数组：" 
         />
     
 
 </LinearLayout>



修改MyCallbackActivity.java文件，定义了一个Handler，当JNI回调java的方法时，用来发送消息；实现3个Button的监听。如下：

Java代码 复制代码 收藏代码
  1. package com.nan.callback; 
  2.   
  3. import android.app.Activity; 
  4. import android.os.Bundle; 
  5. import android.os.Handler; 
  6. import android.os.Message; 
  7. import android.view.View; 
  8. import android.widget.Button; 
  9. import android.widget.TextView; 
  10.   
  11.   
  12. public class MyCallbackActivity extends Activity  
  13. { 
  14.      private Button intButton = null; 
  15.      private Button stringButton = null; 
  16.      private Button arrayButton = null; 
  17.      private TextView intTextView = null;  
  18.      private TextView stringTextView = null;  
  19.      private TextView arrayTextView = null;  
  20.       
  21.      private Handler mHandler = null; 
  22.       
  23.       
  24.      /** Called when the activity is first created. */ 
  25.      @Override 
  26.      public void onCreate(Bundle savedInstanceState)  
  27.      { 
  28.          super.onCreate(savedInstanceState); 
  29.          setContentView(R.layout.main); 
  30.           
  31.          intButton = (Button)this.findViewById(R.id.intbutton); 
  32.          //注册按钮监听 
  33.          intButton.setOnClickListener(new ClickListener()); 
  34.          stringButton = (Button)this.findViewById(R.id.stringbutton); 
  35.          //注册按钮监听 
  36.          stringButton.setOnClickListener(new ClickListener()); 
  37.          arrayButton = (Button)this.findViewById(R.id.arraybutton); 
  38.          //注册按钮监听 
  39.          arrayButton.setOnClickListener(new ClickListener()); 
  40.           
  41.          intTextView = (TextView)this.findViewById(R.id.inttextview); 
  42.          stringTextView = (TextView)this.findViewById(R.id.stringtextview); 
  43.          arrayTextView = (TextView)this.findViewById(R.id.arraytextview); 
  44.           
  45.          //消息处理       
  46.          mHandler = new Handler() 
  47.          { 
  48.              @Override 
  49.              public void handleMessage(Message msg) 
  50.              { 
  51.                  switch(msg.what) 
  52.                  { 
  53.                      //整型 
  54.                      case 0: 
  55.                      { 
  56.                          intTextView.setText(msg.obj.toString()); 
  57.                          break; 
  58.                      } 
  59.                      //字符串 
  60.                      case 1: 
  61.                      { 
  62.                          stringTextView.setText(msg.obj.toString()); 
  63.                          break; 
  64.                      } 
  65.                      //数组 
  66.                      case 2: 
  67.                      {   byte[] b = (byte[])msg.obj;                   
  68.                          arrayTextView.setText(Byte.toString(b[0])+Byte.toString(b[1])+Byte.toString(b[2])+Byte.toString(b[3])+Byte.toString(b[4]));                      
  69.                          break; 
  70.                      } 
  71.                  } 
  72.                                  
  73.              }        
  74.               
  75.          }; 
  76.           
  77.           
  78.      } 
  79.               
  80.      //按钮监听实现 
  81.      public class ClickListener implements View.OnClickListener 
  82.      { 
  83.   
  84.          @Override 
  85.          public void onClick(View v)  
  86.          { 
  87.              // TODO Auto-generated method stub 
  88.              switch(v.getId()) 
  89.              { 
  90.                  case R.id.intbutton: 
  91.                  { 
  92.                      //调用JNI中的函数 
  93.                      callJNIInt(1);       
  94.                      break; 
  95.                  } 
  96.                  case R.id.stringbutton: 
  97.                  { 
  98.                      //调用JNI中的函数 
  99.                      callJNIString("你好A");              
  100.                      break; 
  101.                  } 
  102.                  case R.id.arraybutton: 
  103.                  {                 
  104.                      //调用JNI中的函数 
  105.                      callJNIByte(new byte[]{1,2,3,4,5});                
  106.                      break; 
  107.                  } 
  108.              } 
  109.          } 
  110.           
  111.      } 
  112.     
  113.       
  114.      //被JNI调用，参数由JNI传入 
  115.      private void callbackInt(int i) 
  116.      { 
  117.          Message msg = new Message(); 
  118.          //消息类型 
  119.          msg.what = 0; 
  120.          //消息内容 
  121.          msg.obj = i; 
  122.          //发送消息 
  123.          mHandler.sendMessage(msg); 
  124.      } 
  125.       
  126.      //被JNI调用，参数由JNI传入 
  127.      private void callbackString(String s) 
  128.      { 
  129.          Message msg = new Message(); 
  130.          //消息类型 
  131.          msg.what = 1; 
  132.          //消息内容 
  133.          msg.obj = s; 
  134.          //发送消息 
  135.          mHandler.sendMessage(msg); 
  136.      } 
  137.       
  138.      //被JNI调用，参数由JNI传入 
  139.      private void callbackByte(byte[] b) 
  140.      { 
  141.          Message msg = new Message(); 
  142.          //消息类型 
  143.          msg.what = 2; 
  144.          //消息内容 
  145.          msg.obj = b;      
  146.          //发送消息 
  147.          mHandler.sendMessage(msg); 
  148.      } 
  149.       
  150.      //本地方法，由java调用 
  151.      private native void callJNIInt(int i); 
  152.      private native void callJNIString(String s); 
  153.      private native void callJNIByte(byte[] b); 
  154.       
  155.      static 
  156.      { 
  157.          //加载本地库 
  158.          System.loadLibrary("myjni"); 
  159.      } 
  160.       
  161. }  
package com.nan.callback;
 
 import android.app.Activity;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.view.View;
 import android.widget.Button;
 import android.widget.TextView;
 
 
 public class MyCallbackActivity extends Activity 
 {
     private Button intButton = null;
     private Button stringButton = null;
     private Button arrayButton = null;
     private TextView intTextView = null; 
     private TextView stringTextView = null; 
     private TextView arrayTextView = null; 
     
     private Handler mHandler = null;
     
     
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) 
     {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         
         intButton = (Button)this.findViewById(R.id.intbutton);
         //注册按钮监听
         intButton.setOnClickListener(new ClickListener());
         stringButton = (Button)this.findViewById(R.id.stringbutton);
         //注册按钮监听
         stringButton.setOnClickListener(new ClickListener());
         arrayButton = (Button)this.findViewById(R.id.arraybutton);
         //注册按钮监听
         arrayButton.setOnClickListener(new ClickListener());
         
         intTextView = (TextView)this.findViewById(R.id.inttextview);
         stringTextView = (TextView)this.findViewById(R.id.stringtextview);
         arrayTextView = (TextView)this.findViewById(R.id.arraytextview);
         
         //消息处理      
         mHandler = new Handler()
         {
             @Override
             public void handleMessage(Message msg)
             {
                 switch(msg.what)
                 {
                     //整型
                     case 0:
                     {
                         intTextView.setText(msg.obj.toString());
                         break;
                     }
                     //字符串
                     case 1:
                     {
                         stringTextView.setText(msg.obj.toString());
                         break;
                     }
                     //数组
                     case 2:
                     {   byte[] b = (byte[])msg.obj;                  
                         arrayTextView.setText(Byte.toString(b[0])+Byte.toString(b[1])+Byte.toString(b[2])+Byte.toString(b[3])+Byte.toString(b[4]));                     
                         break;
                     }
                 }
                                
             }       
             
         };
         
         
     }
             
     //按钮监听实现
     public class ClickListener implements View.OnClickListener
     {
 
         @Override
         public void onClick(View v) 
         {
             // TODO Auto-generated method stub
             switch(v.getId())
             {
                 case R.id.intbutton:
                 {
                     //调用JNI中的函数
                     callJNIInt(1);      
                     break;
                 }
                 case R.id.stringbutton:
                 {
                     //调用JNI中的函数
                     callJNIString("你好A");             
                     break;
                 }
                 case R.id.arraybutton:
                 {                
                     //调用JNI中的函数
                     callJNIByte(new byte[]{1,2,3,4,5});               
                     break;
                 }
             }
         }
         
     }
   
     
     //被JNI调用，参数由JNI传入
     private void callbackInt(int i)
     {
         Message msg = new Message();
         //消息类型
         msg.what = 0;
         //消息内容
         msg.obj = i;
         //发送消息
         mHandler.sendMessage(msg);
     }
     
     //被JNI调用，参数由JNI传入
     private void callbackString(String s)
     {
         Message msg = new Message();
         //消息类型
         msg.what = 1;
         //消息内容
         msg.obj = s;
         //发送消息
         mHandler.sendMessage(msg);
     }
     
     //被JNI调用，参数由JNI传入
     private void callbackByte(byte[] b)
     {
         Message msg = new Message();
         //消息类型
         msg.what = 2;
         //消息内容
         msg.obj = b;     
         //发送消息
         mHandler.sendMessage(msg);
     }
     
     //本地方法，由java调用
     private native void callJNIInt(int i);
     private native void callJNIString(String s);
     private native void callJNIByte(byte[] b);
     
     static
     {
         //加载本地库
         System.loadLibrary("myjni");
     }
     
 }



最后就是本篇随笔的“重头戏”，在工程的根目录下新建jni文件夹，在里面添加一个Android.mk文件和一个callback.c文件，Android.mk文件如下：

Java代码 复制代码 收藏代码
  1. LOCAL_PATH := $(call my-dir) 
  2.   
  3. include $(CLEAR_VARS) 
  4.   
  5. LOCAL_MODULE    := myjni 
  6. LOCAL_SRC_FILES := callback.c 
  7.   
  8. LOCAL_LDLIBS    := -llog 
  9.   
  10. include $(BUILD_SHARED_LIBRARY)  
LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
 
 LOCAL_MODULE    := myjni
 LOCAL_SRC_FILES := callback.c
 
 LOCAL_LDLIBS    := -llog
 
 include $(BUILD_SHARED_LIBRARY)



callback.c文件如下：

Java代码 复制代码 收藏代码
  1. #include <string.h> 
  2. #include <stdio.h> 
  3. #include <stdlib.h> 
  4. #include <unistd.h> 
  5. #include <sys/ioctl.h> 
  6. #include <sys/types.h> 
  7. #include <sys/stat.h> 
  8. #include <fcntl.h> 
  9.   
  10. #include <jni.h> 
  11. #include <android/log.h> 
  12.   
  13. #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "native-activity", __VA_ARGS__)) 
  14. #define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "native-activity", __VA_ARGS__)) 
  15.   
  16.   
  17.   
  18. /**********传输整数*************
  20. */ 
  21. JNIEXPORT void JNICALL Java_com_nan_callback_MyCallbackActivity_callJNIInt( JNIEnv* env, jobject obj , jint i) 
  22. { 
  23.      //找到java中的类 
  24.      jclass cls = (*env)->FindClass(env, "com/nan/callback/MyCallbackActivity"); 
  25.      //再找类中的方法 
  26.      jmethodID mid = (*env)->GetMethodID(env, cls, "callbackInt", "(I)V"); 
  27.      if (mid == NULL)  
  28.      { 
  29.          LOGI("int error"); 
  30.          return;   
  31.      } 
  32.      //打印接收到的数据 
  33.      LOGI("from java int: %d",i); 
  34.      //回调java中的方法 
  35.      (*env)->CallVoidMethod(env, obj, mid ,i); 
  36.           
  37. }     
  38.   
  39. /********传输字符串*************
  40. */ 
  41. JNIEXPORT void JNICALL Java_com_nan_callback_MyCallbackActivity_callJNIString( JNIEnv* env, jobject obj , jstring s) 
  42. { 
  43.      //找到java中的类 
  44.      jclass cls = (*env)->FindClass(env, "com/nan/callback/MyCallbackActivity"); 
  45.      //再找类中的方法 
  46.      jmethodID mid = (*env)->GetMethodID(env, cls, "callbackString", "(Ljava/lang/String;)V"); 
  47.      if (mid == NULL)  
  48.      { 
  49.          LOGI("string error"); 
  50.          return;   
  51.      } 
  52.      const char *ch; 
  53.      //获取由java传过来的字符串 
  54.      ch = (*env)->GetStringUTFChars(env, s, NULL); 
  55.      //打印 
  56.      LOGI("from java string: %s",ch); 
  57.      (*env)->ReleaseStringUTFChars(env, s, ch);     
  58.      //回调java中的方法 
  59.      (*env)->CallVoidMethod(env, obj, mid ,(*env)->NewStringUTF(env,"你好haha")); 
  60.   
  61. } 
  62.   
  63. /********传输数组(byte[])*************
  64. */ 
  65. JNIEXPORT void JNICALL Java_com_nan_callback_MyCallbackActivity_callJNIByte( JNIEnv* env, jobject obj , jbyteArray b) 
  66. { 
  67.      //找到java中的类 
  68.      jclass cls = (*env)->FindClass(env, "com/nan/callback/MyCallbackActivity"); 
  69.      //再找类中的方法 
  70.      jmethodID mid = (*env)->GetMethodID(env, cls, "callbackByte", "([B)V"); 
  71.      if (mid == NULL)  
  72.      { 
  73.          LOGI("byte[] error"); 
  74.          return;   
  75.      } 
  76.       
  77.      //获取数组长度 
  78.      jsize length = (*env)->GetArrayLength(env,b); 
  79.      LOGI("length: %d",length);     
  80.      //获取接收到的数据 
  81.      int i; 
  82.      jbyte* p = (*env)->GetByteArrayElements(env,b,NULL); 
  83.      //打印 
  84.      for(i=0;i<length;i++) 
  85.      { 
  86.          LOGI("%d",p[i]);     
  87.      } 
  88.   
  89.      char c[5]; 
  90.      c[0] = 1;c[1] = 2;c[2] = 3;c[3] = 4;c[4] = 5; 
  91.      //构造数组 
  92.      jbyteArray carr = (*env)->NewByteArray(env,length); 
  93.      (*env)->SetByteArrayRegion(env,carr,0,length,c); 
  94.      //回调java中的方法 
  95.      (*env)->CallVoidMethod(env, obj, mid ,carr); 
  96. }  
#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 #include <jni.h>
 #include <android/log.h>
 
 #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "native-activity", __VA_ARGS__))
 #define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "native-activity", __VA_ARGS__))
 
 
 
 /**********传输整数*************
 
 */
 JNIEXPORT void JNICALL Java_com_nan_callback_MyCallbackActivity_callJNIInt( JNIEnv* env, jobject obj , jint i)
 {
     //找到java中的类
     jclass cls = (*env)->FindClass(env, "com/nan/callback/MyCallbackActivity");
     //再找类中的方法
     jmethodID mid = (*env)->GetMethodID(env, cls, "callbackInt", "(I)V");
     if (mid == NULL) 
     {
         LOGI("int error");
         return;  
     }
     //打印接收到的数据
     LOGI("from java int: %d",i);
     //回调java中的方法
     (*env)->CallVoidMethod(env, obj, mid ,i);
         
 }    
 
 /********传输字符串*************
 */
 JNIEXPORT void JNICALL Java_com_nan_callback_MyCallbackActivity_callJNIString( JNIEnv* env, jobject obj , jstring s)
 {
     //找到java中的类
     jclass cls = (*env)->FindClass(env, "com/nan/callback/MyCallbackActivity");
     //再找类中的方法
     jmethodID mid = (*env)->GetMethodID(env, cls, "callbackString", "(Ljava/lang/String;)V");
     if (mid == NULL) 
     {
         LOGI("string error");
         return;  
     }
     const char *ch;
     //获取由java传过来的字符串
     ch = (*env)->GetStringUTFChars(env, s, NULL);
     //打印
     LOGI("from java string: %s",ch);
     (*env)->ReleaseStringUTFChars(env, s, ch);    
     //回调java中的方法
     (*env)->CallVoidMethod(env, obj, mid ,(*env)->NewStringUTF(env,"你好haha"));
 
 }
 
 /********传输数组(byte[])*************
 */
 JNIEXPORT void JNICALL Java_com_nan_callback_MyCallbackActivity_callJNIByte( JNIEnv* env, jobject obj , jbyteArray b)
 {
     //找到java中的类
     jclass cls = (*env)->FindClass(env, "com/nan/callback/MyCallbackActivity");
     //再找类中的方法
     jmethodID mid = (*env)->GetMethodID(env, cls, "callbackByte", "([B)V");
     if (mid == NULL) 
     {
         LOGI("byte[] error");
         return;  
     }
     
     //获取数组长度
     jsize length = (*env)->GetArrayLength(env,b);
     LOGI("length: %d",length);    
     //获取接收到的数据
     int i;
     jbyte* p = (*env)->GetByteArrayElements(env,b,NULL);
     //打印
     for(i=0;i<length;i++)
     {
         LOGI("%d",p[i]);    
     }
 
     char c[5];
     c[0] = 1;c[1] = 2;c[2] = 3;c[3] = 4;c[4] = 5;
     //构造数组
     jbyteArray carr = (*env)->NewByteArray(env,length);
     (*env)->SetByteArrayRegion(env,carr,0,length,c);
     //回调java中的方法
     (*env)->CallVoidMethod(env, obj, mid ,carr);
 }




利用ndk-build编译生成相应的库。

Android Studio NDK开发之一（Java调用C的方法）
hrx-@@
11-15 1946
学习NDK开发的过程中查找了很多资料很多博客，也实验了很多次，觉得还是自己整理一下比较好。省略部分：添加一个button设置监听用于调用native方法。。。开始—– 1、先配置一下NDK环境 2、添加一个专门放native方法的类NativeUtils以及相应要调用的native方法public class NativeUtils { public static native
Android NDK开发（1）----- Java与C互相调用实例详解
04-09
这篇教程将介绍如何在Java与C之间进行互相调用，这对于那些需要利用C/C++高效能特性的场景尤其有用，比如处理图像数据或进行底层驱动开发。 一、Java调用C/C++方法 在Java中，我们可以声明一个`native`关键字修饰的...
Android-JNI完整工程，实现c++调用java和java调用c++
03-16
Android-JNI完整工程，实现c调用java和java调用c
JNI实现原理权威指南
08-10
这是一本详细介绍jni的实现原理的英文版的pdf书记，希望读了以后对您的工作有所帮助
Linux下JNI实现
208studio的专栏
12-10 432
<br />     最近研究Android，涉及到JNI调用。虽然我对Java语言有所了解，但是还没有接触过JNI。今天在Unix Center 的Ubuntu上面用JNI实现了“经典”的“Hello world”程序。通过这个简单的程序把JNI的一些小知识进行一下总结。什么是JNI<br />     JNI是Java native interface的简写，可以译作Java原生接口。Java可以通过JNI调用C/C++的库，这对于那些对性能要求比较高的Java程序无疑是一个福音。<br
Android NDK开发与SO库的调用实例详解
资源摘要信息: "Android NDK开发与SO库调用实例" 知识点概述: 本资源包含关于Android NDK(Native Development Kit)开发的关键知识点，包括如何利用NDK生成共享库(SO库)，以及如何在Android应用中通过JNI(Java ...
Android NDK环境搭建与Java调用C实例代码详解
标题“Android NDK 环境搭建及实例”和描述“Android NDK 环境搭建， Cygwin+ndk+eclipse实例 java调用C 及实例代码”涉及了Android开发中的高级话题，即如何利用Android NDK（Native Development Kit）进行环境的...
NDK开发中C语言调用Java方法与属性获取详解
在Android开发中，NDK（Native Development Kit）为开发者提供了使用C/C++编写高性能代码的能力，尤其是在图像处理、音视频编解码、游戏引擎等对性能要求较高的场景中具有重要意义。本资料标题为“NDK开发之C语言...
Android NDK开发中C语言回调Java方法详解
综上所述，“Android NDK开发——C回调Java中的方法”是一项融合了Java、C语言、JNI规范、Android系统机制的综合性技术，掌握它不仅能提升应用性能，还能增强对底层运行机制的理解，是进阶Android高级开发不可或缺的...
JNI编程实现（Linux）
KelvinFlying的专栏
11-25 420
JNI是Java Native Interface的缩写，是Java平台的本地调用，从Java1.1就成为了Java标准的一部分，它允许Java代码和其它语言的代码进行互相调用，只要调用约定支持即可，尤其和C/C++的互相调用。 虽然使用Java与本地编译的代码进行交互，会丧失平台的可移植性，但是在特定情况下，这些问题是可以接受的，如： 1.使用一些旧的库 2.需要操作系统交互 3.提高程序的性能...
Java JNI简单实现
weixin_34092455的博客
02-01 127
Java JNI简单实现 JNI（Java Native Interface）允许了Java和C&C++进行交互？这不折腾人嘛！ 一、JNI简述 http://baike.baidu.com/view/1272329.htm，真心懒了-_-! 二、JNI基本类型 copy表一份，很详细的了！ ...
JNI 的简单实现
SherJamYu的博客
04-02 406
JNI是Java Native Interface的缩写，它提供了若干的API实现了Java和其他语言的通信，使得Java可以调用系统底层的API，这里简单实现一个JNI的调用过程。 创建文件 TestJNI.java public class TestJNI { public native int sum(int a ,int b); static { Sy...
Android NDK开发之C调用Java及原生代码断点调试（二）
管满满
05-11 1314
上一篇中，我们主要学习了Java调用本地方法，并列举了两大特殊实例来例证我们的论据，还没学习的伙伴必须先去阅读下，本次的学习是直接在上一篇的基础上进行了。点击：Android NDK开发之从Java与C互调中详解JNI使用（一）本篇我们主要学习如何从C源码中调用Java代码，以及使用gradle-experimental来调试原生代码。
基于 Android NDK 的学习之旅-----Java 调用C
wsmking的专栏
04-19 338
随便谈谈为什么要Java调用C 吧： 我认为： 1、  有些公司开发Android项目的时候, 许多组件功能可能是C中已经实现了，所以我们没必要同样的功能又在java中实现一遍。例如我之前做的一个项目，公司C引擎已经很成熟了，所以直接在java中封装好接口,由C去实现。 2、  C的速度一般是java的10-20倍把，有些对速度要求高的就需要在C中实现。例如我以前在Android项目中有要求
JNI简单实现
chimu9074的博客
06-06 141
事情的起因是一部的一个项目需要用到一个爱国者提供的基于U盘的加密技术。对方提供了U盘和一个dll动态链接库hiddenIO.dll。在U盘的隐藏区域内可以储存USB-Key信息，通过这个dll里的两个方法可以使用c/c++编写程序在U盘的隐藏区域读写信息，对方提供了示例代码。由于...
Java基础之JNI的简单实现
叶自飘零水自流的的博客
12-18 1235
java 使用jni调用dll文件
JNI实现机制
热门推荐
haoxuhong的博客
11-09 1万+
写在前面 说到JNI都不陌生，它的全称：Java Native Interface，即Java本地接口。 JNI不仅仅是Android特有的，它是属于Java平台的，它允许在Java虚拟机内运行的java代码与其他编程语言（如c, c++和汇编语言）编写的程序和库进行交互。 JNI调用姿势：Java —&gt; JNI —&gt; C/C++（SO库） 在Android平台中，使用JNI封装了跟...
NDK/JNI | 面向纯小白的 JNI 调用实现
M_zoneL的博客
05-23 336
注意！是面向纯纯纯小白的！ 这是一篇小白笔记，是实现 JNI 的最精简的步骤（能省的步骤就尽可能省，复杂的我也不会）。 JNI（Java Native Interface），简单说就是允许运行于 JVM 的 Java 程序调用本地代码（C/C++ 甚至汇编语言的代码）。 那废话不多说了。 这里实现一个很简单的需求，点击按钮，在 Java 端调用 C 端的方法，C 端返回一个字符串给 Java 端，并显示在界面上，如下图： 分以下几个步骤实现： 1. 新建 Android 项目 2. .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值