examples/tv-app/android/java/application-launcher/ApplicationLauncherManager.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 2024 Project CHIP Authors
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 #include "ApplicationLauncherManager.h"
 #include "../TvApp-JNI.h"
 #include <app-common/zap-generated/attributes/Accessors.h>
 #include <app-common/zap-generated/ids/Clusters.h>
 #include <app/util/config.h>
 #include <jni.h>
 #include <lib/core/CHIPSafeCasts.h>
 #include <lib/support/CHIPJNIError.h>
 #include <lib/support/JniReferences.h>
 #include <lib/support/JniTypeWrappers.h>

 using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::ApplicationLauncher;
 using namespace chip::Uint8;

 void emberAfApplicationLauncherClusterInitCallback(chip::EndpointId endpoint)
 {
     ChipLogProgress(Zcl, "TV Android App: ApplicationLauncher::PostClusterInit");
     if (endpoint > kLocalVideoPlayerEndpointId)
     {
         ChipLogProgress(Zcl, "TV Android App: ignore setting the delegate for endpoints larger than 1");
         return;
     }
     TvAppJNIMgr().PostClusterInit(chip::app::Clusters::ApplicationLauncher::Id, endpoint);
 }

 void ApplicationLauncherManager::NewManager(jint endpoint, jobject manager)
 {
     if (endpoint > kLocalVideoPlayerEndpointId)
     {
         ChipLogProgress(Zcl, "TV Android App: ignore setting the delegate for endpoints larger than 1");
         return;
     }
     ChipLogProgress(Zcl, "TV Android App: ApplicationLauncher::SetDefaultDelegate for endpoint: %d", endpoint);
     ApplicationLauncherManager * mgr = new ApplicationLauncherManager();
     mgr->InitializeWithObjects(manager);
     chip::app::Clusters::ApplicationLauncher::SetDefaultDelegate(static_cast<chip::EndpointId>(endpoint), mgr);
 }

 CHIP_ERROR ApplicationLauncherManager::HandleGetCatalogList(AttributeValueEncoder & aEncoder)
 {
     chip::DeviceLayer::StackUnlock unlock;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     VerifyOrReturnError(env != nullptr, CHIP_JNI_ERROR_NO_ENV, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
     chip::JniLocalReferenceScope scope(env);

     ChipLogProgress(Zcl, "Received ApplicationLauncherManager::GetCatalogList");
     VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
     VerifyOrExit(mGetCatalogListMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

     env->ExceptionClear();

     return aEncoder.EncodeList([this, env](const auto & encoder) -> CHIP_ERROR {
         jintArray jCatalogList =
             (jintArray) env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mGetCatalogListMethod);
         if (env->ExceptionCheck())
         {
             ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::GetCatalogList");
             env->ExceptionDescribe();
             env->ExceptionClear();
             return CHIP_ERROR_INCORRECT_STATE;
         }

         jint size       = env->GetArrayLength(jCatalogList);
         jint * elements = env->GetIntArrayElements(jCatalogList, 0);
         for (int i = 0; i < size; i++)
         {
             jint jCatalogVendorId = elements[i];
             ReturnErrorOnFailure(encoder.Encode(static_cast<uint16_t>(jCatalogVendorId)));
         }

         return CHIP_NO_ERROR;
     });

 exit:
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Zcl, "ApplicationLauncherManager::GetCatalogList status error: %s", err.AsString());
     }

     return err;
 }

 void ApplicationLauncherManager::HandleLaunchApp(CommandResponseHelper<LauncherResponseType> & helper, const ByteSpan & data,
                                                  const ApplicationType & application)
 {
     chip::DeviceLayer::StackUnlock unlock;
     LauncherResponseType response;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
     chip::JniLocalReferenceScope scope(env);

     ChipLogProgress(Zcl, "Received ApplicationLauncherManager::LaunchApp");
     VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
     VerifyOrExit(mLaunchAppMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

     env->ExceptionClear();

     {
         // UtfString accepts const char * data
         chip::UtfString jByteData(env, reinterpret_cast<const char *>(data.data()));

         chip::UtfString jappId(env, application.applicationID);

         // Create an instance of Application
         jobject appObject = env->NewObject(mApplicationClass, mCreateApplicationMethod,
                                            static_cast<jint>(application.catalogVendorID), jappId.jniValue());
         VerifyOrReturn(appObject != nullptr, ChipLogError(Zcl, "Failed to create Application object"));

         jobject resp =
             env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mLaunchAppMethod, appObject, jByteData.jniValue());
         if (env->ExceptionCheck())
         {
             ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::LaunchApp");
             env->ExceptionDescribe();
             env->ExceptionClear();
             err = CHIP_ERROR_INCORRECT_STATE;
             goto exit;
         }

         VerifyOrExit(resp != nullptr, err = CHIP_JNI_ERROR_NULL_OBJECT);
         jclass respCls     = env->GetObjectClass(resp);
         jfieldID statusFid = env->GetFieldID(respCls, "status", "I");
         VerifyOrExit(statusFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
         jint status = env->GetIntField(resp, statusFid);

         jfieldID dataFid = env->GetFieldID(respCls, "data", "Ljava/lang/String;");
         VerifyOrExit(dataFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
         jstring jdataStr = (jstring) env->GetObjectField(resp, dataFid);
         chip::JniUtfString dataStr(env, jdataStr);

         response.status = static_cast<chip::app::Clusters::ApplicationLauncher::StatusEnum>(status);
         response.data   = chip::Optional<chip::ByteSpan>(dataStr.byteSpan());

         err = helper.Success(response);
     }

 exit:
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Zcl, "ApplicationLauncherManager::LaunchApp status error: %s", err.AsString());
     }
 }

 void ApplicationLauncherManager::HandleStopApp(CommandResponseHelper<LauncherResponseType> & helper,
                                                const ApplicationType & application)
 {
     chip::DeviceLayer::StackUnlock unlock;
     LauncherResponseType response;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
     chip::JniLocalReferenceScope scope(env);

     ChipLogProgress(Zcl, "Received ApplicationLauncherManager::StopApp");
     VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
     VerifyOrExit(mStopAppMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

     env->ExceptionClear();

     {
         chip::UtfString jappId(env, application.applicationID);

         // Create an instance of Application
         jobject appObject = env->NewObject(mApplicationClass, mCreateApplicationMethod,
                                            static_cast<jint>(application.catalogVendorID), jappId.jniValue());
         VerifyOrReturn(appObject != nullptr, ChipLogError(Zcl, "Failed to create Application object"));

         jobject resp = env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mStopAppMethod, appObject);
         if (env->ExceptionCheck())
         {
             ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::StopApp");
             env->ExceptionDescribe();
             env->ExceptionClear();
             err = CHIP_ERROR_INCORRECT_STATE;
             goto exit;
         }

         VerifyOrExit(resp != nullptr, err = CHIP_JNI_ERROR_NULL_OBJECT);
         jclass respCls     = env->GetObjectClass(resp);
         jfieldID statusFid = env->GetFieldID(respCls, "status", "I");
         VerifyOrExit(statusFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
         jint status = env->GetIntField(resp, statusFid);

         jfieldID dataFid = env->GetFieldID(respCls, "data", "Ljava/lang/String;");
         VerifyOrExit(dataFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
         jstring jdataStr = (jstring) env->GetObjectField(resp, dataFid);
         chip::JniUtfString dataStr(env, jdataStr);

         response.status = static_cast<chip::app::Clusters::ApplicationLauncher::StatusEnum>(status);
         response.data   = chip::Optional<chip::ByteSpan>(dataStr.byteSpan());

         err = helper.Success(response);
     }

 exit:
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Zcl, "ApplicationLauncherManager::StopApp status error: %s", err.AsString());
     }
 }

 void ApplicationLauncherManager::HandleHideApp(CommandResponseHelper<LauncherResponseType> & helper,
                                                const ApplicationType & application)
 {
     chip::DeviceLayer::StackUnlock unlock;
     LauncherResponseType response;
     CHIP_ERROR err = CHIP_NO_ERROR;
     JNIEnv * env   = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
     chip::JniLocalReferenceScope scope(env);

     ChipLogProgress(Zcl, "Received ApplicationLauncherManager::HideApp");
     VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
     VerifyOrExit(mHideAppMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

     env->ExceptionClear();

     {
         chip::UtfString jappId(env, application.applicationID);

         // Create an instance of Application
         jobject appObject = env->NewObject(mApplicationClass, mCreateApplicationMethod,
                                            static_cast<jint>(application.catalogVendorID), jappId.jniValue());
         VerifyOrReturn(appObject != nullptr, ChipLogError(Zcl, "Failed to create Application object"));

         jobject resp = env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mHideAppMethod, appObject);
         if (env->ExceptionCheck())
         {
             ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::HideApp");
             env->ExceptionDescribe();
             env->ExceptionClear();
             err = CHIP_ERROR_INCORRECT_STATE;
             goto exit;
         }

         VerifyOrExit(resp != nullptr, err = CHIP_JNI_ERROR_NULL_OBJECT);
         jclass respCls     = env->GetObjectClass(resp);
         jfieldID statusFid = env->GetFieldID(respCls, "status", "I");
         VerifyOrExit(statusFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
         jint status = env->GetIntField(resp, statusFid);

         jfieldID dataFid = env->GetFieldID(respCls, "data", "Ljava/lang/String;");
         VerifyOrExit(dataFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
         jstring jdataStr = (jstring) env->GetObjectField(resp, dataFid);
         chip::JniUtfString dataStr(env, jdataStr);

         response.status = static_cast<chip::app::Clusters::ApplicationLauncher::StatusEnum>(status);
         response.data   = chip::Optional<chip::ByteSpan>(dataStr.byteSpan());

         err = helper.Success(response);
     }

 exit:
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Zcl, "ApplicationLauncherManager::HideApp status error: %s", err.AsString());
     }
 }

 void ApplicationLauncherManager::InitializeWithObjects(jobject managerObject)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Failed to GetEnvForCurrentThread for ApplicationLauncherManager"));

     VerifyOrReturn(mApplicationLauncherManagerObject.Init(managerObject) == CHIP_NO_ERROR,
                    ChipLogError(Zcl, "Failed to init mApplicationLauncherManagerObject"));

     jclass applicationLauncherClass = env->GetObjectClass(managerObject);
     VerifyOrReturn(applicationLauncherClass != nullptr, ChipLogError(Zcl, "Failed to get ApplicationLauncherManager Java class"));

     mGetCatalogListMethod = env->GetMethodID(applicationLauncherClass, "getCatalogList", "()[I");
     if (mGetCatalogListMethod == nullptr)
     {
         ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'getCatalogList' method");
         env->ExceptionClear();
     }

     mLaunchAppMethod = env->GetMethodID(applicationLauncherClass, "launchApp",
                                         "(Lcom/matter/tv/server/tvapp/"
                                         "Application;Ljava/lang/String;)Lcom/matter/tv/server/tvapp/LauncherResponse;");
     if (mLaunchAppMethod == nullptr)
     {
         ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'launchApp' method");
         env->ExceptionClear();
     }

     mStopAppMethod = env->GetMethodID(applicationLauncherClass, "stopApp",
                                       "(Lcom/matter/tv/server/tvapp/"
                                       "Application;)Lcom/matter/tv/server/tvapp/LauncherResponse;");
     if (mStopAppMethod == nullptr)
     {
         ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'stopApp' method");
         env->ExceptionClear();
     }

     mHideAppMethod = env->GetMethodID(applicationLauncherClass, "hideApp",
                                       "(Lcom/matter/tv/server/tvapp/"
                                       "Application;)Lcom/matter/tv/server/tvapp/LauncherResponse;");
     if (mHideAppMethod == nullptr)
     {
         ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'hideApp' method");
         env->ExceptionClear();
     }

     // Find the Application class
     jclass jc = env->FindClass("com/matter/tv/server/tvapp/Application");
     // convert it to a global reference, otherwise code will crash
     mApplicationClass = static_cast<jclass>(env->NewGlobalRef(jc));
     if (mApplicationClass == nullptr)
     {
         ChipLogError(Zcl, "Failed to find Application Java class");
         env->ExceptionClear();
     }

     // Get the constructor method ID
     mCreateApplicationMethod = env->GetMethodID(mApplicationClass, "<init>", "(ILjava/lang/String;)V");
     if (mCreateApplicationMethod == nullptr)
     {
         ChipLogError(Zcl, "Failed to find constructor of Application Java class");
         env->ExceptionClear();
     }
 }
	/*
	*
	* Copyright (c) 2024 Project CHIP Authors
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "ApplicationLauncherManager.h"
	#include "../TvApp-JNI.h"
	#include <app-common/zap-generated/attributes/Accessors.h>
	#include <app-common/zap-generated/ids/Clusters.h>
	#include <app/util/config.h>
	#include <jni.h>
	#include <lib/core/CHIPSafeCasts.h>
	#include <lib/support/CHIPJNIError.h>
	#include <lib/support/JniReferences.h>
	#include <lib/support/JniTypeWrappers.h>

	using namespace chip::app;
	using namespace chip::app::Clusters;
	using namespace chip::app::Clusters::ApplicationLauncher;
	using namespace chip::Uint8;

	void emberAfApplicationLauncherClusterInitCallback(chip::EndpointId endpoint)
	{
	ChipLogProgress(Zcl, "TV Android App: ApplicationLauncher::PostClusterInit");
	if (endpoint > kLocalVideoPlayerEndpointId)
	{
	ChipLogProgress(Zcl, "TV Android App: ignore setting the delegate for endpoints larger than 1");
	return;
	}
	TvAppJNIMgr().PostClusterInit(chip::app::Clusters::ApplicationLauncher::Id, endpoint);
	}

	void ApplicationLauncherManager::NewManager(jint endpoint, jobject manager)
	{
	if (endpoint > kLocalVideoPlayerEndpointId)
	{
	ChipLogProgress(Zcl, "TV Android App: ignore setting the delegate for endpoints larger than 1");
	return;
	}
	ChipLogProgress(Zcl, "TV Android App: ApplicationLauncher::SetDefaultDelegate for endpoint: %d", endpoint);
	ApplicationLauncherManager * mgr = new ApplicationLauncherManager();
	mgr->InitializeWithObjects(manager);
	chip::app::Clusters::ApplicationLauncher::SetDefaultDelegate(static_cast<chip::EndpointId>(endpoint), mgr);
	}

	CHIP_ERROR ApplicationLauncherManager::HandleGetCatalogList(AttributeValueEncoder & aEncoder)
	{
	chip::DeviceLayer::StackUnlock unlock;
	CHIP_ERROR err = CHIP_NO_ERROR;
	JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
	VerifyOrReturnError(env != nullptr, CHIP_JNI_ERROR_NO_ENV, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
	chip::JniLocalReferenceScope scope(env);

	ChipLogProgress(Zcl, "Received ApplicationLauncherManager::GetCatalogList");
	VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
	VerifyOrExit(mGetCatalogListMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

	env->ExceptionClear();

	return aEncoder.EncodeList([this, env](const auto & encoder) -> CHIP_ERROR {
	jintArray jCatalogList =
	(jintArray) env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mGetCatalogListMethod);
	if (env->ExceptionCheck())
	{
	ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::GetCatalogList");
	env->ExceptionDescribe();
	env->ExceptionClear();
	return CHIP_ERROR_INCORRECT_STATE;
	}

	jint size = env->GetArrayLength(jCatalogList);
	jint * elements = env->GetIntArrayElements(jCatalogList, 0);
	for (int i = 0; i < size; i++)
	{
	jint jCatalogVendorId = elements[i];
	ReturnErrorOnFailure(encoder.Encode(static_cast<uint16_t>(jCatalogVendorId)));
	}

	return CHIP_NO_ERROR;
	});

	exit:
	if (err != CHIP_NO_ERROR)
	{
	ChipLogError(Zcl, "ApplicationLauncherManager::GetCatalogList status error: %s", err.AsString());
	}

	return err;
	}

	void ApplicationLauncherManager::HandleLaunchApp(CommandResponseHelper<LauncherResponseType> & helper, const ByteSpan & data,
	const ApplicationType & application)
	{
	chip::DeviceLayer::StackUnlock unlock;
	LauncherResponseType response;
	CHIP_ERROR err = CHIP_NO_ERROR;
	JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
	VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
	chip::JniLocalReferenceScope scope(env);

	ChipLogProgress(Zcl, "Received ApplicationLauncherManager::LaunchApp");
	VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
	VerifyOrExit(mLaunchAppMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

	env->ExceptionClear();

	{
	// UtfString accepts const char * data
	chip::UtfString jByteData(env, reinterpret_cast<const char *>(data.data()));

	chip::UtfString jappId(env, application.applicationID);

	// Create an instance of Application
	jobject appObject = env->NewObject(mApplicationClass, mCreateApplicationMethod,
	static_cast<jint>(application.catalogVendorID), jappId.jniValue());
	VerifyOrReturn(appObject != nullptr, ChipLogError(Zcl, "Failed to create Application object"));

	jobject resp =
	env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mLaunchAppMethod, appObject, jByteData.jniValue());
	if (env->ExceptionCheck())
	{
	ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::LaunchApp");
	env->ExceptionDescribe();
	env->ExceptionClear();
	err = CHIP_ERROR_INCORRECT_STATE;
	goto exit;
	}

	VerifyOrExit(resp != nullptr, err = CHIP_JNI_ERROR_NULL_OBJECT);
	jclass respCls = env->GetObjectClass(resp);
	jfieldID statusFid = env->GetFieldID(respCls, "status", "I");
	VerifyOrExit(statusFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
	jint status = env->GetIntField(resp, statusFid);

	jfieldID dataFid = env->GetFieldID(respCls, "data", "Ljava/lang/String;");
	VerifyOrExit(dataFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
	jstring jdataStr = (jstring) env->GetObjectField(resp, dataFid);
	chip::JniUtfString dataStr(env, jdataStr);

	response.status = static_cast<chip::app::Clusters::ApplicationLauncher::StatusEnum>(status);
	response.data = chip::Optional<chip::ByteSpan>(dataStr.byteSpan());

	err = helper.Success(response);
	}

	exit:
	if (err != CHIP_NO_ERROR)
	{
	ChipLogError(Zcl, "ApplicationLauncherManager::LaunchApp status error: %s", err.AsString());
	}
	}

	void ApplicationLauncherManager::HandleStopApp(CommandResponseHelper<LauncherResponseType> & helper,
	const ApplicationType & application)
	{
	chip::DeviceLayer::StackUnlock unlock;
	LauncherResponseType response;
	CHIP_ERROR err = CHIP_NO_ERROR;
	JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
	VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
	chip::JniLocalReferenceScope scope(env);

	ChipLogProgress(Zcl, "Received ApplicationLauncherManager::StopApp");
	VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
	VerifyOrExit(mStopAppMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

	env->ExceptionClear();

	{
	chip::UtfString jappId(env, application.applicationID);

	// Create an instance of Application
	jobject appObject = env->NewObject(mApplicationClass, mCreateApplicationMethod,
	static_cast<jint>(application.catalogVendorID), jappId.jniValue());
	VerifyOrReturn(appObject != nullptr, ChipLogError(Zcl, "Failed to create Application object"));

	jobject resp = env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mStopAppMethod, appObject);
	if (env->ExceptionCheck())
	{
	ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::StopApp");
	env->ExceptionDescribe();
	env->ExceptionClear();
	err = CHIP_ERROR_INCORRECT_STATE;
	goto exit;
	}

	VerifyOrExit(resp != nullptr, err = CHIP_JNI_ERROR_NULL_OBJECT);
	jclass respCls = env->GetObjectClass(resp);
	jfieldID statusFid = env->GetFieldID(respCls, "status", "I");
	VerifyOrExit(statusFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
	jint status = env->GetIntField(resp, statusFid);

	jfieldID dataFid = env->GetFieldID(respCls, "data", "Ljava/lang/String;");
	VerifyOrExit(dataFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
	jstring jdataStr = (jstring) env->GetObjectField(resp, dataFid);
	chip::JniUtfString dataStr(env, jdataStr);

	response.status = static_cast<chip::app::Clusters::ApplicationLauncher::StatusEnum>(status);
	response.data = chip::Optional<chip::ByteSpan>(dataStr.byteSpan());

	err = helper.Success(response);
	}

	exit:
	if (err != CHIP_NO_ERROR)
	{
	ChipLogError(Zcl, "ApplicationLauncherManager::StopApp status error: %s", err.AsString());
	}
	}

	void ApplicationLauncherManager::HandleHideApp(CommandResponseHelper<LauncherResponseType> & helper,
	const ApplicationType & application)
	{
	chip::DeviceLayer::StackUnlock unlock;
	LauncherResponseType response;
	CHIP_ERROR err = CHIP_NO_ERROR;
	JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
	VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNIEnv for current thread"));
	chip::JniLocalReferenceScope scope(env);

	ChipLogProgress(Zcl, "Received ApplicationLauncherManager::HideApp");
	VerifyOrExit(mApplicationLauncherManagerObject.HasValidObjectRef(), err = CHIP_ERROR_INCORRECT_STATE);
	VerifyOrExit(mHideAppMethod != nullptr, err = CHIP_ERROR_INCORRECT_STATE);

	env->ExceptionClear();

	{
	chip::UtfString jappId(env, application.applicationID);

	// Create an instance of Application
	jobject appObject = env->NewObject(mApplicationClass, mCreateApplicationMethod,
	static_cast<jint>(application.catalogVendorID), jappId.jniValue());
	VerifyOrReturn(appObject != nullptr, ChipLogError(Zcl, "Failed to create Application object"));

	jobject resp = env->CallObjectMethod(mApplicationLauncherManagerObject.ObjectRef(), mHideAppMethod, appObject);
	if (env->ExceptionCheck())
	{
	ChipLogError(Zcl, "Java exception in ApplicationLauncherManager::HideApp");
	env->ExceptionDescribe();
	env->ExceptionClear();
	err = CHIP_ERROR_INCORRECT_STATE;
	goto exit;
	}

	VerifyOrExit(resp != nullptr, err = CHIP_JNI_ERROR_NULL_OBJECT);
	jclass respCls = env->GetObjectClass(resp);
	jfieldID statusFid = env->GetFieldID(respCls, "status", "I");
	VerifyOrExit(statusFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
	jint status = env->GetIntField(resp, statusFid);

	jfieldID dataFid = env->GetFieldID(respCls, "data", "Ljava/lang/String;");
	VerifyOrExit(dataFid != nullptr, err = CHIP_JNI_ERROR_FIELD_NOT_FOUND);
	jstring jdataStr = (jstring) env->GetObjectField(resp, dataFid);
	chip::JniUtfString dataStr(env, jdataStr);

	response.status = static_cast<chip::app::Clusters::ApplicationLauncher::StatusEnum>(status);
	response.data = chip::Optional<chip::ByteSpan>(dataStr.byteSpan());

	err = helper.Success(response);
	}

	exit:
	if (err != CHIP_NO_ERROR)
	{
	ChipLogError(Zcl, "ApplicationLauncherManager::HideApp status error: %s", err.AsString());
	}
	}

	void ApplicationLauncherManager::InitializeWithObjects(jobject managerObject)
	{
	JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
	VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Failed to GetEnvForCurrentThread for ApplicationLauncherManager"));

	VerifyOrReturn(mApplicationLauncherManagerObject.Init(managerObject) == CHIP_NO_ERROR,
	ChipLogError(Zcl, "Failed to init mApplicationLauncherManagerObject"));

	jclass applicationLauncherClass = env->GetObjectClass(managerObject);
	VerifyOrReturn(applicationLauncherClass != nullptr, ChipLogError(Zcl, "Failed to get ApplicationLauncherManager Java class"));

	mGetCatalogListMethod = env->GetMethodID(applicationLauncherClass, "getCatalogList", "()[I");
	if (mGetCatalogListMethod == nullptr)
	{
	ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'getCatalogList' method");
	env->ExceptionClear();
	}

	mLaunchAppMethod = env->GetMethodID(applicationLauncherClass, "launchApp",
	"(Lcom/matter/tv/server/tvapp/"
	"Application;Ljava/lang/String;)Lcom/matter/tv/server/tvapp/LauncherResponse;");
	if (mLaunchAppMethod == nullptr)
	{
	ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'launchApp' method");
	env->ExceptionClear();
	}

	mStopAppMethod = env->GetMethodID(applicationLauncherClass, "stopApp",
	"(Lcom/matter/tv/server/tvapp/"
	"Application;)Lcom/matter/tv/server/tvapp/LauncherResponse;");
	if (mStopAppMethod == nullptr)
	{
	ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'stopApp' method");
	env->ExceptionClear();
	}

	mHideAppMethod = env->GetMethodID(applicationLauncherClass, "hideApp",
	"(Lcom/matter/tv/server/tvapp/"
	"Application;)Lcom/matter/tv/server/tvapp/LauncherResponse;");
	if (mHideAppMethod == nullptr)
	{
	ChipLogError(Zcl, "Failed to access ApplicationLauncherManager 'hideApp' method");
	env->ExceptionClear();
	}

	// Find the Application class
	jclass jc = env->FindClass("com/matter/tv/server/tvapp/Application");
	// convert it to a global reference, otherwise code will crash
	mApplicationClass = static_cast<jclass>(env->NewGlobalRef(jc));
	if (mApplicationClass == nullptr)
	{
	ChipLogError(Zcl, "Failed to find Application Java class");
	env->ExceptionClear();
	}

	// Get the constructor method ID
	mCreateApplicationMethod = env->GetMethodID(mApplicationClass, "<init>", "(ILjava/lang/String;)V");
	if (mCreateApplicationMethod == nullptr)
	{
	ChipLogError(Zcl, "Failed to find constructor of Application Java class");
	env->ExceptionClear();
	}
	}