android mmap的使用，2021年展望Android原生开发的现状

static shared_use_st *use_st = NULL;

static jint throwException(JNIEnv* env, jobject clazz, const char *clsname, const char *msg)

{

jclass cls;

cls = ( *env)->FindClass(env, clsname);

if(cls == NULL){

return -1;

}

(*env)->ThrowNew(env,cls, msg);

return -1;

}

static jint openMem(JNIEnv* env, jobject clazz, jstring name, jint length)

{

shared_use_st *st = NULL;

const char* namestr = (name ? (*env)->GetStringUTFChars(env,name, NULL) : NULL);

int result = -1;

if(access(namestr, F_OK) == 0)

{

result = open(namestr, O_RDWR);

}

else

{

result = open(namestr, O_RDWR|O_CREAT);

if(result >= 0)

{

st = (shared_use_st *)malloc(sizeof(shared_use_st));

if(st == NULL)

{

LOGE(“open malloc failed”);

}

if(write(result, st, sizeof(shared_use_st)) < 0)

{

LOGE(“open write failed”);

}

free(st);

}

}

(*env)->ReleaseStringUTFChars(env, name, namestr);

return result;

}

static jint getMem(JNIEnv* env, jobject clazz,int fd)

{

struct stat sb;

int result = -1;

if(fd >= 0)

{

if((fstat(fd, &sb)) == -1)

{

LOGE(“readMem size failed”);

return result;

}

if((use_st = (shared_use_st *)mmap(NULL, sb.st_size,

PROT_READ|PROT_WRITE, MAP_SHARED,

fd, 0)) == (void *)-1)

{

LOGE(“readMem mmap failed”);

return result;

}

result = (jint)use_st->text;

LOGE(“memory address:%0x”, result);

}

return result;

}

static jint writeMem(JNIEnv* env, jobject clazz, int fd, jbyteArray buffer, int size, jint address)

{

int ret = 0;

if(use_st != NULL && address == (int)use_st->text)

{

(*env)->GetByteArrayRegion(env, buffer, 0, size, (jbyte *)address);

ret = size;

}

return ret;

}

static jbyteArray readMem(JNIEnv* env, jobject clazz, int fd, int address)

{

if(fd >= 0)

{

if(use_st != NULL)

{

jbyteArray array = (*env)->NewByteArray(env, TEXT_SZ);

(*env)->SetByteArrayRegion(env, array, 0, TEXT_SZ, (char *)address);

return array;

}

}

return NULL;

}

static void setModeMem(JNIEnv* env, jobject clazz, int mode)

{

if(use_st != NULL)

{

use_st->written = mode;

}

}

static int getModeMem(JNIEnv* env, jobject clazz)

{

int nRet = -1;

if(use_st != NULL)

{

nRet = use_st->written;

}

return nRet;

}

static void closeMem(JNIEnv* env, jobject clazz, int fd)

{

close(fd);

if(use_st != NULL)

{

if ((munmap((void *)use_st,

sizeof(shared_use_st))) == -1)

{

LOGE(“munmap failed”);

}

}

}

static jboolean flushMem(JNIEnv* env, jobject clazz)

{

jboolean isFailed = 1;

if(use_st != NULL)

{

if ((msync((void *)use_st, sizeof(shared_use_st), MS_SYNC)) == -1) {

LOGE(“msync failed”);

}

else

{

isFailed = 0;

}

}

return !isFailed;

}

static JNINativeMethod mehods[] = {

{ “open”, “(Ljava/lang/String;I)I”,

(void *) openMem },

{ “read”, “(II)[B”,

(void *) readMem },

{ “write”, “(I[BII)I”,

(void *) writeMem },

{ “get”, “(I)I”,

(void *) getMem },

{ “setMode”, “(I)V”,

(void *) setModeMem },

{ “getMode”, “()I”,

(void *) getModeMem },

{ “flush”, “()Z”,

(void *) flushMem },

{ “close”, “(I)V”,

(void *) closeMem }

};

static int registerNativeMethods(JNIEnv env, const char className,

const JNINativeMethod* methods, int numMethods)

{

int rc;

jclass clazz;

clazz = (*env)->FindClass(env, className);

if (clazz == NULL) {

LOGE(“Native registration unable to find class ‘%s’\n”, className);

return -1;

}

if (rc = ((*env)->RegisterNatives(env, clazz, methods, numMethods)) < 0) {

LOGE(“RegisterNatives failed for ‘%s’ %d\n”, className, rc);

return -1;

}

return 0;

}

static int register_jni(JNIEnv *env)

{

return registerNativeMethods(env, CLASS_NAME, mehods, NELEM(mehods));

}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)

{

JNIEnv* env = NULL;

jint result = -1;

//获取JNI版本

if ((vm)->GetEnv(vm, (void*)&env, JNI_VERSION_1_4) != JNI_OK)

{

LOGE(“GetEnv failed!”);

return result;

}

InitHelp(env, NULL);

if (register_jni(env) < 0)

{

LOGE(“register method failed!”);

return result;

}

return JNI_VERSION_1_4;

}

com.sailor.ShareMem.java:

package com.sailor;

public class ShareMem {

static {

// 加载动态库

System.loadLibrary(“JNIShm”);

}

public native int open(String path, int length);

public native void close(int fd);

public native int get(int fd);

public native byte[] read(int fd, int address);

public native int write(int fd, byte[] buffer, int size, int address);

public native boolean flush();

public native void setMode(int mode);

public native int getMode();

}

android1 app:

public void startMem3(View view){

mem = new ShareMem();

int fd = mem.open(Environment.getExternalStorageDirectory().getAbsolutePath()+"/test.txt",0);

Log.d(“jacklam”, “startMem fd:” + fd);

int address = mem.get(fd);

Log.d(“jacklam”, “startMem address:” + address);

boolean isFlush = mem.flush();

Log.d(“jacklam”, “flush buffer:” + isFlush);

mem.close(fd);

}

public void startMem2(View view){

mem = new ShareMem();

int fd = mem.open(Environment.getExternalStorageDirectory().getAbsolutePath()+"/test.txt",0);

Log.d(“jacklam”, “startMem fd:” + fd);

int address = mem.get(fd);

Log.d(“jacklam”, “startMem address:” + address);

byte[] buffer = mem.read(fd, address);

Log.d(“jacklam”, “read buffer:” + new String(buffer));

/mem.close(fd);/

}

public void startMem1(View view){

mem = new ShareMem();

int fd = mem.open(Environment.getExternalStorageDirectory().getAbsolutePath()+"/test.txt",0);

Log.d(“jacklam”, “startMem fd:” + fd);

int address = mem.get(fd);

Log.d(“jacklam”, “startMem address:” + address);

byte[] buffer = {‘I’,‘I’,‘t’};

mem.write(fd, buffer, buffer.length, address);

/mem.close(fd);/

}

android app2:

public void startMem3(View view){

mem = new ShareMem();

int fd = mem.open(Environment.getExternalStorageDirectory().getAbsolutePath()+

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

“/test.txt”,0);

Log.d(“jacklam”, “startMem fd:” + fd);

int address = mem.get(fd);

Log.d(“jacklam”, “startMem address:” + address);

boolean isFlush = mem.flush();

Log.d(“jacklam”, “flush buffer:” + isFlush);

mem.close(fd);