src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 2022 Project CHIP Authors
  *
  *    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.
  */

 // THIS FILE IS GENERATED BY ZAP
 #include "CHIPInvokeCallbacks.h"
 #include "CHIPCallbackTypes.h"

 #include <app-common/zap-generated/cluster-objects.h>
 #include <jni.h>
 #include <lib/support/CHIPJNIError.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/JniReferences.h>
 #include <lib/support/JniTypeWrappers.h>
 #include <platform/PlatformManager.h>

 namespace chip {

 CHIPAccountLoginClusterGetSetupPINResponseCallback::CHIPAccountLoginClusterGetSetupPINResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPAccountLoginClusterGetSetupPINResponseCallbackType>(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");
     }
 }

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

 void CHIPAccountLoginClusterGetSetupPINResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::AccountLogin::Commands::GetSetupPINResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPAccountLoginClusterGetSetupPINResponseCallback,
                     void (*)(CHIPAccountLoginClusterGetSetupPINResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPAccountLoginClusterGetSetupPINResponseCallback *>(context),
                     chip::Platform::Delete<CHIPAccountLoginClusterGetSetupPINResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/String;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject setupPIN;
     setupPIN = env->NewStringUTF(std::string(dataResponse.setupPIN.data(), dataResponse.setupPIN.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, setupPIN);
 }
 CHIPApplicationLauncherClusterLauncherResponseCallback::CHIPApplicationLauncherClusterLauncherResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPApplicationLauncherClusterLauncherResponseCallbackType>(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");
     }
 }

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

 void CHIPApplicationLauncherClusterLauncherResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::ApplicationLauncher::Commands::LauncherResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPApplicationLauncherClusterLauncherResponseCallback,
                     void (*)(CHIPApplicationLauncherClusterLauncherResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPApplicationLauncherClusterLauncherResponseCallback *>(context),
                     chip::Platform::Delete<CHIPApplicationLauncherClusterLauncherResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject data;
     data = env->NewStringUTF(std::string(dataResponse.data.data(), dataResponse.data.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, data);
 }
 CHIPChannelClusterChangeChannelResponseCallback::CHIPChannelClusterChangeChannelResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPChannelClusterChangeChannelResponseCallbackType>(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");
     }
 }

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

 void CHIPChannelClusterChangeChannelResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Channel::Commands::ChangeChannelResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPChannelClusterChangeChannelResponseCallback, void (*)(CHIPChannelClusterChangeChannelResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPChannelClusterChangeChannelResponseCallback *>(context),
                     chip::Platform::Delete<CHIPChannelClusterChangeChannelResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess", "(Lchip/devicecontroller/ChipStructs$ChannelClusterChannelInfo;Ljava/lang/Integer;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject channelMatch;
     jobject channelMatch_majorNumber;
     std::string channelMatch_majorNumberClassName     = "java/lang/Integer";
     std::string channelMatch_majorNumberCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(channelMatch_majorNumberClassName.c_str(),
                                                                    channelMatch_majorNumberCtorSignature.c_str(),
                                                                    dataResponse.channelMatch.majorNumber, channelMatch_majorNumber);
     jobject channelMatch_minorNumber;
     std::string channelMatch_minorNumberClassName     = "java/lang/Integer";
     std::string channelMatch_minorNumberCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(channelMatch_minorNumberClassName.c_str(),
                                                                    channelMatch_minorNumberCtorSignature.c_str(),
                                                                    dataResponse.channelMatch.minorNumber, channelMatch_minorNumber);
     jobject channelMatch_name;
     channelMatch_name =
         env->NewStringUTF(std::string(dataResponse.channelMatch.name.data(), dataResponse.channelMatch.name.size()).c_str());
     jobject channelMatch_callSign;
     channelMatch_callSign = env->NewStringUTF(
         std::string(dataResponse.channelMatch.callSign.data(), dataResponse.channelMatch.callSign.size()).c_str());
     jobject channelMatch_affiliateCallSign;
     channelMatch_affiliateCallSign = env->NewStringUTF(
         std::string(dataResponse.channelMatch.affiliateCallSign.data(), dataResponse.channelMatch.affiliateCallSign.size())
             .c_str());

     jclass channelInfoStructClass;
     err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$ChannelClusterChannelInfo",
                                                          channelInfoStructClass);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find class ChipStructs$ChannelClusterChannelInfo"));
     chip::JniClass structJniClass(channelInfoStructClass);
     jmethodID channelInfoStructCtor =
         env->GetMethodID(channelInfoStructClass, "<init>",
                          "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
     VerifyOrReturn(channelInfoStructCtor != nullptr,
                    ChipLogError(Zcl, "Could not find ChipStructs$ChannelClusterChannelInfo constructor"));

     channelMatch = env->NewObject(channelInfoStructClass, channelInfoStructCtor, channelMatch_majorNumber, channelMatch_minorNumber,
                                   channelMatch_name, channelMatch_callSign, channelMatch_affiliateCallSign);
     jobject errorType;
     std::string errorTypeClassName     = "java/lang/Integer";
     std::string errorTypeCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(errorTypeClassName.c_str(), errorTypeCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.errorType), errorType);

     env->CallVoidMethod(javaCallbackRef, javaMethod, channelMatch, errorType);
 }
 CHIPContentLauncherClusterLaunchResponseCallback::CHIPContentLauncherClusterLaunchResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPContentLauncherClusterLaunchResponseCallbackType>(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");
     }
 }

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

 void CHIPContentLauncherClusterLaunchResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::ContentLauncher::Commands::LaunchResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPContentLauncherClusterLaunchResponseCallback, void (*)(CHIPContentLauncherClusterLaunchResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPContentLauncherClusterLaunchResponseCallback *>(context),
                     chip::Platform::Delete<CHIPContentLauncherClusterLaunchResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject data;
     data = env->NewStringUTF(std::string(dataResponse.data.data(), dataResponse.data.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, data);
 }
 CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback::CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPDiagnosticLogsClusterRetrieveLogsResponseCallbackType>(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");
     }
 }

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

 void CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback,
                     void (*)(CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback *>(context),
                     chip::Platform::Delete<CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;[BLjava/lang/Long;Ljava/lang/Long;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject content;
     jbyteArray contentByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.content.size()));
     env->SetByteArrayRegion(contentByteArray, 0, static_cast<jsize>(dataResponse.content.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.content.data()));
     content = contentByteArray;
     jobject timeStamp;
     std::string timeStampClassName     = "java/lang/Long";
     std::string timeStampCtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(timeStampClassName.c_str(), timeStampCtorSignature.c_str(),
                                                                    dataResponse.timeStamp, timeStamp);
     jobject timeSinceBoot;
     std::string timeSinceBootClassName     = "java/lang/Long";
     std::string timeSinceBootCtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
         timeSinceBootClassName.c_str(), timeSinceBootCtorSignature.c_str(), dataResponse.timeSinceBoot, timeSinceBoot);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, content, timeStamp, timeSinceBoot);
 }
 CHIPDoorLockClusterGetCredentialStatusResponseCallback::CHIPDoorLockClusterGetCredentialStatusResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPDoorLockClusterGetCredentialStatusResponseCallbackType>(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");
     }
 }

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

 void CHIPDoorLockClusterGetCredentialStatusResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::DoorLock::Commands::GetCredentialStatusResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPDoorLockClusterGetCredentialStatusResponseCallback,
                     void (*)(CHIPDoorLockClusterGetCredentialStatusResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPDoorLockClusterGetCredentialStatusResponseCallback *>(context),
                     chip::Platform::Delete<CHIPDoorLockClusterGetCredentialStatusResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Boolean;Ljava/lang/Integer;Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject credentialExists;
     std::string credentialExistsClassName     = "java/lang/Boolean";
     std::string credentialExistsCtorSignature = "(Z)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<bool>(
         credentialExistsClassName.c_str(), credentialExistsCtorSignature.c_str(), dataResponse.credentialExists, credentialExists);
     jobject userIndex;
     if (dataResponse.userIndex.IsNull())
     {
         userIndex = nullptr;
     }
     else
     {
         std::string userIndexClassName     = "java/lang/Integer";
         std::string userIndexCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(userIndexClassName.c_str(), userIndexCtorSignature.c_str(),
                                                                        dataResponse.userIndex.Value(), userIndex);
     }
     jobject nextCredentialIndex;
     if (dataResponse.nextCredentialIndex.IsNull())
     {
         nextCredentialIndex = nullptr;
     }
     else
     {
         std::string nextCredentialIndexClassName     = "java/lang/Integer";
         std::string nextCredentialIndexCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
             nextCredentialIndexClassName.c_str(), nextCredentialIndexCtorSignature.c_str(),
             dataResponse.nextCredentialIndex.Value(), nextCredentialIndex);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, credentialExists, userIndex, nextCredentialIndex);
 }
 CHIPDoorLockClusterGetUserResponseCallback::CHIPDoorLockClusterGetUserResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPDoorLockClusterGetUserResponseCallbackType>(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");
     }
 }

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

 void CHIPDoorLockClusterGetUserResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::DoorLock::Commands::GetUserResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPDoorLockClusterGetUserResponseCallback, void (*)(CHIPDoorLockClusterGetUserResponseCallback *)> cppCallback(
         reinterpret_cast<CHIPDoorLockClusterGetUserResponseCallback *>(context),
         chip::Platform::Delete<CHIPDoorLockClusterGetUserResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess",
         "(Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/"
         "ArrayList;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject userIndex;
     std::string userIndexClassName     = "java/lang/Integer";
     std::string userIndexCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(userIndexClassName.c_str(), userIndexCtorSignature.c_str(),
                                                                    dataResponse.userIndex, userIndex);
     jobject userName;
     if (dataResponse.userName.IsNull())
     {
         userName = nullptr;
     }
     else
     {
         userName =
             env->NewStringUTF(std::string(dataResponse.userName.Value().data(), dataResponse.userName.Value().size()).c_str());
     }
     jobject userUniqueId;
     if (dataResponse.userUniqueId.IsNull())
     {
         userUniqueId = nullptr;
     }
     else
     {
         std::string userUniqueIdClassName     = "java/lang/Long";
         std::string userUniqueIdCtorSignature = "(J)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
             userUniqueIdClassName.c_str(), userUniqueIdCtorSignature.c_str(), dataResponse.userUniqueId.Value(), userUniqueId);
     }
     jobject userStatus;
     if (dataResponse.userStatus.IsNull())
     {
         userStatus = nullptr;
     }
     else
     {
         std::string userStatusClassName     = "java/lang/Integer";
         std::string userStatusCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(userStatusClassName.c_str(), userStatusCtorSignature.c_str(),
                                                                       static_cast<uint8_t>(dataResponse.userStatus.Value()),
                                                                       userStatus);
     }
     jobject userType;
     if (dataResponse.userType.IsNull())
     {
         userType = nullptr;
     }
     else
     {
         std::string userTypeClassName     = "java/lang/Integer";
         std::string userTypeCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(userTypeClassName.c_str(), userTypeCtorSignature.c_str(),
                                                                       static_cast<uint8_t>(dataResponse.userType.Value()),
                                                                       userType);
     }
     jobject credentialRule;
     if (dataResponse.credentialRule.IsNull())
     {
         credentialRule = nullptr;
     }
     else
     {
         std::string credentialRuleClassName     = "java/lang/Integer";
         std::string credentialRuleCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
             credentialRuleClassName.c_str(), credentialRuleCtorSignature.c_str(),
             static_cast<uint8_t>(dataResponse.credentialRule.Value()), credentialRule);
     }
     jobject credentials;
     if (dataResponse.credentials.IsNull())
     {
         credentials = nullptr;
     }
     else
     {
         chip::JniReferences::GetInstance().CreateArrayList(credentials);

         auto iter_credentials_1 = dataResponse.credentials.Value().begin();
         while (iter_credentials_1.Next())
         {
             auto & entry_1 = iter_credentials_1.GetValue();
             jobject newElement_1;
             jobject newElement_1_credentialType;
             std::string newElement_1_credentialTypeClassName     = "java/lang/Integer";
             std::string newElement_1_credentialTypeCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
                 newElement_1_credentialTypeClassName.c_str(), newElement_1_credentialTypeCtorSignature.c_str(),
                 static_cast<uint8_t>(entry_1.credentialType), newElement_1_credentialType);
             jobject newElement_1_credentialIndex;
             std::string newElement_1_credentialIndexClassName     = "java/lang/Integer";
             std::string newElement_1_credentialIndexCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(newElement_1_credentialIndexClassName.c_str(),
                                                                            newElement_1_credentialIndexCtorSignature.c_str(),
                                                                            entry_1.credentialIndex, newElement_1_credentialIndex);

             jclass dlCredentialStructClass;
             err = chip::JniReferences::GetInstance().GetClassRef(
                 env, "chip/devicecontroller/ChipStructs$DoorLockClusterDlCredential", dlCredentialStructClass);
             VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find class ChipStructs$DoorLockClusterDlCredential"));
             chip::JniClass structJniClass(dlCredentialStructClass);
             jmethodID dlCredentialStructCtor =
                 env->GetMethodID(dlCredentialStructClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/Integer;)V");
             VerifyOrReturn(dlCredentialStructCtor != nullptr,
                            ChipLogError(Zcl, "Could not find ChipStructs$DoorLockClusterDlCredential constructor"));

             newElement_1 = env->NewObject(dlCredentialStructClass, dlCredentialStructCtor, newElement_1_credentialType,
                                           newElement_1_credentialIndex);
             chip::JniReferences::GetInstance().AddToArrayList(credentials, newElement_1);
         }
     }
     jobject creatorFabricIndex;
     if (dataResponse.creatorFabricIndex.IsNull())
     {
         creatorFabricIndex = nullptr;
     }
     else
     {
         std::string creatorFabricIndexClassName     = "java/lang/Integer";
         std::string creatorFabricIndexCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(creatorFabricIndexClassName.c_str(),
                                                                       creatorFabricIndexCtorSignature.c_str(),
                                                                       dataResponse.creatorFabricIndex.Value(), creatorFabricIndex);
     }
     jobject lastModifiedFabricIndex;
     if (dataResponse.lastModifiedFabricIndex.IsNull())
     {
         lastModifiedFabricIndex = nullptr;
     }
     else
     {
         std::string lastModifiedFabricIndexClassName     = "java/lang/Integer";
         std::string lastModifiedFabricIndexCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
             lastModifiedFabricIndexClassName.c_str(), lastModifiedFabricIndexCtorSignature.c_str(),
             dataResponse.lastModifiedFabricIndex.Value(), lastModifiedFabricIndex);
     }
     jobject nextUserIndex;
     if (dataResponse.nextUserIndex.IsNull())
     {
         nextUserIndex = nullptr;
     }
     else
     {
         std::string nextUserIndexClassName     = "java/lang/Integer";
         std::string nextUserIndexCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
             nextUserIndexClassName.c_str(), nextUserIndexCtorSignature.c_str(), dataResponse.nextUserIndex.Value(), nextUserIndex);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, userIndex, userName, userUniqueId, userStatus, userType, credentialRule,
                         credentials, creatorFabricIndex, lastModifiedFabricIndex, nextUserIndex);
 }
 CHIPDoorLockClusterGetWeekDayScheduleResponseCallback::CHIPDoorLockClusterGetWeekDayScheduleResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPDoorLockClusterGetWeekDayScheduleResponseCallbackType>(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");
     }
 }

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

 void CHIPDoorLockClusterGetWeekDayScheduleResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::DoorLock::Commands::GetWeekDayScheduleResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPDoorLockClusterGetWeekDayScheduleResponseCallback,
                     void (*)(CHIPDoorLockClusterGetWeekDayScheduleResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPDoorLockClusterGetWeekDayScheduleResponseCallback *>(context),
                     chip::Platform::Delete<CHIPDoorLockClusterGetWeekDayScheduleResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess",
         "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/"
         "Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject weekDayIndex;
     std::string weekDayIndexClassName     = "java/lang/Integer";
     std::string weekDayIndexCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(weekDayIndexClassName.c_str(), weekDayIndexCtorSignature.c_str(),
                                                                   dataResponse.weekDayIndex, weekDayIndex);
     jobject userIndex;
     std::string userIndexClassName     = "java/lang/Integer";
     std::string userIndexCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(userIndexClassName.c_str(), userIndexCtorSignature.c_str(),
                                                                    dataResponse.userIndex, userIndex);
     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject daysMask;
     if (!dataResponse.daysMask.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, daysMask);
     }
     else
     {
         std::string daysMaskClassName     = "java/lang/Integer";
         std::string daysMaskCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(daysMaskClassName.c_str(), daysMaskCtorSignature.c_str(),
                                                                       dataResponse.daysMask.Value().Raw(), daysMask);
     }
     jobject startHour;
     if (!dataResponse.startHour.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, startHour);
     }
     else
     {
         std::string startHourClassName     = "java/lang/Integer";
         std::string startHourCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(startHourClassName.c_str(), startHourCtorSignature.c_str(),
                                                                       dataResponse.startHour.Value(), startHour);
     }
     jobject startMinute;
     if (!dataResponse.startMinute.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, startMinute);
     }
     else
     {
         std::string startMinuteClassName     = "java/lang/Integer";
         std::string startMinuteCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
             startMinuteClassName.c_str(), startMinuteCtorSignature.c_str(), dataResponse.startMinute.Value(), startMinute);
     }
     jobject endHour;
     if (!dataResponse.endHour.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, endHour);
     }
     else
     {
         std::string endHourClassName     = "java/lang/Integer";
         std::string endHourCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(endHourClassName.c_str(), endHourCtorSignature.c_str(),
                                                                       dataResponse.endHour.Value(), endHour);
     }
     jobject endMinute;
     if (!dataResponse.endMinute.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, endMinute);
     }
     else
     {
         std::string endMinuteClassName     = "java/lang/Integer";
         std::string endMinuteCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(endMinuteClassName.c_str(), endMinuteCtorSignature.c_str(),
                                                                       dataResponse.endMinute.Value(), endMinute);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, weekDayIndex, userIndex, status, daysMask, startHour, startMinute, endHour,
                         endMinute);
 }
 CHIPDoorLockClusterGetYearDayScheduleResponseCallback::CHIPDoorLockClusterGetYearDayScheduleResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPDoorLockClusterGetYearDayScheduleResponseCallbackType>(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");
     }
 }

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

 void CHIPDoorLockClusterGetYearDayScheduleResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::DoorLock::Commands::GetYearDayScheduleResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPDoorLockClusterGetYearDayScheduleResponseCallback,
                     void (*)(CHIPDoorLockClusterGetYearDayScheduleResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPDoorLockClusterGetYearDayScheduleResponseCallback *>(context),
                     chip::Platform::Delete<CHIPDoorLockClusterGetYearDayScheduleResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess",
         "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject yearDayIndex;
     std::string yearDayIndexClassName     = "java/lang/Integer";
     std::string yearDayIndexCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(yearDayIndexClassName.c_str(), yearDayIndexCtorSignature.c_str(),
                                                                   dataResponse.yearDayIndex, yearDayIndex);
     jobject userIndex;
     std::string userIndexClassName     = "java/lang/Integer";
     std::string userIndexCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(userIndexClassName.c_str(), userIndexCtorSignature.c_str(),
                                                                    dataResponse.userIndex, userIndex);
     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject localStartTime;
     if (!dataResponse.localStartTime.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, localStartTime);
     }
     else
     {
         std::string localStartTimeClassName     = "java/lang/Long";
         std::string localStartTimeCtorSignature = "(J)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(localStartTimeClassName.c_str(),
                                                                        localStartTimeCtorSignature.c_str(),
                                                                        dataResponse.localStartTime.Value(), localStartTime);
     }
     jobject localEndTime;
     if (!dataResponse.localEndTime.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, localEndTime);
     }
     else
     {
         std::string localEndTimeClassName     = "java/lang/Long";
         std::string localEndTimeCtorSignature = "(J)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
             localEndTimeClassName.c_str(), localEndTimeCtorSignature.c_str(), dataResponse.localEndTime.Value(), localEndTime);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, yearDayIndex, userIndex, status, localStartTime, localEndTime);
 }
 CHIPDoorLockClusterSetCredentialResponseCallback::CHIPDoorLockClusterSetCredentialResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPDoorLockClusterSetCredentialResponseCallbackType>(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");
     }
 }

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

 void CHIPDoorLockClusterSetCredentialResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::DoorLock::Commands::SetCredentialResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPDoorLockClusterSetCredentialResponseCallback, void (*)(CHIPDoorLockClusterSetCredentialResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPDoorLockClusterSetCredentialResponseCallback *>(context),
                     chip::Platform::Delete<CHIPDoorLockClusterSetCredentialResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject userIndex;
     if (dataResponse.userIndex.IsNull())
     {
         userIndex = nullptr;
     }
     else
     {
         std::string userIndexClassName     = "java/lang/Integer";
         std::string userIndexCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(userIndexClassName.c_str(), userIndexCtorSignature.c_str(),
                                                                        dataResponse.userIndex.Value(), userIndex);
     }
     jobject nextCredentialIndex;
     if (dataResponse.nextCredentialIndex.IsNull())
     {
         nextCredentialIndex = nullptr;
     }
     else
     {
         std::string nextCredentialIndexClassName     = "java/lang/Integer";
         std::string nextCredentialIndexCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
             nextCredentialIndexClassName.c_str(), nextCredentialIndexCtorSignature.c_str(),
             dataResponse.nextCredentialIndex.Value(), nextCredentialIndex);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, userIndex, nextCredentialIndex);
 }
 CHIPGeneralCommissioningClusterArmFailSafeResponseCallback::CHIPGeneralCommissioningClusterArmFailSafeResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPGeneralCommissioningClusterArmFailSafeResponseCallbackType>(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");
     }
 }

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

 void CHIPGeneralCommissioningClusterArmFailSafeResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGeneralCommissioningClusterArmFailSafeResponseCallback,
                     void (*)(CHIPGeneralCommissioningClusterArmFailSafeResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPGeneralCommissioningClusterArmFailSafeResponseCallback *>(context),
                     chip::Platform::Delete<CHIPGeneralCommissioningClusterArmFailSafeResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject errorCode;
     std::string errorCodeClassName     = "java/lang/Integer";
     std::string errorCodeCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(errorCodeClassName.c_str(), errorCodeCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.errorCode), errorCode);
     jobject debugText;
     debugText = env->NewStringUTF(std::string(dataResponse.debugText.data(), dataResponse.debugText.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, errorCode, debugText);
 }
 CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::
     CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(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");
     }
 }

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

 void CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::CallbackFn(
     void * context,
     const chip::app::Clusters::GeneralCommissioning::Commands::CommissioningCompleteResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback,
                     void (*)(CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback *>(context),
                     chip::Platform::Delete<CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject errorCode;
     std::string errorCodeClassName     = "java/lang/Integer";
     std::string errorCodeCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(errorCodeClassName.c_str(), errorCodeCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.errorCode), errorCode);
     jobject debugText;
     debugText = env->NewStringUTF(std::string(dataResponse.debugText.data(), dataResponse.debugText.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, errorCode, debugText);
 }
 CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::
     CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(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");
     }
 }

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

 void CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::CallbackFn(
     void * context,
     const chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfigResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback,
                     void (*)(CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback *>(context),
                     chip::Platform::Delete<CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject errorCode;
     std::string errorCodeClassName     = "java/lang/Integer";
     std::string errorCodeCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(errorCodeClassName.c_str(), errorCodeCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.errorCode), errorCode);
     jobject debugText;
     debugText = env->NewStringUTF(std::string(dataResponse.debugText.data(), dataResponse.debugText.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, errorCode, debugText);
 }
 CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::
     CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(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");
     }
 }

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

 void CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::CallbackFn(
     void * context,
     const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndicesResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback,
                     void (*)(CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback *>(context),
                     chip::Platform::Delete<CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/ArrayList;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject groupKeySetIDs;
     chip::JniReferences::GetInstance().CreateArrayList(groupKeySetIDs);

     auto iter_groupKeySetIDs_0 = dataResponse.groupKeySetIDs.begin();
     while (iter_groupKeySetIDs_0.Next())
     {
         auto & entry_0 = iter_groupKeySetIDs_0.GetValue();
         jobject newElement_0;
         std::string newElement_0ClassName     = "java/lang/Integer";
         std::string newElement_0CtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(newElement_0ClassName.c_str(),
                                                                        newElement_0CtorSignature.c_str(), entry_0, newElement_0);
         chip::JniReferences::GetInstance().AddToArrayList(groupKeySetIDs, newElement_0);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, groupKeySetIDs);
 }
 CHIPGroupKeyManagementClusterKeySetReadResponseCallback::CHIPGroupKeyManagementClusterKeySetReadResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPGroupKeyManagementClusterKeySetReadResponseCallbackType>(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");
     }
 }

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

 void CHIPGroupKeyManagementClusterKeySetReadResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGroupKeyManagementClusterKeySetReadResponseCallback,
                     void (*)(CHIPGroupKeyManagementClusterKeySetReadResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPGroupKeyManagementClusterKeySetReadResponseCallback *>(context),
                     chip::Platform::Delete<CHIPGroupKeyManagementClusterKeySetReadResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Lchip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupKeySet;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject groupKeySet;
     jobject groupKeySet_groupKeySetID;
     std::string groupKeySet_groupKeySetIDClassName     = "java/lang/Integer";
     std::string groupKeySet_groupKeySetIDCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
         groupKeySet_groupKeySetIDClassName.c_str(), groupKeySet_groupKeySetIDCtorSignature.c_str(),
         dataResponse.groupKeySet.groupKeySetID, groupKeySet_groupKeySetID);
     jobject groupKeySet_securityPolicy;
     std::string groupKeySet_securityPolicyClassName     = "java/lang/Integer";
     std::string groupKeySet_securityPolicyCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
         groupKeySet_securityPolicyClassName.c_str(), groupKeySet_securityPolicyCtorSignature.c_str(),
         static_cast<uint8_t>(dataResponse.groupKeySet.securityPolicy), groupKeySet_securityPolicy);
     jobject groupKeySet_epochKey0;
     jbyteArray groupKeySet_epochKey0ByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.groupKeySet.epochKey0.size()));
     env->SetByteArrayRegion(groupKeySet_epochKey0ByteArray, 0, static_cast<jsize>(dataResponse.groupKeySet.epochKey0.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.groupKeySet.epochKey0.data()));
     groupKeySet_epochKey0 = groupKeySet_epochKey0ByteArray;
     jobject groupKeySet_epochStartTime0;
     std::string groupKeySet_epochStartTime0ClassName     = "java/lang/Long";
     std::string groupKeySet_epochStartTime0CtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(
         groupKeySet_epochStartTime0ClassName.c_str(), groupKeySet_epochStartTime0CtorSignature.c_str(),
         dataResponse.groupKeySet.epochStartTime0, groupKeySet_epochStartTime0);
     jobject groupKeySet_epochKey1;
     jbyteArray groupKeySet_epochKey1ByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.groupKeySet.epochKey1.size()));
     env->SetByteArrayRegion(groupKeySet_epochKey1ByteArray, 0, static_cast<jsize>(dataResponse.groupKeySet.epochKey1.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.groupKeySet.epochKey1.data()));
     groupKeySet_epochKey1 = groupKeySet_epochKey1ByteArray;
     jobject groupKeySet_epochStartTime1;
     std::string groupKeySet_epochStartTime1ClassName     = "java/lang/Long";
     std::string groupKeySet_epochStartTime1CtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(
         groupKeySet_epochStartTime1ClassName.c_str(), groupKeySet_epochStartTime1CtorSignature.c_str(),
         dataResponse.groupKeySet.epochStartTime1, groupKeySet_epochStartTime1);
     jobject groupKeySet_epochKey2;
     jbyteArray groupKeySet_epochKey2ByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.groupKeySet.epochKey2.size()));
     env->SetByteArrayRegion(groupKeySet_epochKey2ByteArray, 0, static_cast<jsize>(dataResponse.groupKeySet.epochKey2.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.groupKeySet.epochKey2.data()));
     groupKeySet_epochKey2 = groupKeySet_epochKey2ByteArray;
     jobject groupKeySet_epochStartTime2;
     std::string groupKeySet_epochStartTime2ClassName     = "java/lang/Long";
     std::string groupKeySet_epochStartTime2CtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(
         groupKeySet_epochStartTime2ClassName.c_str(), groupKeySet_epochStartTime2CtorSignature.c_str(),
         dataResponse.groupKeySet.epochStartTime2, groupKeySet_epochStartTime2);

     jclass groupKeySetStructClass;
     err = chip::JniReferences::GetInstance().GetClassRef(
         env, "chip/devicecontroller/ChipStructs$GroupKeyManagementClusterGroupKeySet", groupKeySetStructClass);
     VerifyOrReturn(err == CHIP_NO_ERROR,
                    ChipLogError(Zcl, "Could not find class ChipStructs$GroupKeyManagementClusterGroupKeySet"));
     chip::JniClass structJniClass(groupKeySetStructClass);
     jmethodID groupKeySetStructCtor =
         env->GetMethodID(groupKeySetStructClass, "<init>",
                          "(Ljava/lang/Integer;Ljava/lang/Integer;[BLjava/lang/Long;[BLjava/lang/Long;[BLjava/lang/Long;)V");
     VerifyOrReturn(groupKeySetStructCtor != nullptr,
                    ChipLogError(Zcl, "Could not find ChipStructs$GroupKeyManagementClusterGroupKeySet constructor"));

     groupKeySet =
         env->NewObject(groupKeySetStructClass, groupKeySetStructCtor, groupKeySet_groupKeySetID, groupKeySet_securityPolicy,
                        groupKeySet_epochKey0, groupKeySet_epochStartTime0, groupKeySet_epochKey1, groupKeySet_epochStartTime1,
                        groupKeySet_epochKey2, groupKeySet_epochStartTime2);

     env->CallVoidMethod(javaCallbackRef, javaMethod, groupKeySet);
 }
 CHIPGroupsClusterAddGroupResponseCallback::CHIPGroupsClusterAddGroupResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGroupsClusterAddGroupResponseCallbackType>(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");
     }
 }

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

 void CHIPGroupsClusterAddGroupResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Groups::Commands::AddGroupResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGroupsClusterAddGroupResponseCallback, void (*)(CHIPGroupsClusterAddGroupResponseCallback *)> cppCallback(
         reinterpret_cast<CHIPGroupsClusterAddGroupResponseCallback *>(context),
         chip::Platform::Delete<CHIPGroupsClusterAddGroupResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId);
 }
 CHIPGroupsClusterGetGroupMembershipResponseCallback::CHIPGroupsClusterGetGroupMembershipResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGroupsClusterGetGroupMembershipResponseCallbackType>(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");
     }
 }

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

 void CHIPGroupsClusterGetGroupMembershipResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Groups::Commands::GetGroupMembershipResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGroupsClusterGetGroupMembershipResponseCallback,
                     void (*)(CHIPGroupsClusterGetGroupMembershipResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPGroupsClusterGetGroupMembershipResponseCallback *>(context),
                     chip::Platform::Delete<CHIPGroupsClusterGetGroupMembershipResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/util/ArrayList;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject capacity;
     std::string capacityClassName     = "java/lang/Integer";
     std::string capacityCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(capacityClassName.c_str(), capacityCtorSignature.c_str(),
                                                                   dataResponse.capacity, capacity);
     jobject groupList;
     chip::JniReferences::GetInstance().CreateArrayList(groupList);

     auto iter_groupList_0 = dataResponse.groupList.begin();
     while (iter_groupList_0.Next())
     {
         auto & entry_0 = iter_groupList_0.GetValue();
         jobject newElement_0;
         std::string newElement_0ClassName     = "java/lang/Integer";
         std::string newElement_0CtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(newElement_0ClassName.c_str(),
                                                                        newElement_0CtorSignature.c_str(), entry_0, newElement_0);
         chip::JniReferences::GetInstance().AddToArrayList(groupList, newElement_0);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, capacity, groupList);
 }
 CHIPGroupsClusterRemoveGroupResponseCallback::CHIPGroupsClusterRemoveGroupResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGroupsClusterRemoveGroupResponseCallbackType>(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");
     }
 }

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

 void CHIPGroupsClusterRemoveGroupResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Groups::Commands::RemoveGroupResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGroupsClusterRemoveGroupResponseCallback, void (*)(CHIPGroupsClusterRemoveGroupResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPGroupsClusterRemoveGroupResponseCallback *>(context),
                     chip::Platform::Delete<CHIPGroupsClusterRemoveGroupResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId);
 }
 CHIPGroupsClusterViewGroupResponseCallback::CHIPGroupsClusterViewGroupResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGroupsClusterViewGroupResponseCallbackType>(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");
     }
 }

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

 void CHIPGroupsClusterViewGroupResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Groups::Commands::ViewGroupResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPGroupsClusterViewGroupResponseCallback, void (*)(CHIPGroupsClusterViewGroupResponseCallback *)> cppCallback(
         reinterpret_cast<CHIPGroupsClusterViewGroupResponseCallback *>(context),
         chip::Platform::Delete<CHIPGroupsClusterViewGroupResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);
     jobject groupName;
     groupName = env->NewStringUTF(std::string(dataResponse.groupName.data(), dataResponse.groupName.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId, groupName);
 }
 CHIPIdentifyClusterIdentifyQueryResponseCallback::CHIPIdentifyClusterIdentifyQueryResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPIdentifyClusterIdentifyQueryResponseCallbackType>(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");
     }
 }

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

 void CHIPIdentifyClusterIdentifyQueryResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Identify::Commands::IdentifyQueryResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPIdentifyClusterIdentifyQueryResponseCallback, void (*)(CHIPIdentifyClusterIdentifyQueryResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPIdentifyClusterIdentifyQueryResponseCallback *>(context),
                     chip::Platform::Delete<CHIPIdentifyClusterIdentifyQueryResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject timeout;
     std::string timeoutClassName     = "java/lang/Integer";
     std::string timeoutCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(timeoutClassName.c_str(), timeoutCtorSignature.c_str(),
                                                                    dataResponse.timeout, timeout);

     env->CallVoidMethod(javaCallbackRef, javaMethod, timeout);
 }
 CHIPKeypadInputClusterSendKeyResponseCallback::CHIPKeypadInputClusterSendKeyResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPKeypadInputClusterSendKeyResponseCallbackType>(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");
     }
 }

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

 void CHIPKeypadInputClusterSendKeyResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::KeypadInput::Commands::SendKeyResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPKeypadInputClusterSendKeyResponseCallback, void (*)(CHIPKeypadInputClusterSendKeyResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPKeypadInputClusterSendKeyResponseCallback *>(context),
                     chip::Platform::Delete<CHIPKeypadInputClusterSendKeyResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status);
 }
 CHIPMediaPlaybackClusterPlaybackResponseCallback::CHIPMediaPlaybackClusterPlaybackResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPMediaPlaybackClusterPlaybackResponseCallbackType>(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");
     }
 }

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

 void CHIPMediaPlaybackClusterPlaybackResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPMediaPlaybackClusterPlaybackResponseCallback, void (*)(CHIPMediaPlaybackClusterPlaybackResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPMediaPlaybackClusterPlaybackResponseCallback *>(context),
                     chip::Platform::Delete<CHIPMediaPlaybackClusterPlaybackResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status);
 }
 CHIPNetworkCommissioningClusterConnectNetworkResponseCallback::CHIPNetworkCommissioningClusterConnectNetworkResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPNetworkCommissioningClusterConnectNetworkResponseCallbackType>(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");
     }
 }

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

 void CHIPNetworkCommissioningClusterConnectNetworkResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetworkResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPNetworkCommissioningClusterConnectNetworkResponseCallback,
                     void (*)(CHIPNetworkCommissioningClusterConnectNetworkResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPNetworkCommissioningClusterConnectNetworkResponseCallback *>(context),
                     chip::Platform::Delete<CHIPNetworkCommissioningClusterConnectNetworkResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/Long;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject NetworkingStatus;
     std::string NetworkingStatusClassName     = "java/lang/Integer";
     std::string NetworkingStatusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
         NetworkingStatusClassName.c_str(), NetworkingStatusCtorSignature.c_str(),
         static_cast<uint8_t>(dataResponse.networkingStatus), NetworkingStatus);
     jobject DebugText;
     DebugText = env->NewStringUTF(std::string(dataResponse.debugText.data(), dataResponse.debugText.size()).c_str());
     jobject ErrorValue;
     std::string ErrorValueClassName     = "java/lang/Long";
     std::string ErrorValueCtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<int32_t>(ErrorValueClassName.c_str(), ErrorValueCtorSignature.c_str(),
                                                                   dataResponse.errorValue, ErrorValue);

     env->CallVoidMethod(javaCallbackRef, javaMethod, NetworkingStatus, DebugText, ErrorValue);
 }
 CHIPNetworkCommissioningClusterNetworkConfigResponseCallback::CHIPNetworkCommissioningClusterNetworkConfigResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPNetworkCommissioningClusterNetworkConfigResponseCallbackType>(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");
     }
 }

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

 void CHIPNetworkCommissioningClusterNetworkConfigResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPNetworkCommissioningClusterNetworkConfigResponseCallback,
                     void (*)(CHIPNetworkCommissioningClusterNetworkConfigResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPNetworkCommissioningClusterNetworkConfigResponseCallback *>(context),
                     chip::Platform::Delete<CHIPNetworkCommissioningClusterNetworkConfigResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject NetworkingStatus;
     std::string NetworkingStatusClassName     = "java/lang/Integer";
     std::string NetworkingStatusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
         NetworkingStatusClassName.c_str(), NetworkingStatusCtorSignature.c_str(),
         static_cast<uint8_t>(dataResponse.networkingStatus), NetworkingStatus);
     jobject DebugText;
     DebugText = env->NewStringUTF(std::string(dataResponse.debugText.data(), dataResponse.debugText.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, NetworkingStatus, DebugText);
 }
 CHIPNetworkCommissioningClusterScanNetworksResponseCallback::CHIPNetworkCommissioningClusterScanNetworksResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPNetworkCommissioningClusterScanNetworksResponseCallbackType>(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");
     }
 }

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

 void CHIPNetworkCommissioningClusterScanNetworksResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworksResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPNetworkCommissioningClusterScanNetworksResponseCallback,
                     void (*)(CHIPNetworkCommissioningClusterScanNetworksResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPNetworkCommissioningClusterScanNetworksResponseCallback *>(context),
                     chip::Platform::Delete<CHIPNetworkCommissioningClusterScanNetworksResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;Ljava/util/Optional;Ljava/util/Optional;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject NetworkingStatus;
     std::string NetworkingStatusClassName     = "java/lang/Integer";
     std::string NetworkingStatusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
         NetworkingStatusClassName.c_str(), NetworkingStatusCtorSignature.c_str(),
         static_cast<uint8_t>(dataResponse.networkingStatus), NetworkingStatus);
     jobject DebugText;
     DebugText = env->NewStringUTF(std::string(dataResponse.debugText.data(), dataResponse.debugText.size()).c_str());
     jobject WiFiScanResults;
     if (!dataResponse.wiFiScanResults.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, WiFiScanResults);
     }
     else
     {
         chip::JniReferences::GetInstance().CreateArrayList(WiFiScanResults);

         auto iter_WiFiScanResults_1 = dataResponse.wiFiScanResults.Value().begin();
         while (iter_WiFiScanResults_1.Next())
         {
             auto & entry_1 = iter_WiFiScanResults_1.GetValue();
             jobject newElement_1;
             jobject newElement_1_security;
             std::string newElement_1_securityClassName     = "java/lang/Integer";
             std::string newElement_1_securityCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(newElement_1_securityClassName.c_str(),
                                                                           newElement_1_securityCtorSignature.c_str(),
                                                                           entry_1.security, newElement_1_security);
             jobject newElement_1_ssid;
             jbyteArray newElement_1_ssidByteArray = env->NewByteArray(static_cast<jsize>(entry_1.ssid.size()));
             env->SetByteArrayRegion(newElement_1_ssidByteArray, 0, static_cast<jsize>(entry_1.ssid.size()),
                                     reinterpret_cast<const jbyte *>(entry_1.ssid.data()));
             newElement_1_ssid = newElement_1_ssidByteArray;
             jobject newElement_1_bssid;
             jbyteArray newElement_1_bssidByteArray = env->NewByteArray(static_cast<jsize>(entry_1.bssid.size()));
             env->SetByteArrayRegion(newElement_1_bssidByteArray, 0, static_cast<jsize>(entry_1.bssid.size()),
                                     reinterpret_cast<const jbyte *>(entry_1.bssid.data()));
             newElement_1_bssid = newElement_1_bssidByteArray;
             jobject newElement_1_channel;
             std::string newElement_1_channelClassName     = "java/lang/Integer";
             std::string newElement_1_channelCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(newElement_1_channelClassName.c_str(),
                                                                            newElement_1_channelCtorSignature.c_str(),
                                                                            entry_1.channel, newElement_1_channel);
             jobject newElement_1_wiFiBand;
             std::string newElement_1_wiFiBandClassName     = "java/lang/Integer";
             std::string newElement_1_wiFiBandCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
                 newElement_1_wiFiBandClassName.c_str(), newElement_1_wiFiBandCtorSignature.c_str(),
                 static_cast<uint8_t>(entry_1.wiFiBand), newElement_1_wiFiBand);
             jobject newElement_1_rssi;
             std::string newElement_1_rssiClassName     = "java/lang/Integer";
             std::string newElement_1_rssiCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<int8_t>(
                 newElement_1_rssiClassName.c_str(), newElement_1_rssiCtorSignature.c_str(), entry_1.rssi, newElement_1_rssi);

             jclass wiFiInterfaceScanResultStructClass;
             err = chip::JniReferences::GetInstance().GetClassRef(
                 env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterWiFiInterfaceScanResult",
                 wiFiInterfaceScanResultStructClass);
             VerifyOrReturn(
                 err == CHIP_NO_ERROR,
                 ChipLogError(Zcl, "Could not find class ChipStructs$NetworkCommissioningClusterWiFiInterfaceScanResult"));
             chip::JniClass structJniClass(wiFiInterfaceScanResultStructClass);
             jmethodID wiFiInterfaceScanResultStructCtor =
                 env->GetMethodID(wiFiInterfaceScanResultStructClass, "<init>",
                                  "(Ljava/lang/Integer;[B[BLjava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V");
             VerifyOrReturn(
                 wiFiInterfaceScanResultStructCtor != nullptr,
                 ChipLogError(Zcl, "Could not find ChipStructs$NetworkCommissioningClusterWiFiInterfaceScanResult constructor"));

             newElement_1 = env->NewObject(wiFiInterfaceScanResultStructClass, wiFiInterfaceScanResultStructCtor,
                                           newElement_1_security, newElement_1_ssid, newElement_1_bssid, newElement_1_channel,
                                           newElement_1_wiFiBand, newElement_1_rssi);
             chip::JniReferences::GetInstance().AddToArrayList(WiFiScanResults, newElement_1);
         }
     }
     jobject ThreadScanResults;
     if (!dataResponse.threadScanResults.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, ThreadScanResults);
     }
     else
     {
         chip::JniReferences::GetInstance().CreateArrayList(ThreadScanResults);

         auto iter_ThreadScanResults_1 = dataResponse.threadScanResults.Value().begin();
         while (iter_ThreadScanResults_1.Next())
         {
             auto & entry_1 = iter_ThreadScanResults_1.GetValue();
             jobject newElement_1;
             jobject newElement_1_panId;
             std::string newElement_1_panIdClassName     = "java/lang/Long";
             std::string newElement_1_panIdCtorSignature = "(J)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(
                 newElement_1_panIdClassName.c_str(), newElement_1_panIdCtorSignature.c_str(), entry_1.panId, newElement_1_panId);
             jobject newElement_1_extendedPanId;
             std::string newElement_1_extendedPanIdClassName     = "java/lang/Long";
             std::string newElement_1_extendedPanIdCtorSignature = "(J)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(newElement_1_extendedPanIdClassName.c_str(),
                                                                            newElement_1_extendedPanIdCtorSignature.c_str(),
                                                                            entry_1.extendedPanId, newElement_1_extendedPanId);
             jobject newElement_1_networkName;
             newElement_1_networkName =
                 env->NewStringUTF(std::string(entry_1.networkName.data(), entry_1.networkName.size()).c_str());
             jobject newElement_1_channel;
             std::string newElement_1_channelClassName     = "java/lang/Integer";
             std::string newElement_1_channelCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(newElement_1_channelClassName.c_str(),
                                                                            newElement_1_channelCtorSignature.c_str(),
                                                                            entry_1.channel, newElement_1_channel);
             jobject newElement_1_version;
             std::string newElement_1_versionClassName     = "java/lang/Integer";
             std::string newElement_1_versionCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(newElement_1_versionClassName.c_str(),
                                                                           newElement_1_versionCtorSignature.c_str(),
                                                                           entry_1.version, newElement_1_version);
             jobject newElement_1_extendedAddress;
             std::string newElement_1_extendedAddressClassName     = "java/lang/Long";
             std::string newElement_1_extendedAddressCtorSignature = "(J)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(newElement_1_extendedAddressClassName.c_str(),
                                                                            newElement_1_extendedAddressCtorSignature.c_str(),
                                                                            entry_1.extendedAddress, newElement_1_extendedAddress);
             jobject newElement_1_rssi;
             std::string newElement_1_rssiClassName     = "java/lang/Integer";
             std::string newElement_1_rssiCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<int8_t>(
                 newElement_1_rssiClassName.c_str(), newElement_1_rssiCtorSignature.c_str(), entry_1.rssi, newElement_1_rssi);
             jobject newElement_1_lqi;
             std::string newElement_1_lqiClassName     = "java/lang/Integer";
             std::string newElement_1_lqiCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
                 newElement_1_lqiClassName.c_str(), newElement_1_lqiCtorSignature.c_str(), entry_1.lqi, newElement_1_lqi);

             jclass threadInterfaceScanResultStructClass;
             err = chip::JniReferences::GetInstance().GetClassRef(
                 env, "chip/devicecontroller/ChipStructs$NetworkCommissioningClusterThreadInterfaceScanResult",
                 threadInterfaceScanResultStructClass);
             VerifyOrReturn(
                 err == CHIP_NO_ERROR,
                 ChipLogError(Zcl, "Could not find class ChipStructs$NetworkCommissioningClusterThreadInterfaceScanResult"));
             chip::JniClass structJniClass(threadInterfaceScanResultStructClass);
             jmethodID threadInterfaceScanResultStructCtor =
                 env->GetMethodID(threadInterfaceScanResultStructClass, "<init>",
                                  "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/"
                                  "lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V");
             VerifyOrReturn(
                 threadInterfaceScanResultStructCtor != nullptr,
                 ChipLogError(Zcl, "Could not find ChipStructs$NetworkCommissioningClusterThreadInterfaceScanResult constructor"));

             newElement_1 =
                 env->NewObject(threadInterfaceScanResultStructClass, threadInterfaceScanResultStructCtor, newElement_1_panId,
                                newElement_1_extendedPanId, newElement_1_networkName, newElement_1_channel, newElement_1_version,
                                newElement_1_extendedAddress, newElement_1_rssi, newElement_1_lqi);
             chip::JniReferences::GetInstance().AddToArrayList(ThreadScanResults, newElement_1);
         }
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, NetworkingStatus, DebugText, WiFiScanResults, ThreadScanResults);
 }
 CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback::CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(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");
     }
 }

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

 void CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback::CallbackFn(
     void * context,
     const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback,
                     void (*)(CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback *>(context),
                     chip::Platform::Delete<CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/Long;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject action;
     std::string actionClassName     = "java/lang/Integer";
     std::string actionCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(actionClassName.c_str(), actionCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.action), action);
     jobject delayedActionTime;
     std::string delayedActionTimeClassName     = "java/lang/Long";
     std::string delayedActionTimeCtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(delayedActionTimeClassName.c_str(),
                                                                    delayedActionTimeCtorSignature.c_str(),
                                                                    dataResponse.delayedActionTime, delayedActionTime);

     env->CallVoidMethod(javaCallbackRef, javaMethod, action, delayedActionTime);
 }
 CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback::CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(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");
     }
 }

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

 void CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback::CallbackFn(
     void * context,
     const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback,
                     void (*)(CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback *>(context),
                     chip::Platform::Delete<CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess",
         "(Ljava/lang/Integer;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/"
         "Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject delayedActionTime;
     if (!dataResponse.delayedActionTime.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, delayedActionTime);
     }
     else
     {
         std::string delayedActionTimeClassName     = "java/lang/Long";
         std::string delayedActionTimeCtorSignature = "(J)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(delayedActionTimeClassName.c_str(),
                                                                        delayedActionTimeCtorSignature.c_str(),
                                                                        dataResponse.delayedActionTime.Value(), delayedActionTime);
     }
     jobject imageURI;
     if (!dataResponse.imageURI.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, imageURI);
     }
     else
     {
         imageURI =
             env->NewStringUTF(std::string(dataResponse.imageURI.Value().data(), dataResponse.imageURI.Value().size()).c_str());
     }
     jobject softwareVersion;
     if (!dataResponse.softwareVersion.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, softwareVersion);
     }
     else
     {
         std::string softwareVersionClassName     = "java/lang/Long";
         std::string softwareVersionCtorSignature = "(J)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(softwareVersionClassName.c_str(),
                                                                        softwareVersionCtorSignature.c_str(),
                                                                        dataResponse.softwareVersion.Value(), softwareVersion);
     }
     jobject softwareVersionString;
     if (!dataResponse.softwareVersionString.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, softwareVersionString);
     }
     else
     {
         softwareVersionString = env->NewStringUTF(
             std::string(dataResponse.softwareVersionString.Value().data(), dataResponse.softwareVersionString.Value().size())
                 .c_str());
     }
     jobject updateToken;
     if (!dataResponse.updateToken.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, updateToken);
     }
     else
     {
         jbyteArray updateTokenByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.updateToken.Value().size()));
         env->SetByteArrayRegion(updateTokenByteArray, 0, static_cast<jsize>(dataResponse.updateToken.Value().size()),
                                 reinterpret_cast<const jbyte *>(dataResponse.updateToken.Value().data()));
         updateToken = updateTokenByteArray;
     }
     jobject userConsentNeeded;
     if (!dataResponse.userConsentNeeded.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, userConsentNeeded);
     }
     else
     {
         std::string userConsentNeededClassName     = "java/lang/Boolean";
         std::string userConsentNeededCtorSignature = "(Z)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<bool>(userConsentNeededClassName.c_str(),
                                                                    userConsentNeededCtorSignature.c_str(),
                                                                    dataResponse.userConsentNeeded.Value(), userConsentNeeded);
     }
     jobject metadataForRequestor;
     if (!dataResponse.metadataForRequestor.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, metadataForRequestor);
     }
     else
     {
         jbyteArray metadataForRequestorByteArray =
             env->NewByteArray(static_cast<jsize>(dataResponse.metadataForRequestor.Value().size()));
         env->SetByteArrayRegion(metadataForRequestorByteArray, 0,
                                 static_cast<jsize>(dataResponse.metadataForRequestor.Value().size()),
                                 reinterpret_cast<const jbyte *>(dataResponse.metadataForRequestor.Value().data()));
         metadataForRequestor = metadataForRequestorByteArray;
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, delayedActionTime, imageURI, softwareVersion, softwareVersionString,
                         updateToken, userConsentNeeded, metadataForRequestor);
 }
 CHIPOperationalCredentialsClusterAttestationResponseCallback::CHIPOperationalCredentialsClusterAttestationResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPOperationalCredentialsClusterAttestationResponseCallbackType>(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");
     }
 }

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

 void CHIPOperationalCredentialsClusterAttestationResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::OperationalCredentials::Commands::AttestationResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPOperationalCredentialsClusterAttestationResponseCallback,
                     void (*)(CHIPOperationalCredentialsClusterAttestationResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPOperationalCredentialsClusterAttestationResponseCallback *>(context),
                     chip::Platform::Delete<CHIPOperationalCredentialsClusterAttestationResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "([B[B)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject AttestationElements;
     jbyteArray AttestationElementsByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.attestationElements.size()));
     env->SetByteArrayRegion(AttestationElementsByteArray, 0, static_cast<jsize>(dataResponse.attestationElements.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.attestationElements.data()));
     AttestationElements = AttestationElementsByteArray;
     jobject Signature;
     jbyteArray SignatureByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.signature.size()));
     env->SetByteArrayRegion(SignatureByteArray, 0, static_cast<jsize>(dataResponse.signature.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.signature.data()));
     Signature = SignatureByteArray;

     env->CallVoidMethod(javaCallbackRef, javaMethod, AttestationElements, Signature);
 }
 CHIPOperationalCredentialsClusterCertificateChainResponseCallback::
     CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPOperationalCredentialsClusterCertificateChainResponseCallbackType>(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");
     }
 }

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

 void CHIPOperationalCredentialsClusterCertificateChainResponseCallback::CallbackFn(
     void * context,
     const chip::app::Clusters::OperationalCredentials::Commands::CertificateChainResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPOperationalCredentialsClusterCertificateChainResponseCallback,
                     void (*)(CHIPOperationalCredentialsClusterCertificateChainResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPOperationalCredentialsClusterCertificateChainResponseCallback *>(context),
                     chip::Platform::Delete<CHIPOperationalCredentialsClusterCertificateChainResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "([B)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject Certificate;
     jbyteArray CertificateByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.certificate.size()));
     env->SetByteArrayRegion(CertificateByteArray, 0, static_cast<jsize>(dataResponse.certificate.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.certificate.data()));
     Certificate = CertificateByteArray;

     env->CallVoidMethod(javaCallbackRef, javaMethod, Certificate);
 }
 CHIPOperationalCredentialsClusterNOCResponseCallback::CHIPOperationalCredentialsClusterNOCResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPOperationalCredentialsClusterNOCResponseCallbackType>(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");
     }
 }

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

 void CHIPOperationalCredentialsClusterNOCResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPOperationalCredentialsClusterNOCResponseCallback,
                     void (*)(CHIPOperationalCredentialsClusterNOCResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPOperationalCredentialsClusterNOCResponseCallback *>(context),
                     chip::Platform::Delete<CHIPOperationalCredentialsClusterNOCResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject StatusCode;
     std::string StatusCodeClassName     = "java/lang/Integer";
     std::string StatusCodeCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(StatusCodeClassName.c_str(), StatusCodeCtorSignature.c_str(),
                                                                   dataResponse.statusCode, StatusCode);
     jobject FabricIndex;
     std::string FabricIndexClassName     = "java/lang/Integer";
     std::string FabricIndexCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(FabricIndexClassName.c_str(), FabricIndexCtorSignature.c_str(),
                                                                   dataResponse.fabricIndex, FabricIndex);
     jobject DebugText;
     DebugText = env->NewStringUTF(std::string(dataResponse.debugText.data(), dataResponse.debugText.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, StatusCode, FabricIndex, DebugText);
 }
 CHIPOperationalCredentialsClusterOpCSRResponseCallback::CHIPOperationalCredentialsClusterOpCSRResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPOperationalCredentialsClusterOpCSRResponseCallbackType>(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");
     }
 }

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

 void CHIPOperationalCredentialsClusterOpCSRResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::OperationalCredentials::Commands::OpCSRResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPOperationalCredentialsClusterOpCSRResponseCallback,
                     void (*)(CHIPOperationalCredentialsClusterOpCSRResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPOperationalCredentialsClusterOpCSRResponseCallback *>(context),
                     chip::Platform::Delete<CHIPOperationalCredentialsClusterOpCSRResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "([B[B)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject NOCSRElements;
     jbyteArray NOCSRElementsByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.NOCSRElements.size()));
     env->SetByteArrayRegion(NOCSRElementsByteArray, 0, static_cast<jsize>(dataResponse.NOCSRElements.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.NOCSRElements.data()));
     NOCSRElements = NOCSRElementsByteArray;
     jobject AttestationSignature;
     jbyteArray AttestationSignatureByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.attestationSignature.size()));
     env->SetByteArrayRegion(AttestationSignatureByteArray, 0, static_cast<jsize>(dataResponse.attestationSignature.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.attestationSignature.data()));
     AttestationSignature = AttestationSignatureByteArray;

     env->CallVoidMethod(javaCallbackRef, javaMethod, NOCSRElements, AttestationSignature);
 }
 CHIPScenesClusterAddSceneResponseCallback::CHIPScenesClusterAddSceneResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPScenesClusterAddSceneResponseCallbackType>(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");
     }
 }

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

 void CHIPScenesClusterAddSceneResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Scenes::Commands::AddSceneResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPScenesClusterAddSceneResponseCallback, void (*)(CHIPScenesClusterAddSceneResponseCallback *)> cppCallback(
         reinterpret_cast<CHIPScenesClusterAddSceneResponseCallback *>(context),
         chip::Platform::Delete<CHIPScenesClusterAddSceneResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);
     jobject sceneId;
     std::string sceneIdClassName     = "java/lang/Integer";
     std::string sceneIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(sceneIdClassName.c_str(), sceneIdCtorSignature.c_str(),
                                                                   dataResponse.sceneId, sceneId);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId, sceneId);
 }
 CHIPScenesClusterGetSceneMembershipResponseCallback::CHIPScenesClusterGetSceneMembershipResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPScenesClusterGetSceneMembershipResponseCallbackType>(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");
     }
 }

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

 void CHIPScenesClusterGetSceneMembershipResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Scenes::Commands::GetSceneMembershipResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPScenesClusterGetSceneMembershipResponseCallback,
                     void (*)(CHIPScenesClusterGetSceneMembershipResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPScenesClusterGetSceneMembershipResponseCallback *>(context),
                     chip::Platform::Delete<CHIPScenesClusterGetSceneMembershipResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess",
         "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/ArrayList;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject capacity;
     std::string capacityClassName     = "java/lang/Integer";
     std::string capacityCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(capacityClassName.c_str(), capacityCtorSignature.c_str(),
                                                                   dataResponse.capacity, capacity);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);
     jobject sceneCount;
     std::string sceneCountClassName     = "java/lang/Integer";
     std::string sceneCountCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(sceneCountClassName.c_str(), sceneCountCtorSignature.c_str(),
                                                                   dataResponse.sceneCount, sceneCount);
     jobject sceneList;
     chip::JniReferences::GetInstance().CreateArrayList(sceneList);

     auto iter_sceneList_0 = dataResponse.sceneList.begin();
     while (iter_sceneList_0.Next())
     {
         auto & entry_0 = iter_sceneList_0.GetValue();
         jobject newElement_0;
         std::string newElement_0ClassName     = "java/lang/Integer";
         std::string newElement_0CtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(newElement_0ClassName.c_str(),
                                                                       newElement_0CtorSignature.c_str(), entry_0, newElement_0);
         chip::JniReferences::GetInstance().AddToArrayList(sceneList, newElement_0);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, capacity, groupId, sceneCount, sceneList);
 }
 CHIPScenesClusterRemoveAllScenesResponseCallback::CHIPScenesClusterRemoveAllScenesResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPScenesClusterRemoveAllScenesResponseCallbackType>(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");
     }
 }

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

 void CHIPScenesClusterRemoveAllScenesResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Scenes::Commands::RemoveAllScenesResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPScenesClusterRemoveAllScenesResponseCallback, void (*)(CHIPScenesClusterRemoveAllScenesResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPScenesClusterRemoveAllScenesResponseCallback *>(context),
                     chip::Platform::Delete<CHIPScenesClusterRemoveAllScenesResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId);
 }
 CHIPScenesClusterRemoveSceneResponseCallback::CHIPScenesClusterRemoveSceneResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPScenesClusterRemoveSceneResponseCallbackType>(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");
     }
 }

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

 void CHIPScenesClusterRemoveSceneResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Scenes::Commands::RemoveSceneResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPScenesClusterRemoveSceneResponseCallback, void (*)(CHIPScenesClusterRemoveSceneResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPScenesClusterRemoveSceneResponseCallback *>(context),
                     chip::Platform::Delete<CHIPScenesClusterRemoveSceneResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);
     jobject sceneId;
     std::string sceneIdClassName     = "java/lang/Integer";
     std::string sceneIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(sceneIdClassName.c_str(), sceneIdCtorSignature.c_str(),
                                                                   dataResponse.sceneId, sceneId);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId, sceneId);
 }
 CHIPScenesClusterStoreSceneResponseCallback::CHIPScenesClusterStoreSceneResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPScenesClusterStoreSceneResponseCallbackType>(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");
     }
 }

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

 void CHIPScenesClusterStoreSceneResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Scenes::Commands::StoreSceneResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPScenesClusterStoreSceneResponseCallback, void (*)(CHIPScenesClusterStoreSceneResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPScenesClusterStoreSceneResponseCallback *>(context),
                     chip::Platform::Delete<CHIPScenesClusterStoreSceneResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess",
                                                   "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);
     jobject sceneId;
     std::string sceneIdClassName     = "java/lang/Integer";
     std::string sceneIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(sceneIdClassName.c_str(), sceneIdCtorSignature.c_str(),
                                                                   dataResponse.sceneId, sceneId);

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId, sceneId);
 }
 CHIPScenesClusterViewSceneResponseCallback::CHIPScenesClusterViewSceneResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPScenesClusterViewSceneResponseCallbackType>(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");
     }
 }

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

 void CHIPScenesClusterViewSceneResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Scenes::Commands::ViewSceneResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPScenesClusterViewSceneResponseCallback, void (*)(CHIPScenesClusterViewSceneResponseCallback *)> cppCallback(
         reinterpret_cast<CHIPScenesClusterViewSceneResponseCallback *>(context),
         chip::Platform::Delete<CHIPScenesClusterViewSceneResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess",
         "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/String;Ljava/util/ArrayList;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   dataResponse.status, status);
     jobject groupId;
     std::string groupIdClassName     = "java/lang/Integer";
     std::string groupIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(groupIdClassName.c_str(), groupIdCtorSignature.c_str(),
                                                                    dataResponse.groupId, groupId);
     jobject sceneId;
     std::string sceneIdClassName     = "java/lang/Integer";
     std::string sceneIdCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(sceneIdClassName.c_str(), sceneIdCtorSignature.c_str(),
                                                                   dataResponse.sceneId, sceneId);
     jobject transitionTime;
     std::string transitionTimeClassName     = "java/lang/Integer";
     std::string transitionTimeCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
         transitionTimeClassName.c_str(), transitionTimeCtorSignature.c_str(), dataResponse.transitionTime, transitionTime);
     jobject sceneName;
     sceneName = env->NewStringUTF(std::string(dataResponse.sceneName.data(), dataResponse.sceneName.size()).c_str());
     jobject extensionFieldSets;
     chip::JniReferences::GetInstance().CreateArrayList(extensionFieldSets);

     auto iter_extensionFieldSets_0 = dataResponse.extensionFieldSets.begin();
     while (iter_extensionFieldSets_0.Next())
     {
         auto & entry_0 = iter_extensionFieldSets_0.GetValue();
         jobject newElement_0;
         jobject newElement_0_clusterId;
         std::string newElement_0_clusterIdClassName     = "java/lang/Long";
         std::string newElement_0_clusterIdCtorSignature = "(J)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(newElement_0_clusterIdClassName.c_str(),
                                                                        newElement_0_clusterIdCtorSignature.c_str(),
                                                                        entry_0.clusterId, newElement_0_clusterId);
         jobject newElement_0_length;
         std::string newElement_0_lengthClassName     = "java/lang/Integer";
         std::string newElement_0_lengthCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
             newElement_0_lengthClassName.c_str(), newElement_0_lengthCtorSignature.c_str(), entry_0.length, newElement_0_length);
         jobject newElement_0_value;
         std::string newElement_0_valueClassName     = "java/lang/Integer";
         std::string newElement_0_valueCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
             newElement_0_valueClassName.c_str(), newElement_0_valueCtorSignature.c_str(), entry_0.value, newElement_0_value);

         jclass sceneExtensionFieldSetStructClass;
         err = chip::JniReferences::GetInstance().GetClassRef(
             env, "chip/devicecontroller/ChipStructs$ScenesClusterSceneExtensionFieldSet", sceneExtensionFieldSetStructClass);
         VerifyOrReturn(err == CHIP_NO_ERROR,
                        ChipLogError(Zcl, "Could not find class ChipStructs$ScenesClusterSceneExtensionFieldSet"));
         chip::JniClass structJniClass(sceneExtensionFieldSetStructClass);
         jmethodID sceneExtensionFieldSetStructCtor = env->GetMethodID(sceneExtensionFieldSetStructClass, "<init>",
                                                                       "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/lang/Integer;)V");
         VerifyOrReturn(sceneExtensionFieldSetStructCtor != nullptr,
                        ChipLogError(Zcl, "Could not find ChipStructs$ScenesClusterSceneExtensionFieldSet constructor"));

         newElement_0 = env->NewObject(sceneExtensionFieldSetStructClass, sceneExtensionFieldSetStructCtor, newElement_0_clusterId,
                                       newElement_0_length, newElement_0_value);
         chip::JniReferences::GetInstance().AddToArrayList(extensionFieldSets, newElement_0);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, groupId, sceneId, transitionTime, sceneName, extensionFieldSets);
 }
 CHIPTargetNavigatorClusterNavigateTargetResponseCallback::CHIPTargetNavigatorClusterNavigateTargetResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPTargetNavigatorClusterNavigateTargetResponseCallbackType>(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");
     }
 }

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

 void CHIPTargetNavigatorClusterNavigateTargetResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TargetNavigator::Commands::NavigateTargetResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTargetNavigatorClusterNavigateTargetResponseCallback,
                     void (*)(CHIPTargetNavigatorClusterNavigateTargetResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTargetNavigatorClusterNavigateTargetResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTargetNavigatorClusterNavigateTargetResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/String;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject status;
     std::string statusClassName     = "java/lang/Integer";
     std::string statusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(statusClassName.c_str(), statusCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.status), status);
     jobject data;
     data = env->NewStringUTF(std::string(dataResponse.data.data(), dataResponse.data.size()).c_str());

     env->CallVoidMethod(javaCallbackRef, javaMethod, status, data);
 }
 CHIPTestClusterClusterBooleanResponseCallback::CHIPTestClusterClusterBooleanResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterBooleanResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterBooleanResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterBooleanResponseCallback, void (*)(CHIPTestClusterClusterBooleanResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterBooleanResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterBooleanResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Boolean;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject value;
     std::string valueClassName     = "java/lang/Boolean";
     std::string valueCtorSignature = "(Z)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<bool>(valueClassName.c_str(), valueCtorSignature.c_str(),
                                                                dataResponse.value, value);

     env->CallVoidMethod(javaCallbackRef, javaMethod, value);
 }
 CHIPTestClusterClusterSimpleStructResponseCallback::CHIPTestClusterClusterSimpleStructResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterSimpleStructResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterSimpleStructResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterSimpleStructResponseCallback,
                     void (*)(CHIPTestClusterClusterSimpleStructResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterSimpleStructResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterSimpleStructResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess", "(Lchip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject arg1;
     jobject arg1_a;
     std::string arg1_aClassName     = "java/lang/Integer";
     std::string arg1_aCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(arg1_aClassName.c_str(), arg1_aCtorSignature.c_str(),
                                                                   dataResponse.arg1.a, arg1_a);
     jobject arg1_b;
     std::string arg1_bClassName     = "java/lang/Boolean";
     std::string arg1_bCtorSignature = "(Z)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<bool>(arg1_bClassName.c_str(), arg1_bCtorSignature.c_str(),
                                                                dataResponse.arg1.b, arg1_b);
     jobject arg1_c;
     std::string arg1_cClassName     = "java/lang/Integer";
     std::string arg1_cCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(arg1_cClassName.c_str(), arg1_cCtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.arg1.c), arg1_c);
     jobject arg1_d;
     jbyteArray arg1_dByteArray = env->NewByteArray(static_cast<jsize>(dataResponse.arg1.d.size()));
     env->SetByteArrayRegion(arg1_dByteArray, 0, static_cast<jsize>(dataResponse.arg1.d.size()),
                             reinterpret_cast<const jbyte *>(dataResponse.arg1.d.data()));
     arg1_d = arg1_dByteArray;
     jobject arg1_e;
     arg1_e = env->NewStringUTF(std::string(dataResponse.arg1.e.data(), dataResponse.arg1.e.size()).c_str());
     jobject arg1_f;
     std::string arg1_fClassName     = "java/lang/Integer";
     std::string arg1_fCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(arg1_fClassName.c_str(), arg1_fCtorSignature.c_str(),
                                                                   dataResponse.arg1.f.Raw(), arg1_f);
     jobject arg1_g;
     std::string arg1_gClassName     = "java/lang/Float";
     std::string arg1_gCtorSignature = "(F)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<float>(arg1_gClassName.c_str(), arg1_gCtorSignature.c_str(),
                                                                 dataResponse.arg1.g, arg1_g);
     jobject arg1_h;
     std::string arg1_hClassName     = "java/lang/Double";
     std::string arg1_hCtorSignature = "(D)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<double>(arg1_hClassName.c_str(), arg1_hCtorSignature.c_str(),
                                                                  dataResponse.arg1.h, arg1_h);

     jclass simpleStructStructClass;
     err = chip::JniReferences::GetInstance().GetClassRef(env, "chip/devicecontroller/ChipStructs$TestClusterClusterSimpleStruct",
                                                          simpleStructStructClass);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find class ChipStructs$TestClusterClusterSimpleStruct"));
     chip::JniClass structJniClass(simpleStructStructClass);
     jmethodID simpleStructStructCtor = env->GetMethodID(simpleStructStructClass, "<init>",
                                                         "(Ljava/lang/Integer;Ljava/lang/Boolean;Ljava/lang/Integer;[BLjava/lang/"
                                                         "String;Ljava/lang/Integer;Ljava/lang/Float;Ljava/lang/Double;)V");
     VerifyOrReturn(simpleStructStructCtor != nullptr,
                    ChipLogError(Zcl, "Could not find ChipStructs$TestClusterClusterSimpleStruct constructor"));

     arg1 = env->NewObject(simpleStructStructClass, simpleStructStructCtor, arg1_a, arg1_b, arg1_c, arg1_d, arg1_e, arg1_f, arg1_g,
                           arg1_h);

     env->CallVoidMethod(javaCallbackRef, javaMethod, arg1);
 }
 CHIPTestClusterClusterTestAddArgumentsResponseCallback::CHIPTestClusterClusterTestAddArgumentsResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterTestAddArgumentsResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterTestAddArgumentsResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterTestAddArgumentsResponseCallback,
                     void (*)(CHIPTestClusterClusterTestAddArgumentsResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterTestAddArgumentsResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterTestAddArgumentsResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject returnValue;
     std::string returnValueClassName     = "java/lang/Integer";
     std::string returnValueCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(returnValueClassName.c_str(), returnValueCtorSignature.c_str(),
                                                                   dataResponse.returnValue, returnValue);

     env->CallVoidMethod(javaCallbackRef, javaMethod, returnValue);
 }
 CHIPTestClusterClusterTestEmitTestEventResponseCallback::CHIPTestClusterClusterTestEmitTestEventResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterTestEmitTestEventResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterTestEmitTestEventResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::TestEmitTestEventResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterTestEmitTestEventResponseCallback,
                     void (*)(CHIPTestClusterClusterTestEmitTestEventResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterTestEmitTestEventResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterTestEmitTestEventResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject value;
     std::string valueClassName     = "java/lang/Long";
     std::string valueCtorSignature = "(J)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint64_t>(valueClassName.c_str(), valueCtorSignature.c_str(),
                                                                    dataResponse.value, value);

     env->CallVoidMethod(javaCallbackRef, javaMethod, value);
 }
 CHIPTestClusterClusterTestEnumsResponseCallback::CHIPTestClusterClusterTestEnumsResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterTestEnumsResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterTestEnumsResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::TestEnumsResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterTestEnumsResponseCallback, void (*)(CHIPTestClusterClusterTestEnumsResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterTestEnumsResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterTestEnumsResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/Integer;)V",
                                                   &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject arg1;
     std::string arg1ClassName     = "java/lang/Integer";
     std::string arg1CtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(arg1ClassName.c_str(), arg1CtorSignature.c_str(),
                                                                    static_cast<uint16_t>(dataResponse.arg1), arg1);
     jobject arg2;
     std::string arg2ClassName     = "java/lang/Integer";
     std::string arg2CtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(arg2ClassName.c_str(), arg2CtorSignature.c_str(),
                                                                   static_cast<uint8_t>(dataResponse.arg2), arg2);

     env->CallVoidMethod(javaCallbackRef, javaMethod, arg1, arg2);
 }
 CHIPTestClusterClusterTestListInt8UReverseResponseCallback::CHIPTestClusterClusterTestListInt8UReverseResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterTestListInt8UReverseResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterTestListInt8UReverseResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterTestListInt8UReverseResponseCallback,
                     void (*)(CHIPTestClusterClusterTestListInt8UReverseResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterTestListInt8UReverseResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterTestListInt8UReverseResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/ArrayList;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject arg1;
     chip::JniReferences::GetInstance().CreateArrayList(arg1);

     auto iter_arg1_0 = dataResponse.arg1.begin();
     while (iter_arg1_0.Next())
     {
         auto & entry_0 = iter_arg1_0.GetValue();
         jobject newElement_0;
         std::string newElement_0ClassName     = "java/lang/Integer";
         std::string newElement_0CtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(newElement_0ClassName.c_str(),
                                                                       newElement_0CtorSignature.c_str(), entry_0, newElement_0);
         chip::JniReferences::GetInstance().AddToArrayList(arg1, newElement_0);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, arg1);
 }
 CHIPTestClusterClusterTestNullableOptionalResponseCallback::CHIPTestClusterClusterTestNullableOptionalResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterTestNullableOptionalResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterTestNullableOptionalResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::TestNullableOptionalResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterTestNullableOptionalResponseCallback,
                     void (*)(CHIPTestClusterClusterTestNullableOptionalResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterTestNullableOptionalResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterTestNullableOptionalResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess", "(Ljava/lang/Boolean;Ljava/util/Optional;Ljava/util/Optional;Ljava/util/Optional;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject wasPresent;
     std::string wasPresentClassName     = "java/lang/Boolean";
     std::string wasPresentCtorSignature = "(Z)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<bool>(wasPresentClassName.c_str(), wasPresentCtorSignature.c_str(),
                                                                dataResponse.wasPresent, wasPresent);
     jobject wasNull;
     if (!dataResponse.wasNull.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, wasNull);
     }
     else
     {
         std::string wasNullClassName     = "java/lang/Boolean";
         std::string wasNullCtorSignature = "(Z)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<bool>(wasNullClassName.c_str(), wasNullCtorSignature.c_str(),
                                                                    dataResponse.wasNull.Value(), wasNull);
     }
     jobject value;
     if (!dataResponse.value.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, value);
     }
     else
     {
         std::string valueClassName     = "java/lang/Integer";
         std::string valueCtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(valueClassName.c_str(), valueCtorSignature.c_str(),
                                                                       dataResponse.value.Value(), value);
     }
     jobject originalValue;
     if (!dataResponse.originalValue.HasValue())
     {
         chip::JniReferences::GetInstance().CreateOptional(nullptr, originalValue);
     }
     else
     {
         if (dataResponse.originalValue.Value().IsNull())
         {
             originalValue = nullptr;
         }
         else
         {
             std::string originalValueClassName     = "java/lang/Integer";
             std::string originalValueCtorSignature = "(I)V";
             chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
                 originalValueClassName.c_str(), originalValueCtorSignature.c_str(), dataResponse.originalValue.Value().Value(),
                 originalValue);
         }
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, wasPresent, wasNull, value, originalValue);
 }
 CHIPTestClusterClusterTestSpecificResponseCallback::CHIPTestClusterClusterTestSpecificResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPTestClusterClusterTestSpecificResponseCallbackType>(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");
     }
 }

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

 void CHIPTestClusterClusterTestSpecificResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::TestCluster::Commands::TestSpecificResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPTestClusterClusterTestSpecificResponseCallback,
                     void (*)(CHIPTestClusterClusterTestSpecificResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPTestClusterClusterTestSpecificResponseCallback *>(context),
                     chip::Platform::Delete<CHIPTestClusterClusterTestSpecificResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject returnValue;
     std::string returnValueClassName     = "java/lang/Integer";
     std::string returnValueCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(returnValueClassName.c_str(), returnValueCtorSignature.c_str(),
                                                                   dataResponse.returnValue, returnValue);

     env->CallVoidMethod(javaCallbackRef, javaMethod, returnValue);
 }
 CHIPThermostatClusterGetRelayStatusLogResponseCallback::CHIPThermostatClusterGetRelayStatusLogResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPThermostatClusterGetRelayStatusLogResponseCallbackType>(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");
     }
 }

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

 void CHIPThermostatClusterGetRelayStatusLogResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Thermostat::Commands::GetRelayStatusLogResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPThermostatClusterGetRelayStatusLogResponseCallback,
                     void (*)(CHIPThermostatClusterGetRelayStatusLogResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPThermostatClusterGetRelayStatusLogResponseCallback *>(context),
                     chip::Platform::Delete<CHIPThermostatClusterGetRelayStatusLogResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess",
         "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject timeOfDay;
     std::string timeOfDayClassName     = "java/lang/Integer";
     std::string timeOfDayCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(timeOfDayClassName.c_str(), timeOfDayCtorSignature.c_str(),
                                                                    dataResponse.timeOfDay, timeOfDay);
     jobject relayStatus;
     std::string relayStatusClassName     = "java/lang/Integer";
     std::string relayStatusCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(relayStatusClassName.c_str(), relayStatusCtorSignature.c_str(),
                                                                    dataResponse.relayStatus, relayStatus);
     jobject localTemperature;
     std::string localTemperatureClassName     = "java/lang/Integer";
     std::string localTemperatureCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<int16_t>(
         localTemperatureClassName.c_str(), localTemperatureCtorSignature.c_str(), dataResponse.localTemperature, localTemperature);
     jobject humidityInPercentage;
     std::string humidityInPercentageClassName     = "java/lang/Integer";
     std::string humidityInPercentageCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(humidityInPercentageClassName.c_str(),
                                                                   humidityInPercentageCtorSignature.c_str(),
                                                                   dataResponse.humidityInPercentage, humidityInPercentage);
     jobject setpoint;
     std::string setpointClassName     = "java/lang/Integer";
     std::string setpointCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<int16_t>(setpointClassName.c_str(), setpointCtorSignature.c_str(),
                                                                   dataResponse.setpoint, setpoint);
     jobject unreadEntries;
     std::string unreadEntriesClassName     = "java/lang/Integer";
     std::string unreadEntriesCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(
         unreadEntriesClassName.c_str(), unreadEntriesCtorSignature.c_str(), dataResponse.unreadEntries, unreadEntries);

     env->CallVoidMethod(javaCallbackRef, javaMethod, timeOfDay, relayStatus, localTemperature, humidityInPercentage, setpoint,
                         unreadEntries);
 }
 CHIPThermostatClusterGetWeeklyScheduleResponseCallback::CHIPThermostatClusterGetWeeklyScheduleResponseCallback(
     jobject javaCallback) :
     Callback::Callback<CHIPThermostatClusterGetWeeklyScheduleResponseCallbackType>(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");
     }
 }

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

 void CHIPThermostatClusterGetWeeklyScheduleResponseCallback::CallbackFn(
     void * context, const chip::app::Clusters::Thermostat::Commands::GetWeeklyScheduleResponse::DecodableType & dataResponse)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = JniReferences::GetInstance().GetEnvForCurrentThread();
     jobject javaCallbackRef;
     jmethodID javaMethod;

     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv"));

     std::unique_ptr<CHIPThermostatClusterGetWeeklyScheduleResponseCallback,
                     void (*)(CHIPThermostatClusterGetWeeklyScheduleResponseCallback *)>
         cppCallback(reinterpret_cast<CHIPThermostatClusterGetWeeklyScheduleResponseCallback *>(context),
                     chip::Platform::Delete<CHIPThermostatClusterGetWeeklyScheduleResponseCallback>);
     VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback"));

     javaCallbackRef = cppCallback->javaCallbackRef;
     // Java callback is allowed to be null, exit early if this is the case.
     VerifyOrReturn(javaCallbackRef != nullptr);

     err = JniReferences::GetInstance().FindMethod(
         env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/ArrayList;)V",
         &javaMethod);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err)));

     jobject numberOfTransitionsForSequence;
     std::string numberOfTransitionsForSequenceClassName     = "java/lang/Integer";
     std::string numberOfTransitionsForSequenceCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(
         numberOfTransitionsForSequenceClassName.c_str(), numberOfTransitionsForSequenceCtorSignature.c_str(),
         dataResponse.numberOfTransitionsForSequence, numberOfTransitionsForSequence);
     jobject dayOfWeekForSequence;
     std::string dayOfWeekForSequenceClassName     = "java/lang/Integer";
     std::string dayOfWeekForSequenceCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(dayOfWeekForSequenceClassName.c_str(),
                                                                   dayOfWeekForSequenceCtorSignature.c_str(),
                                                                   dataResponse.dayOfWeekForSequence.Raw(), dayOfWeekForSequence);
     jobject modeForSequence;
     std::string modeForSequenceClassName     = "java/lang/Integer";
     std::string modeForSequenceCtorSignature = "(I)V";
     chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(modeForSequenceClassName.c_str(),
                                                                   modeForSequenceCtorSignature.c_str(),
                                                                   dataResponse.modeForSequence.Raw(), modeForSequence);
     jobject payload;
     chip::JniReferences::GetInstance().CreateArrayList(payload);

     auto iter_payload_0 = dataResponse.payload.begin();
     while (iter_payload_0.Next())
     {
         auto & entry_0 = iter_payload_0.GetValue();
         jobject newElement_0;
         std::string newElement_0ClassName     = "java/lang/Integer";
         std::string newElement_0CtorSignature = "(I)V";
         chip::JniReferences::GetInstance().CreateBoxedObject<uint8_t>(newElement_0ClassName.c_str(),
                                                                       newElement_0CtorSignature.c_str(), entry_0, newElement_0);
         chip::JniReferences::GetInstance().AddToArrayList(payload, newElement_0);
     }

     env->CallVoidMethod(javaCallbackRef, javaMethod, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence,
                         payload);
 }
 } // namespace chip