/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "utils/intents/jni.h"
#include <memory>
#include "utils/intents/intent-generator.h"
#include "utils/java/scoped_local_ref.h"
namespace libtextclassifier3 {
// The macros below are intended to reduce the boilerplate and avoid
// easily introduced copy/paste errors.
#define TC3_CHECK_JNI_PTR(PTR) TC3_CHECK((PTR) != nullptr)
#define TC3_GET_CLASS(FIELD, NAME) \
handler->FIELD = MakeGlobalRef(env->FindClass(NAME), env, jni_cache->jvm); \
TC3_CHECK_JNI_PTR(handler->FIELD) << "Error finding class: " << NAME;
#define TC3_GET_METHOD(CLASS, FIELD, NAME, SIGNATURE) \
handler->FIELD = env->GetMethodID(handler->CLASS.get(), NAME, SIGNATURE); \
TC3_CHECK(handler->FIELD) << "Error finding method: " << NAME;
std::unique_ptr<RemoteActionTemplatesHandler>
RemoteActionTemplatesHandler::Create(
const std::shared_ptr<JniCache>& jni_cache) {
JNIEnv* env = jni_cache->GetEnv();
if (env == nullptr) {
return nullptr;
}
std::unique_ptr<RemoteActionTemplatesHandler> handler(
new RemoteActionTemplatesHandler(jni_cache));
TC3_GET_CLASS(integer_class_, "java/lang/Integer");
TC3_GET_METHOD(integer_class_, integer_init_, "<init>", "(I)V");
TC3_GET_CLASS(remote_action_template_class_,
TC3_PACKAGE_PATH TC3_REMOTE_ACTION_TEMPLATE_CLASS_NAME_STR);
TC3_GET_METHOD(
remote_action_template_class_, remote_action_template_init_, "<init>",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/"
"String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/"
"Integer;[Ljava/lang/String;Ljava/lang/String;[L" TC3_PACKAGE_PATH
TC3_NAMED_VARIANT_CLASS_NAME_STR ";Ljava/lang/Integer;)V");
TC3_GET_CLASS(named_variant_class_,
TC3_PACKAGE_PATH TC3_NAMED_VARIANT_CLASS_NAME_STR);
TC3_GET_METHOD(named_variant_class_, named_variant_from_int_, "<init>",
"(Ljava/lang/String;I)V");
TC3_GET_METHOD(named_variant_class_, named_variant_from_long_, "<init>",
"(Ljava/lang/String;J)V");
TC3_GET_METHOD(named_variant_class_, named_variant_from_float_, "<init>",
"(Ljava/lang/String;F)V");
TC3_GET_METHOD(named_variant_class_, named_variant_from_double_, "<init>",
"(Ljava/lang/String;D)V");
TC3_GET_METHOD(named_variant_class_, named_variant_from_bool_, "<init>",
"(Ljava/lang/String;Z)V");
TC3_GET_METHOD(named_variant_class_, named_variant_from_string_, "<init>",
"(Ljava/lang/String;Ljava/lang/String;)V");
return handler;
}
jstring RemoteActionTemplatesHandler::AsUTF8String(
const Optional<std::string>& optional) const {
if (!optional.has_value()) {
return nullptr;
}
return jni_cache_->ConvertToJavaString(optional.value()).release();
}
jobject RemoteActionTemplatesHandler::AsInteger(
const Optional<int>& optional) const {
return (optional.has_value()
? jni_cache_->GetEnv()->NewObject(integer_class_.get(),
integer_init_, optional.value())
: nullptr);
}
jobjectArray RemoteActionTemplatesHandler::AsStringArray(
const std::vector<std::string>& values) const {
if (values.empty()) {
return nullptr;
}
jobjectArray result = jni_cache_->GetEnv()->NewObjectArray(
values.size(), jni_cache_->string_class.get(), nullptr);
if (result == nullptr) {
return nullptr;
}
for (int k = 0; k < values.size(); k++) {
ScopedLocalRef<jstring> value_str =
jni_cache_->ConvertToJavaString(values[k]);
jni_cache_->GetEnv()->SetObjectArrayElement(result, k, value_str.get());
}
return result;
}
jobject RemoteActionTemplatesHandler::AsNamedVariant(
const std::string& name_str, const Variant& value) const {
ScopedLocalRef<jstring> name = jni_cache_->ConvertToJavaString(name_str);
if (name == nullptr) {
return nullptr;
}
switch (value.GetType()) {
case Variant::TYPE_INT_VALUE:
return jni_cache_->GetEnv()->NewObject(named_variant_class_.get(),
named_variant_from_int_,
name.get(), value.IntValue());
case Variant::TYPE_INT64_VALUE:
return jni_cache_->GetEnv()->NewObject(named_variant_class_.get(),
named_variant_from_long_,
name.get(), value.Int64Value());
case Variant::TYPE_FLOAT_VALUE:
return jni_cache_->GetEnv()->NewObject(named_variant_class_.get(),
named_variant_from_float_,
name.get(), value.FloatValue());
case Variant::TYPE_DOUBLE_VALUE:
return jni_cache_->GetEnv()->NewObject(named_variant_class_.get(),
named_variant_from_double_,
name.get(), value.DoubleValue());
case Variant::TYPE_BOOL_VALUE:
return jni_cache_->GetEnv()->NewObject(named_variant_class_.get(),
named_variant_from_bool_,
name.get(), value.BoolValue());
case Variant::TYPE_STRING_VALUE: {
ScopedLocalRef<jstring> value_jstring =
jni_cache_->ConvertToJavaString(value.StringValue());
if (value_jstring == nullptr) {
return nullptr;
}
return jni_cache_->GetEnv()->NewObject(named_variant_class_.get(),
named_variant_from_string_,
name.get(), value_jstring.get());
}
default:
return nullptr;
}
}
jobjectArray RemoteActionTemplatesHandler::AsNamedVariantArray(
const std::map<std::string, Variant>& values) const {
if (values.empty()) {
return nullptr;
}
jobjectArray result = jni_cache_->GetEnv()->NewObjectArray(
values.size(), named_variant_class_.get(), nullptr);
int element_index = 0;
for (auto key_value_pair : values) {
if (!key_value_pair.second.HasValue()) {
element_index++;
continue;
}
ScopedLocalRef<jobject> named_extra(
AsNamedVariant(key_value_pair.first, key_value_pair.second),
jni_cache_->GetEnv());
if (named_extra == nullptr) {
return nullptr;
}
jni_cache_->GetEnv()->SetObjectArrayElement(result, element_index,
named_extra.get());
element_index++;
}
return result;
}
jobjectArray RemoteActionTemplatesHandler::RemoteActionTemplatesToJObjectArray(
const std::vector<RemoteActionTemplate>& remote_actions) const {
const jobjectArray results = jni_cache_->GetEnv()->NewObjectArray(
remote_actions.size(), remote_action_template_class_.get(), nullptr);
if (results == nullptr) {
return nullptr;
}
for (int i = 0; i < remote_actions.size(); i++) {
const RemoteActionTemplate& remote_action = remote_actions[i];
const jstring title_without_entity =
AsUTF8String(remote_action.title_without_entity);
const jstring title_with_entity =
AsUTF8String(remote_action.title_with_entity);
const jstring description = AsUTF8String(remote_action.description);
const jstring description_with_app_name =
AsUTF8String(remote_action.description_with_app_name);
const jstring action = AsUTF8String(remote_action.action);
const jstring data = AsUTF8String(remote_action.data);
const jstring type = AsUTF8String(remote_action.type);
const jobject flags = AsInteger(remote_action.flags);
const jobjectArray category = AsStringArray(remote_action.category);
const jstring package = AsUTF8String(remote_action.package_name);
const jobjectArray extra = AsNamedVariantArray(remote_action.extra);
const jobject request_code = AsInteger(remote_action.request_code);
ScopedLocalRef<jobject> result(
jni_cache_->GetEnv()->NewObject(
remote_action_template_class_.get(), remote_action_template_init_,
title_without_entity, title_with_entity, description,
description_with_app_name, action, data, type, flags, category,
package, extra, request_code),
jni_cache_->GetEnv());
if (result == nullptr) {
return nullptr;
}
jni_cache_->GetEnv()->SetObjectArrayElement(results, i, result.get());
}
return results;
}
jobject RemoteActionTemplatesHandler::EntityDataAsNamedVariantArray(
const reflection::Schema* entity_data_schema,
const std::string& serialized_entity_data) const {
ReflectiveFlatbufferBuilder entity_data_builder(entity_data_schema);
std::unique_ptr<ReflectiveFlatbuffer> buffer = entity_data_builder.NewRoot();
buffer->MergeFromSerializedFlatbuffer(serialized_entity_data);
std::map<std::string, Variant> entity_data_map = buffer->AsFlatMap();
return AsNamedVariantArray(entity_data_map);
}
} // namespace libtextclassifier3