EncryptAndDecrypt , 文件加密解密与分割合并
接续上篇NDK开发基础①使用Android Studio编写NDK
随着Android Studio的越来越完善 ， 我们编写NDK就会越来越方便，使用Android Studio 2.2 RC2 ， 编写NDK的时候 ， 不需要使用javah命令来生成头文件 ， 创建一个native方法 ， 使用alt + enter会提示要你创建一个JNI函数 ， C/C++语法提示也相对比较完善了， 减少了一些重复代码的编写，相信使用Android Studio 2.2编写NDK， 不会让你失望 。
###Part 1 ， -- 文件的加密解密 在C语言基础系列第八章文件IO，介绍了文件的加密解密 ， 开发工具使用的是VS ， 在上篇NDK开发基础①使用Android Studio编写NDK简单介绍了Android Studio来搭建NDK开发环境，今天我们使用Android Studio来玩一把 。
界面 与Project目录结构
就几个按钮 ， 布局文件就不贴代码了 ， 读者也可以整个输入框，可以输入加密的密码 。
从目录上可以看出ndk包下面的 ， 就是一个native方法的类， cpp目录下的就是JNI C文件 ， CMakeLists.txt配置我们的编译流程，以及生成库与添加库的配置。
Java native code
/**
* 带密码的文件加密
* @param normalFilePath 要加密的文件路径
* @param encryptFilePath 加密之后的文件路径
* @param password 加密密码
*/
public static native void fileEncrypt(String normalFilePath,String encryptFilePath,String password) ;
/**
* 带密码的文件解密
* @param encryptFilePath 要解密的文件路径
* @param encryptFilePath 解密之后的文件路径
* @param password 加密密码
*/
public static native void fileDecrypt(String encryptFilePath,String decryptFilePath,String password) ;简要提示：文件的加密解密 ， 实质上在复制文件的时候进行^运算，在计算机中 ， 所有的文件都是以二进制存储的 ， 所有可以进行运算来进行文件的加密解密 ， 当然 ， 密码的算法是可逆的 ， 也就是可解密的 。
use java native code
// SD_CARD 根路径
private static final String SD_CARD_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() ;
/*文件加密*/
private void fileEncrypt() {
String normalFilePath = SD_CARD_PATH+ File.separatorChar+"neck.jpg" ;
String encryptFilePath = SD_CARD_PATH+File.separatorChar+"neck_encrypt.jpg" ;
Log.e(TAG, "fileEncrypt: normalFilePath = "+ normalFilePath + " encryptFilePath = "+encryptFilePath);
try{
HelloNDK.fileEncrypt(normalFilePath,encryptFilePath,"xj");
}catch (Exception e) {
e.printStackTrace();
}
}
/*文件解密*/
private void fileDecrypt() {
String encryptFilePath = SD_CARD_PATH+File.separatorChar+"neck_encrypt.jpg" ;
String decryptFilePath = SD_CARD_PATH+File.separatorChar+"neck_decrypt.jpg" ;
try{
HelloNDK.fileDecrypt(encryptFilePath,decryptFilePath,"xj");
}catch (Exception e) {
e.printStackTrace();
}
}文件加密解密实现
/*加密文件*/
JNIEXPORT void JNICALL
Java_com_zeno_encryptanddecrypt_ndk_HelloNDK_fileEncrypt(JNIEnv *env, jclass type,
jstring normalFilePath_,
jstring encryptFilePath_,
jstring password_) {
const char *normalFilePath = (*env)->GetStringUTFChars(env, normalFilePath_, 0);
const char *encryptFilePath = (*env)->GetStringUTFChars(env, encryptFilePath_, 0);
const char *password = (*env)->GetStringUTFChars(env, password_, 0);
int passwordLen = strlen(password);
LOGE("MainActivity","path1 == %s , path2 == %s",normalFilePath , encryptFilePath) ;
// 读文件指针
FILE* frp = fopen(normalFilePath,"rb") ;
// 写文件指针
FILE* fwp = fopen(encryptFilePath,"wb") ;
if(frp == NULL) {
LOGE("MainActivity","%s","文件不存在") ;
return;
}
if(fwp == NULL) {
LOGE("MainActivity","%s","没有写权限") ;
}
// 边读边写边加密
int buffer ;
int index = 0 ;
while((buffer = fgetc(frp)) != EOF) {
// write
fputc(buffer ^ *(password+(index % passwordLen)),fwp) ;
index++ ;
}
// 关闭文件流
fclose(fwp);
fclose(frp);
LOGE("MainActivity","%s","文件加密成功") ;
(*env)->ReleaseStringUTFChars(env, normalFilePath_, normalFilePath);
(*env)->ReleaseStringUTFChars(env, encryptFilePath_, encryptFilePath);
(*env)->ReleaseStringUTFChars(env, password_, password);
}简要提示：加密解密算法，在C语言：文件IO里面就介绍了 ， 这里就不加赘述了，加密与解密共用的是一套算法， 解密的就不贴代码了 。在使用*password指针的时候需要注意，password+1可以得到下一个字符，但是password+0的时候不会得到第一个字符，会输出整个字符指针，所有在使用字符指针的时候一个一个取字符 ， 需要使用*(password+0) ,*(password+1) 取第一个第二字符 。如果您对C语言以及JNI开发都不了解的话 ， 可以关注的我的专题Android NDK开发之旅
__使用场景：__大文件上传 ， 如视频文件 ， 进行文件拆分 ， 分批上传 。
Java native code
/**
* 文件分割
* @param splitFilePath 要分割文件的路径
* @param suffix 分割文件拓展名
* @param fileNum 分割文件的数量
*/
public static native void fileSplit(String splitFilePath,String suffix,int fileNum);
/**
* 文件合并
* @param splitFilePath 分割文件的路径
* @param splitSuffix 分割文件拓展名
* @param mergeSuffix 合并文件的拓展名
* @param fileNum 分割文件的数量
*/
public static native void fileMerge(String splitFilePath,String splitSuffix,String mergeSuffix,int fileNum);use java native code
/*分割文件*/
private void fileSplit() {
String splitFilePath = SD_CARD_PATH+File.separatorChar+"neck.jpg" ;
String suffix = ".b";
try{
HelloNDK.fileSplit(splitFilePath,suffix,3);
}catch (Exception e) {
e.printStackTrace();
}
}
/*文件合并*/
private void fileMerge() {
String splitFilePath = SD_CARD_PATH+File.separatorChar+"neck.jpg" ;
String splitSuffix = ".b";
String mergeSuffix = ".jpeg";
try{
HelloNDK.fileMerge(splitFilePath,splitSuffix,mergeSuffix,3);
}catch (Exception e) {
e.printStackTrace();
}
}文件分割实现
算法分析图：
伪代码：
// 平均分配文件大小
if(fileSize % fileNum) {
int i= 0 ;
for(; i < fileNum ; i++) {
// 创建分割文件
int j= 0 ;
for(;j < partFileSize ; j++) {
// 读写数据
}
}
}
// 不可平均分配大小
else {
// 前面的文件平分文件大小 ， 将剩下的大小全部给最后一个文件
if(fileSize % (fileNum-1)){
int i= 0 ;
for(; i < (fileNum-1) ; i++) {
// 创建分割文件
int j= 0 ;
for(;j < partFileSize ; j++) {
// 读写数据
}
}
}else {
// 将剩余大小fileSize % (fileNum-1)写入到最后一个文件中
int j = 0 ;
for(;j < fileSize % (fileNum-1)){
// 读写数据
}
}
}
文件分割算法就分析到这里 ， 下面我们来看看具体的实现：
java native code
/*分割文件*/
private void fileSplit() {
String splitFilePath = SD_CARD_PATH+File.separatorChar+"neck.jpg" ;
String suffix = ".b";
try{
HelloNDK.fileSplit(splitFilePath,suffix,3);
}catch (Exception e) {
e.printStackTrace();
}
}
/*文件合并*/
private void fileMerge() {
String splitFilePath = SD_CARD_PATH+File.separatorChar+"neck.jpg" ;
String splitSuffix = ".b";
String mergeSuffix = ".jpeg";
try{
HelloNDK.fileMerge(splitFilePath,splitSuffix,mergeSuffix,3);
}catch (Exception e) {
e.printStackTrace();
}
}具体实现：
/*文件分割*/
JNIEXPORT void JNICALL
Java_com_zeno_encryptanddecrypt_ndk_HelloNDK_fileSplit(JNIEnv *env, jclass type,
jstring splitFilePath_,
jstring suffix_,
jint fileNum) {
const char *splitFilePath = (*env)->GetStringUTFChars(env, splitFilePath_, 0);
const char *suffix = (*env)->GetStringUTFChars(env, suffix_, 0);
// 要分割文件 ， 首先要得到分割文件的路径列表 ,申请动态内存存储路径列表
char** split_path_list = (char**)malloc(sizeof(char*) * fileNum);
// 得到文件大小
long file_size = getFileSize(splitFilePath);
// 得到路径字符长度
int file_path_str_len = strlen(splitFilePath);
// 组合路径
char file_path[file_path_str_len + 5] ;
strcpy(file_path,splitFilePath);
strtok(file_path,".");
strcat(file_path,"_%d");
strcat(file_path,suffix);
int i=0 ;
for (; i < fileNum; ++i) {
// 申请单个文件的路径动态内存存储
split_path_list[i] = (char*)malloc(sizeof(char) * 128);
// 组合分割的单个文件路径
sprintf(split_path_list[i],file_path,(i+1)) ;
LOGE("MainActivity","%s",split_path_list[i]);
}
LOGE("MainActivity","文件大小 == %ld",file_size);
LOGE("MainActivity","文件路径 == %s",splitFilePath);
// 读文件
FILE* fp = fopen(splitFilePath,"rb");
if(fp == NULL) {
LOGE("MainActivity","%s","文件不存在，或文件不可读");
return;
}
// 整除 ， 说明各个文件划分大小一致
if (file_size % fileNum) {
// 单个文件大小
int part_file_size = file_size/fileNum ;
LOGE("MainActivity","单个文件大小 == %d",part_file_size);
int i = 0 ;
// 分割多少个文件就分段读多少次
for (; i < fileNum; i++) {
// 写文件
FILE* fwp = fopen(split_path_list[i],"wb");
if(fwp == NULL) {
LOGE("MainActivity","%s","没有文件写入权限");
return;
}
int j = 0 ;
// 单个文件有多大 ， 就读写多少次
for (; j < part_file_size; j++) {
// 边读边写
fputc(fgetc(fp),fwp) ;
}
// 关闭文件流
fclose(fwp);
}
}
/*文件大小不整除*/
else{
// 不整除
int part_file_size = file_size / (fileNum -1 ) ;
LOGE("MainActivity","单个文件大小 == %d",part_file_size);
int i = 0 ;
for (; i < (fileNum - 1); i++) {
// 写文件
FILE* fwp = fopen(split_path_list[i],"wb");
if(fwp == NULL) {
LOGE("MainActivity","%s","没有文件写入权限") ;
return;
}
int j = 0 ;
for (; j < part_file_size; j++) {
// 边读边写
fputc(fgetc(fp),fwp);
}
// 关闭流
fclose(fwp);
}
// 剩余部分
FILE* last_fwp = fopen(split_path_list[fileNum - 1],"wb") ;
i= 0 ;
for (; i < file_size % (fileNum -1); i++) {
fputc(fgetc(fp),last_fwp) ;
}
// 关闭流
fclose(last_fwp);
}
// 关闭文件流
fclose(fp);
// 释放动态内存
i= 0 ;
for (; i < fileNum ; i++) {
free(split_path_list[i]) ;
}
free(split_path_list);
(*env)->ReleaseStringUTFChars(env, splitFilePath_, splitFilePath);
(*env)->ReleaseStringUTFChars(env, suffix_, suffix);
}简要提示：组合路径的时候，使用了strtok来进行文件路径的分割，将.jpg去掉，用strcat拼接了_%d，最后拼接了传入的文件拓展名，这样设计是为了让分割的文件 ， 不那么见名知意 。
LOGE定义的一个预处理函数，在C语言基础系列C语言基础及指针⑩预编译及jni.h分析有着详细说明。
#define LOGE(TAG,FORMAT,...) __android_log_print(ANDROID_LOG_ERROR,TAG,FORMAT,__VA_ARGS__)文件合并
文件的分割 ， 是件一个文件分割成多个子文件 。文件的合并 ， 则是将多个子文件合并成一个文件 。
算法分析图：
具体实现
/*合并文件*/
JNIEXPORT void JNICALL
Java_com_zeno_encryptanddecrypt_ndk_HelloNDK_fileMerge(JNIEnv *env, jclass type,
jstring splitFilePath_,
jstring splitSuffix_,
jstring mergeSuffix_, jint fileNum) {
const char *splitFilePath = (*env)->GetStringUTFChars(env, splitFilePath_, 0);
const char *splitSuffix = (*env)->GetStringUTFChars(env, splitSuffix_, 0);
const char *mergeSuffix = (*env)->GetStringUTFChars(env, mergeSuffix_, 0);
// 1. 申请split文件路径列表动态内存
char** split_path_list = (char**)malloc(sizeof(char*) * fileNum) ;
// 2. 组装split文件路径
int split_file_path_len = strlen(splitFilePath) ;
int split_file_path_suffix_len = strlen(splitSuffix);
char split_file_path[split_file_path_len + split_file_path_suffix_len] ;
strcpy(split_file_path,splitFilePath);
strtok(split_file_path,".");
strcat(split_file_path,"_%d");
strcat(split_file_path,splitSuffix);
// 3. 组装merge文件路径
int merge_file_path_len = strlen(mergeSuffix);
char merge_file_path[split_file_path_len + merge_file_path_len] ;
strcpy(merge_file_path,splitFilePath);
strtok(merge_file_path,".");
strcat(merge_file_path,mergeSuffix);
LOGE("MainActivity","merge 文件路径 = %s",merge_file_path) ;
// 4. 循环得到split文件路径列表
int file_path_str_len = strlen(split_file_path);
int i= 0;
for (; i < fileNum; i++) {
split_path_list[i] = (char*)malloc(sizeof(char) * file_path_str_len) ;
sprintf(split_path_list[i],split_file_path,(i+1)) ;
LOGE("MainActivity","split文件路径列表 = %s",split_path_list[i]) ;
}
// 5. 创建并打开 merge file
FILE* merge_fwp = fopen(merge_file_path,"wb") ;
// 6. 边读边写 ， 读多个文件，写入一个文件
i = 0 ;
for (; i < fileNum ; i++) {
FILE* split_frp = fopen(split_path_list[i],"rb") ;
if(split_frp == NULL) {
LOGE("MainActivity","%s","文件不存在，或没有读文件权限");
return;
}
long part_split_file_size = getFileSize(split_path_list[i]);
int j = 0 ;
for (; j < part_split_file_size; j++) {
fputc(fgetc(split_frp),merge_fwp);
}
// 关闭流
fclose(split_frp) ;
// 每合并一个文件 ，就删除它
remove(split_path_list[i]) ;
}
// 关闭文件流
fclose(merge_fwp);
// 释放动态内存
i = 0 ;
for (; i < fileNum; i++) {
free(split_path_list[i]) ;
}
free(split_path_list);
LOGE("MainActivity","%s","文件合并完成") ;
(*env)->ReleaseStringUTFChars(env, splitFilePath_, splitFilePath);
(*env)->ReleaseStringUTFChars(env, splitSuffix_, splitSuffix);
(*env)->ReleaseStringUTFChars(env, mergeSuffix_, mergeSuffix);
}简要提示：在编写文件分割与合并的时候 ， 文件的路径千万不要弄混了，笔者有有时候也会因为变量的提示没细看 ， 而将分割的子文件路径与目标文件路径弄混 ，在命名的时候 ， 尽量规范 ， 见名知意 。在发生错误的时候 ， 一步一步的调试 ， 首先猜测哪里发生异常的可能性比较大 ， 再进行log输出查看 。
文件的加密解密 ， 可以引申为对数据的加密解密 ， 可以使用C/C++进行加密解密， 这样对反编译APK增加了难度 ， 也多了一层防范 ， 因为java实在是太容易反编译了， 即使不反编译成java代码， 通过smail文件也可以看个大概 ， 还是很危险的 。
文件的分割与合并 ， 对文件数据传输有很大益处 。
如果想了解更多关于Android NDK的知识 ， 欢迎关注我的专题Android NDK 开发之旅 ， 从零开始 ， 带你一步一步进入NDK开发的世界 。