| /* |
| * 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/base/status_macros.h" |
| #include "utils/base/statusor.h" |
| #include "utils/java/jni-base.h" |
| #include "utils/java/jni-helper.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) \ |
| { \ |
| TC3_ASSIGN_OR_RETURN(ScopedLocalRef<jclass> clazz, \ |
| JniHelper::FindClass(env, NAME)); \ |
| handler->FIELD = MakeGlobalRef(clazz.release(), env, jni_cache->jvm); \ |
| TC3_CHECK_JNI_PTR(handler->FIELD) << "Error finding class: " << NAME; \ |
| } |
| #define TC3_GET_METHOD(CLASS, FIELD, NAME, SIGNATURE) \ |
| TC3_ASSIGN_OR_RETURN( \ |
| handler->FIELD, \ |
| JniHelper::GetMethodID(env, handler->CLASS.get(), NAME, SIGNATURE)); |
| |
| StatusOr<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"); |
| TC3_GET_METHOD(named_variant_class_, named_variant_from_string_array_, |
| "<init>", "(Ljava/lang/String;[Ljava/lang/String;)V"); |
| TC3_GET_METHOD(named_variant_class_, named_variant_from_float_array_, |
| "<init>", "(Ljava/lang/String;[F)V"); |
| TC3_GET_METHOD(named_variant_class_, named_variant_from_int_array_, "<init>", |
| "(Ljava/lang/String;[I)V"); |
| TC3_GET_METHOD( |
| named_variant_class_, named_variant_from_named_variant_array_, "<init>", |
| "(Ljava/lang/String;[L" TC3_PACKAGE_PATH TC3_NAMED_VARIANT_CLASS_NAME_STR |
| ";)V"); |
| return handler; |
| } |
| |
| StatusOr<ScopedLocalRef<jstring>> RemoteActionTemplatesHandler::AsUTF8String( |
| const Optional<std::string>& optional) const { |
| if (!optional.has_value()) { |
| return {{nullptr, jni_cache_->GetEnv()}}; |
| } |
| return jni_cache_->ConvertToJavaString(optional.value()); |
| } |
| |
| StatusOr<ScopedLocalRef<jobject>> RemoteActionTemplatesHandler::AsInteger( |
| const Optional<int>& optional) const { |
| if (!optional.has_value()) { |
| return {{nullptr, jni_cache_->GetEnv()}}; |
| } |
| |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jobject> result, |
| JniHelper::NewObject(jni_cache_->GetEnv(), integer_class_.get(), |
| integer_init_, optional.value())); |
| |
| return result; |
| } |
| |
| StatusOr<ScopedLocalRef<jobjectArray>> |
| RemoteActionTemplatesHandler::AsStringArray( |
| const std::vector<std::string>& values) const { |
| if (values.empty()) { |
| return {{nullptr, jni_cache_->GetEnv()}}; |
| } |
| |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jobjectArray> result, |
| JniHelper::NewObjectArray(jni_cache_->GetEnv(), values.size(), |
| jni_cache_->string_class.get(), nullptr)); |
| |
| for (int k = 0; k < values.size(); k++) { |
| TC3_ASSIGN_OR_RETURN(ScopedLocalRef<jstring> value_str, |
| jni_cache_->ConvertToJavaString(values[k])); |
| TC3_RETURN_IF_ERROR(JniHelper::SetObjectArrayElement( |
| jni_cache_->GetEnv(), result.get(), k, value_str.get())); |
| } |
| return result; |
| } |
| |
| StatusOr<ScopedLocalRef<jfloatArray>> |
| RemoteActionTemplatesHandler::AsFloatArray( |
| const std::vector<float>& values) const { |
| if (values.empty()) { |
| return {{nullptr, jni_cache_->GetEnv()}}; |
| } |
| |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jfloatArray> result, |
| JniHelper::NewFloatArray(jni_cache_->GetEnv(), values.size())); |
| |
| TC3_RETURN_IF_ERROR(JniHelper::SetFloatArrayRegion( |
| jni_cache_->GetEnv(), result.get(), /*start=*/0, |
| /*len=*/values.size(), &(values[0]))); |
| return result; |
| } |
| |
| StatusOr<ScopedLocalRef<jintArray>> RemoteActionTemplatesHandler::AsIntArray( |
| const std::vector<int>& values) const { |
| if (values.empty()) { |
| return {{nullptr, jni_cache_->GetEnv()}}; |
| } |
| |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jintArray> result, |
| JniHelper::NewIntArray(jni_cache_->GetEnv(), values.size())); |
| |
| TC3_RETURN_IF_ERROR(JniHelper::SetIntArrayRegion( |
| jni_cache_->GetEnv(), result.get(), /*start=*/0, |
| /*len=*/values.size(), &(values[0]))); |
| return result; |
| } |
| |
| StatusOr<ScopedLocalRef<jobject>> RemoteActionTemplatesHandler::AsNamedVariant( |
| const std::string& name_str, const Variant& value) const { |
| TC3_ASSIGN_OR_RETURN(ScopedLocalRef<jstring> name, |
| jni_cache_->ConvertToJavaString(name_str)); |
| |
| JNIEnv* env = jni_cache_->GetEnv(); |
| switch (value.GetType()) { |
| case Variant::TYPE_INT_VALUE: |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_int_, name.get(), |
| value.Value<int>()); |
| |
| case Variant::TYPE_INT64_VALUE: |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_long_, name.get(), |
| value.Value<int64>()); |
| |
| case Variant::TYPE_FLOAT_VALUE: |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_float_, name.get(), |
| value.Value<float>()); |
| |
| case Variant::TYPE_DOUBLE_VALUE: |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_double_, name.get(), |
| value.Value<double>()); |
| |
| case Variant::TYPE_BOOL_VALUE: |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_bool_, name.get(), |
| value.Value<bool>()); |
| |
| case Variant::TYPE_STRING_VALUE: { |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jstring> value_jstring, |
| jni_cache_->ConvertToJavaString(value.ConstRefValue<std::string>())); |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_string_, name.get(), |
| value_jstring.get()); |
| } |
| |
| case Variant::TYPE_STRING_VECTOR_VALUE: { |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jobjectArray> value_jstring_array, |
| AsStringArray(value.ConstRefValue<std::vector<std::string>>())); |
| |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_string_array_, name.get(), |
| value_jstring_array.get()); |
| } |
| |
| case Variant::TYPE_FLOAT_VECTOR_VALUE: { |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jfloatArray> value_jfloat_array, |
| AsFloatArray(value.ConstRefValue<std::vector<float>>())); |
| |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_float_array_, name.get(), |
| value_jfloat_array.get()); |
| } |
| |
| case Variant::TYPE_INT_VECTOR_VALUE: { |
| TC3_ASSIGN_OR_RETURN(ScopedLocalRef<jintArray> value_jint_array, |
| AsIntArray(value.ConstRefValue<std::vector<int>>())); |
| |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_int_array_, name.get(), |
| value_jint_array.get()); |
| } |
| |
| case Variant::TYPE_STRING_VARIANT_MAP_VALUE: { |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jobjectArray> value_jobect_array, |
| AsNamedVariantArray( |
| value.ConstRefValue<std::map<std::string, Variant>>())); |
| return JniHelper::NewObject(env, named_variant_class_.get(), |
| named_variant_from_named_variant_array_, |
| name.get(), value_jobect_array.get()); |
| } |
| |
| case Variant::TYPE_EMPTY: |
| return {Status::UNKNOWN}; |
| |
| default: |
| TC3_LOG(ERROR) << "Unsupported NamedVariant type: " << value.GetType(); |
| return {Status::UNKNOWN}; |
| } |
| } |
| |
| StatusOr<ScopedLocalRef<jobjectArray>> |
| RemoteActionTemplatesHandler::AsNamedVariantArray( |
| const std::map<std::string, Variant>& values) const { |
| JNIEnv* env = jni_cache_->GetEnv(); |
| if (values.empty()) { |
| return {{nullptr, env}}; |
| } |
| |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jobjectArray> result, |
| JniHelper::NewObjectArray(jni_cache_->GetEnv(), values.size(), |
| named_variant_class_.get(), nullptr)); |
| int element_index = 0; |
| for (const auto& key_value_pair : values) { |
| if (!key_value_pair.second.HasValue()) { |
| element_index++; |
| continue; |
| } |
| TC3_ASSIGN_OR_RETURN( |
| StatusOr<ScopedLocalRef<jobject>> named_extra, |
| AsNamedVariant(key_value_pair.first, key_value_pair.second)); |
| TC3_RETURN_IF_ERROR(JniHelper::SetObjectArrayElement( |
| env, result.get(), element_index, named_extra.ValueOrDie().get())); |
| element_index++; |
| } |
| return result; |
| } |
| |
| StatusOr<ScopedLocalRef<jobjectArray>> |
| RemoteActionTemplatesHandler::RemoteActionTemplatesToJObjectArray( |
| const std::vector<RemoteActionTemplate>& remote_actions) const { |
| JNIEnv* env = jni_cache_->GetEnv(); |
| TC3_ASSIGN_OR_RETURN( |
| ScopedLocalRef<jobjectArray> results, |
| JniHelper::NewObjectArray(env, remote_actions.size(), |
| remote_action_template_class_.get(), nullptr)); |
| |
| for (int i = 0; i < remote_actions.size(); i++) { |
| const RemoteActionTemplate& remote_action = remote_actions[i]; |
| |
| TC3_ASSIGN_OR_RETURN( |
| const StatusOr<ScopedLocalRef<jstring>> title_without_entity, |
| AsUTF8String(remote_action.title_without_entity)); |
| TC3_ASSIGN_OR_RETURN( |
| const StatusOr<ScopedLocalRef<jstring>> title_with_entity, |
| AsUTF8String(remote_action.title_with_entity)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jstring>> description, |
| AsUTF8String(remote_action.description)); |
| TC3_ASSIGN_OR_RETURN( |
| const StatusOr<ScopedLocalRef<jstring>> description_with_app_name, |
| AsUTF8String(remote_action.description_with_app_name)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jstring>> action, |
| AsUTF8String(remote_action.action)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jstring>> data, |
| AsUTF8String(remote_action.data)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jstring>> type, |
| AsUTF8String(remote_action.type)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jobject>> flags, |
| AsInteger(remote_action.flags)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jobjectArray>> category, |
| AsStringArray(remote_action.category)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jstring>> package, |
| AsUTF8String(remote_action.package_name)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jobjectArray>> extra, |
| AsNamedVariantArray(remote_action.extra)); |
| TC3_ASSIGN_OR_RETURN(const StatusOr<ScopedLocalRef<jobject>> request_code, |
| AsInteger(remote_action.request_code)); |
| |
| TC3_ASSIGN_OR_RETURN( |
| const ScopedLocalRef<jobject> result, |
| JniHelper::NewObject( |
| env, remote_action_template_class_.get(), |
| remote_action_template_init_, |
| title_without_entity.ValueOrDie().get(), |
| title_with_entity.ValueOrDie().get(), |
| description.ValueOrDie().get(), |
| description_with_app_name.ValueOrDie().get(), |
| action.ValueOrDie().get(), data.ValueOrDie().get(), |
| type.ValueOrDie().get(), flags.ValueOrDie().get(), |
| category.ValueOrDie().get(), package.ValueOrDie().get(), |
| extra.ValueOrDie().get(), request_code.ValueOrDie().get())); |
| TC3_RETURN_IF_ERROR( |
| JniHelper::SetObjectArrayElement(env, results.get(), i, result.get())); |
| } |
| return results; |
| } |
| |
| StatusOr<ScopedLocalRef<jobjectArray>> |
| RemoteActionTemplatesHandler::EntityDataAsNamedVariantArray( |
| const reflection::Schema* entity_data_schema, |
| const std::string& serialized_entity_data) const { |
| MutableFlatbufferBuilder entity_data_builder(entity_data_schema); |
| std::unique_ptr<MutableFlatbuffer> 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 |
