| /* |
| * 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 |
