[Android]-图片JNI（C++\Java）高斯模糊的实现与比較

前几天一直在弄android上的图片模糊效果的实现！

一直找不到方法，看别人说都是调用JNI，可是JNI这个东西我还真不熟悉啊！

仅仅好从零開始了！这里不讲JNI的平台搭建，仅仅讲JNI的关键代码，详细的项目我会共享出来给大家！

对于JNI下使用C++来模糊图片这个我真的没找到，仅仅好自己写C++的来实现了。

在国外的一个项目中找到了一个”堆栈模糊效果“，原型例如以下：

// Stack Blur v1.0

//

// Author: Mario Klingemann <[email protected]>

// http://incubator.quasimondo.com

// created Feburary 29, 2004


// This is a compromise between Gaussian Blur and Box blur

// It creates much better looking blurs than Box Blur, but is

// 7x faster than my Gaussian Blur implementation.

//

// I called it Stack Blur because this describes best how this

// filter works internally: it creates a kind of moving stack

// of colors whilst scanning through the image. Thereby it

// just has to add one new block of color to the right side

// of the stack and remove the leftmost color. The remaining

// colors on the topmost layer of the stack are either added on

// or reduced by one, depending on if they are on the right or

// on the left side of the stack.

//

// If you are using this algorithm in your code please add

// the following line:

//

// Stack Blur Algorithm by Mario Klingemann <[email protected]>


PImage a;

PImage b;


void setup()

{

  a=loadImage("dog.jpg");

  size(a.width, a.height);

  b=new PImage(a.width, a.height);

  fill(255);

  noStroke();

  frameRate(25);

}


void draw()

{

  System.arraycopy(a.pixels,0,b.pixels,0,a.pixels.length);

  fastblur(b,mouseY/4);

  image(b, 0, 0);

}


void fastblur(PImage img,int radius){


if (radius<1){

    return;

  }

  int[] pix=img.pixels;

  int w=img.width;

  int h=img.height;

  int wm=w-1;

  int hm=h-1;

  int wh=w*h;

  int div=radius+radius+1;


int r[]=new int[wh];

  int g[]=new int[wh];

  int b[]=new int[wh];

  int rsum,gsum,bsum,x,y,i,p,yp,yi,yw;

  int vmin[] = new int[max(w,h)];


int divsum=(div+1)>>1;

  divsum*=divsum;

  int dv[]=new int[256*divsum];

  for (i=0;i<256*divsum;i++){

    dv[i]=(i/divsum);

  }


yw=yi=0;


int[][] stack=new int[div][3];

  int stackpointer;

  int stackstart;

  int[] sir;

  int rbs;

  int r1=radius+1;

  int routsum,goutsum,boutsum;

  int rinsum,ginsum,binsum;


for (y=0;y<h;y++){

    rinsum=ginsum=binsum=routsum=goutsum=boutsum=rsum=gsum=bsum=0;

    for(i=-radius;i<=radius;i++){

      p=pix[yi+min(wm,max(i,0))];

      sir=stack[i+radius];

      sir[0]=(p & 0xff0000)>>16;

      sir[1]=(p & 0x00ff00)>>8;

      sir[2]=(p & 0x0000ff);

      rbs=r1-abs(i);

      rsum+=sir[0]*rbs;

      gsum+=sir[1]*rbs;

      bsum+=sir[2]*rbs;

      if (i>0){

        rinsum+=sir[0];

        ginsum+=sir[1];

        binsum+=sir[2];

      } else {

        routsum+=sir[0];

        goutsum+=sir[1];

        boutsum+=sir[2];

      }

    }

    stackpointer=radius;


for (x=0;x<w;x++){


r[yi]=dv[rsum];

      g[yi]=dv[gsum];

      b[yi]=dv[bsum];


rsum-=routsum;

      gsum-=goutsum;

      bsum-=boutsum;


stackstart=stackpointer-radius+div;

      sir=stack[stackstart%div];


routsum-=sir[0];

      goutsum-=sir[1];

      boutsum-=sir[2];


if(y==0){

        vmin[x]=min(x+radius+1,wm);

      }

      p=pix[yw+vmin[x]];


sir[0]=(p & 0xff0000)>>16;

      sir[1]=(p & 0x00ff00)>>8;

      sir[2]=(p & 0x0000ff);


rinsum+=sir[0];

      ginsum+=sir[1];

      binsum+=sir[2];


rsum+=rinsum;

      gsum+=ginsum;

      bsum+=binsum;


stackpointer=(stackpointer+1)%div;

      sir=stack[(stackpointer)%div];


routsum+=sir[0];

      goutsum+=sir[1];

      boutsum+=sir[2];


rinsum-=sir[0];

      ginsum-=sir[1];

      binsum-=sir[2];


yi++;

    }

    yw+=w;

  }

  for (x=0;x<w;x++){

    rinsum=ginsum=binsum=routsum=goutsum=boutsum=rsum=gsum=bsum=0;

    yp=-radius*w;

    for(i=-radius;i<=radius;i++){

      yi=max(0,yp)+x;


sir=stack[i+radius];


sir[0]=r[yi];

      sir[1]=g[yi];

      sir[2]=b[yi];


rbs=r1-abs(i);


rsum+=r[yi]*rbs;

      gsum+=g[yi]*rbs;

      bsum+=b[yi]*rbs;


if (i>0){

        rinsum+=sir[0];

        ginsum+=sir[1];

        binsum+=sir[2];

      } else {

        routsum+=sir[0];

        goutsum+=sir[1];

        boutsum+=sir[2];

      }


if(i<hm){

        yp+=w;

      }

    }

    yi=x;

    stackpointer=radius;

    for (y=0;y<h;y++){

      pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];


rsum-=routsum;

      gsum-=goutsum;

      bsum-=boutsum;


stackstart=stackpointer-radius+div;

      sir=stack[stackstart%div];


routsum-=sir[0];

      goutsum-=sir[1];

      boutsum-=sir[2];


if(x==0){

        vmin[y]=min(y+r1,hm)*w;

      }

      p=x+vmin[y];


sir[0]=r[p];

      sir[1]=g[p];

      sir[2]=b[p];


rinsum+=sir[0];

      ginsum+=sir[1];

      binsum+=sir[2];


rsum+=rinsum;

      gsum+=ginsum;

      bsum+=binsum;


stackpointer=(stackpointer+1)%div;

      sir=stack[stackpointer];


routsum+=sir[0];

      goutsum+=sir[1];

      boutsum+=sir[2];


rinsum-=sir[0];

      ginsum-=sir[1];

      binsum-=sir[2];


yi+=w;

    }

  }


img.updatePixels();

}


同一时候找到一个借鉴这个所改进后成为Java的代码，详细例如以下：

    public static Bitmap doBlur(Bitmap sentBitmap, int radius, boolean canReuseInBitmap) {

        // Stack Blur v1.0 from

        // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html

        //

        // Java Author: Mario Klingemann <mario at quasimondo.com>

        // http://incubator.quasimondo.com

        // created Feburary 29, 2004

        // Android port : Yahel Bouaziz <yahel at kayenko.com>

        // http://www.kayenko.com

        // ported april 5th, 2012


// This is a compromise between Gaussian Blur and Box blur

        // It creates much better looking blurs than Box Blur, but is

        // 7x faster than my Gaussian Blur implementation.

        //

        // I called it Stack Blur because this describes best how this

        // filter works internally: it creates a kind of moving stack

        // of colors whilst scanning through the image. Thereby it

        // just has to add one new block of color to the right side

        // of the stack and remove the leftmost color. The remaining

        // colors on the topmost layer of the stack are either added on

        // or reduced by one, depending on if they are on the right or

        // on the left side of the stack.

        //

        // If you are using this algorithm in your code please add

        // the following line:

        //

        // Stack Blur Algorithm by Mario Klingemann <[email protected]>


Bitmap bitmap;

        if (canReuseInBitmap) {

            bitmap = sentBitmap;

        } else {

            bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);

        }


if (radius < 1) {

            return (null);

        }


int w = bitmap.getWidth();

        int h = bitmap.getHeight();


int[] pix = new int[w * h];

        bitmap.getPixels(pix, 0, w, 0, 0, w, h);


int wm = w - 1;

        int hm = h - 1;

        int wh = w * h;

        int div = radius + radius + 1;


int r[] = new int[wh];

        int g[] = new int[wh];

        int b[] = new int[wh];

        int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;

        int vmin[] = new int[Math.max(w, h)];


int divsum = (div + 1) >> 1;

        divsum *= divsum;

        int dv[] = new int[256 * divsum];

        for (i = 0; i < 256 * divsum; i++) {

            dv[i] = (i / divsum);

        }


yw = yi = 0;


int[][] stack = new int[div][3];

        int stackpointer;

        int stackstart;

        int[] sir;

        int rbs;

        int r1 = radius + 1;

        int routsum, goutsum, boutsum;

        int rinsum, ginsum, binsum;


for (y = 0; y < h; y++) {

            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;

            for (i = -radius; i <= radius; i++) {

                p = pix[yi + Math.min(wm, Math.max(i, 0))];

                sir = stack[i + radius];

                sir[0] = (p & 0xff0000) >> 16;

                sir[1] = (p & 0x00ff00) >> 8;

                sir[2] = (p & 0x0000ff);

                rbs = r1 - Math.abs(i);

                rsum += sir[0] * rbs;

                gsum += sir[1] * rbs;

                bsum += sir[2] * rbs;

                if (i > 0) {

                    rinsum += sir[0];

                    ginsum += sir[1];

                    binsum += sir[2];

                } else {

                    routsum += sir[0];

                    goutsum += sir[1];

                    boutsum += sir[2];

                }

            }

            stackpointer = radius;


for (x = 0; x < w; x++) {


r[yi] = dv[rsum];

                g[yi] = dv[gsum];

                b[yi] = dv[bsum];


rsum -= routsum;

                gsum -= goutsum;

                bsum -= boutsum;


stackstart = stackpointer - radius + div;

                sir = stack[stackstart % div];


routsum -= sir[0];

                goutsum -= sir[1];

                boutsum -= sir[2];


if (y == 0) {

                    vmin[x] = Math.min(x + radius + 1, wm);

                }

                p = pix[yw + vmin[x]];


sir[0] = (p & 0xff0000) >> 16;

                sir[1] = (p & 0x00ff00) >> 8;

                sir[2] = (p & 0x0000ff);


rinsum += sir[0];

                ginsum += sir[1];

                binsum += sir[2];


rsum += rinsum;

                gsum += ginsum;

                bsum += binsum;


stackpointer = (stackpointer + 1) % div;

                sir = stack[(stackpointer) % div];


routsum += sir[0];

                goutsum += sir[1];

                boutsum += sir[2];


rinsum -= sir[0];

                ginsum -= sir[1];

                binsum -= sir[2];


yi++;

            }

            yw += w;

        }

        for (x = 0; x < w; x++) {

            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;

            yp = -radius * w;

            for (i = -radius; i <= radius; i++) {

                yi = Math.max(0, yp) + x;


sir = stack[i + radius];


sir[0] = r[yi];

                sir[1] = g[yi];

                sir[2] = b[yi];


rbs = r1 - Math.abs(i);


rsum += r[yi] * rbs;

                gsum += g[yi] * rbs;

                bsum += b[yi] * rbs;


if (i > 0) {

                    rinsum += sir[0];

                    ginsum += sir[1];

                    binsum += sir[2];

                } else {

                    routsum += sir[0];

                    goutsum += sir[1];

                    boutsum += sir[2];

                }


if (i < hm) {

                    yp += w;

                }

            }

            yi = x;

            stackpointer = radius;

            for (y = 0; y < h; y++) {

                // Preserve alpha channel: ( 0xff000000 & pix[yi] )

                pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];


rsum -= routsum;

                gsum -= goutsum;

                bsum -= boutsum;


stackstart = stackpointer - radius + div;

                sir = stack[stackstart % div];


routsum -= sir[0];

                goutsum -= sir[1];

                boutsum -= sir[2];


if (x == 0) {

                    vmin[y] = Math.min(y + r1, hm) * w;

                }

                p = x + vmin[y];


sir[0] = r[p];

                sir[1] = g[p];

                sir[2] = b[p];


rinsum += sir[0];

                ginsum += sir[1];

                binsum += sir[2];


rsum += rinsum;

                gsum += ginsum;

                bsum += binsum;


stackpointer = (stackpointer + 1) % div;

                sir = stack[stackpointer];


routsum += sir[0];

                goutsum += sir[1];

                boutsum += sir[2];


rinsum -= sir[0];

                ginsum -= sir[1];

                binsum -= sir[2];


yi += w;

            }

        }


bitmap.setPixels(pix, 0, w, 0, 0, w, h);

        return (bitmap);

    }


借鉴于此我弄了一个C的代码，基本上的总体过程都没有变化，仅仅是改变成了C（C++也可已）的而已：

文件名称：ImageBlur.c

/*************************************************

Copyright:  Copyright QIUJUER 2013.

Author:		Qiujuer

Date:		2014-04-18

Description:实现图片模糊处理

**************************************************/

#include<malloc.h>


#define ABS(a) ((a)<(0)?(-a):(a))

#define MAX(a,b) ((a)>(b)?(a):(b))

#define MIN(a,b) ((a)<(b)?(a):(b))


/*************************************************

Function:		StackBlur(堆栈模糊)

Description:    使用堆栈方式进行图片像素模糊处理

Calls:          malloc

Table Accessed: NULL

Table Updated:	NULL

Input:          像素点集合，图片宽，图片高，模糊半径

Output:         返回模糊后的像素点集合

Return:         返回模糊后的像素点集合

Others:         NULL

*************************************************/

static int* StackBlur(int* pix, int w, int h, int radius) {

	int wm = w - 1;

	int hm = h - 1;

	int wh = w * h;

	int div = radius + radius + 1;


int *r = (int *)malloc(wh * sizeof(int));

	int *g = (int *)malloc(wh * sizeof(int));

	int *b = (int *)malloc(wh * sizeof(int));

	int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;


int *vmin = (int *)malloc(MAX(w,h) * sizeof(int));


int divsum = (div + 1) >> 1;

	divsum *= divsum;

	int *dv = (int *)malloc(256 * divsum * sizeof(int));

	for (i = 0; i < 256 * divsum; i++) {

		dv[i] = (i / divsum);

	}


yw = yi = 0;


int(*stack)[3] = (int(*)[3])malloc(div * 3 * sizeof(int));

	int stackpointer;

	int stackstart;

	int *sir;

	int rbs;

	int r1 = radius + 1;

	int routsum, goutsum, boutsum;

	int rinsum, ginsum, binsum;


for (y = 0; y < h; y++) {

		rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;

		for (i = -radius; i <= radius; i++) {

			p = pix[yi + (MIN(wm, MAX(i, 0)))];

			sir = stack[i + radius];

			sir[0] = (p & 0xff0000) >> 16;

			sir[1] = (p & 0x00ff00) >> 8;

			sir[2] = (p & 0x0000ff);


rbs = r1 - ABS(i);

			rsum += sir[0] * rbs;

			gsum += sir[1] * rbs;

			bsum += sir[2] * rbs;

			if (i > 0) {

				rinsum += sir[0];

				ginsum += sir[1];

				binsum += sir[2];

			}

			else {

				routsum += sir[0];

				goutsum += sir[1];

				boutsum += sir[2];

			}

		}

		stackpointer = radius;


for (x = 0; x < w; x++) {


r[yi] = dv[rsum];

			g[yi] = dv[gsum];

			b[yi] = dv[bsum];


rsum -= routsum;

			gsum -= goutsum;

			bsum -= boutsum;


stackstart = stackpointer - radius + div;

			sir = stack[stackstart % div];


routsum -= sir[0];

			goutsum -= sir[1];

			boutsum -= sir[2];


if (y == 0) {

				vmin[x] = MIN(x + radius + 1, wm);

			}

			p = pix[yw + vmin[x]];


sir[0] = (p & 0xff0000) >> 16;

			sir[1] = (p & 0x00ff00) >> 8;

			sir[2] = (p & 0x0000ff);


rinsum += sir[0];

			ginsum += sir[1];

			binsum += sir[2];


rsum += rinsum;

			gsum += ginsum;

			bsum += binsum;


stackpointer = (stackpointer + 1) % div;

			sir = stack[(stackpointer) % div];


routsum += sir[0];

			goutsum += sir[1];

			boutsum += sir[2];


rinsum -= sir[0];

			ginsum -= sir[1];

			binsum -= sir[2];


yi++;

		}

		yw += w;

	}

	for (x = 0; x < w; x++) {

		rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;

		yp = -radius * w;

		for (i = -radius; i <= radius; i++) {

			yi = MAX(0, yp) + x;


sir = stack[i + radius];


sir[0] = r[yi];

			sir[1] = g[yi];

			sir[2] = b[yi];


rbs = r1 - ABS(i);


rsum += r[yi] * rbs;

			gsum += g[yi] * rbs;

			bsum += b[yi] * rbs;


if (i > 0) {

				rinsum += sir[0];

				ginsum += sir[1];

				binsum += sir[2];

			}

			else {

				routsum += sir[0];

				goutsum += sir[1];

				boutsum += sir[2];

			}


if (i < hm) {

				yp += w;

			}

		}

		yi = x;

		stackpointer = radius;

		for (y = 0; y < h; y++) {

			// Preserve alpha channel: ( 0xff000000 & pix[yi] )

			pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];


rsum -= routsum;

			gsum -= goutsum;

			bsum -= boutsum;


stackstart = stackpointer - radius + div;

			sir = stack[stackstart % div];


routsum -= sir[0];

			goutsum -= sir[1];

			boutsum -= sir[2];


if (x == 0) {

				vmin[y] = MIN(y + r1, hm) * w;

			}

			p = x + vmin[y];


sir[0] = r[p];

			sir[1] = g[p];

			sir[2] = b[p];


rinsum += sir[0];

			ginsum += sir[1];

			binsum += sir[2];


rsum += rinsum;

			gsum += ginsum;

			bsum += binsum;


stackpointer = (stackpointer + 1) % div;

			sir = stack[stackpointer];


routsum += sir[0];

			goutsum += sir[1];

			boutsum += sir[2];


rinsum -= sir[0];

			ginsum -= sir[1];

			binsum -= sir[2];


yi += w;

		}

	}


free(r);

	free(g);

	free(b);

	free(vmin);

	free(dv);

	free(stack);

	return(pix);

}
在改为这个的过程中还遇到
了一个非常喜剧的问题，我发现我使用这个来进行调用后结果程序内存一直增大，直到500多M，直接卡死。我知道是我写的有内存泄漏了！

然后找了一下，发现果然是。仅仅好进行free了。然后一下就好了，发现内存占用的确比Java的要少，速度也是要快一些！

在JNI中的实现我使用了两种方案，一种是直接传递文件，一直是传递像素点集合进行模糊！分别例如以下：

/*

 * Class:     com_accumulation_imageblurring_app_jni_ImageBlur

 * Method:    blurIntArray

 * Signature: ([IIII)V

 */

JNIEXPORT void JNICALL Java_com_accumulation_imageblurring_app_jni_ImageBlur_blurIntArray

  (JNIEnv *, jclass, jintArray, jint, jint, jint);


/*

 * Class:     com_accumulation_imageblurring_app_jni_ImageBlur

 * Method:    blurBitMap

 * Signature: (Landroid/graphics/Bitmap;I)V

 */

JNIEXPORT void JNICALL Java_com_accumulation_imageblurring_app_jni_ImageBlur_blurBitMap

  (JNIEnv *, jclass, jobject, jint);


相应的Java调用：

public class ImageBlur {

    public static native void blurIntArray(int[] pImg, int w, int h, int r);


public static native void blurBitMap(Bitmap bitmap, int r);


static {

        System.loadLibrary("JNI_ImageBlur");

    }

}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

此时我做了3种測试，一种是直接在Java层实现，一种是传递像素点集合模糊，还有就是直接传递图片进行模糊，结果例如以下：

通过上面的比較我们能够得出这种结论：

1.Java的确最慢，可是事实上也慢不了多少，虚拟机优化好了一样猛。

2.C中直接传递像素集合的速度最快（第一次启动）

3.在我多次切换界面后发现，直接传递像素点集合的耗时会添加?，从60多到120多。

4.多次切换后发现，事实上直接传递像素点的速度与传递图片过去的速度差点儿一样。

5.多次操作后发现传递文件的波动较小，在100~138之间，其次是传递像素点集合的波动较大，java的波动最大！

以上就是我的结论，可能有些不对，可是在我的机器上的确是这样！

注：勾选选择框“Downscale before
blur”会先压缩图片后模糊然后放大图片，这种情况下，模糊效果会略微损失一些效果，可是其速度确实无法比拟的。

其耗时在：1~10ms内可运算完毕。当然与你要模糊的大小有关系！

最后：项目地址：GitHub

原创作品，转载请注明出处！

QIUJUER([email protected])

时间： 2024-12-12 14:15:53

[Android]-图片JNI（C++\Java）高斯模糊的实现与比較的相关文章

[Android] 图片JNI（C++\Java）高斯模糊 多线程

在我的博客中,曾经发布了一篇高斯模糊(堆栈模糊)的文章:在其中使用了国外的一个堆栈模糊来实现对图片的模糊处理:同时弄了一个JNI C++ 的版本. 这篇文章依然是堆栈模糊:可以说最原始的地方还是堆栈模糊部分:只不过是支持多线程的. 纳尼??感情是之前那个不支持多线程?Sorry,我说错了:两个都是支持多线程调用的.不过新讲的这个是能在内部采用多线程进行分段模糊. 原来的:[Android]-图片JNI(C++\Java)高斯模糊的实现与比较 开工吧 说明:其中代码大部分来源于网络,不过都是开源的

Android与JNI(二) ---- Java调用C 动态调用(转载)

目录: 1. 简介 2. JNI 组件的入口函数 3. 使用 registerNativeMethods 方法 4. 测试 5. JNI 帮助方法 6. 参考资料 1. 简介 目录: 1. 简介 2. JNI 组件的入口函数 3. 使用 registerNativeMethods 方法 4. 测试 5. JNI 帮助方法 6. 参考资料 1. 简介 Android与JNI(一)已经简单介绍了如何在 android  环境下使用 JNI 了.但是遵循 JNI 开发的基本步骤似乎有点死板,而且得到的

【我的Android进阶之旅】Android调用JNI出错 java.lang.UnsatisfiedLinkError: No implementation found for的解决方法

错误描述 今天使用第三方的so库时候,调用JNI方法时出现了错误.报错如下所示: 11-01 16:39:20.979 4669-4669/com.netease.xtc.cloudmusic E/art: No implementation found for void com.netease.xtc.cloudmusic.utils.NeteaseMusicUtils.nativeInit(android.content.Context) (tried Java_com_netease_xt

Android使用JNI实现Java与C之间传递数据（转）

介绍Java如何将数据传递给C和C回调Java的方法.  java传递数据给C,在C代码中进行处理数据,处理完数据后返回给java.C的回调是Java传递数据给C,C需要用到Java中的某个方法,就需要调用java的方法. Android中使用JNI七个步骤: 1.创建一个android工程 2.JAVA代码中写声明native 方法 public native String helloFromJNI(); 3.用javah工具生成头文件 4. 创建jni目录,引入头文件,根据头文件实现c代码

coco2dx jni 调用 java 相机返回 图片数据

新建 一个项目 名字:testJin  包名:com.TanSon.org  python命令:python create_project.py -project testJin -package com.TanSon.org -language cpp eclipse 导入项目配置 ... 略去,(可以google) 1 c++ 调用 andriod 1.1 包含头文件 #if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) #include <jni.

Android使用JNI（从java调用本地函数）

当编写一个混合有本地C代码和Java的应用程序时,需要使用Java本地接口(JNI)作为连接桥梁.JNI作为一个软件层和API,允许使用本地代码调用Java对象的方法,同时也允许在Java方法中调用本地函数. 在Java端,开发者所需要做的仅仅是在连接本地函数的方法之前加上native关键字.这样VM就会去寻找这个本地函数. 1.从Java调用本地函数 从Java调用本地函数时,需要在类中定义一个带有native关键字的特有方法,作为连接本地代码的桥梁.通过这个定义,尝试调用本地方法时JVM会找

Android JNI之JAVA与C++对象建立对称关联（JNI优化设计，确保JNI调用的稳定性）

转载请声明:原文转自:http://www.cnblogs.com/xiezie/p/5930503.html Android JNI之JAVA与C++对象建立对称关联 1.JAVA对象持有C++对象的指针 在JAVA类中创建一个int类型的变量(如int mObj),用于储存C++对象的指针 在创建C++对象(如MyCPlusObj)的本地方法中,将C++对象的指针存入JAVA变量中(mObj) JNIEXPORT void JNICALL Java_nativeMethod (JNIEnv

Android NDK开发之Jni调用Java对象

https://my.oschina.net/zhiweiofli/blog/114064 通过使用合适的JNI函数,你可以创建Java对象,get.set 静态(static)和 实例(instance)的域,调用静态(static)和实例(instance)函数.JNI通过ID识别域和方法,一个域或方法的ID是任何处理域和方法的函数的必须参数.下表列出了用以得到静态(static)和实例(instance)的域与方法的JNI函数.每个函数接受(作为参数)域或方法的类,它们的名称,符号和它们对

Android开发实践：Java层与Jni层的数组传递

Android开发中,经常会在Java代码与Jni层之间传递数组(byte[]),一个典型的应用是Java层把需要发送给客户端的数据流传递到Jni层,由Jni层的Socket代码发送出去,当然,Jni层也需要把从Socket接收到的数据流返回给Java层.我简单地总结了一下,从Java层到Jni层,从Jni层到JAVA层,各有3种传递方式,下面用代码示例简单地介绍一下. 示例代码的主要文件有两个,一个是Native.java,是Java层的类:另一个是Native.c,是JNI层的文件,关键的地