diff --git a/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/MainActivity.java b/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/MainActivity.java
index e71a4663ea412d..08816f922a5746 100644
--- a/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/MainActivity.java
+++ b/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/MainActivity.java
@@ -4,6 +4,7 @@
 import android.os.Bundle;
 import android.view.View;
 import android.widget.ImageView;
+import android.widget.SeekBar;
 import android.widget.TextView;
 import androidx.appcompat.app.AppCompatActivity;
 import chip.setuppayload.DiscoveryCapability;
@@ -33,6 +34,29 @@ public void onClick(View view) {
                 MatterServant.get().restart();
               }
             });
+    findViewById(R.id.OnOffBtn)
+        .setOnClickListener(
+            new View.OnClickListener() {
+              @Override
+              public void onClick(View view) {
+                MatterServant.get().toggleOnOff();
+              }
+            });
+
+    SeekBar sb = findViewById(R.id.seekBar);
+    sb.setOnSeekBarChangeListener(
+        new SeekBar.OnSeekBarChangeListener() {
+          @Override
+          public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
+            MatterServant.get().updateLevel(i);
+          }
+
+          @Override
+          public void onStartTrackingTouch(SeekBar seekBar) {}
+
+          @Override
+          public void onStopTrackingTouch(SeekBar seekBar) {}
+        });
 
     // TODO: Get these parameters from PreferencesConfigurationManager
     HashSet<DiscoveryCapability> discoveryCapabilities = new HashSet<>();
diff --git a/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/service/MatterServant.java b/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/service/MatterServant.java
index 18842aabde64b9..8e24c3e17967f8 100644
--- a/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/service/MatterServant.java
+++ b/examples/tv-app/android/App/app/src/main/java/com/tcl/chip/chiptvserver/service/MatterServant.java
@@ -32,9 +32,11 @@
 import com.tcl.chip.tvapp.ContentLaunchManagerStub;
 import com.tcl.chip.tvapp.DACProviderStub;
 import com.tcl.chip.tvapp.KeypadInputManagerStub;
+import com.tcl.chip.tvapp.LevelManagerStub;
 import com.tcl.chip.tvapp.LowPowerManagerStub;
 import com.tcl.chip.tvapp.MediaInputManagerStub;
 import com.tcl.chip.tvapp.MediaPlaybackManagerStub;
+import com.tcl.chip.tvapp.OnOffManagerStub;
 import com.tcl.chip.tvapp.TvApp;
 import com.tcl.chip.tvapp.WakeOnLanManagerStub;
 
@@ -44,6 +46,10 @@ public class MatterServant {
   public int testDiscriminator = 0xF00;
 
   private ChipAppServer chipAppServer;
+  private TvApp mTvApp;
+  private boolean mIsOn = true;
+  private int mOnOffEndpoint;
+  private int mLevelEndpoint;
 
   private MatterServant() {}
 
@@ -61,7 +67,7 @@ public void init(@NonNull Context context) {
     // then chipPlatform to prepare platform
     // then TvApp.postInit to init app which needs platform
     // then start ChipAppServer
-    TvApp tvApp =
+    mTvApp =
         new TvApp(
             (app, clusterId, endpoint) -> {
               switch (clusterId) {
@@ -86,9 +92,17 @@ public void init(@NonNull Context context) {
                 case Clusters.ClusterId_Channel:
                   app.setChannelManager(endpoint, new ChannelManagerStub(endpoint));
                   break;
+                case Clusters.ClusterId_OnOff:
+                  mOnOffEndpoint = endpoint;
+                  app.setOnOffManager(endpoint, new OnOffManagerStub(endpoint));
+                  break;
+                case Clusters.ClusterId_LevelControl:
+                  mLevelEndpoint = endpoint;
+                  app.setLevelManager(endpoint, new LevelManagerStub(endpoint));
+                  break;
               }
             });
-    tvApp.setDACProvider(new DACProviderStub());
+    mTvApp.setDACProvider(new DACProviderStub());
 
     Context applicationContext = context.getApplicationContext();
     AndroidChipPlatform chipPlatform =
@@ -103,7 +117,7 @@ public void init(@NonNull Context context) {
     chipPlatform.updateCommissionableDataProviderData(
         null, null, 0, testSetupPasscode, testDiscriminator);
 
-    tvApp.postInit();
+    mTvApp.postInit();
 
     chipAppServer = new ChipAppServer();
     chipAppServer.startApp();
@@ -113,4 +127,13 @@ public void restart() {
     chipAppServer.stopApp();
     chipAppServer.startApp();
   }
+
+  public void toggleOnOff() {
+    mTvApp.setOnOff(mOnOffEndpoint, mIsOn);
+    mIsOn = !mIsOn;
+  }
+
+  public void updateLevel(int value) {
+    mTvApp.setCurrentLevel(mLevelEndpoint, value);
+  }
 }
diff --git a/examples/tv-app/android/App/app/src/main/res/layout/activity_main.xml b/examples/tv-app/android/App/app/src/main/res/layout/activity_main.xml
index f26237c235c4eb..32a1ab4bf46648 100644
--- a/examples/tv-app/android/App/app/src/main/res/layout/activity_main.xml
+++ b/examples/tv-app/android/App/app/src/main/res/layout/activity_main.xml
@@ -42,4 +42,25 @@
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent" />
 
+    <Button
+        android:id="@+id/OnOffBtn"
+        android:text="OnOff"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:layout_constraintTop_toBottomOf="@+id/resetBtn"
+        android:layout_marginTop="20dp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"/>
+
+    <SeekBar
+        android:id="@+id/seekBar"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        app:layout_constraintTop_toBottomOf="@+id/OnOffBtn"
+        android:layout_marginTop="20dp"
+        android:maxHeight="2dp"
+        android:minHeight="2dp"
+        android:max="100"
+        />
+
 </androidx.constraintlayout.widget.ConstraintLayout>
\ No newline at end of file
diff --git a/examples/tv-app/android/BUILD.gn b/examples/tv-app/android/BUILD.gn
index 4411c68a3536d5..7f7b1b1c689df8 100644
--- a/examples/tv-app/android/BUILD.gn
+++ b/examples/tv-app/android/BUILD.gn
@@ -32,7 +32,6 @@ shared_library("jni") {
     "include/application-launcher/ApplicationLauncherManager.h",
     "include/audio-output/AudioOutputManager.cpp",
     "include/audio-output/AudioOutputManager.h",
-    "include/cluster-change-attribute.cpp",
     "include/cluster-init.cpp",
     "include/endpoint-configuration/EndpointConfigurationStorage.cpp",
     "include/endpoint-configuration/EndpointConfigurationStorage.h",
@@ -40,18 +39,23 @@ shared_library("jni") {
     "include/target-navigator/TargetNavigatorManager.h",
     "java/ChannelManager.cpp",
     "java/ChannelManager.h",
+    "java/ClusterChangeAttribute.cpp",
     "java/ContentLauncherManager.cpp",
     "java/ContentLauncherManager.h",
     "java/JNIDACProvider.cpp",
     "java/JNIDACProvider.h",
     "java/KeypadInputManager.cpp",
     "java/KeypadInputManager.h",
+    "java/LevelManager.cpp",
+    "java/LevelManager.h",
     "java/LowPowerManager.cpp",
     "java/LowPowerManager.h",
     "java/MediaInputManager.cpp",
     "java/MediaInputManager.h",
     "java/MediaPlaybackManager.cpp",
     "java/MediaPlaybackManager.h",
+    "java/OnOffManager.cpp",
+    "java/OnOffManager.h",
     "java/TVApp-JNI.cpp",
     "java/WakeOnLanManager.cpp",
     "java/WakeOnLanManager.h",
@@ -99,6 +103,8 @@ android_library("java") {
     "java/src/com/tcl/chip/tvapp/DACProviderStub.java",
     "java/src/com/tcl/chip/tvapp/KeypadInputManager.java",
     "java/src/com/tcl/chip/tvapp/KeypadInputManagerStub.java",
+    "java/src/com/tcl/chip/tvapp/LevelManager.java",
+    "java/src/com/tcl/chip/tvapp/LevelManagerStub.java",
     "java/src/com/tcl/chip/tvapp/LowPowerManager.java",
     "java/src/com/tcl/chip/tvapp/LowPowerManagerStub.java",
     "java/src/com/tcl/chip/tvapp/MediaInputInfo.java",
@@ -107,6 +113,8 @@ android_library("java") {
     "java/src/com/tcl/chip/tvapp/MediaPlaybackManager.java",
     "java/src/com/tcl/chip/tvapp/MediaPlaybackManagerStub.java",
     "java/src/com/tcl/chip/tvapp/MediaPlaybackPosition.java",
+    "java/src/com/tcl/chip/tvapp/OnOffManager.java",
+    "java/src/com/tcl/chip/tvapp/OnOffManagerStub.java",
     "java/src/com/tcl/chip/tvapp/TvApp.java",
     "java/src/com/tcl/chip/tvapp/TvAppCallback.java",
     "java/src/com/tcl/chip/tvapp/WakeOnLanManager.java",
diff --git a/examples/tv-app/android/include/cluster-change-attribute.cpp b/examples/tv-app/android/java/ClusterChangeAttribute.cpp
similarity index 51%
rename from examples/tv-app/android/include/cluster-change-attribute.cpp
rename to examples/tv-app/android/java/ClusterChangeAttribute.cpp
index b82682e4ea9e9f..da264151f07b62 100644
--- a/examples/tv-app/android/include/cluster-change-attribute.cpp
+++ b/examples/tv-app/android/java/ClusterChangeAttribute.cpp
@@ -16,6 +16,8 @@
  *    limitations under the License.
  */
 
+#include "LevelManager.h"
+#include "OnOffManager.h"
 #include <app-common/zap-generated/ids/Attributes.h>
 #include <app-common/zap-generated/ids/Clusters.h>
 #include <app/ConcreteAttributePath.h>
@@ -24,44 +26,24 @@
 using namespace chip;
 using namespace ::chip::app::Clusters;
 
-enum TvCommand
+void MatterPostAttributeChangeCallback(const app::ConcreteAttributePath & attributePath, uint8_t mask, uint8_t type, uint16_t size,
+                                       uint8_t * value)
 {
-    PowerToggle,
-    MuteToggle
-};
-
-void runTvCommand(TvCommand command)
-{
-    switch (command)
+    if (attributePath.mClusterId == OnOff::Id && attributePath.mAttributeId == OnOff::Attributes::OnOff::Id)
     {
-    case PowerToggle:
-        // TODO: Insert your code here to send power toggle command
-        break;
-    case MuteToggle:
-        // TODO: Insert your code here to send mute toggle command
-        break;
+        bool onoff = static_cast<bool>(*value);
 
-    default:
-        break;
-    }
-}
+        ChipLogProgress(Zcl, "Received on/off command endpoint %d value = %d", static_cast<int>(attributePath.mEndpointId), onoff);
 
-void MatterAfPostAttributeChangeCallback(const app::ConcreteAttributePath & attributePath, uint8_t mask, uint8_t type,
-                                         uint16_t size, uint8_t * value)
-{
-    if (attributePath.mClusterId == OnOff::Id && attributePath.mAttributeId == OnOff::Attributes::OnOff::Id)
+        OnOffManager().PostOnOffChanged(attributePath.mEndpointId, onoff);
+    }
+    else if (attributePath.mClusterId == LevelControl::Id &&
+             attributePath.mAttributeId == LevelControl::Attributes::CurrentLevel::Id)
     {
-        ChipLogProgress(Zcl, "Received on/off command for cluster id: " ChipLogFormatMEI, ChipLogValueMEI(OnOff::Id));
+        uint8_t level = *value;
+
+        ChipLogProgress(Zcl, "Received level command endpoint %d value = %d", static_cast<int>(attributePath.mEndpointId), level);
 
-        if (attributePath.mEndpointId == 0)
-        {
-            ChipLogProgress(Zcl, "Execute POWER_TOGGLE");
-            runTvCommand(PowerToggle);
-        }
-        else if (attributePath.mEndpointId == 1)
-        {
-            ChipLogProgress(Zcl, "Execute MUTE_TOGGLE");
-            runTvCommand(MuteToggle);
-        }
+        LevelManager().PostLevelChanged(attributePath.mEndpointId, level);
     }
 }
diff --git a/examples/tv-app/android/java/LevelManager.cpp b/examples/tv-app/android/java/LevelManager.cpp
new file mode 100644
index 00000000000000..bf5316d92c0bf0
--- /dev/null
+++ b/examples/tv-app/android/java/LevelManager.cpp
@@ -0,0 +1,126 @@
+/**
+ *
+ *    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.
+ */
+#include "LevelManager.h"
+#include "TvApp-JNI.h"
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/util/af.h>
+#include <jni.h>
+#include <lib/support/CHIPJNIError.h>
+#include <lib/support/JniReferences.h>
+#include <lib/support/JniTypeWrappers.h>
+
+using namespace chip;
+
+static constexpr size_t kLevelManagerTableSize = EMBER_AF_LEVEL_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT;
+
+namespace {
+
+LevelManager * gLevelManagerTable[kLevelManagerTableSize] = { nullptr };
+
+}
+
+void emberAfLevelControlClusterInitCallback(EndpointId endpoint)
+{
+    ChipLogProgress(Zcl, "TV Android App::Level::PostClusterInit");
+    TvAppJNIMgr().PostClusterInit(chip::app::Clusters::LevelControl::Id, endpoint);
+}
+
+void LevelManager::NewManager(jint endpoint, jobject manager)
+{
+    ChipLogProgress(Zcl, "TV Android App: LevelManager::NewManager");
+    uint16_t ep = emberAfFindClusterServerEndpointIndex(static_cast<chip::EndpointId>(endpoint), app::Clusters::LevelControl::Id);
+    VerifyOrReturn(ep != kEmberInvalidEndpointIndex && ep < kLevelManagerTableSize,
+                   ChipLogError(Zcl, "TV Android App::Level::NewManager: endpoint %d not found", endpoint));
+
+    VerifyOrReturn(gLevelManagerTable[ep] == nullptr,
+                   ChipLogError(Zcl, "TV Android App::Level::NewManager: endpoint %d already has a manager", endpoint));
+    LevelManager * mgr = new LevelManager();
+    CHIP_ERROR err     = mgr->InitializeWithObjects(manager);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Zcl, "TV Android App::Level::NewManager: failed to initialize manager for endpoint %d", endpoint);
+        delete mgr;
+    }
+    else
+    {
+        gLevelManagerTable[ep] = mgr;
+    }
+}
+
+LevelManager * GetLevelManager(EndpointId endpoint)
+{
+    uint16_t ep = emberAfFindClusterServerEndpointIndex(endpoint, app::Clusters::LevelControl::Id);
+    return ((ep == kEmberInvalidEndpointIndex || ep >= kLevelManagerTableSize) ? nullptr : gLevelManagerTable[ep]);
+}
+
+void LevelManager::PostLevelChanged(chip::EndpointId endpoint, uint8_t value)
+{
+    ChipLogProgress(Zcl, "TV Android App: LevelManager::PostLevelChanged");
+    LevelManager * mgr = GetLevelManager(endpoint);
+    VerifyOrReturn(mgr != nullptr, ChipLogError(Zcl, "LevelManager null"));
+
+    mgr->HandleLevelChanged(value);
+}
+
+jboolean LevelManager::SetLevel(jint endpoint, jint value)
+{
+    EmberAfStatus status = app::Clusters::LevelControl::Attributes::CurrentLevel::Set(static_cast<chip::EndpointId>(endpoint),
+                                                                                      static_cast<uint8_t>(value));
+    return status == EMBER_ZCL_STATUS_SUCCESS;
+}
+
+CHIP_ERROR LevelManager::InitializeWithObjects(jobject managerObject)
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturnLogError(env != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    mLevelManagerObject = env->NewGlobalRef(managerObject);
+    VerifyOrReturnLogError(mLevelManagerObject != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    jclass LevelManagerClass = env->GetObjectClass(managerObject);
+    VerifyOrReturnLogError(LevelManagerClass != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    mHandleLevelChangedMethod = env->GetMethodID(LevelManagerClass, "HandleLevelChanged", "(I)V");
+    if (mHandleLevelChangedMethod == nullptr)
+    {
+        ChipLogError(Zcl, "Failed to access LevelManager 'HandleLevelChanged' method");
+        env->ExceptionClear();
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+void LevelManager::HandleLevelChanged(uint8_t value)
+{
+    ChipLogProgress(Zcl, "LevelManager::HandleLevelChanged");
+
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturn(env != NULL, ChipLogProgress(Zcl, "env null"));
+    VerifyOrReturn(mLevelManagerObject != nullptr, ChipLogProgress(Zcl, "mLevelManagerObject null"));
+    VerifyOrReturn(mHandleLevelChangedMethod != nullptr, ChipLogProgress(Zcl, "mHandleLevelChangedMethod null"));
+
+    env->ExceptionClear();
+    env->CallVoidMethod(mLevelManagerObject, mHandleLevelChangedMethod, static_cast<jint>(value));
+    if (env->ExceptionCheck())
+    {
+        ChipLogError(AppServer, "Java exception in LevelManager::HandleLevelChanged");
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+    }
+}
diff --git a/examples/tv-app/android/java/LevelManager.h b/examples/tv-app/android/java/LevelManager.h
new file mode 100644
index 00000000000000..ca8fbabe569bcf
--- /dev/null
+++ b/examples/tv-app/android/java/LevelManager.h
@@ -0,0 +1,46 @@
+/*
+ *
+ *    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.
+ */
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <cstdint>
+#include <jni.h>
+
+/**
+ * @brief Handles interfacing between java code and C++ code for the purposes of LevelControl clusters.
+ */
+class LevelManager
+{
+public:
+    // installed a bridege for a LevelControl cluster endpoint and java object
+    static void NewManager(jint endpoint, jobject manager);
+
+    // helps for java to set attributes::CurrentLevel of LevelControl cluster
+    static jboolean SetLevel(jint endpoint, jint value);
+
+    // posts a CurrentLevelChanged event to suitable LevelManager
+    static void PostLevelChanged(chip::EndpointId endpoint, uint8_t value);
+
+    // handles `Changed` callbacks by calling the java `void HandleLevelChanged()` method
+    void HandleLevelChanged(uint8_t value);
+
+private:
+    // init with java objects
+    CHIP_ERROR InitializeWithObjects(jobject managerObject);
+    jobject mLevelManagerObject         = nullptr;
+    jmethodID mHandleLevelChangedMethod = nullptr;
+};
diff --git a/examples/tv-app/android/java/OnOffManager.cpp b/examples/tv-app/android/java/OnOffManager.cpp
new file mode 100644
index 00000000000000..338a5c8bd8409e
--- /dev/null
+++ b/examples/tv-app/android/java/OnOffManager.cpp
@@ -0,0 +1,127 @@
+/**
+ *
+ *    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.
+ */
+#include "OnOffManager.h"
+#include "TvApp-JNI.h"
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/util/af.h>
+#include <jni.h>
+#include <lib/support/CHIPJNIError.h>
+#include <lib/support/JniReferences.h>
+#include <lib/support/JniTypeWrappers.h>
+
+using namespace chip;
+
+static constexpr size_t kOnffManagerTableSize = EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT;
+
+namespace {
+
+OnOffManager * gOnOffManagerTable[kOnffManagerTableSize] = { nullptr };
+
+}
+
+void emberAfOnOffClusterInitCallback(EndpointId endpoint)
+{
+    ChipLogProgress(Zcl, "TV Android App::OnOff::PostClusterInit");
+    TvAppJNIMgr().PostClusterInit(chip::app::Clusters::OnOff::Id, endpoint);
+}
+
+void OnOffManager::NewManager(jint endpoint, jobject manager)
+{
+    ChipLogProgress(Zcl, "TV Android App: OnOffManager::NewManager");
+    uint16_t ep = emberAfFindClusterServerEndpointIndex(static_cast<chip::EndpointId>(endpoint), app::Clusters::OnOff::Id);
+    VerifyOrReturn(ep != kEmberInvalidEndpointIndex && ep < EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT,
+                   ChipLogError(Zcl, "TV Android App::OnOff::NewManager: endpoint %d not found", endpoint));
+
+    VerifyOrReturn(gOnOffManagerTable[ep] == nullptr,
+                   ChipLogError(Zcl, "TV Android App::OnOff::NewManager: endpoint %d already has a manager", endpoint));
+    OnOffManager * mgr = new OnOffManager();
+    CHIP_ERROR err     = mgr->InitializeWithObjects(manager);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Zcl, "TV Android App::OnOff::NewManager: failed to initialize manager for endpoint %d", endpoint);
+        delete mgr;
+    }
+    else
+    {
+        gOnOffManagerTable[ep] = mgr;
+    }
+}
+
+OnOffManager * GetOnOffManager(EndpointId endpoint)
+{
+    uint16_t ep = emberAfFindClusterServerEndpointIndex(endpoint, app::Clusters::OnOff::Id);
+    return ((ep == kEmberInvalidEndpointIndex || ep >= EMBER_AF_MEDIA_PLAYBACK_CLUSTER_SERVER_ENDPOINT_COUNT)
+                ? nullptr
+                : gOnOffManagerTable[ep]);
+}
+
+void OnOffManager::PostOnOffChanged(chip::EndpointId endpoint, bool value)
+{
+    ChipLogProgress(Zcl, "TV Android App: OnOffManager::PostOnOffChange");
+    OnOffManager * mgr = GetOnOffManager(endpoint);
+    VerifyOrReturn(mgr != nullptr, ChipLogError(Zcl, "OnOffManager null"));
+
+    mgr->HandleOnOffChanged(value);
+}
+
+jboolean OnOffManager::SetOnOff(jint endpoint, bool value)
+{
+    EmberAfStatus status = app::Clusters::OnOff::Attributes::OnOff::Set(static_cast<chip::EndpointId>(endpoint), value);
+    return status == EMBER_ZCL_STATUS_SUCCESS;
+}
+
+CHIP_ERROR OnOffManager::InitializeWithObjects(jobject managerObject)
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturnLogError(env != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    mOnOffManagerObject = env->NewGlobalRef(managerObject);
+    VerifyOrReturnLogError(mOnOffManagerObject != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    jclass OnOffManagerClass = env->GetObjectClass(managerObject);
+    VerifyOrReturnLogError(OnOffManagerClass != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    mHandleOnOffChangedMethod = env->GetMethodID(OnOffManagerClass, "HandleOnOffChanged", "(Z)V");
+    if (mHandleOnOffChangedMethod == nullptr)
+    {
+        ChipLogError(Zcl, "Failed to access OnOffManager 'HandleOnOffChanged' method");
+        env->ExceptionClear();
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+void OnOffManager::HandleOnOffChanged(bool value)
+{
+    ChipLogProgress(Zcl, "OnOffManager::HandleOnOffChanged");
+
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturn(env != NULL, ChipLogProgress(Zcl, "env null"));
+    VerifyOrReturn(mOnOffManagerObject != nullptr, ChipLogProgress(Zcl, "mOnOffManagerObject null"));
+    VerifyOrReturn(mHandleOnOffChangedMethod != nullptr, ChipLogProgress(Zcl, "mHandleOnOffChangedMethod null"));
+
+    env->ExceptionClear();
+    env->CallVoidMethod(mOnOffManagerObject, mHandleOnOffChangedMethod, static_cast<jboolean>(value));
+    if (env->ExceptionCheck())
+    {
+        ChipLogError(AppServer, "Java exception in OnOffManager::HandleOnOffChanged");
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+    }
+}
diff --git a/examples/tv-app/android/java/OnOffManager.h b/examples/tv-app/android/java/OnOffManager.h
new file mode 100644
index 00000000000000..02420b8fd14dd3
--- /dev/null
+++ b/examples/tv-app/android/java/OnOffManager.h
@@ -0,0 +1,45 @@
+/*
+ *
+ *    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.
+ */
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <jni.h>
+
+/**
+ * @brief Handles interfacing between java code and C++ code for the purposes of On/Off clusters.
+ */
+class OnOffManager
+{
+public:
+    // installed a bridege for a On/Off cluster endpoint and java object
+    static void NewManager(jint endpoint, jobject manager);
+
+    // helps for java to set attributes::OnOff of OnOff cluster
+    static jboolean SetOnOff(jint endpoint, bool value);
+
+    // posts a OnOffChanged event to suitable OnOffManager
+    static void PostOnOffChanged(chip::EndpointId endpoint, bool value);
+
+    // handles `Changed` callbacks by calling the java `void HandleOnOffChanged()` method
+    void HandleOnOffChanged(bool value);
+
+private:
+    // init with java objects
+    CHIP_ERROR InitializeWithObjects(jobject managerObject);
+    jobject mOnOffManagerObject         = nullptr;
+    jmethodID mHandleOnOffChangedMethod = nullptr;
+};
diff --git a/examples/tv-app/android/java/TVApp-JNI.cpp b/examples/tv-app/android/java/TVApp-JNI.cpp
index 71a659abcf789c..6841c4e4d5af9e 100644
--- a/examples/tv-app/android/java/TVApp-JNI.cpp
+++ b/examples/tv-app/android/java/TVApp-JNI.cpp
@@ -21,9 +21,11 @@
 #include "ContentLauncherManager.h"
 #include "JNIDACProvider.h"
 #include "KeypadInputManager.h"
+#include "LevelManager.h"
 #include "LowPowerManager.h"
 #include "MediaInputManager.h"
 #include "MediaPlaybackManager.h"
+#include "OnOffManager.h"
 #include "WakeOnLanManager.h"
 #include "credentials/DeviceAttestationCredsProvider.h"
 #include <app/server/Dnssd.h>
@@ -144,3 +146,23 @@ JNI_METHOD(void, postInit)(JNIEnv *, jobject app)
     DnssdServer::Instance().SetExtendedDiscoveryTimeoutSecs(EXTENDED_DISCOVERY_TIMEOUT_SEC);
 #endif
 }
+
+JNI_METHOD(void, setOnOffManager)(JNIEnv *, jobject, jint endpoint, jobject manager)
+{
+    OnOffManager::NewManager(endpoint, manager);
+}
+
+JNI_METHOD(jboolean, setOnOff)(JNIEnv *, jobject, jint endpoint, jboolean value)
+{
+    return OnOffManager::SetOnOff(endpoint, value);
+}
+
+JNI_METHOD(void, setLevelManager)(JNIEnv *, jobject, jint endpoint, jobject manager)
+{
+    LevelManager::NewManager(endpoint, manager);
+}
+
+JNI_METHOD(jboolean, setCurrentLevel)(JNIEnv *, jobject, jint endpoint, jboolean value)
+{
+    return LevelManager::SetLevel(endpoint, value);
+}
diff --git a/examples/tv-app/android/java/src/com/tcl/chip/tvapp/LevelManager.java b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/LevelManager.java
new file mode 100644
index 00000000000000..072840b8b09184
--- /dev/null
+++ b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/LevelManager.java
@@ -0,0 +1,11 @@
+package com.tcl.chip.tvapp;
+
+public interface LevelManager {
+  /**
+   * Notify that the Level value be changed by matter and should effect it. Note, set by TvApp will
+   * also trigger this function, so must check if value is same
+   *
+   * @param value
+   */
+  void HandleLevelChanged(int value);
+}
diff --git a/examples/tv-app/android/java/src/com/tcl/chip/tvapp/LevelManagerStub.java b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/LevelManagerStub.java
new file mode 100644
index 00000000000000..4a95f07985095e
--- /dev/null
+++ b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/LevelManagerStub.java
@@ -0,0 +1,17 @@
+package com.tcl.chip.tvapp;
+
+import android.util.Log;
+
+public class LevelManagerStub implements LevelManager {
+  private final String TAG = LevelManagerStub.class.getSimpleName();
+  private int mEndpoint;
+
+  public LevelManagerStub(int endpoint) {
+    mEndpoint = endpoint;
+  }
+
+  @Override
+  public void HandleLevelChanged(int value) {
+    Log.d(TAG, "HandleOnOffChanged for mEndpoint " + mEndpoint + " = " + value);
+  }
+}
diff --git a/examples/tv-app/android/java/src/com/tcl/chip/tvapp/OnOffManager.java b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/OnOffManager.java
new file mode 100644
index 00000000000000..40bf552a6c9a47
--- /dev/null
+++ b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/OnOffManager.java
@@ -0,0 +1,11 @@
+package com.tcl.chip.tvapp;
+
+public interface OnOffManager {
+  /**
+   * Notify that the OnOff value be changed by matter and should effect it. Note, set by TvApp will
+   * also trigger this function, so must check if value is same
+   *
+   * @param value
+   */
+  void HandleOnOffChanged(boolean value);
+}
diff --git a/examples/tv-app/android/java/src/com/tcl/chip/tvapp/OnOffManagerStub.java b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/OnOffManagerStub.java
new file mode 100644
index 00000000000000..9c99fdc77e21d9
--- /dev/null
+++ b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/OnOffManagerStub.java
@@ -0,0 +1,17 @@
+package com.tcl.chip.tvapp;
+
+import android.util.Log;
+
+public class OnOffManagerStub implements OnOffManager {
+  private final String TAG = OnOffManagerStub.class.getSimpleName();
+  private int mEndpoint;
+
+  public OnOffManagerStub(int endpoint) {
+    mEndpoint = endpoint;
+  }
+
+  @Override
+  public void HandleOnOffChanged(boolean value) {
+    Log.d(TAG, "HandleOnOffChanged for mEndpoint " + mEndpoint + " = " + value);
+  }
+}
diff --git a/examples/tv-app/android/java/src/com/tcl/chip/tvapp/TvApp.java b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/TvApp.java
index 1479dc73a3b0e0..a919bb8d1d8d6a 100644
--- a/examples/tv-app/android/java/src/com/tcl/chip/tvapp/TvApp.java
+++ b/examples/tv-app/android/java/src/com/tcl/chip/tvapp/TvApp.java
@@ -54,6 +54,14 @@ private void postClusterInit(int clusterId, int endpoint) {
 
   public native void setChannelManager(int endpoint, ChannelManager manager);
 
+  public native void setOnOffManager(int endpoint, OnOffManager manager);
+
+  public native boolean setOnOff(int endpoint, boolean value);
+
+  public native void setLevelManager(int endpoint, LevelManager manager);
+
+  public native boolean setCurrentLevel(int endpoint, int value);
+
   public native void setDACProvider(DACProvider provider);
 
   static {
diff --git a/src/app/util/af.h b/src/app/util/af.h
index b35fd63fe0275c..8b9efc516debf1 100644
--- a/src/app/util/af.h
+++ b/src/app/util/af.h
@@ -79,6 +79,8 @@
 /** @name Attribute Storage */
 // @{
 
+static constexpr uint16_t kEmberInvalidEndpointIndex = 0xFFFF;
+
 /**
  * @brief locate attribute metadata
  *
diff --git a/src/app/util/attribute-storage.cpp b/src/app/util/attribute-storage.cpp
index 748ac1c84cddf3..925d891d693114 100644
--- a/src/app/util/attribute-storage.cpp
+++ b/src/app/util/attribute-storage.cpp
@@ -195,7 +195,7 @@ uint16_t emberAfGetDynamicIndexFromEndpoint(EndpointId id)
             return static_cast<uint8_t>(index - FIXED_ENDPOINT_COUNT);
         }
     }
-    return 0xFFFF;
+    return kEmberInvalidEndpointIndex;
 }
 
 EmberAfStatus emberAfSetDynamicEndpoint(uint16_t index, EndpointId id, EmberAfEndpointType * ep, uint16_t deviceId,
@@ -664,7 +664,7 @@ EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord * attRecord,
 const EmberAfEndpointType * emberAfFindEndpointType(chip::EndpointId endpointId)
 {
     uint16_t ep = emberAfIndexFromEndpoint(endpointId);
-    if (ep == 0xFFFF)
+    if (ep == kEmberInvalidEndpointIndex)
     {
         return nullptr;
     }
@@ -742,7 +742,7 @@ bool emberAfContainsClient(EndpointId endpoint, ClusterId clusterId)
 // This will find the first server that has the clusterId given from the index of endpoint.
 bool emberAfContainsServerFromIndex(uint16_t index, ClusterId clusterId)
 {
-    if (index == 0xFFFF)
+    if (index == kEmberInvalidEndpointIndex)
     {
         return false;
     }
@@ -787,7 +787,7 @@ void EnabledEndpointsWithServerCluster::EnsureMatchingEndpoint()
 const EmberAfCluster * emberAfFindCluster(EndpointId endpoint, ClusterId clusterId, EmberAfClusterMask mask)
 {
     uint16_t ep = emberAfIndexFromEndpoint(endpoint);
-    if (ep == 0xFFFF)
+    if (ep == kEmberInvalidEndpointIndex)
     {
         return nullptr;
     }
@@ -826,7 +826,7 @@ static uint16_t findClusterEndpointIndex(EndpointId endpoint, ClusterId clusterI
 
     if (emberAfFindCluster(endpoint, clusterId, mask) == nullptr)
     {
-        return 0xFFFF;
+        return kEmberInvalidEndpointIndex;
     }
 
     for (i = 0; i < emberAfEndpointCount(); i++)
@@ -853,7 +853,7 @@ static uint16_t findIndexFromEndpoint(EndpointId endpoint, bool ignoreDisabledEn
             return epi;
         }
     }
-    return 0xFFFF;
+    return kEmberInvalidEndpointIndex;
 }
 
 bool emberAfEndpointIsEnabled(EndpointId endpoint)
@@ -861,9 +861,9 @@ bool emberAfEndpointIsEnabled(EndpointId endpoint)
     uint16_t index = findIndexFromEndpoint(endpoint,
                                            false); // ignore disabled endpoints?
 
-    EMBER_TEST_ASSERT(0xFFFF != index);
+    EMBER_TEST_ASSERT(kEmberInvalidEndpointIndex != index);
 
-    if (0xFFFF == index)
+    if (kEmberInvalidEndpointIndex == index)
     {
         return false;
     }
@@ -877,7 +877,7 @@ bool emberAfEndpointEnableDisable(EndpointId endpoint, bool enable)
                                            false); // ignore disabled endpoints?
     bool currentlyEnabled;
 
-    if (0xFFFF == index)
+    if (kEmberInvalidEndpointIndex == index)
     {
         return false;
     }
@@ -991,7 +991,7 @@ EndpointId emberAfEndpointFromIndex(uint16_t index)
 uint8_t emberAfClusterCount(EndpointId endpoint, bool server)
 {
     uint16_t index = emberAfIndexFromEndpoint(endpoint);
-    if (index == 0xFFFF)
+    if (index == kEmberInvalidEndpointIndex)
     {
         return 0;
     }
@@ -1031,7 +1031,7 @@ uint8_t emberAfClusterCountForEndpointType(const EmberAfEndpointType * type, boo
 uint8_t emberAfGetClusterCountForEndpoint(EndpointId endpoint)
 {
     uint16_t index = emberAfIndexFromEndpoint(endpoint);
-    if (index == 0xFFFF)
+    if (index == kEmberInvalidEndpointIndex)
     {
         return 0;
     }
@@ -1052,7 +1052,7 @@ const EmberAfCluster * emberAfGetClusterByIndex(EndpointId endpoint, uint8_t clu
     uint16_t endpointIndex = emberAfIndexFromEndpoint(endpoint);
     EmberAfDefinedEndpoint * definedEndpoint;
 
-    if (endpointIndex == 0xFFFF)
+    if (endpointIndex == kEmberInvalidEndpointIndex)
     {
         return nullptr;
     }
@@ -1068,9 +1068,9 @@ const EmberAfCluster * emberAfGetClusterByIndex(EndpointId endpoint, uint8_t clu
 uint16_t emberAfGetDeviceIdForEndpoint(EndpointId endpoint)
 {
     uint16_t endpointIndex = emberAfIndexFromEndpoint(endpoint);
-    if (endpointIndex == 0xFFFF)
+    if (endpointIndex == kEmberInvalidEndpointIndex)
     {
-        return 0xFFFF;
+        return kEmberInvalidEndpointIndex;
     }
     return emAfEndpoints[endpointIndex].deviceId;
 }
@@ -1084,7 +1084,7 @@ const EmberAfCluster * emberAfGetNthCluster(EndpointId endpoint, uint8_t n, bool
     uint8_t i, c = 0;
     const EmberAfCluster * cluster;
 
-    if (index == 0xFFFF)
+    if (index == kEmberInvalidEndpointIndex)
     {
         return nullptr;
     }
@@ -1133,7 +1133,7 @@ uint8_t emberAfGetClustersFromEndpoint(EndpointId endpoint, ClusterId * clusterL
     for (i = 0; i < clusterCount; i++)
     {
         cluster        = emberAfGetNthCluster(endpoint, i, server);
-        clusterList[i] = (cluster == nullptr ? 0xFFFF : cluster->clusterId);
+        clusterList[i] = (cluster == nullptr ? kEmberInvalidEndpointIndex : cluster->clusterId);
     }
     return clusterCount;
 }
@@ -1166,7 +1166,7 @@ void emAfLoadAttributeDefaults(EndpointId endpoint, bool ignoreStorage, Optional
         if (endpoint != EMBER_BROADCAST_ENDPOINT)
         {
             ep = emberAfIndexFromEndpoint(endpoint);
-            if (ep == 0xFFFF)
+            if (ep == kEmberInvalidEndpointIndex)
             {
                 return;
             }
@@ -1419,7 +1419,7 @@ Optional<AttributeId> emberAfGetServerAttributeIdByIndex(EndpointId endpoint, Cl
 DataVersion * emberAfDataVersionStorage(const chip::app::ConcreteClusterPath & aConcreteClusterPath)
 {
     uint16_t index = emberAfIndexFromEndpoint(aConcreteClusterPath.mEndpointId);
-    if (index == 0xFFFF)
+    if (index == kEmberInvalidEndpointIndex)
     {
         // Unknown endpoint.
         return nullptr;
diff --git a/zzz_generated/tv-app/zap-generated/af-gen-event.h b/zzz_generated/tv-app/zap-generated/af-gen-event.h
index 814d4aab6b8bec..ae3ba4abd7b336 100644
--- a/zzz_generated/tv-app/zap-generated/af-gen-event.h
+++ b/zzz_generated/tv-app/zap-generated/af-gen-event.h
@@ -31,9 +31,49 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
+// This file is generated by Simplicity Studio.  Please do not edit manually.
+//
+//
 
 // Enclosing macro to prevent multiple inclusion
 #ifndef __AF_GEN_EVENT__
 #define __AF_GEN_EVENT__
 
+// Code used to configure the cluster event mechanism
+#define EMBER_AF_GENERATED_EVENT_CODE                                                                                              \
+    EmberEventControl emberAfLevelControlClusterServerTickCallbackControl1;                                                        \
+    EmberEventControl emberAfLevelControlClusterServerTickCallbackControl2;                                                        \
+    static void clusterTickWrapper(EmberEventControl * control, EmberAfTickFunction callback, uint8_t endpoint)                    \
+    {                                                                                                                              \
+        /* emberAfPushEndpointNetworkIndex(endpoint); */                                                                           \
+        emberEventControlSetInactive(control);                                                                                     \
+        (*callback)(endpoint);                                                                                                     \
+        /* emberAfPopNetworkIndex(); */                                                                                            \
+    }                                                                                                                              \
+    void emberAfLevelControlClusterServerTickCallbackWrapperFunction1(void)                                                        \
+    {                                                                                                                              \
+        clusterTickWrapper(&emberAfLevelControlClusterServerTickCallbackControl1, emberAfLevelControlClusterServerTickCallback,    \
+                           1);                                                                                                     \
+    }                                                                                                                              \
+    void emberAfLevelControlClusterServerTickCallbackWrapperFunction2(void)                                                        \
+    {                                                                                                                              \
+        clusterTickWrapper(&emberAfLevelControlClusterServerTickCallbackControl1, emberAfLevelControlClusterServerTickCallback,    \
+                           2);                                                                                                     \
+    }
+
+// EmberEventData structs used to populate the EmberEventData table
+#define EMBER_AF_GENERATED_EVENTS                                                                                                  \
+    { &emberAfLevelControlClusterServerTickCallbackControl1, emberAfLevelControlClusterServerTickCallbackWrapperFunction1 },       \
+        { &emberAfLevelControlClusterServerTickCallbackControl2, emberAfLevelControlClusterServerTickCallbackWrapperFunction2 },
+
+#define EMBER_AF_GENERATED_EVENT_STRINGS "Level Server EP 1", "Level Server EP 2",
+
+// The length of the event context table used to track and retrieve cluster events
+#define EMBER_AF_EVENT_CONTEXT_LENGTH 2
+
+// EmberAfEventContext structs used to populate the EmberAfEventContext table
+#define EMBER_AF_GENERATED_EVENT_CONTEXT                                                                                           \
+    { 0x1, 0x8, false, EMBER_AF_LONG_POLL, EMBER_AF_OK_TO_SLEEP, &emberAfLevelControlClusterServerTickCallbackControl1 },          \
+        { 0x2, 0x8, false, EMBER_AF_LONG_POLL, EMBER_AF_OK_TO_SLEEP, &emberAfLevelControlClusterServerTickCallbackControl2 },
+
 #endif // __AF_GEN_EVENT__