diff --git a/host-bmc/dbus_to_event_handler.cpp b/host-bmc/dbus_to_event_handler.cpp
new file mode 100644
index 0000000..7b2d207
--- /dev/null
+++ b/host-bmc/dbus_to_event_handler.cpp
@@ -0,0 +1,161 @@
+#include "dbus_to_event_handler.hpp"
+
+#include "libpldm/requester/pldm.h"
+
+#include "libpldmresponder/pdr.hpp"
+
+namespace pldm
+{
+
+using namespace pldm::responder::pdr;
+using namespace pldm::utils;
+using namespace sdbusplus::bus::match::rules;
+
+namespace state_sensor
+{
+const std::vector<uint8_t> pdrTypes{PLDM_STATE_SENSOR_PDR};
+
+DbusToPLDMEvent::DbusToPLDMEvent(int mctp_fd, uint8_t mctp_eid,
+                                 Requester& requester) :
+    mctp_fd(mctp_fd),
+    mctp_eid(mctp_eid), requester(requester)
+{}
+
+void DbusToPLDMEvent::sendEventMsg(uint8_t eventType,
+                                   const std::vector<uint8_t>& eventDataVec)
+{
+    auto instanceId = requester.getInstanceId(mctp_eid);
+    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
+                                    PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
+                                    eventDataVec.size());
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+    auto rc = encode_platform_event_message_req(
+        instanceId, 1 /*formatVersion*/, 0 /*tId*/, eventType,
+        eventDataVec.data(), eventDataVec.size(), request,
+        eventDataVec.size() + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES);
+    if (rc != PLDM_SUCCESS)
+    {
+        requester.markFree(mctp_eid, instanceId);
+        std::cerr << "Failed to encode_platform_event_message_req, rc = " << rc
+                  << std::endl;
+        return;
+    }
+
+    uint8_t* responseMsg = nullptr;
+    size_t responseMsgSize{};
+
+    auto requesterRc =
+        pldm_send_recv(mctp_eid, mctp_fd, requestMsg.data(), requestMsg.size(),
+                       &responseMsg, &responseMsgSize);
+    std::unique_ptr<uint8_t, decltype(std::free)*> responseMsgPtr{responseMsg,
+                                                                  std::free};
+
+    requester.markFree(mctp_eid, instanceId);
+    if (requesterRc != PLDM_REQUESTER_SUCCESS)
+    {
+        std::cerr
+            << "Failed to send msg to report state sensor event changes, rc = "
+            << requesterRc << std::endl;
+        return;
+    }
+    uint8_t completionCode{};
+    uint8_t status{};
+    auto responsePtr = reinterpret_cast<struct pldm_msg*>(responseMsgPtr.get());
+    rc = decode_platform_event_message_resp(
+        responsePtr, responseMsgSize - sizeof(pldm_msg_hdr), &completionCode,
+        &status);
+
+    if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
+    {
+        std::cerr << "Failed to decode_platform_event_message_resp: "
+                  << "rc=" << rc
+                  << ", cc=" << static_cast<unsigned>(completionCode)
+                  << std::endl;
+    }
+}
+
+void DbusToPLDMEvent::sendStateSensorEvent(SensorId sensorId,
+                                           const DbusObjMaps& dbusMaps)
+{
+    // Encode PLDM platform event msg to indicate a state sensor change.
+    // DSP0248_1.2.0 Table 19
+    size_t sensorEventSize = PLDM_SENSOR_EVENT_DATA_MIN_LENGTH + 1;
+    const auto& [dbusMappings, dbusValMaps] = dbusMaps.at(sensorId);
+    for (uint8_t offset = 0; offset < dbusMappings.size(); ++offset)
+    {
+        std::vector<uint8_t> sensorEventDataVec{};
+        sensorEventDataVec.resize(sensorEventSize);
+        auto eventData = reinterpret_cast<struct pldm_sensor_event_data*>(
+            sensorEventDataVec.data());
+        eventData->sensor_id = sensorId;
+        eventData->sensor_event_class_type = PLDM_STATE_SENSOR_STATE;
+        eventData->event_class[0] = offset;
+        eventData->event_class[1] = PLDM_SENSOR_UNKNOWN;
+        eventData->event_class[2] = PLDM_SENSOR_UNKNOWN;
+
+        const auto& dbusMapping = dbusMappings[offset];
+        const auto& dbusValueMapping = dbusValMaps[offset];
+        auto stateSensorMatch = std::make_unique<sdbusplus::bus::match::match>(
+            pldm::utils::DBusHandler::getBus(),
+            propertiesChanged(dbusMapping.objectPath.c_str(),
+                              dbusMapping.interface.c_str()),
+            [this, sensorEventDataVec, dbusValueMapping](auto& msg) mutable {
+                DbusChangedProps props{};
+                std::string intf;
+                msg.read(intf, props);
+                const auto& first = props.begin();
+                for (const auto& itr : dbusValueMapping)
+                {
+                    if (itr.second == first->second)
+                    {
+                        auto eventData =
+                            reinterpret_cast<struct pldm_sensor_event_data*>(
+                                sensorEventDataVec.data());
+                        eventData->event_class[1] = itr.first;
+                        eventData->event_class[2] = itr.first;
+                        this->sendEventMsg(PLDM_SENSOR_EVENT,
+                                           sensorEventDataVec);
+                    }
+                }
+            });
+        stateSensorMatchs.emplace_back(std::move(stateSensorMatch));
+    }
+}
+
+void DbusToPLDMEvent::listenSensorEvent(const pdr_utils::Repo& repo,
+                                        const DbusObjMaps& dbusMaps)
+{
+    const std::map<Type, sensorEvent> sensorHandlers = {
+        {PLDM_STATE_SENSOR_PDR,
+         [this](SensorId sensorId, const DbusObjMaps& dbusMaps) {
+             this->sendStateSensorEvent(sensorId, dbusMaps);
+         }}};
+
+    pldm_state_sensor_pdr* pdr = nullptr;
+    std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> sensorPdrRepo(
+        pldm_pdr_init(), pldm_pdr_destroy);
+
+    for (auto pdrType : pdrTypes)
+    {
+        Repo sensorPDRs(sensorPdrRepo.get());
+        getRepoByType(repo, sensorPDRs, pdrType);
+        if (sensorPDRs.empty())
+        {
+            return;
+        }
+
+        PdrEntry pdrEntry{};
+        auto pdrRecord = sensorPDRs.getFirstRecord(pdrEntry);
+        while (pdrRecord)
+        {
+            pdr = reinterpret_cast<pldm_state_sensor_pdr*>(pdrEntry.data);
+            SensorId sensorId = LE16TOH(pdr->sensor_id);
+            sensorHandlers.at(pdrType)(sensorId, dbusMaps);
+            pdrRecord = sensorPDRs.getNextRecord(pdrRecord, pdrEntry);
+        }
+    }
+}
+
+} // namespace state_sensor
+} // namespace pldm
diff --git a/host-bmc/dbus_to_event_handler.hpp b/host-bmc/dbus_to_event_handler.hpp
new file mode 100644
index 0000000..add5c2d
--- /dev/null
+++ b/host-bmc/dbus_to_event_handler.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "libpldm/platform.h"
+
+#include "libpldmresponder/pdr_utils.hpp"
+#include "pldmd/dbus_impl_requester.hpp"
+
+#include <map>
+
+using namespace pldm::dbus_api;
+using namespace pldm::responder;
+
+namespace pldm
+{
+
+using SensorId = uint16_t;
+using DbusObjMaps =
+    std::map<SensorId,
+             std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps>>;
+using sensorEvent =
+    std::function<void(SensorId sensorId, const DbusObjMaps& dbusMaps)>;
+
+namespace state_sensor
+{
+/** @class DbusToPLDMEvent
+ *  @brief This class can listen to the state sensor PDRs and send PLDM event
+ *         msg when a D-Bus property changes
+ */
+class DbusToPLDMEvent
+{
+  public:
+    DbusToPLDMEvent() = delete;
+    DbusToPLDMEvent(const DbusToPLDMEvent&) = delete;
+    DbusToPLDMEvent(DbusToPLDMEvent&&) = delete;
+    DbusToPLDMEvent& operator=(const DbusToPLDMEvent&) = delete;
+    DbusToPLDMEvent& operator=(DbusToPLDMEvent&&) = delete;
+    ~DbusToPLDMEvent() = default;
+
+    /** @brief Constructor
+     *  @param[in] mctp_fd - fd of MCTP communications socket
+     *  @param[in] mctp_eid - MCTP EID of host firmware
+     *  @param[in] requester - reference to Requester object
+     */
+    explicit DbusToPLDMEvent(int mctp_fd, uint8_t mctp_eid,
+                             Requester& requester);
+
+  public:
+    /** @brief Listen all of the state sensor PDRs
+     *  @param[in] repo - pdr utils repo object
+     *  @param[in] dbusMaps - The map of D-Bus mapping and value
+     */
+    void listenSensorEvent(const pdr_utils::Repo& repo,
+                           const DbusObjMaps& dbusMaps);
+
+  private:
+    /** @brief Send state sensor event msg when a D-Bus property changes
+     *  @param[in] sensorId - sensor id
+     */
+    void sendStateSensorEvent(SensorId sensorId, const DbusObjMaps& dbusMaps);
+
+    /** @brief Send all of sensor event
+     *  @param[in] eventType - PLDM Event types
+     *  @param[in] eventDataVec - std::vector, contains send event data
+     */
+    void sendEventMsg(uint8_t eventType,
+                      const std::vector<uint8_t>& eventDataVec);
+
+    /** @brief fd of MCTP communications socket */
+    int mctp_fd;
+
+    /** @brief MCTP EID of host firmware */
+    uint8_t mctp_eid;
+
+    /** @brief reference to Requester object, primarily used to access API to
+     *  obtain PLDM instance id.
+     */
+    Requester& requester;
+
+    /** @brief D-Bus property changed signal match */
+    std::vector<std::unique_ptr<sdbusplus::bus::match::match>>
+        stateSensorMatchs;
+};
+
+} // namespace state_sensor
+} // namespace pldm