// C++ 的标准输入，输出头文件
#include<iostream>

// 标准命名空间
// 当引入该命名空间后，我们就可以直接调用其中的函数，省略掉前缀
using namespace std;

// 命名空间类似于Java中的包，通过命名空间，允许我们在不同的命名空间中，定义同名
// 的变量和函数
// 命名空间可以用来归类同一种类型的函数和变量；
// Java中的包允许有别的包，同样命名空间中也允许别的命名空间
namespace NSP_A{
	int a = 9;

	namespace NSP_AA{
		int a = 100;
	}
}
namespace NSP_B{
	int a = 8;

	// 定义结构体
	struct Human{
		char* name;
	};
}

int main(){

	// C++下的标准输入输出
	// 其中，std是标准输入输出的命名空间；
	// cout是其中定义的函数
	// << 则是该命名空间中重载的输出操作符
	//std::cout << "this is C plus plus!" << std::endl;
	// :: 访问修饰符，相当于Java中的.
	cout << "no namespace C plus plus!" << endl;

	// 命名空间使用
	cout << NSP_A::a << endl;
	cout << NSP_A::NSP_AA::a << endl;

	// 使用命名空间中的结构体
	NSP_B::Human h = {"Adam"};

	using namespace NSP_B;
	// C++中，结构体允许省略前面的struct
	struct Human human = { "Lili" };
	Human human = {"Lili"};

	system("pause");
}

class Err{
public:
	// 定义一个范畴内的多种异常
	class MyException2{
	public:
		MyException2(){}
	};
};

void myThrow4(){
	// 抛出内部类异常
	// 这种写法不一定是命名空间，C++中也是有内部类的
	throw Err::MyException2();
}

暂时只需要bsdiff.cpp，用来拆分新包，bspatch.cpp不可以引入；
bspatch是用来合并包文件的，需要引入bzip2的源码来辅助操作，如果引入将会报错！！！

由于项目中可能使用了老版本、非安全版本的函数，所以编译时将会报错，解决方案是继续使用这些
函数。

另一个问题是，如果存在多个这种情况的源文件时，可以通过在命令行中输入：
-D _CRT_SECURE_NO_WARNINGS

原因与上面类似，可以通过增加宏定义来消除警告:_CRT_NONSTDC_NO_DEPRECATE

由于源码使用了不同系统的编译器，而visual studio默认对语法进行了严格的检查，所以会出现以上的警告，解决方案是关闭掉vs的检查；

// 将main函数修改为bsdiff_main，方便我们的jni函数调用
int bsdiff_main(int argc,char *argv[]){
  //...

  // 可以看到，此处要求我们传入四个参数
  // 参数1：任意
  // 参数2：旧apk文件的路径
  // 参数3：新apk文件的路径
  // 参数4：拆分出来的文件保存路径
  if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);

}

JNIEXPORT void JNICALL Java_com_hsh_bsdiff_BsdiffUtill_diff_1apk
(JNIEnv *env, jclass jcls, jstring fileName_, jstring oldFile_, jstring newFile_, jstring patchFile_){

	char* fileName = (char*)env->GetStringUTFChars(fileName_, 0);
	char* oldFile = (char*)env->GetStringUTFChars(oldFile_, 0);
	char* newFile = (char*)env->GetStringUTFChars(newFile_, 0);
	char* patchFile = (char*)env->GetStringUTFChars(patchFile_, 0);


	char *args[] = { fileName, oldFile, newFile, patchFile};

	bsdiff_main(4, args);

	env->ReleaseStringUTFChars(fileName_, fileName);
	env->ReleaseStringUTFChars(oldFile_, oldFile);
	env->ReleaseStringUTFChars(newFile_, newFile);
	env->ReleaseStringUTFChars(patchFile_, patchFile);
}

public class BsdiffUtill {

	static{
		System.loadLibrary("jni/patch_dispatch_apk");
	}

	/**
	 *
	 * @param name
	 * @param oldFile
	 * @param newFile
	 * @param patchFile
	 */
	public native static void diff_apk(String name,String oldFile,String newFile,String patchFile);
}


public class Bsdiff {

	public static void main(String[] args) {
		BsdiffUtill.diff_apk("apk_patch", "H:\\bsdiff_patch\\app_1.0version.apk",
				"H:\\bsdiff_patch\\app_2.0version.apk", "H:\\bsdiff_patch\\app_patch.patch");
	}
}

// 本源文件只要求引入该头文件
#include "bzip2/bzlib.c"

// 但实际编译时，缺报bzlib.c缺少对应的引用函数(BZ2_crc32Table,BZ2_compressBlock,BZ2_crc32Table...)，
// 大概猜测原因是：在配置CMakeLists时，只配置了bspatch.c文件，而bzip2源文件并没有配置，所以这些文件没有
// 被项目管理起来。在bzlib.c中，头文件bzlib_private.h声明的函数无法被项目知道，所以在bzlib.c进行调用时，
// 才会报出找不到这些函数的错误。解决方案就是引入底下的源文件，不再通过bzlib_private.h找，而是直接引用；
#include "bzip2/crctable.c"
#include "bzip2/compress.c"
#include "bzip2/decompress.c"
#include "bzip2/randtable.c"
#include "bzip2/blocksort.c"
#include "bzip2/huffman.c"

JNIEXPORT void JNICALL
Java_com_hsh_bsdiff_1patch_PatchUtil_patchFile(JNIEnv *env, jclass type, jstring oldFile_,
                                               jstring newFile_, jstring patchFile_) {
    char *oldFile = (char *) (*env)->GetStringUTFChars(env, oldFile_, 0);
    char *newFile = (char *) (*env)->GetStringUTFChars(env, newFile_, 0);
    char *patchFile = (char *) (*env)->GetStringUTFChars(env, patchFile_, 0);

    char *fileName = "apk_patch";

    char *params[] = {fileName, oldFile, newFile, patchFile};
    // 将源文件的main函数直接修改为patch_main，进行调用
    patch_main(4,params);

    __android_log_print(ANDROID_LOG_INFO, "PatchFile", "oldFile = %s", oldFile);
    __android_log_print(ANDROID_LOG_INFO, "PatchFile", "newFile = %s", newFile);
    __android_log_print(ANDROID_LOG_INFO, "PatchFile", "patchFile = %s", patchFile);

    (*env)->ReleaseStringUTFChars(env, oldFile_, oldFile);
    (*env)->ReleaseStringUTFChars(env, newFile_, newFile);
    (*env)->ReleaseStringUTFChars(env, patchFile_, patchFile);
}

public class PatchUtil {

    static{
        System.loadLibrary("native-lib");
    }

    public native static void patchFile(String oldFile,String newFile,String patchFile);
}

// 获得应用包下保存的当前版本的apk
final String apkPath = getApplicationContext().getPackageResourcePath();

new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            PatchUtil.patchFile(apkPath, newPath, patch_path);
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(MainActivity.this, "success", Toast.LENGTH_LONG).show();
                    // 7.0以上需要配置FileProvider才能安装
                    ApkUtils.installApk(MainActivity.this, newPath);
                }
            });
        } catch (Error error) {
            error.printStackTrace();
        }
    }
}).start();

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "jni.h"

// 缓存策略

JNIEXPORT void JNICALL Java_com_my_jnitest_JniTest_cached
(JNIEnv * env, jobject obj){
	jclass cls = (*env)->GetObjectClass(env, obj);

	// 静态局部变量
	// 作用域存在于本函数
	// 生命周期为应用生命周期
	// 全局的其他地方无法使用到
	static jfieldID key_id = NULL;
	// 只在函数被第一次调用时进行初始化
	if (key_id == NULL){
		key_id = (*env)->GetFieldID(env, cls, "key", "Ljava/lang/String;");
		printf("init key id;");
	}
}

public native void cached();

 for (int i = 0; i < 5; i++) {
   test.cached();
 }

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "jni.h"

// 初始化全局变量
// 在初始化动态库之后，调用该方法，进行全局变量的初始化，并且能够确保只调用一次。
jmethodID method_id;
jfieldID fid;
JNIEXPORT void JNICALL Java_com_my_jnitest_JniTest_initIds
(JNIEnv * env, jclass jcls){
	method_id = (*env)->GetMethodID(env, jcls, "randomInt", "()I");
	fid = (*env)->GetFieldID(env, jcls, "key", "Ljava/lang/String;");
	printf("first init!");
}

static {
  System.out.println( System.getProperty("java.library.path"));
  System.loadLibrary("jni/jini_04");
  // 加载完成动态库之后，立刻调用初始化方法，初始化全局变量
  initIds();
}

JNIEXPORT void JNICALL Java_com_my_jnitest_JniTest_catchException
(JNIEnv * env, jobject jobj){
	jclass cls = (*env)->GetObjectClass(env, jobj);
	jfieldID fid = (*env)->GetFieldID(env, cls, "key2", "Ljava/lang/String;");

	// 捕获Jni异常
	jthrowable exc = (*env)->ExceptionOccurred(env);
	if (exc != NULL){
		// 清空异常，确保Java层能够运行
		(*env)->ExceptionClear(env);

		// 重新获取
		fid = (*env)->GetFieldID(env, cls, "key", "Ljava/lang/String;");

		jstring str = (*env)->GetObjectField(env, jobj, fid);
		char* c_str = (*env)->GetStringUTFChars(env, str, NULL);

		// 抛出Java层能够捕获的异常
		if (_stricmp(c_str, "hsh") != 0){
			jclass new_exc = (*env)->FindClass(env, "java/lang/IllegalArgumentException");
			(*env)->ThrowNew(env, new_exc, "key's value is invalid!");
		}
	}
}

try {
  // Jni层次的异常是无法被捕获到的
  test.catchException();
} catch (Exception e) {
  // 我们在Jni中主动抛出的异常能够被捕获
  System.out.println(e.getMessage());
}

try {
  // Jni层次的异常是无法被捕获到的
  test.catchException();
} catch (Throwable e) {
  // 我们在Jni中主动抛出的异常能够被捕获
  System.out.println(e.getMessage());
}

public interface Source extends Closeable {
  /**
   * Removes at least 1, and up to {@code byteCount} bytes from this and appends
   * them to {@code sink}. Returns the number of bytes read, or -1 if this
   * source is exhausted.
   */
  // 将字节数据从source中移除，并添加到Sink中
  long read(Buffer sink, long byteCount) throws IOException;

  /** Returns the timeout for this source. */
  Timeout timeout();

  /**
   * Closes this source and releases the resources held by this source. It is an
   * error to read a closed source. It is safe to close a source more than once.
   */
  @Override void close() throws IOException;
}

Okio.buffer(Sink);

public interface Sink extends Closeable, Flushable {
  /** Removes {@code byteCount} bytes from {@code source} and appends them to this. */
  // 基础的write操作,该方法将指定数量的字节从source中移出，并写入自己的Buffer
  void write(Buffer source, long byteCount) throws IOException;

  /** Pushes all buffered bytes to their final destination. */
  @Override void flush() throws IOException;

  /** Returns the timeout for this sink. */
  Timeout timeout();

  /**
   * Pushes all buffered bytes to their final destination and releases the
   * resources held by this sink. It is an error to write a closed sink. It is
   * safe to close a sink more than once.
   */
   // Sink可以多次调用close
  @Override void close() throws IOException;
}

/** The size of all segments in bytes. */
static final int SIZE = 8192;

/** Segments will be shared when doing so avoids {@code arraycopy()} of this many bytes. */
// 在调用split分割Segment时，如果要求分割的字节数超过了该值，则不会采用复制数组的方式进行
// 分割，而是采用共享的方式
static final int SHARE_MINIMUM = 1024;

final byte[] data;

// Segment保存的字节数组中，第一个可读的位置
/** The next byte of application data byte to read in this segment. */
int pos;

// Segment的剩余可写的字节数组的第一个位置
// 所以Segment实际保存的数据为pos ~ limit-1
/** The first byte of available data ready to be written to. */
int limit;

// Segment的字节数据是不是与别的Segment共享的，默认情况下是false
// 当在split时采用的是共享的方式，则分割出来的Segment该变量为true
/** True if other segments or byte strings use the same byte array. */
boolean shared;

// 当前Segment是否是其中字节数据的拥有者
/** True if this segment owns the byte array and can append to it, extending {@code limit}. */
boolean owner;

/** Next segment in a linked or circularly-linked list. */
Segment next;

/** Previous segment in a circularly-linked list. */
Segment prev;

Segment sharedCopy() {
  shared = true;
  return new Segment(data, pos, limit, true, false);
}

Segment unsharedCopy() {
  return new Segment(data.clone(), pos, limit, false, true);
}

public @Nullable Segment pop() {
  Segment result = next != this ? next : null;
  prev.next = next;
  next.prev = prev;
  next = null;
  prev = null;
  return result;
}

public Segment push(Segment segment) {
  segment.prev = this;
  segment.next = next;
  next.prev = segment;
  next = segment;
  return segment;
}

public Segment split(int byteCount) {
  if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
  Segment prefix;

  // We have two competing performance goals:
  //  - Avoid copying data. We accomplish this by sharing segments.
  //  - Avoid short shared segments. These are bad for performance because they are readonly and
  //    may lead to long chains of short segments.
  // To balance these goals we only share segments when the copy will be large.
  // 如果分割的字节数超过了1024，则采用共享字节数组的方式
  if (byteCount >= SHARE_MINIMUM) {
    prefix = sharedCopy();
  } else {
    // 否则直接创建一个新的Segment，并复制数据
    prefix = SegmentPool.take();
    System.arraycopy(data, pos, prefix.data, 0, byteCount);
  }

  // 如果采用共享数据的方式，data数据拥有者的pos最大不会超过limit
  // 如果是共享数据的方式，分割后的两个Segment实际是通过pos和limit来分别指向同一个字节数组的
  // 不同数据段
  prefix.limit = prefix.pos + byteCount;
  // 当前Segment的pos重新指向
  pos += byteCount;
  // 将分割出去的Segment放到前一个Segment的后面，也就是当前Segment的前面
  prev.push(prefix);
  return prefix;
}

public void compact() {
  if (prev == this) throw new IllegalStateException();
  if (!prev.owner) return; // Cannot compact: prev isn't writable.
  int byteCount = limit - pos;
  // 如果prev是与别的Segment共享字节数组的，则其只能使用从limit～SIZE的部分
  // 否则，0～pos部分也是可以使用的，当然，一般情况下，pos是等于0的
  int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);
  if (byteCount > availableByteCount) return; // Cannot compact: not enough writable space.
  // 开始合并到prev中
  writeTo(prev, byteCount);
  // 移除当前Segment
  pop();
  SegmentPool.recycle(this);
}

public void writeTo(Segment sink, int byteCount) {
  if (!sink.owner) throw new IllegalArgumentException();
  // sink从limit~SIZE的部分不足以放入当前Segment，则检查Sink的0~pos部分是否可以放入数据
  if (sink.limit + byteCount > SIZE) {
    // We can't fit byteCount bytes at the sink's current position. Shift sink first.
    // 虽然Sink是其字节数组的拥有者，但是其字节数组一部分是与别人共享的，这部分共享的数据，
    // 可能使用了0～pos的部分，所以这部分不能被修改
    if (sink.shared) throw new IllegalArgumentException();
    // 加上前面的pos部分也不足以将当前Segment数据移进Sink中
    if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException();
    // 将sink的字节数组数据移到pos = 0的位置
    System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos);
    sink.limit -= sink.pos;
    sink.pos = 0;
  }
  // 将当前Segment的数据移到Sink中
  System.arraycopy(data, pos, sink.data, sink.limit, byteCount);
  sink.limit += byteCount;
  pos += byteCount;
}

void main(){
	char* path = "C:\\Users\\dell\\Desktop\\文件加密.png";
	FILE* file = fopen(path, "rb");

	// 重新定位指针到文件末尾
	fseek(file, 0, SEEK_END);

	// 返回当前的文件指针，相对于文件开头的偏移量
	int length = ftell(file);

	printf("%d\n",length);

	getchar();
}