[Android] Support complex types

src/app/zap-templates/zcl/zcl.json

@@ -88,7 +88,5 @@
             "commandDiscovery": true
         }
     },
-    "listsUseAttributeAccessInterface": true,
-    "attributeAccessInterfaceAttributes": {},
     "defaultReportingPolicy": "mandatory"
 }

src/controller/java/BUILD.gn

@@ -83,6 +83,7 @@ android_library("java") {
     "src/chip/devicecontroller/NetworkCredentials.java",
     "src/chip/devicecontroller/PaseVerifierParams.java",
     "zap-generated/chip/devicecontroller/ChipClusters.java",
+    "zap-generated/chip/devicecontroller/ChipStructs.java",
     "zap-generated/chip/devicecontroller/ClusterInfoMapping.java",
     "zap-generated/chip/devicecontroller/ClusterReadMapping.java",
     "zap-generated/chip/devicecontroller/ClusterWriteMapping.java",

src/controller/java/templates/CHIPClusters-JNI.zapt

@@ -14,9 +14,11 @@
 #include <lib/support/JniReferences.h>
 #include <lib/support/JniTypeWrappers.h>
 #include <jni.h>
+#include <lib/support/CHIPListUtils.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/Span.h>
 #include <platform/PlatformManager.h>
+#include <vector>
 
 #define JNI_METHOD(RETURN, CLASS_NAME, METHOD_NAME)                                                                                            \
     extern "C" JNIEXPORT RETURN JNICALL Java_chip_devicecontroller_ChipClusters_00024##CLASS_NAME##_##METHOD_NAME
@@ -44,16 +46,19 @@ JNI_METHOD(jlong, {{asUpperCamelCase name}}Cluster, initWithDevice)(JNIEnv * env
 }
 
 {{#chip_cluster_commands}}
-JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, {{asLowerCamelCase name}})(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback{{#chip_cluster_command_arguments_with_structs_expanded}}, {{asJniBasicType type true}} {{asLowerCamelCase label}}{{/chip_cluster_command_arguments_with_structs_expanded}}, jobject timedInvokeTimeoutMs)
+JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, {{asLowerCamelCase name}})(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback{{#chip_cluster_command_arguments}}, {{asJniBasicType type true}} {{asLowerCamelCase label}}{{/chip_cluster_command_arguments}}, jobject timedInvokeTimeoutMs)
 {
     chip::DeviceLayer::StackLock lock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     {{asUpperCamelCase ../name}}Cluster * cppCluster;
 
+    ListFreer listFreer;
     chip::app::Clusters::{{asUpperCamelCase parent.name}}::Commands::{{asUpperCamelCase name}}::Type request;
 
+    std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
+    std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
     {{#chip_cluster_command_arguments}}
-    {{>encode_value target=(concat "request." (asLowerCamelCase label)) source=(asLowerCamelCase label) cluster=parent.parent.name}}
+    {{>encode_value target=(concat "request." (asLowerCamelCase label)) source=(asLowerCamelCase label) cluster=(asUpperCamelCase parent.parent.name) depth=0}}
     {{/chip_cluster_command_arguments}}
 
     {{#*inline "callbackName"}}{{#if hasSpecificResponse}}{{asUpperCamelCase parent.name false}}Cluster{{asUpperCamelCase responseName false}}{{else}}DefaultSuccess{{/if}}{{/inline}}
@@ -88,7 +93,6 @@ JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, {{asLowerCamelCase name}})
 {{#chip_server_cluster_attributes}}
 {{#unless (isStrEqual chipCallback.name "Unsupported")}}
 {{#if isReportableAttribute}}
-{{#unless isList}}
 JNI_METHOD(void, {{asCamelCased ../name false}}Cluster, subscribe{{asCamelCased name false}}Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval)
 {
     chip::DeviceLayer::StackLock lock;
@@ -120,7 +124,6 @@ JNI_METHOD(void, {{asCamelCased ../name false}}Cluster, subscribe{{asCamelCased
     onSuccess.release();
     onFailure.release();
 }
-{{/unless}}
 {{/if}}
 {{/unless}}
 {{/chip_server_cluster_attributes}}

src/controller/java/templates/CHIPClustersWrite-JNI.zapt

@@ -14,9 +14,11 @@
 #include <lib/support/JniReferences.h>
 #include <lib/support/JniTypeWrappers.h>
 #include <jni.h>
+#include <lib/support/CHIPListUtils.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/Span.h>
 #include <platform/PlatformManager.h>
+#include <vector>
 
 #define JNI_METHOD(RETURN, CLASS_NAME, METHOD_NAME)                                                                                            \
     extern "C" JNIEXPORT RETURN JNICALL Java_chip_devicecontroller_ChipClusters_00024##CLASS_NAME##_##METHOD_NAME
@@ -28,16 +30,18 @@ using namespace chip::Controller;
 {{#chip_server_cluster_attributes}}
 {{#unless (isStrEqual chipCallback.name "Unsupported")}}
 {{#if isWritableAttribute}}
-{{! TODO: Lists not supported in attribute writes yet. }}
-{{#unless isList}}
 
 JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, write{{asUpperCamelCase name}}Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, {{asJniBasicType type true}} value, jobject timedWriteTimeoutMs)
 {
     chip::DeviceLayer::StackLock lock;
+    ListFreer listFreer;
     using TypeInfo = chip::app::Clusters::{{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::TypeInfo;
     TypeInfo::Type cppValue;
 
-    {{>encode_value target="cppValue" source="value" cluster=parent.name}}
+    std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
+    std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
+
+    {{>encode_value target="cppValue" source="value" cluster=(asUpperCamelCase parent.name) depth=0}}
 
     std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
     VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY));
@@ -66,7 +70,6 @@ JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, write{{asUpperCamelCase na
     onSuccess.release();
     onFailure.release();
 }
-{{/unless}}
 {{/if}}
 {{/unless}}
 {{/chip_server_cluster_attributes}}

src/controller/java/templates/CHIPInvokeCallbacks-src.zapt

@@ -61,11 +61,11 @@ void CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callbac
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);
 
-    err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#chip_cluster_response_arguments}}{{#if isArray}}{{else}}{{#if_is_struct type}}{{else if isOptional}}Ljava/util/Optional;{{else if (isOctetString type)}}[B{{else if (isCharString type)}}Ljava/lang/String;{{else}}{{asJniSignature type true}}{{/if_is_struct}}{{/if}}{{/chip_cluster_response_arguments}})V", &javaMethod);
+    err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#chip_cluster_response_arguments}}{{asJniSignature type null parent.parent.name true}}{{/chip_cluster_response_arguments}})V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));
 
     {{#chip_cluster_response_arguments}}
-    {{>decode_value source=(concat "dataResponse." (asLowerCamelCase name)) target=(asSymbol label) cluster=parent.parent.name}}
+    {{>decode_value source=(concat "dataResponse." (asLowerCamelCase name)) target=(asSymbol label) cluster=(asUpperCamelCase parent.parent.name) depth=0}}
     {{/chip_cluster_response_arguments}}
 
     env->CallVoidMethod(javaCallbackRef, javaMethod{{#chip_cluster_response_arguments}}, {{asSymbol label}}{{/chip_cluster_response_arguments}});

src/controller/java/templates/CHIPReadCallbacks-src.zapt

@@ -88,14 +88,6 @@ void CHIP{{chipCallback.name}}AttributeCallback::CallbackFn(void * context, {{ch
 {{! TODO: Add support for struct-typed attributes }}
 {{#unless (isStrEqual chipCallback.name "Unsupported")}}
 
-{{! NOTE: Some of our helpers rely on broken ZAP APIs that sniff for "isArray"
-    when we are just trying to work with the type of an array element.  Fix
-    that by defining some inline partials that let us force isArray to false as
-    needed. }}
-{{~#*inline "asUnboxedJniSignature"}}{{asJniSignature type false}}{{/inline}}
-{{~#*inline "asUnboxedJniSignatureForEntry"}}{{> asUnboxedJniSignature isArray=false}}{{/inline~}}
-{{~#*inline "asBoxedJavaBasicType"}}{{asJavaBasicTypeForZclType type true}}{{/inline~}}
-{{~#*inline "asBoxedJavaBasicTypeForEntry"}}{{>asBoxedJavaBasicType isArray=false}}{{/inline~}}
 {{#if_in_global_responses}}
 {{else}}
 CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback::CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback(jobject javaCallback, bool keepAlive) :
@@ -140,181 +132,11 @@ void CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallb
     javaCallbackRef = cppCallback.get()->javaCallbackRef;
     VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));
 
-    jclass arrayListClass;
-    err = chip::JniReferences::GetInstance().GetClassRef(env, "java/util/ArrayList", arrayListClass);
-    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error using Java ArrayList"));
-    chip::JniClass arrayListJniClass(arrayListClass);
-    jmethodID arrayListCtor = env->GetMethodID(arrayListClass, "<init>", "()V");
-    jmethodID arrayListAddMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");
-    VerifyOrReturn(arrayListCtor != nullptr && arrayListAddMethod != nullptr, ChipLogError(Zcl, "Error finding Java ArrayList methods"));
-    jobject arrayListObj = env->NewObject(arrayListClass, arrayListCtor);
-    VerifyOrReturn(arrayListObj != nullptr, ChipLogError(Zcl, "Error creating Java ArrayList"));
-
     jmethodID javaMethod;
     err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method"));
 
-    {{#if isStruct}}
-    jclass attributeClass;
-    err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipClusters${{asUpperCamelCase parent.name}}Cluster${{asUpperCamelCase name}}Attribute", attributeClass);
-    VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find class chip/devicecontroller/ChipClusters${{asUpperCamelCase parent.name}}Cluster${{asUpperCamelCase name}}Attribute"));
-    chip::JniClass attributeJniClass(attributeClass);
-    jmethodID attributeCtor = env->GetMethodID(attributeClass, "<init>"
-        , "({{#chip_attribute_list_entryTypes}}{{#if isArray}}{{! TODO: Add support for lists here }}{{else if isStruct}}{{! TODO: Add support for structs here }}{{else if isOptional}}Ljava/util/Optional;{{else if (isString type)}}{{#if (isOctetString type)}}[B{{else}}Ljava/lang/String;{{/if}}{{else}}{{asJniSignature type true}}{{/if}}{{/chip_attribute_list_entryTypes}})V");
-    VerifyOrReturn(attributeCtor != nullptr, ChipLogError(Zcl, "Could not find {{asUpperCamelCase name}}Attribute constructor"));
-    {{/if}}
-
-    auto iter = list.begin();
-    while (iter.Next())
-    {
-        auto & entry = iter.GetValue();
-        {{#if isStruct}}
-        (void)entry; {{! In case all our struct members are not supported yet }}
-        {{#chip_attribute_list_entryTypes}}
-        {{#unless isArray}}
-        {{#unless isStruct}}
-        bool {{asLowerCamelCase name}}Null = false;
-        bool {{asLowerCamelCase name}}HasValue = true;
-        {{#if isNullable}}
-        {{#unless isOptional}}
-        {{chipType}} {{asLowerCamelCase name}}Value;
-        {{asLowerCamelCase name}}Null = entry.{{asLowerCamelCase name}}.IsNull();
-        if (!{{asLowerCamelCase name}}Null) {
-            {{asLowerCamelCase name}}Value = entry.{{asLowerCamelCase name}}.Value();
-        }
-        {{/unless}}
-        {{/if}}
-
-        {{#if isOptional}}
-        {{zapTypeToDecodableClusterObjectType type forceNotOptional=true forceNotNullable=true ns=parent.parent.name}} {{asLowerCamelCase name}}Value;
-        {{#if isNullable}}
-        {{asLowerCamelCase name}}HasValue = entry.{{asLowerCamelCase name}}.HasValue();
-        if ({{asLowerCamelCase name}}HasValue) {
-            auto {{asLowerCamelCase name}}ValueFromOptional = entry.{{asLowerCamelCase name}}.Value();
-            {{asLowerCamelCase name}}Null = {{asLowerCamelCase name}}ValueFromOptional.IsNull();
-            if (!{{asLowerCamelCase name}}Null) {
-                {{asLowerCamelCase name}}Value = {{asLowerCamelCase name}}ValueFromOptional.Value();
-            }
-        }
-        {{else}}
-        {{asLowerCamelCase name}}HasValue = entry.{{asLowerCamelCase name}}.HasValue();
-        if ({{asLowerCamelCase name}}HasValue) {
-            {{asLowerCamelCase name}}Value = entry.{{asLowerCamelCase name}}.Value();
-        }
-        {{/if}}
-        {{/if}}
-
-        {{#unless isOptional}}
-        {{#unless isNullable}}
-        {{zapTypeToDecodableClusterObjectType type ns=parent.parent.name}} {{asLowerCamelCase name}}Value = entry.{{asLowerCamelCase name}};
-        {{/unless}}
-        {{/unless}}
-
-        {{/unless}}
-        {{/unless}}
-
-        {{#if isArray}}
-        {{! TODO: Add support for lists here }}
-        {{else if isStruct}}
-        {{! TODO: Add support for structs here }}
-        {{else if (isOctetString type)}}
-        jbyteArray {{asLowerCamelCase name}} = nullptr;
-        if (!{{asLowerCamelCase name}}Null && {{asLowerCamelCase name}}HasValue) {
-            {{asLowerCamelCase name}} = env->NewByteArray({{asLowerCamelCase name}}Value.size());
-            env->SetByteArrayRegion({{asLowerCamelCase name}}, 0, {{asLowerCamelCase name}}Value.size(), reinterpret_cast<const jbyte *>({{asLowerCamelCase name}}Value.data()));
-        }
-        {{else if (isCharString type)}}
-        jstring {{asLowerCamelCase name}} = nullptr;
-        chip::UtfString {{asLowerCamelCase name}}Str(env, {{asLowerCamelCase name}}Value);
-        if (!{{asLowerCamelCase name}}Null && {{asLowerCamelCase name}}HasValue) {
-            {{asLowerCamelCase name}} = jstring({{asLowerCamelCase name}}Str.jniValue());
-        }
-        {{else}}
-        jobject {{asLowerCamelCase name}} = nullptr;
-        if (!{{asLowerCamelCase name}}Null && {{asLowerCamelCase name}}HasValue) {
-            jclass {{asLowerCamelCase name}}EntryCls;
-            chip::JniReferences::GetInstance().GetClassRef(env, "java/lang/{{>asBoxedJavaBasicTypeForEntry}}", {{asLowerCamelCase name}}EntryCls);
-            chip::JniClass {{asLowerCamelCase name}}JniClass({{asLowerCamelCase name}}EntryCls);
-            jmethodID {{asLowerCamelCase name}}EntryTypeCtor = env->GetMethodID({{asLowerCamelCase name}}EntryCls, "<init>", "({{>asUnboxedJniSignatureForEntry}})V");
-            {{asLowerCamelCase name}} = env->NewObject({{asLowerCamelCase name}}EntryCls, {{asLowerCamelCase name}}EntryTypeCtor, {{asLowerCamelCase name}}Value);
-        }
-        {{/if}}
-
-        {{#if isOptional}}
-        {{#unless isArray}}
-        {{#unless isStruct}}
-        jobject {{asLowerCamelCase name}}Optional = nullptr;
-        chip::JniReferences::GetInstance().CreateOptional({{asLowerCamelCase name}}, {{asLowerCamelCase name}}Optional);
-        {{/unless}}
-        {{/unless}}
-        {{/if}}
-        {{/chip_attribute_list_entryTypes}}
-
-        jobject attributeObj = env->NewObject(attributeClass, attributeCtor
-            {{#chip_attribute_list_entryTypes}}
-            {{#if isArray}}
-            {{! TODO: Add support for lists here }}
-            {{else if isStruct}}
-            {{! TODO: Add support for structs here }}
-            {{else isOptional}}
-            , {{asLowerCamelCase name}}Optional
-            {{else}}
-            , {{asLowerCamelCase name}}
-            {{/if}}
-            {{/chip_attribute_list_entryTypes}}
-        );
-        VerifyOrReturn(attributeObj != nullptr, ChipLogError(Zcl, "Could not create {{asUpperCamelCase name}}Attribute object"));
-
-        env->CallBooleanMethod(arrayListObj, arrayListAddMethod, attributeObj);
-        {{else}}
-        bool entryNull = false;
-        {{#unless isStruct}}
-        {{#if isNullable}}
-        {{zapTypeToDecodableClusterObjectType type ns=parent.name forceNotList=true}} entryValue;
-        entryNull = entry.IsNull();
-        if (!entryNull) {
-            entryValue = entry.Value();
-        }
-        {{else}}
-        {{zapTypeToDecodableClusterObjectType type ns=parent.name forceNotList=true}} entryValue = entry;
-        {{/if}}
-        {{/unless}}
-
-        {{#if isStruct}}
-        {{! TODO: Add support for structs here }}
-        {{else if (isOctetString type)}}
-        jbyteArray entryObject = nullptr;
-        if (!entryNull) {
-            entryObject = env->NewByteArray(entryValue.size());
-            env->SetByteArrayRegion(entryObject, 0, entryValue.size(), reinterpret_cast<const jbyte *>(entryValue.data()));
-        }
-        {{else if (isCharString type)}}
-        jstring entryObject = nullptr;
-        chip::UtfString entryStr(env, entryValue);
-        if (!entryNull) {
-            entryObject = jstring(entryStr.jniValue());
-        }
-        {{else}}
-        jobject entryObject = nullptr;
-        if (!entryNull) {
-            jclass entryTypeCls;
-            chip::JniReferences::GetInstance().GetClassRef(env, "java/lang/{{>asBoxedJavaBasicTypeForEntry}}", entryTypeCls);
-            chip::JniClass jniClass(entryTypeCls);
-            jmethodID entryTypeCtor = env->GetMethodID(entryTypeCls, "<init>", "({{>asUnboxedJniSignatureForEntry}})V");
-            entryObject = env->NewObject(entryTypeCls, entryTypeCtor, entryValue);
-        }
-        {{/if}}
-
-        {{#if isOptional}}
-        jobject entryOptional = nullptr;
-        chip::JniReferences::GetInstance().CreateOptional(entryObject, entryOptional);
-        env->CallBooleanMethod(arrayListObj, arrayListAddMethod, entryOptional);
-        {{else}}
-        env->CallBooleanMethod(arrayListObj, arrayListAddMethod, entryObject);
-        {{/if}}
-        {{/if}}
-    }
-    VerifyOrReturn(iter.GetStatus() == CHIP_NO_ERROR, ChipLogError(Zcl, "Error decoding {{asUpperCamelCase name}}Attribute value: %" CHIP_ERROR_FORMAT, iter.GetStatus().Format()));
+    {{>decode_value source="list" target="arrayListObj" cluster=(asUpperCamelCase parent.name) depth=0}}
 
     env->ExceptionClear();
     env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
@@ -337,10 +159,10 @@ void CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallb
         VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));
 
         jmethodID javaMethod;
-        err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#if isArray}}{{else if isStruct}}{{else if isOptional}}Ljava/util/Optional;{{else if (isOctetString type)}}[B{{else if (isCharString type)}}Ljava/lang/String;{{else}}{{asJniSignature type true}}{{/if}})V", &javaMethod);
+        err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#if isArray}}{{else if isStruct}}{{else if isOptional}}Ljava/util/Optional;{{else if (isOctetString type)}}[B{{else if (isCharString type)}}Ljava/lang/String;{{else}}{{asJniSignatureBasic type true}}{{/if}})V", &javaMethod);
         VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method"));
 
-        {{>decode_value source="value" target="javaValue" cluster=parent.name}}
+        {{>decode_value source="value" target="javaValue" cluster=(asUpperCamelCase parent.name) depth=0}}
 
         env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue);
     }