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

{{> header}}
{{#if (chip_has_client_clusters)}}

#include <zap-generated/CHIPClusters.h>
#include <zap-generated/CHIPClientCallbacks.h>

#include <controller/java/CHIPJNIError.h>
#include <controller/java/JniReferences.h>
#include <controller/java/JniTypeWrappers.h>
#include <controller/java/StackLock.h>
#include <jni.h>
#include <lib/core/CHIPSafeCasts.h>
#include <lib/support/CodeUtils.h>
#include <lib/support/Span.h>

#define JNI_METHOD(RETURN, CLASS_NAME, METHOD_NAME)                                                                                            \
    extern "C" JNIEXPORT RETURN JNICALL Java_chip_devicecontroller_ChipClusters_00024##CLASS_NAME##_##METHOD_NAME

using namespace chip;
using namespace chip::Controller;

static CHIP_ERROR CreateChipClusterException(JNIEnv * env, jint errorCode, jthrowable & outEx);
static CHIP_ERROR CreateIllegalStateException(JNIEnv * env, const char message[], jint errorCode, jthrowable & outEx);
static void ReturnIllegalStateException(JNIEnv * env, jobject callback, const char message[], jint errorCode);

CHIP_ERROR CreateChipClusterException(JNIEnv * env, jint errorCode, jthrowable & outEx) {
    CHIP_ERROR err = CHIP_NO_ERROR;
    jmethodID exceptionConstructor;
    jclass clusterExceptionCls;

    err = JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipClusterException", clusterExceptionCls);
    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
    JniClass clusterExceptionJniCls(clusterExceptionCls);
    
    exceptionConstructor = env->GetMethodID(clusterExceptionCls, "<init>", "(I)V");
    VerifyOrReturnError(exceptionConstructor != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
    
    outEx = (jthrowable) env->NewObject(clusterExceptionCls, exceptionConstructor, errorCode);
    VerifyOrReturnError(outEx != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);

    return err;
}

CHIP_ERROR CreateIllegalStateException(JNIEnv * env, const char message[], jint errorCode, jthrowable & outEx) {
    CHIP_ERROR err = CHIP_NO_ERROR;
    jmethodID exceptionConstructor;
    jclass exceptionClass;
    jstring errStr;

    err = JniReferences::GetInstance().GetClassRef(env, "java/lang/IllegalStateException", exceptionClass);
    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
    JniClass exceptionJniClass(exceptionClass);
    
    exceptionConstructor = env->GetMethodID(exceptionClass, "<init>", "(Ljava/lang/String;)V");
    VerifyOrReturnError(exceptionConstructor != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
    
    char buf[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE];
    snprintf(buf, sizeof(buf), "%s: %d", message, errorCode);
    errStr = env->NewStringUTF(buf);

    outEx = (jthrowable) env->NewObject(exceptionClass, exceptionConstructor, errStr);
    VerifyOrReturnError(outEx != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);

    return err;
}

void ReturnIllegalStateException(JNIEnv * env, jobject callback, const char message[], jint errorCode) {
    VerifyOrReturn(callback == nullptr, ChipLogDetail(Zcl, "Callback is null in ReturnIllegalStateException(), exiting early"));

    CHIP_ERROR err = CHIP_NO_ERROR;
    jmethodID method;
    err = JniReferences::GetInstance().FindMethod(env, callback, "onError", "(Ljava/lang/Exception;)V", &method);
    if (err != CHIP_NO_ERROR) {
        ChipLogError(Zcl, "Error throwing IllegalStateException %d", errorCode);
        return;
    }

    jthrowable exception;
    err = CreateIllegalStateException(env, message, errorCode, exception);
    if (err != CHIP_NO_ERROR) {
        ChipLogError(Zcl, "Error throwing IllegalStateException %d", errorCode);
        return;
    }
    env->CallVoidMethod(callback, method, exception);
}

class CHIPDefaultSuccessCallback : public Callback::Callback<DefaultSuccessCallback> {
    public:
        CHIPDefaultSuccessCallback(jobject javaCallback): Callback::Callback<DefaultSuccessCallback>(CallbackFn, this)
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }
            javaCallbackRef = env->NewGlobalRef(javaCallback);
            if (javaCallbackRef == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
            }
        }

        ~CHIPDefaultSuccessCallback()
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }
            env->DeleteGlobalRef(javaCallbackRef);
        };

        static void CallbackFn(void * context)
        {
            StackUnlockGuard unlockGuard(JniReferences::GetInstance().GetStackLock());
            CHIP_ERROR err = CHIP_NO_ERROR;
            jmethodID javaMethod;
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            jobject javaCallbackRef;
            CHIPDefaultSuccessCallback * cppCallback = nullptr;

            VerifyOrExit(env != nullptr, err = CHIP_JNI_ERROR_NO_ENV);

            cppCallback = reinterpret_cast<CHIPDefaultSuccessCallback *>(context);
            VerifyOrExit(cppCallback != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

            // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
            javaCallbackRef = cppCallback->javaCallbackRef;
            VerifyOrExit(javaCallbackRef != nullptr, err = CHIP_NO_ERROR);

            err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "()V", &javaMethod);
            SuccessOrExit(err);
        
            env->ExceptionClear();
            env->CallVoidMethod(javaCallbackRef, javaMethod);

        exit:
            if (err != CHIP_NO_ERROR) {
                ChipLogError(Zcl, "Error invoking Java callback: %" CHIP_ERROR_FORMAT, err.Format());
            }
            if (cppCallback != nullptr) {
                cppCallback->Cancel();
                delete cppCallback;
            }
        }
    
    private:
        jobject javaCallbackRef;
};

class CHIPDefaultFailureCallback : public Callback::Callback<DefaultFailureCallback> {
    public:
        CHIPDefaultFailureCallback(jobject javaCallback): Callback::Callback<DefaultFailureCallback>(CallbackFn, this)
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }
            javaCallbackRef = env->NewGlobalRef(javaCallback);
            if (javaCallbackRef == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
            }
        }

        ~CHIPDefaultFailureCallback()
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }
            env->DeleteGlobalRef(javaCallbackRef);
        };

        static void CallbackFn(void * context, uint8_t status)
        {
            StackUnlockGuard unlockGuard(JniReferences::GetInstance().GetStackLock());
            CHIP_ERROR err = CHIP_NO_ERROR;
            jmethodID javaMethod;
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            jobject javaCallbackRef;
            jthrowable exception;
            CHIPDefaultFailureCallback * cppCallback = nullptr;

            VerifyOrExit(env != nullptr, err = CHIP_JNI_ERROR_NO_ENV);

            cppCallback = reinterpret_cast<CHIPDefaultFailureCallback *>(context);
            VerifyOrExit(cppCallback != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

            // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
            javaCallbackRef = cppCallback->javaCallbackRef;
            VerifyOrExit(javaCallbackRef != nullptr, err = CHIP_NO_ERROR);

            err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onError", "(Ljava/lang/Exception;)V", &javaMethod);
            SuccessOrExit(err);

            err = CreateChipClusterException(env, status, exception);
            SuccessOrExit(err);
        
            env->ExceptionClear();
            env->CallVoidMethod(javaCallbackRef, javaMethod, exception);
        exit:
            if (err != CHIP_NO_ERROR) {
                ChipLogError(Zcl, "Error invoking Java callback: %" CHIP_ERROR_FORMAT, err.Format());
            }
            if (cppCallback != nullptr) {
                cppCallback->Cancel();
                delete cppCallback;
            }
        }
    
    private:
        jobject javaCallbackRef;
};

{{#chip_server_global_responses}}

class CHIP{{chipCallback.name}}AttributeCallback : public Callback::Callback<{{chipCallback.name}}AttributeCallback> {
    public:
        CHIP{{chipCallback.name}}AttributeCallback(jobject javaCallback, bool keepAlive = false): Callback::Callback<{{chipCallback.name}}AttributeCallback>(CallbackFn, this)
        , keepAlive(keepAlive)
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }
            javaCallbackRef = env->NewGlobalRef(javaCallback);
            if (javaCallbackRef == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
            }
        }

        static void maybeDestroy(CHIP{{chipCallback.name}}AttributeCallback * callback) {
            if (!callback->keepAlive) {
                callback->Cancel();
                delete callback;
            }
        }

        static void CallbackFn(void * context, {{chipCallback.type}} value)
        {
            StackUnlockGuard unlockGuard(JniReferences::GetInstance().GetStackLock());
            CHIP_ERROR err = CHIP_NO_ERROR;

            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env"));

            std::unique_ptr<CHIP{{chipCallback.name}}AttributeCallback, decltype(&maybeDestroy)> cppCallback(reinterpret_cast<CHIP{{chipCallback.name}}AttributeCallback *>(context), maybeDestroy);

            // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
            jobject javaCallbackRef = cppCallback.get()->javaCallbackRef;
            VerifyOrReturn(javaCallbackRef != nullptr, ChipLogDetail(Zcl, "Early return from attribute callback since Java callback is null"));

            jmethodID javaMethod;
            {{#unless (isStrEqual chipCallback.name "OctetString")}}
            {{#unless (isStrEqual chipCallback.name "CharString")}}
            err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{convertCTypeToJniSignature chipCallback.type}})V", &javaMethod);
            VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess method"));
            env->CallVoidMethod(javaCallbackRef, javaMethod, static_cast<{{convertBasicCTypeToJniType chipCallback.type}}>(value));
            {{/unless}}
            {{/unless}}

            {{#if (isStrEqual chipCallback.name "OctetString")}}
            err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "([B)V", &javaMethod);
            VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess method"));

            jbyteArray valueArr = env->NewByteArray(value.size());
            env->ExceptionClear();
            env->SetByteArrayRegion(valueArr, 0, value.size(), reinterpret_cast<const jbyte *>(value.data()));

            env->CallVoidMethod(javaCallbackRef, javaMethod, valueArr);
            {{/if}}

            {{#if (isStrEqual chipCallback.name "CharString")}}
            err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/String;)V", &javaMethod);
            VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess method"));

            UtfString valueStr(env, value);
            env->CallVoidMethod(javaCallbackRef, javaMethod, valueStr.jniValue());
            {{/if}}
        }

    private:
        jobject javaCallbackRef;
        bool keepAlive;
};
{{/chip_server_global_responses}}

{{#chip_client_clusters}}
{{#chip_cluster_responses}}
class CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback : public Callback::Callback<{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback>
{
    public:
        CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback(jobject javaCallback): Callback::Callback<{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback>(CallbackFn, this)
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }

            javaCallbackRef = env->NewGlobalRef(javaCallback);
            if (javaCallbackRef == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
            }
        }
        ~CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback()
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }
            env->DeleteGlobalRef(javaCallbackRef);
        };

        static void CallbackFn(void * context{{#chip_cluster_response_arguments}}, {{asUnderlyingZclType type}} {{asSymbol label}}{{/chip_cluster_response_arguments}})
        {
            StackUnlockGuard unlockGuard(JniReferences::GetInstance().GetStackLock());
            CHIP_ERROR err = CHIP_NO_ERROR;
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            jobject javaCallbackRef;
            jmethodID javaMethod;
            CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback * cppCallback = nullptr;
            {{#chip_cluster_response_arguments}}
            {{#if (isOctetString type)}}
            jbyteArray {{asSymbol label}}Arr;
            {{else if (isShortString type)}}
            // ByteSpan is not properly returned yet, temporarily use empty string
            UtfString {{asSymbol label}}Str(env, "");
            {{/if}}
            {{/chip_cluster_response_arguments}}

            VerifyOrExit(env != nullptr, err = CHIP_JNI_ERROR_NO_ENV);

            cppCallback = reinterpret_cast<CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback *>(context);
            VerifyOrExit(cppCallback != nullptr, err = CHIP_JNI_ERROR_NULL_OBJECT);

            javaCallbackRef = cppCallback->javaCallbackRef;
            VerifyOrExit(javaCallbackRef != nullptr, err = CHIP_NO_ERROR);

            err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#chip_cluster_response_arguments}}{{#if isArray}}{{else if (isOctetString type)}}[B{{else if (isShortString type)}}Ljava/lang/String;{{else}}{{asJniSignature type}}{{/if}}{{/chip_cluster_response_arguments}})V", &javaMethod);
            SuccessOrExit(err);

            {{#chip_cluster_response_arguments}}
            {{#if (isOctetString type)}}
            {{asSymbol label}}Arr = env->NewByteArray({{asSymbol label}}.size());
            VerifyOrExit({{asSymbol label}}Arr != nullptr, err = CHIP_ERROR_NO_MEMORY);
            env->ExceptionClear();
            env->SetByteArrayRegion({{asSymbol label}}Arr, 0, {{asSymbol label}}.size(), reinterpret_cast<const jbyte *>({{asSymbol label}}.data()));
            VerifyOrExit(!env->ExceptionCheck(), err = CHIP_JNI_ERROR_EXCEPTION_THROWN);
            {{/if}}
            {{/chip_cluster_response_arguments}}

            env->CallVoidMethod(javaCallbackRef, javaMethod
                {{#chip_cluster_response_arguments}}
                {{#if isArray}}
                // {{asSymbol label}}: {{asUnderlyingZclType type}}
                // Conversion from this type to Java is not properly implemented yet
                {{else if (isOctetString type)}}
                , {{asSymbol label}}Arr
                {{else if (isShortString type)}}
                , {{asSymbol label}}Str.jniValue()
                {{else}}
                , static_cast<{{asJniBasicTypeForZclType type}}>({{asSymbol label}})
                {{/if}}
                {{/chip_cluster_response_arguments}}
            );

            {{#chip_cluster_response_arguments}}
            {{#if (isOctetString type)}}
            env->DeleteLocalRef({{asSymbol label}}Arr);
            {{/if}}
            {{/chip_cluster_response_arguments}}

        exit:
            if (err != CHIP_NO_ERROR) {
                ChipLogError(Zcl, "Error invoking Java callback: %" CHIP_ERROR_FORMAT, err.Format());
            }
            if (cppCallback != nullptr) {
                cppCallback->Cancel();
                delete cppCallback;
            }
        }
        
    private:
        jobject javaCallbackRef;
};

{{/chip_cluster_responses}}
{{/chip_client_clusters}}

{{#chip_client_clusters}}
{{#chip_server_cluster_attributes}}
{{#if isList}}
class CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback : public Callback::Callback<{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}ListAttributeCallback>
{
    public:
        CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback(jobject javaCallback): Callback::Callback<{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}ListAttributeCallback>(CallbackFn, this)
        {
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            if (env == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
                return;
            }

            javaCallbackRef = env->NewGlobalRef(javaCallback);
            if (javaCallbackRef == nullptr) {
                ChipLogError(Zcl, "Could not create global reference for Java callback");
            }
        }

        static void CallbackFn(void * context, uint16_t count, {{chipType}} * entries)
        {
            StackUnlockGuard unlockGuard(JniReferences::GetInstance().GetStackLock());
            CHIP_ERROR err = CHIP_NO_ERROR;
            JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
            jobject javaCallbackRef;

            VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env"));

            std::unique_ptr<CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback> cppCallback(reinterpret_cast<CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback *>(context));

            // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
            javaCallbackRef = cppCallback.get()->javaCallbackRef;
            VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));

            jclass arrayListClass;
            err = JniReferences::GetInstance().GetClassRef(env, "java/util/ArrayList", arrayListClass);
            VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error using Java ArrayList"));
            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 = 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 = 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"));
            JniClass attributeJniClass(attributeClass);
            jmethodID attributeCtor = env->GetMethodID(attributeClass, "<init>"
                , "({{#chip_attribute_list_entryTypes}}{{#if (isString type)}}{{#if (isOctetString type)}}[B{{else}}Ljava/lang/String;{{/if}}{{else}}{{asJniSignature type}}{{/if}}{{/chip_attribute_list_entryTypes}})V");
            VerifyOrReturn(attributeCtor != nullptr, ChipLogError(Zcl, "Could not find {{asUpperCamelCase name}}Attribute constructor"));
            {{/if}}

            for (uint16_t i = 0; i < count; i++)
            {
                {{#if isStruct}}
                {{#chip_attribute_list_entryTypes}}
                {{#if (isOctetString type)}}
                jbyteArray {{asLowerCamelCase name}} = env->NewByteArray(entries[i].{{name}}.size());
                env->SetByteArrayRegion({{asLowerCamelCase name}}, 0, entries[i].{{name}}.size(), reinterpret_cast<const jbyte *>(entries[i].{{name}}.data()));
                {{else if (isCharString type)}}
                // Implement after ByteSpan is emitted instead of uint8_t *.
                {{else}}
                {{asJniBasicType type}} {{asLowerCamelCase name}} = entries[i].{{name}};
                {{/if}}
                {{/chip_attribute_list_entryTypes}}

                jobject attributeObj = env->NewObject(attributeClass, attributeCtor,
                    {{#chip_attribute_list_entryTypes}}
                    {{asLowerCamelCase name}}{{#not_last}}, {{/not_last}}
                    {{/chip_attribute_list_entryTypes}}
                );
                VerifyOrReturn(attributeObj != nullptr, ChipLogError(Zcl, "Could not create {{asUpperCamelCase name}}Attribute object"));

                env->CallBooleanMethod(arrayListObj, arrayListAddMethod, attributeObj);
                {{else}}
                {{#if (isOctetString type)}}
                jbyteArray {{asLowerCamelCase name}} = env->NewByteArray(entries[i].size());
                env->SetByteArrayRegion({{asLowerCamelCase name}}, 0, entries[i].size(), reinterpret_cast<const jbyte *>(entries[i].data()));
                {{else if (isCharString type)}}
                // Implement after ByteSpan is emitted instead of uint8_t *
                {{else}}
                jclass entryTypeCls;
                JniReferences::GetInstance().GetClassRef(env, "java/lang/{{asJavaBasicTypeForZclType type true}}", entryTypeCls);
                jmethodID entryTypeCtor = env->GetMethodID(entryTypeCls, "<init>", "({{asJniSignature type}})V");
                jobject {{asLowerCamelCase name}} = env->NewObject(entryTypeCls, entryTypeCtor, entries[i]);
                {{/if}}
                env->CallBooleanMethod(arrayListObj, arrayListAddMethod, {{asLowerCamelCase name}});
                {{/if}}
            }

            env->ExceptionClear();
            env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
        }
            
    private:
        jobject javaCallbackRef;
};

{{/if}}
{{/chip_server_cluster_attributes}}
{{/chip_client_clusters}}

JNI_METHOD(void, BaseChipCluster, deleteCluster)(JNIEnv * env, jobject self, jlong clusterPtr)
{
    StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
    ClusterBase * cluster = reinterpret_cast<ClusterBase *>(clusterPtr);
    if (cluster != nullptr) {
        delete cluster;
    }
}

{{#chip_client_clusters}}
JNI_METHOD(jlong, {{asUpperCamelCase name}}Cluster, initWithDevice)(JNIEnv * env, jobject self, jlong devicePtr, jint endpointId)
{
    StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
    {{asUpperCamelCase name}}Cluster * cppCluster = new {{asUpperCamelCase name}}Cluster();

    cppCluster->Associate(reinterpret_cast<Device *>(devicePtr), endpointId);
    return reinterpret_cast<jlong>(cppCluster);
}

{{#chip_cluster_commands}}
{{#if (zcl_command_arguments_count this.id)}}
JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, {{asLowerCamelCase name}})(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, {{#chip_cluster_command_arguments}}{{asJniBasicType type}} {{asLowerCamelCase label}}{{#not_last}}, {{/not_last}}{{/chip_cluster_command_arguments}})
{{else}}
JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, {{asLowerCamelCase name}})(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
{{/if}}
{
    StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
    CHIP_ERROR err = CHIP_NO_ERROR;
    {{asUpperCamelCase ../name}}Cluster * cppCluster;
    
    {{#chip_cluster_command_arguments}}
    {{#if (isOctetString type)}}
    JniByteArray {{asLowerCamelCase label}}Arr(env, {{asLowerCamelCase label}});
    {{else if (isCharString type)}}
    JniUtfString {{asLowerCamelCase label}}Str(env, {{asLowerCamelCase label}});
    {{/if}}
    {{/chip_cluster_command_arguments}}
    {{#if hasSpecificResponse}}
    CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase responseName}}Callback * onSuccess;
    {{else}}
    CHIPDefaultSuccessCallback * onSuccess;
    {{/if}}
    CHIPDefaultFailureCallback * onFailure;

    cppCluster = reinterpret_cast<{{asUpperCamelCase ../name}}Cluster *>(clusterPtr);
    VerifyOrExit(cppCluster != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

    {{#if hasSpecificResponse}}
    onSuccess = new CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase responseName}}Callback(callback);
    {{else}}
    onSuccess = new CHIPDefaultSuccessCallback(callback);
    {{/if}}
    VerifyOrExit(onSuccess != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
    onFailure = new CHIPDefaultFailureCallback(callback);
    VerifyOrExit(onFailure != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

    err = cppCluster->{{asUpperCamelCase name}}(onSuccess->Cancel(), onFailure->Cancel(){{#chip_cluster_command_arguments}}, {{#if (isOctetString type)}}{{asUnderlyingZclType type}}((const uint8_t*) {{asLowerCamelCase label}}Arr.data(), {{asLowerCamelCase label}}Arr.size()){{else if (isCharString type)}}chip::ByteSpan((const uint8_t*) {{asLowerCamelCase label}}, strlen({{asLowerCamelCase label}}Str.c_str())){{else}}{{asLowerCamelCase label}}{{/if}}{{/chip_cluster_command_arguments}});
    SuccessOrExit(err);

exit: 
    if (err != CHIP_NO_ERROR) {
        delete onSuccess;
        delete onFailure;

        jthrowable exception;
        jmethodID method;

        err = JniReferences::GetInstance().FindMethod(env, callback, "onError", "(Ljava/lang/Exception;)V", &method);
        if (err != CHIP_NO_ERROR) {
            ChipLogError(Zcl, "Error throwing IllegalStateException %" CHIP_ERROR_FORMAT, err.Format());
            return;
        }

        err = CreateIllegalStateException(env, "Error invoking cluster", err.Format(), exception);
        if (err != CHIP_NO_ERROR) {
            ChipLogError(Zcl, "Error throwing IllegalStateException %" CHIP_ERROR_FORMAT, err.Format());
            return;
        }
        env->CallVoidMethod(callback, method, exception);
    }
}
{{/chip_cluster_commands}}
{{#chip_server_cluster_attributes}}

JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, read{{asUpperCamelCase name}}Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
{
    StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
{{#if isList}}
    CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback * onSuccess = new CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback(callback);
{{else}}
    CHIP{{chipCallback.name}}AttributeCallback * onSuccess = new CHIP{{chipCallback.name}}AttributeCallback(callback);
{{/if}}
    if (!onSuccess) {
        ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
        return;
    }

    CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
    if (!onFailure) {
        delete onSuccess;
        ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
        return;
    }

    CHIP_ERROR err = CHIP_NO_ERROR;
    {{asUpperCamelCase ../name}}Cluster * cppCluster = reinterpret_cast<{{asUpperCamelCase ../name}}Cluster *>(clusterPtr);
    if (cppCluster == nullptr) {
        delete onSuccess;
        delete onFailure;
        ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
        return;
    }

    err = cppCluster->ReadAttribute{{asUpperCamelCase name}}(onSuccess->Cancel(), onFailure->Cancel());
    if (err != CHIP_NO_ERROR) {
        delete onSuccess;
        delete onFailure;
        ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
    }
}
{{#if isWritableAttribute}}

JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, write{{asUpperCamelCase name}}Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, {{asJniBasicType type}} value)
{
    StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
    CHIPDefaultSuccessCallback * onSuccess = new CHIPDefaultSuccessCallback(callback);
    if (!onSuccess) {
        ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
        return;
    }

    CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
    if (!onFailure) {
        delete onSuccess;
        ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
        return;
    }

    CHIP_ERROR err = CHIP_NO_ERROR;
    {{asUpperCamelCase ../name}}Cluster * cppCluster = reinterpret_cast<{{asUpperCamelCase ../name}}Cluster *>(clusterPtr);
    if (cppCluster == nullptr) {
        delete onSuccess;
        delete onFailure;
        ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
        return;
    }

    {{#if (isOctetString type)}}
    JniByteArray jniArr(env, value);
    err = cppCluster->WriteAttribute{{asUpperCamelCase name}}(onSuccess->Cancel(), onFailure->Cancel(), chip::ByteSpan((const uint8_t*) jniArr.data(), jniArr.size()));
    {{else if (isCharString type)}}
    JniUtfString valueStr(env, value);
    err = cppCluster->WriteAttribute{{asUpperCamelCase name}}(onSuccess->Cancel(), onFailure->Cancel(), chip::ByteSpan((const uint8_t*) valueStr.c_str(), strlen(valueStr.c_str())));
    {{else}}
    err = cppCluster->WriteAttribute{{asUpperCamelCase name}}(onSuccess->Cancel(), onFailure->Cancel(), static_cast<{{chipCallback.type}}>(value));
    {{/if}}
    if (err != CHIP_NO_ERROR) {
        delete onSuccess;
        delete onFailure;
        ReturnIllegalStateException(env, callback, "Error writing attribute", err.AsInteger());
    }
}
{{/if}}
{{/chip_server_cluster_attributes}}
{{/chip_client_clusters}}
{{/if}}