diff --git a/examples/virtual-device-app/android/BUILD.gn b/examples/virtual-device-app/android/BUILD.gn
index 61b29e9..8ff5677 100644
--- a/examples/virtual-device-app/android/BUILD.gn
+++ b/examples/virtual-device-app/android/BUILD.gn
@@ -30,10 +30,14 @@
     "java/ColorControlManager.cpp",
     "java/ColorControlManager.h",
     "java/DeviceApp-JNI.cpp",
+    "java/DoorLockManager.cpp",
+    "java/DoorLockManager.h",
     "java/JNIDACProvider.cpp",
     "java/JNIDACProvider.h",
     "java/OnOffManager.cpp",
     "java/OnOffManager.h",
+    "java/PowerSourceManager.cpp",
+    "java/PowerSourceManager.h",
   ]
 
   deps = [
@@ -72,7 +76,9 @@
     "java/src/com/matter/virtual/device/app/DeviceApp.java",
     "java/src/com/matter/virtual/device/app/DeviceAppCallback.java",
     "java/src/com/matter/virtual/device/app/DeviceEventType.java",
+    "java/src/com/matter/virtual/device/app/DoorLockManager.java",
     "java/src/com/matter/virtual/device/app/OnOffManager.java",
+    "java/src/com/matter/virtual/device/app/PowerSourceManager.java",
   ]
 
   javac_flags = [ "-Xlint:deprecation" ]
diff --git a/examples/virtual-device-app/android/java/ClusterChangeAttribute.cpp b/examples/virtual-device-app/android/java/ClusterChangeAttribute.cpp
index 721f468..edb373b 100644
--- a/examples/virtual-device-app/android/java/ClusterChangeAttribute.cpp
+++ b/examples/virtual-device-app/android/java/ClusterChangeAttribute.cpp
@@ -17,6 +17,7 @@
  */
 
 #include "ColorControlManager.h"
+#include "DoorLockManager.h"
 #include "OnOffManager.h"
 #include <app-common/zap-generated/attributes/Accessors.h>
 #include <app-common/zap-generated/ids/Attributes.h>
@@ -89,6 +90,19 @@
     }
 }
 
+static void DoorLockClusterAttributeChangeCallback(const app::ConcreteAttributePath & attributePath, uint16_t size, uint8_t * value)
+{
+    if (attributePath.mAttributeId == DoorLock::Attributes::LockState::Id)
+    {
+        uint8_t lockState = *value;
+
+        ChipLogProgress(Zcl, "Received lock state command endpoint %d value = %d", static_cast<int>(attributePath.mEndpointId),
+                        lockState);
+
+        DoorLockManager().PostLockStateChanged(attributePath.mEndpointId, lockState);
+    }
+}
+
 void MatterPostAttributeChangeCallback(const app::ConcreteAttributePath & attributePath, uint8_t type, uint16_t size,
                                        uint8_t * value)
 {
@@ -103,6 +117,9 @@
     case ColorControl::Id:
         ColorControlClusterAttributeChangeCallback(attributePath, size, value);
         break;
+    case DoorLock::Id:
+        DoorLockClusterAttributeChangeCallback(attributePath, size, value);
+        break;
 
     default:
         break;
diff --git a/examples/virtual-device-app/android/java/DeviceApp-JNI.cpp b/examples/virtual-device-app/android/java/DeviceApp-JNI.cpp
index 02998bb..cb80a1d 100644
--- a/examples/virtual-device-app/android/java/DeviceApp-JNI.cpp
+++ b/examples/virtual-device-app/android/java/DeviceApp-JNI.cpp
@@ -21,7 +21,9 @@
 #include "JNIDACProvider.h"
 
 #include "ColorControlManager.h"
+#include "DoorLockManager.h"
 #include "OnOffManager.h"
+#include "PowerSourceManager.h"
 #include "credentials/DeviceAttestationCredsProvider.h"
 #include <app/app-platform/ContentAppPlatform.h>
 #include <app/server/Dnssd.h>
@@ -166,3 +168,67 @@
 {
     ColorControlManager::NewManager(endpoint, manager);
 }
+
+/*
+ * Door Lock Manager
+ */
+JNI_METHOD(void, setDoorLockManager)(JNIEnv *, jobject, jint endpoint, jobject manager)
+{
+    DoorLockManager::NewManager(endpoint, manager);
+}
+
+JNI_METHOD(jboolean, setLockType)(JNIEnv *, jobject, jint endpoint, jint value)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda([endpoint, value] { DoorLockManager::SetLockType(endpoint, value); }) ==
+        CHIP_NO_ERROR;
+}
+
+JNI_METHOD(jboolean, setLockState)(JNIEnv *, jobject, jint endpoint, jint value)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda([endpoint, value] { DoorLockManager::SetLockState(endpoint, value); }) ==
+        CHIP_NO_ERROR;
+}
+
+JNI_METHOD(jboolean, setActuatorEnabled)(JNIEnv *, jobject, jint endpoint, jboolean value)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda([endpoint, value] { DoorLockManager::SetActuatorEnabled(endpoint, value); }) ==
+        CHIP_NO_ERROR;
+}
+
+JNI_METHOD(jboolean, setAutoRelockTime)(JNIEnv *, jobject, jint endpoint, jint value)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda([endpoint, value] { DoorLockManager::SetAutoRelockTime(endpoint, value); }) ==
+        CHIP_NO_ERROR;
+}
+
+JNI_METHOD(jboolean, setOperatingMode)(JNIEnv *, jobject, jint endpoint, jint value)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda([endpoint, value] { DoorLockManager::SetOperatingMode(endpoint, value); }) ==
+        CHIP_NO_ERROR;
+}
+
+JNI_METHOD(jboolean, setSupportedOperatingModes)(JNIEnv *, jobject, jint endpoint, jint value)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda(
+               [endpoint, value] { DoorLockManager::SetSupportedOperatingModes(endpoint, value); }) == CHIP_NO_ERROR;
+}
+
+JNI_METHOD(jboolean, sendLockAlarmEvent)(JNIEnv *, jobject, jint endpoint)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda([endpoint] { DoorLockManager::SendLockAlarmEvent(endpoint); }) ==
+        CHIP_NO_ERROR;
+}
+
+/*
+ * Power Source Manager
+ */
+JNI_METHOD(void, setPowerSourceManager)(JNIEnv *, jobject, jint endpoint, jobject manager)
+{
+    PowerSourceManager::NewManager(endpoint, manager);
+}
+
+JNI_METHOD(jboolean, setBatPercentRemaining)(JNIEnv *, jobject, jint endpoint, jint value)
+{
+    return DeviceLayer::SystemLayer().ScheduleLambda(
+               [endpoint, value] { PowerSourceManager::SetBatPercentRemaining(endpoint, value); }) == CHIP_NO_ERROR;
+}
diff --git a/examples/virtual-device-app/android/java/DoorLockManager.cpp b/examples/virtual-device-app/android/java/DoorLockManager.cpp
new file mode 100644
index 0000000..9a2c574
--- /dev/null
+++ b/examples/virtual-device-app/android/java/DoorLockManager.cpp
@@ -0,0 +1,195 @@
+/**
+ *
+ *    Copyright (c) 2023 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 "DoorLockManager.h"
+#include "DeviceApp-JNI.h"
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/ConcreteAttributePath.h>
+#include <app/clusters/door-lock-server/door-lock-server.h>
+#include <app/reporting/reporting.h>
+#include <app/util/af.h>
+#include <jni.h>
+#include <lib/support/CHIPJNIError.h>
+#include <lib/support/JniReferences.h>
+#include <lib/support/JniTypeWrappers.h>
+#include <lib/support/ZclString.h>
+#include <platform/PlatformManager.h>
+#include <vector>
+
+using namespace chip;
+using namespace chip::app::Clusters;
+using namespace chip::app::Clusters::DoorLock;
+using namespace chip::DeviceLayer;
+
+static constexpr size_t kDoorLockManagerTableSize =
+    EMBER_AF_DOOR_LOCK_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT;
+
+namespace {
+
+DoorLockManager * gDoorLockManagerTable[kDoorLockManagerTableSize] = { nullptr };
+
+}
+
+void emberAfDoorLockClusterInitCallback(EndpointId endpoint)
+{
+    ChipLogProgress(Zcl, "Device App::DoorLock::PostClusterInit");
+    DeviceAppJNIMgr().PostClusterInit(chip::app::Clusters::DoorLock::Id, endpoint);
+    DoorLockServer::Instance().InitServer(endpoint);
+    EmberAfStatus status = DoorLock::Attributes::FeatureMap::Set(endpoint, 0);
+    if (status != EMBER_ZCL_STATUS_SUCCESS)
+    {
+        ChipLogProgress(Zcl, "Device App::DoorLock::emberAfDoorLockClusterInitCallback()::Updating feature map %x", status);
+    }
+}
+
+bool emberAfPluginDoorLockOnDoorLockCommand(EndpointId endpointId, const Nullable<chip::FabricIndex> & fabricIdx,
+                                            const Nullable<chip::NodeId> & nodeId, const Optional<ByteSpan> & pinCode,
+                                            OperationErrorEnum & err)
+{
+    ChipLogProgress(Zcl, "Device App::DoorLock::emberAfPluginDoorLockOnDoorLockCommand");
+    return DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kLocked);
+}
+
+bool emberAfPluginDoorLockOnDoorUnlockCommand(EndpointId endpointId, const Nullable<chip::FabricIndex> & fabricIdx,
+                                              const Nullable<chip::NodeId> & nodeId, const Optional<ByteSpan> & pinCode,
+                                              OperationErrorEnum & err)
+{
+    ChipLogProgress(Zcl, "Device App::DoorLock::emberAfPluginDoorLockOnDoorUnlockCommand");
+    return DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kUnlocked);
+}
+
+void DoorLockManager::NewManager(jint endpoint, jobject manager)
+{
+    ChipLogProgress(Zcl, "Device App: DoorLockManager::NewManager");
+    uint16_t ep = emberAfGetClusterServerEndpointIndex(static_cast<chip::EndpointId>(endpoint), app::Clusters::DoorLock::Id,
+                                                       EMBER_AF_DOOR_LOCK_CLUSTER_SERVER_ENDPOINT_COUNT);
+    VerifyOrReturn(ep < kDoorLockManagerTableSize,
+                   ChipLogError(Zcl, "Device App::DoorLock::NewManager: endpoint %d not found", endpoint));
+
+    VerifyOrReturn(gDoorLockManagerTable[ep] == nullptr,
+                   ChipLogError(Zcl, "Device App::DoorLock::NewManager: endpoint %d already has a manager", endpoint));
+    DoorLockManager * mgr = new DoorLockManager();
+    CHIP_ERROR err        = mgr->InitializeWithObjects(manager);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Zcl, "Device App::DoorLock::NewManager: failed to initialize manager for endpoint %d", endpoint);
+        delete mgr;
+    }
+    else
+    {
+        gDoorLockManagerTable[ep] = mgr;
+    }
+}
+
+DoorLockManager * GetDoorLockManager(EndpointId endpoint)
+{
+    uint16_t ep = emberAfGetClusterServerEndpointIndex(endpoint, app::Clusters::DoorLock::Id,
+                                                       EMBER_AF_DOOR_LOCK_CLUSTER_SERVER_ENDPOINT_COUNT);
+    return ((ep >= kDoorLockManagerTableSize) ? nullptr : gDoorLockManagerTable[ep]);
+}
+
+jboolean DoorLockManager::SetLockType(jint endpoint, jint value)
+{
+    EmberAfStatus status = app::Clusters::DoorLock::Attributes::LockType::Set(
+        static_cast<chip::EndpointId>(endpoint), static_cast<app::Clusters::DoorLock::DlLockType>(value));
+    return status == EMBER_ZCL_STATUS_SUCCESS;
+}
+
+jboolean DoorLockManager::SetLockState(jint endpoint, jint value)
+{
+    return DoorLockServer::Instance().SetLockState(static_cast<chip::EndpointId>(endpoint),
+                                                   static_cast<app::Clusters::DoorLock::DlLockState>(value));
+}
+
+jboolean DoorLockManager::SetActuatorEnabled(jint endpoint, jboolean value)
+{
+    return DoorLockServer::Instance().SetActuatorEnabled(static_cast<chip::EndpointId>(endpoint), value);
+}
+
+jboolean DoorLockManager::SetAutoRelockTime(jint endpoint, jint value)
+{
+    return DoorLockServer::Instance().SetAutoRelockTime(static_cast<chip::EndpointId>(endpoint), static_cast<uint32_t>(value));
+}
+
+jboolean DoorLockManager::SetOperatingMode(jint endpoint, jint value)
+{
+    EmberAfStatus status = app::Clusters::DoorLock::Attributes::OperatingMode::Set(
+        static_cast<chip::EndpointId>(endpoint), static_cast<app::Clusters::DoorLock::OperatingModeEnum>(value));
+    return status == EMBER_ZCL_STATUS_SUCCESS;
+}
+
+jboolean DoorLockManager::SetSupportedOperatingModes(jint endpoint, jint value)
+{
+    EmberAfStatus status = app::Clusters::DoorLock::Attributes::SupportedOperatingModes::Set(
+        static_cast<chip::EndpointId>(endpoint), static_cast<app::Clusters::DoorLock::DlSupportedOperatingModes>(value));
+    return status == EMBER_ZCL_STATUS_SUCCESS;
+}
+
+jboolean DoorLockManager::SendLockAlarmEvent(jint endpoint)
+{
+    return DoorLockServer::Instance().SendLockAlarmEvent(static_cast<chip::EndpointId>(endpoint), AlarmCodeEnum::kDoorForcedOpen);
+}
+
+void DoorLockManager::PostLockStateChanged(chip::EndpointId endpoint, int value)
+{
+    ChipLogProgress(Zcl, "Device App: DoorLockManager::PostLockStateChanged:%d", value);
+    DoorLockManager * mgr = GetDoorLockManager(endpoint);
+    VerifyOrReturn(mgr != nullptr, ChipLogError(Zcl, "DoorLockManager null"));
+
+    mgr->HandleLockStateChanged(static_cast<int>(endpoint), value);
+}
+
+CHIP_ERROR DoorLockManager::InitializeWithObjects(jobject managerObject)
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturnLogError(env != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    mDoorLockManagerObject = env->NewGlobalRef(managerObject);
+    VerifyOrReturnLogError(mDoorLockManagerObject != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    jclass DoorLockManagerClass = env->GetObjectClass(managerObject);
+    VerifyOrReturnLogError(DoorLockManagerClass != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    mHandleLockStateChangedMethod = env->GetMethodID(DoorLockManagerClass, "handleLockStateChanged", "(I)V");
+    if (mHandleLockStateChangedMethod == nullptr)
+    {
+        ChipLogError(Zcl, "Failed to access DoorLockManager 'handleLockStateChanged' method");
+        env->ExceptionClear();
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+void DoorLockManager::HandleLockStateChanged(jint endpoint, jint value)
+{
+    ChipLogProgress(Zcl, "DoorLockManager::HandleLockStateChanged:%d", value);
+
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturn(env != NULL, ChipLogProgress(Zcl, "env null"));
+    VerifyOrReturn(mDoorLockManagerObject != nullptr, ChipLogProgress(Zcl, "mDoorLockManagerObject null"));
+    VerifyOrReturn(mHandleLockStateChangedMethod != nullptr, ChipLogProgress(Zcl, "mHandleLockStateChangedMethod null"));
+
+    env->ExceptionClear();
+    env->CallVoidMethod(mDoorLockManagerObject, mHandleLockStateChangedMethod, value);
+    if (env->ExceptionCheck())
+    {
+        ChipLogError(AppServer, "Java exception in DoorLockManager::HandleLockStateChanged");
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+    }
+}
diff --git a/examples/virtual-device-app/android/java/DoorLockManager.h b/examples/virtual-device-app/android/java/DoorLockManager.h
new file mode 100644
index 0000000..d6dac14
--- /dev/null
+++ b/examples/virtual-device-app/android/java/DoorLockManager.h
@@ -0,0 +1,67 @@
+/*
+ *
+ *    Copyright (c) 2023 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.
+ */
+
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/clusters/door-lock-server/door-lock-server.h>
+#include <app/util/attribute-storage.h>
+#include <jni.h>
+
+/**
+ * @brief Handles interfacing between java code and C++ code for the purposes of DoorLock clusters.
+ */
+class DoorLockManager
+{
+public:
+    // installed a bridege for a DoorLock cluster endpoint and java object
+    static void NewManager(jint endpoint, jobject manager);
+
+    // helps for java to set attributes::LockType of DoorLock cluster
+    static jboolean SetLockType(jint endpoint, jint value);
+
+    // helps for java to set attributes::LockState of DoorLock cluster
+    static jboolean SetLockState(jint endpoint, jint value);
+
+    // helps for java to set attributes::ActuatorEnabled of DoorLock cluster
+    static jboolean SetActuatorEnabled(jint endpoint, jboolean value);
+
+    // helps for java to set attributes::AutoRelockTime of DoorLock cluster
+    static jboolean SetAutoRelockTime(jint endpoint, jint value);
+
+    // helps for java to set attributes::OperatingMode of DoorLock cluster
+    static jboolean SetOperatingMode(jint endpoint, jint value);
+
+    // helps for java to set attributes::SupportedOperatingMode of DoorLock cluster
+    static jboolean SetSupportedOperatingModes(jint endpoint, jint value);
+
+    // helps for java to send LockAlarmEvent of DoorLock cluster
+    static jboolean SendLockAlarmEvent(jint endpoint);
+
+    // posts a LockStateChanged event to suitable DoorLockManager
+    static void PostLockStateChanged(chip::EndpointId endpoint, int value);
+
+    // handles `Changed` callbacks by calling the java `void HandleLockStateChanged()` method
+    void HandleLockStateChanged(int endpoint, int value);
+
+private:
+    // init with java objects
+    CHIP_ERROR InitializeWithObjects(jobject managerObject);
+    jobject mDoorLockManagerObject          = nullptr;
+    jmethodID mHandleLockStateChangedMethod = nullptr;
+};
diff --git a/examples/virtual-device-app/android/java/PowerSourceManager.cpp b/examples/virtual-device-app/android/java/PowerSourceManager.cpp
new file mode 100644
index 0000000..0d56b58
--- /dev/null
+++ b/examples/virtual-device-app/android/java/PowerSourceManager.cpp
@@ -0,0 +1,107 @@
+/**
+ *
+ *    Copyright (c) 2023 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 "PowerSourceManager.h"
+#include "DeviceApp-JNI.h"
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/ConcreteAttributePath.h>
+#include <app/clusters/door-lock-server/door-lock-server.h>
+#include <app/reporting/reporting.h>
+#include <app/util/af.h>
+#include <jni.h>
+#include <lib/support/CHIPJNIError.h>
+#include <lib/support/JniReferences.h>
+#include <lib/support/JniTypeWrappers.h>
+#include <lib/support/ZclString.h>
+#include <platform/PlatformManager.h>
+
+using namespace chip;
+using namespace chip::app::Clusters;
+using namespace chip::app::Clusters::PowerSource;
+
+static constexpr size_t kPowerSourceManagerTableSize =
+    EMBER_AF_POWER_SOURCE_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT;
+
+namespace {
+
+PowerSourceManager * gPowerSourceManagerTable[kPowerSourceManagerTableSize] = { nullptr };
+
+}
+
+void emberAfPowerSourceClusterInitCallback(EndpointId endpoint)
+{
+    ChipLogProgress(Zcl, "Device App::PowerSource::PostClusterInit");
+    DeviceAppJNIMgr().PostClusterInit(chip::app::Clusters::PowerSource::Id, endpoint);
+}
+
+void PowerSourceManager::NewManager(jint endpoint, jobject manager)
+{
+    ChipLogProgress(Zcl, "Device App: PowerSourceManager::NewManager");
+    uint16_t ep = emberAfGetClusterServerEndpointIndex(static_cast<chip::EndpointId>(endpoint), app::Clusters::PowerSource::Id,
+                                                       EMBER_AF_POWER_SOURCE_CLUSTER_SERVER_ENDPOINT_COUNT);
+    VerifyOrReturn(ep < kPowerSourceManagerTableSize,
+                   ChipLogError(Zcl, "Device App::PowerSource::NewManager: endpoint %d not found", endpoint));
+
+    VerifyOrReturn(gPowerSourceManagerTable[ep] == nullptr,
+                   ChipLogError(Zcl, "Device App::PowerSource::NewManager: endpoint %d already has a manager", endpoint));
+    PowerSourceManager * mgr = new PowerSourceManager();
+    CHIP_ERROR err           = mgr->InitializeWithObjects(manager);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Zcl, "Device App::PowerSource::NewManager: failed to initialize manager for endpoint %d", endpoint);
+        delete mgr;
+    }
+    else
+    {
+        gPowerSourceManagerTable[ep] = mgr;
+    }
+}
+
+PowerSourceManager * GetPowerSourceManager(EndpointId endpoint)
+{
+    uint16_t ep = emberAfGetClusterServerEndpointIndex(endpoint, app::Clusters::PowerSource::Id,
+                                                       EMBER_AF_POWER_SOURCE_CLUSTER_SERVER_ENDPOINT_COUNT);
+    return ((ep >= kPowerSourceManagerTableSize) ? nullptr : gPowerSourceManagerTable[ep]);
+}
+
+jboolean PowerSourceManager::SetBatPercentRemaining(jint endpoint, jint value)
+{
+    using namespace chip::app::Clusters;
+    using namespace chip::DeviceLayer;
+    EmberAfStatus status = EMBER_ZCL_STATUS_SUCCESS;
+
+    status =
+        PowerSource::Attributes::BatPercentRemaining::Set(static_cast<chip::EndpointId>(endpoint), static_cast<uint8_t>(value * 2));
+
+    ChipLogDetail(Zcl, "Device App::PowerSource::SetBatPercentRemaining: endpoint:%d, percent:%d", endpoint, value);
+    return status == EMBER_ZCL_STATUS_SUCCESS;
+}
+
+CHIP_ERROR PowerSourceManager::InitializeWithObjects(jobject managerObject)
+{
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturnLogError(env != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    mPowerSourceManagerObject = env->NewGlobalRef(managerObject);
+    VerifyOrReturnLogError(mPowerSourceManagerObject != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    jclass PowerSourceManagerClass = env->GetObjectClass(managerObject);
+    VerifyOrReturnLogError(PowerSourceManagerClass != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    return CHIP_NO_ERROR;
+}
diff --git a/examples/virtual-device-app/android/java/PowerSourceManager.h b/examples/virtual-device-app/android/java/PowerSourceManager.h
new file mode 100644
index 0000000..54b2c68
--- /dev/null
+++ b/examples/virtual-device-app/android/java/PowerSourceManager.h
@@ -0,0 +1,39 @@
+/*
+ *
+ *    Copyright (c) 2023 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.
+ */
+
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/util/attribute-storage.h>
+#include <jni.h>
+
+/**
+ * @brief Handles interfacing between java code and C++ code for the purposes of PowerSource clusters.
+ */
+class PowerSourceManager
+{
+public:
+    // installed a bridege for a PowerSource cluster endpoint and java object
+    static void NewManager(jint endpoint, jobject manager);
+    static jboolean SetBatPercentRemaining(jint endpoint, jint value);
+
+private:
+    // init with java objects
+    CHIP_ERROR InitializeWithObjects(jobject managerObject);
+    jobject mPowerSourceManagerObject = nullptr;
+};
diff --git a/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/DeviceApp.java b/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/DeviceApp.java
index 3df52b0..feb9f91 100644
--- a/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/DeviceApp.java
+++ b/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/DeviceApp.java
@@ -53,11 +53,31 @@
   // called after Matter server is initiated
   public native void postServerInit(int deviceTypeId);
 
+  public native void setDACProvider(DACProvider provider);
+
   public native void setOnOffManager(int endpoint, OnOffManager manager);
 
   public native boolean setOnOff(int endpoint, boolean value);
 
-  public native void setDACProvider(DACProvider provider);
+  public native void setDoorLockManager(int endpoint, DoorLockManager manager);
+
+  public native boolean setLockType(int endpoint, int value);
+
+  public native boolean setLockState(int endpoint, int value);
+
+  public native boolean setActuatorEnabled(int endpoint, boolean value);
+
+  public native boolean setAutoRelockTime(int endpoint, int value);
+
+  public native boolean setOperatingMode(int endpoint, int value);
+
+  public native boolean setSupportedOperatingModes(int endpoint, int value);
+
+  public native boolean sendLockAlarmEvent(int endpoint);
+
+  public native void setPowerSourceManager(int endpoint, PowerSourceManager manager);
+
+  public native boolean setBatPercentRemaining(int endpoint, int value);
 
   static {
     System.loadLibrary("DeviceApp");
diff --git a/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/DoorLockManager.java b/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/DoorLockManager.java
new file mode 100644
index 0000000..6e03667
--- /dev/null
+++ b/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/DoorLockManager.java
@@ -0,0 +1,39 @@
+package com.matter.virtual.device.app;
+
+public interface DoorLockManager {
+
+  int DlLockState_kNotFullyLocked = 0;
+  int DlLockState_kLocked = 1;
+  int DlLockState_kUnlocked = 2;
+  int DlLockState_kUnlatched = 3;
+
+  int DlLockType_kDeadBolt = 0;
+  int DlLockType_kMagnetic = 1;
+  int DlLockType_kOther = 2;
+  int DlLockType_kMortise = 3;
+  int DlLockType_kRim = 4;
+  int DlLockType_kLatchBolt = 5;
+  int DlLockType_kCylindricalLock = 6;
+  int DlLockType_kTubularLock = 7;
+  int DlLockType_kInterconnectedLock = 8;
+  int DlLockType_kDeadLatch = 9;
+  int DlLockType_kDoorFurniture = 10;
+  int DlLockType_kEurocylinder = 11;
+
+  int OperatingModeEnum_kNormal = 0;
+  int OperatingModeEnum_kVacation = 1;
+  int OperatingModeEnum_kPrivacy = 2;
+  int OperatingModeEnum_kNoRemoteLockUnlock = 3;
+  int OperatingModeEnum_kPassage = 4;
+
+  int DlSupportedOperatingModes_kNormal = 0x1;
+  int DlSupportedOperatingModes_kVacation = 0x2;
+  int DlSupportedOperatingModes_kPrivacy = 0x4;
+  int DlSupportedOperatingModes_kNoRemoteLockUnlock = 0x8;
+  int DlSupportedOperatingModes_kPassage = 0x10;
+
+  /** initialize attribute by DeviceApp */
+  void initAttributeValue();
+
+  void handleLockStateChanged(int value);
+}
diff --git a/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/PowerSourceManager.java b/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/PowerSourceManager.java
new file mode 100644
index 0000000..5245b49
--- /dev/null
+++ b/examples/virtual-device-app/android/java/src/com/matter/virtual/device/app/PowerSourceManager.java
@@ -0,0 +1,6 @@
+package com.matter.virtual.device.app;
+
+public interface PowerSourceManager {
+
+  void initAttributeValue();
+}