react-native-update 10.37.20 → 10.38.0-beta.0

package/cpp/patch_core/update_core_android.cpp

@@ -0,0 +1,469 @@
+#include <jni.h>
+
+#include <string>
+#include <vector>
+
+#include "archive_patch_core.h"
+#include "state_core.h"
+
+namespace {
+
+enum class StateOperation {
+  kSwitchVersion = 1,
+  kMarkSuccess = 2,
+  kRollback = 3,
+  kClearFirstTime = 4,
+  kClearRollbackMark = 5,
+  kResolveLaunch = 6,
+};
+
+std::string JStringToString(JNIEnv* env, jstring value) {
+  if (value == nullptr) {
+    return std::string();
+  }
+
+  const char* chars = env->GetStringUTFChars(value, nullptr);
+  if (chars == nullptr) {
+    return std::string();
+  }
+
+  std::string result(chars);
+  env->ReleaseStringUTFChars(value, chars);
+  return result;
+}
+
+std::vector<std::string> JArrayToVector(JNIEnv* env, jobjectArray values) {
+  std::vector<std::string> result;
+  if (values == nullptr) {
+    return result;
+  }
+
+  const jsize size = env->GetArrayLength(values);
+  result.reserve(static_cast<size_t>(size));
+  for (jsize index = 0; index < size; ++index) {
+    auto* item = static_cast<jstring>(env->GetObjectArrayElement(values, index));
+    result.push_back(JStringToString(env, item));
+    env->DeleteLocalRef(item);
+  }
+  return result;
+}
+
+void ThrowRuntimeException(JNIEnv* env, const std::string& message) {
+  jclass exception = env->FindClass("java/lang/RuntimeException");
+  if (exception != nullptr) {
+    env->ThrowNew(exception, message.c_str());
+  }
+}
+
+void SetStringField(
+    JNIEnv* env,
+    jobject target,
+    jclass target_class,
+    const char* field_name,
+    const std::string& value) {
+  jfieldID field =
+      env->GetFieldID(target_class, field_name, "Ljava/lang/String;");
+  if (field == nullptr) {
+    return;
+  }
+  if (value.empty()) {
+    env->SetObjectField(target, field, nullptr);
+    return;
+  }
+
+  jstring java_value = env->NewStringUTF(value.c_str());
+  env->SetObjectField(target, field, java_value);
+  env->DeleteLocalRef(java_value);
+}
+
+void SetBooleanField(
+    JNIEnv* env,
+    jobject target,
+    jclass target_class,
+    const char* field_name,
+    bool value) {
+  jfieldID field = env->GetFieldID(target_class, field_name, "Z");
+  if (field != nullptr) {
+    env->SetBooleanField(target, field, value ? JNI_TRUE : JNI_FALSE);
+  }
+}
+
+std::string GetStringField(
+    JNIEnv* env,
+    jobject target,
+    jclass target_class,
+    const char* field_name) {
+  jfieldID field =
+      env->GetFieldID(target_class, field_name, "Ljava/lang/String;");
+  if (field == nullptr) {
+    return std::string();
+  }
+  auto* value = static_cast<jstring>(env->GetObjectField(target, field));
+  std::string result = JStringToString(env, value);
+  if (value != nullptr) {
+    env->DeleteLocalRef(value);
+  }
+  return result;
+}
+
+bool GetBooleanField(
+    JNIEnv* env,
+    jobject target,
+    jclass target_class,
+    const char* field_name) {
+  jfieldID field = env->GetFieldID(target_class, field_name, "Z");
+  return field != nullptr && env->GetBooleanField(target, field) == JNI_TRUE;
+}
+
+pushy::state::State ReadState(
+    const std::string& package_version,
+    const std::string& build_time,
+    const std::string& current_version,
+    const std::string& last_version,
+    bool first_time,
+    bool first_time_ok,
+    const std::string& rolled_back_version) {
+  pushy::state::State state;
+  state.package_version = package_version;
+  state.build_time = build_time;
+  state.current_version = current_version;
+  state.last_version = last_version;
+  state.first_time = first_time;
+  state.first_time_ok = first_time_ok;
+  state.rolled_back_version = rolled_back_version;
+  return state;
+}
+
+pushy::state::State ReadStateFromResult(JNIEnv* env, jobject state_result) {
+  if (state_result == nullptr) {
+    return pushy::state::State();
+  }
+
+  jclass state_class = env->GetObjectClass(state_result);
+  if (state_class == nullptr) {
+    return pushy::state::State();
+  }
+
+  pushy::state::State state = ReadState(
+      GetStringField(env, state_result, state_class, "packageVersion"),
+      GetStringField(env, state_result, state_class, "buildTime"),
+      GetStringField(env, state_result, state_class, "currentVersion"),
+      GetStringField(env, state_result, state_class, "lastVersion"),
+      GetBooleanField(env, state_result, state_class, "firstTime"),
+      GetBooleanField(env, state_result, state_class, "firstTimeOk"),
+      GetStringField(env, state_result, state_class, "rolledBackVersion"));
+  env->DeleteLocalRef(state_class);
+  return state;
+}
+
+jobject NewStateCoreResult(
+    JNIEnv* env,
+    const pushy::state::State& state,
+    bool changed,
+    const std::string& stale_version_to_delete,
+    const std::string& load_version,
+    bool did_rollback,
+    bool consumed_first_time) {
+  jclass result_class =
+      env->FindClass("cn/reactnative/modules/update/StateCoreResult");
+  if (result_class == nullptr) {
+    return nullptr;
+  }
+
+  jmethodID constructor = env->GetMethodID(result_class, "<init>", "()V");
+  if (constructor == nullptr) {
+    return nullptr;
+  }
+
+  jobject result = env->NewObject(result_class, constructor);
+  if (result == nullptr) {
+    return nullptr;
+  }
+
+  SetStringField(env, result, result_class, "packageVersion", state.package_version);
+  SetStringField(env, result, result_class, "buildTime", state.build_time);
+  SetStringField(env, result, result_class, "currentVersion", state.current_version);
+  SetStringField(env, result, result_class, "lastVersion", state.last_version);
+  SetBooleanField(env, result, result_class, "firstTime", state.first_time);
+  SetBooleanField(env, result, result_class, "firstTimeOk", state.first_time_ok);
+  SetStringField(
+      env,
+      result,
+      result_class,
+      "rolledBackVersion",
+      state.rolled_back_version);
+  SetBooleanField(env, result, result_class, "changed", changed);
+  SetStringField(
+      env,
+      result,
+      result_class,
+      "staleVersionToDelete",
+      stale_version_to_delete);
+  SetStringField(env, result, result_class, "loadVersion", load_version);
+  SetBooleanField(env, result, result_class, "didRollback", did_rollback);
+  SetBooleanField(
+      env,
+      result,
+      result_class,
+      "consumedFirstTime",
+      consumed_first_time);
+  return result;
+}
+
+jobject NewArchivePatchPlanResult(
+    JNIEnv* env,
+    const pushy::archive_patch::ArchivePatchPlan& plan) {
+  jclass result_class =
+      env->FindClass("cn/reactnative/modules/update/ArchivePatchPlanResult");
+  if (result_class == nullptr) {
+    return nullptr;
+  }
+
+  jmethodID constructor = env->GetMethodID(result_class, "<init>", "()V");
+  if (constructor == nullptr) {
+    return nullptr;
+  }
+
+  jobject result = env->NewObject(result_class, constructor);
+  if (result == nullptr) {
+    return nullptr;
+  }
+
+  SetStringField(
+      env,
+      result,
+      result_class,
+      "mergeSourceSubdir",
+      plan.merge_source_subdir);
+  SetBooleanField(env, result, result_class, "enableMerge", plan.enable_merge);
+  return result;
+}
+
+jobject NewCopyGroupResult(
+    JNIEnv* env,
+    const pushy::archive_patch::CopyGroup& group) {
+  jclass result_class =
+      env->FindClass("cn/reactnative/modules/update/CopyGroupResult");
+  if (result_class == nullptr) {
+    return nullptr;
+  }
+
+  jmethodID constructor = env->GetMethodID(result_class, "<init>", "()V");
+  if (constructor == nullptr) {
+    return nullptr;
+  }
+
+  jobject result = env->NewObject(result_class, constructor);
+  if (result == nullptr) {
+    return nullptr;
+  }
+
+  SetStringField(env, result, result_class, "from", group.from);
+  jfieldID to_paths_field =
+      env->GetFieldID(result_class, "toPaths", "[Ljava/lang/String;");
+  if (to_paths_field != nullptr) {
+    jclass string_class = env->FindClass("java/lang/String");
+    jobjectArray to_paths = env->NewObjectArray(
+        static_cast<jsize>(group.to_paths.size()), string_class, nullptr);
+    if (to_paths != nullptr) {
+      for (jsize index = 0; index < static_cast<jsize>(group.to_paths.size());
+           ++index) {
+        jstring value = env->NewStringUTF(group.to_paths[index].c_str());
+        env->SetObjectArrayElement(to_paths, index, value);
+        env->DeleteLocalRef(value);
+      }
+      env->SetObjectField(result, to_paths_field, to_paths);
+      env->DeleteLocalRef(to_paths);
+    }
+  }
+
+  return result;
+}
+
+pushy::archive_patch::ArchivePatchType ToArchivePatchType(jint patch_type) {
+  switch (patch_type) {
+    case 1:
+      return pushy::archive_patch::ArchivePatchType::kFull;
+    case 2:
+      return pushy::archive_patch::ArchivePatchType::kPatchFromPackage;
+    case 3:
+      return pushy::archive_patch::ArchivePatchType::kPatchFromPpk;
+    default:
+      return pushy::archive_patch::ArchivePatchType::kFull;
+  }
+}
+
+pushy::patch::PatchManifest BuildManifest(
+    const std::vector<std::string>& copy_froms,
+    const std::vector<std::string>& copy_tos,
+    const std::vector<std::string>& deletes) {
+  pushy::patch::PatchManifest manifest;
+  for (size_t index = 0; index < copy_froms.size(); ++index) {
+    manifest.copies.push_back(
+        pushy::patch::CopyOperation{copy_froms[index], copy_tos[index]});
+  }
+  manifest.deletes = deletes;
+  return manifest;
+}
+
+jobject MakeStateResult(
+    JNIEnv* env,
+    const pushy::state::State& state,
+    bool changed = false,
+    const std::string& stale_version_to_delete = std::string(),
+    const std::string& load_version = std::string(),
+    bool did_rollback = false,
+    bool consumed_first_time = false) {
+  return NewStateCoreResult(
+      env,
+      state,
+      changed,
+      stale_version_to_delete,
+      load_version,
+      did_rollback,
+      consumed_first_time);
+}
+
+}  // namespace
+
+extern "C" JNIEXPORT jobject JNICALL
+Java_cn_reactnative_modules_update_UpdateContext_syncStateWithBinaryVersion(
+    JNIEnv* env,
+    jclass,
+    jstring package_version,
+    jstring build_time,
+    jobject state_result) {
+  pushy::state::State state = ReadStateFromResult(env, state_result);
+  pushy::state::BinaryVersionSyncResult result = pushy::state::SyncBinaryVersion(
+      state,
+      JStringToString(env, package_version),
+      JStringToString(env, build_time));
+  return MakeStateResult(env, result.state, result.changed);
+}
+
+extern "C" JNIEXPORT jobject JNICALL
+Java_cn_reactnative_modules_update_UpdateContext_runStateCore(
+    JNIEnv* env,
+    jclass,
+    jint operation,
+    jobject state_result,
+    jstring string_arg,
+    jboolean flag_a,
+    jboolean flag_b) {
+  const pushy::state::State state = ReadStateFromResult(env, state_result);
+  switch (static_cast<StateOperation>(operation)) {
+    case StateOperation::kSwitchVersion:
+      return MakeStateResult(
+          env,
+          pushy::state::SwitchVersion(state, JStringToString(env, string_arg)));
+    case StateOperation::kMarkSuccess: {
+      const pushy::state::MarkSuccessResult result =
+          pushy::state::MarkSuccess(state);
+      return MakeStateResult(
+          env,
+          result.state,
+          false,
+          result.stale_version_to_delete);
+    }
+    case StateOperation::kRollback: {
+      const pushy::state::State next = pushy::state::Rollback(state);
+      return MakeStateResult(
+          env, next, false, std::string(), next.current_version, true);
+    }
+    case StateOperation::kClearFirstTime:
+      return MakeStateResult(env, pushy::state::ClearFirstTime(state));
+    case StateOperation::kClearRollbackMark:
+      return MakeStateResult(env, pushy::state::ClearRollbackMark(state));
+    case StateOperation::kResolveLaunch: {
+      const pushy::state::LaunchDecision decision =
+          pushy::state::ResolveLaunchState(
+              state, flag_a == JNI_TRUE, flag_b == JNI_TRUE);
+      return MakeStateResult(
+          env,
+          decision.state,
+          false,
+          std::string(),
+          decision.load_version,
+          decision.did_rollback,
+          decision.consumed_first_time);
+    }
+  }
+
+  ThrowRuntimeException(env, "Unknown state operation");
+  return nullptr;
+}
+
+extern "C" JNIEXPORT jobject JNICALL
+Java_cn_reactnative_modules_update_DownloadTask_buildArchivePatchPlan(
+    JNIEnv* env,
+    jclass,
+    jint patch_type,
+    jobjectArray entry_names,
+    jobjectArray copy_froms,
+    jobjectArray copy_tos,
+    jobjectArray deletes) {
+  const std::vector<std::string> from_values = JArrayToVector(env, copy_froms);
+  const std::vector<std::string> to_values = JArrayToVector(env, copy_tos);
+  if (from_values.size() != to_values.size()) {
+    ThrowRuntimeException(env, "copy_froms and copy_tos length mismatch");
+    return nullptr;
+  }
+
+  pushy::patch::PatchManifest manifest =
+      BuildManifest(from_values, to_values, JArrayToVector(env, deletes));
+  pushy::archive_patch::ArchivePatchPlan plan;
+  pushy::patch::Status status = pushy::archive_patch::BuildArchivePatchPlan(
+      ToArchivePatchType(patch_type),
+      manifest,
+      JArrayToVector(env, entry_names),
+      &plan);
+  if (!status.ok) {
+    ThrowRuntimeException(env, status.message);
+    return nullptr;
+  }
+
+  return NewArchivePatchPlanResult(env, plan);
+}
+
+extern "C" JNIEXPORT jobjectArray JNICALL
+Java_cn_reactnative_modules_update_DownloadTask_buildCopyGroups(
+    JNIEnv* env,
+    jclass,
+    jobjectArray copy_froms,
+    jobjectArray copy_tos) {
+  const std::vector<std::string> from_values = JArrayToVector(env, copy_froms);
+  const std::vector<std::string> to_values = JArrayToVector(env, copy_tos);
+  if (from_values.size() != to_values.size()) {
+    ThrowRuntimeException(env, "copy_froms and copy_tos length mismatch");
+    return nullptr;
+  }
+
+  pushy::patch::PatchManifest manifest = BuildManifest(
+      from_values, to_values, std::vector<std::string>());
+  std::vector<pushy::archive_patch::CopyGroup> groups;
+  pushy::patch::Status status =
+      pushy::archive_patch::BuildCopyGroups(manifest, &groups);
+  if (!status.ok) {
+    ThrowRuntimeException(env, status.message);
+    return nullptr;
+  }
+
+  jclass result_class =
+      env->FindClass("cn/reactnative/modules/update/CopyGroupResult");
+  if (result_class == nullptr) {
+    return nullptr;
+  }
+
+  jobjectArray result = env->NewObjectArray(
+      static_cast<jsize>(groups.size()), result_class, nullptr);
+  if (result == nullptr) {
+    return nullptr;
+  }
+
+  for (jsize index = 0; index < static_cast<jsize>(groups.size()); ++index) {
+    jobject group = NewCopyGroupResult(env, groups[index]);
+    env->SetObjectArrayElement(result, index, group);
+    env->DeleteLocalRef(group);
+  }
+  return result;
+}