diff --git a/examples/all-clusters-app/nxp/mw320/main.cpp b/examples/all-clusters-app/nxp/mw320/main.cpp index 23675050c73052..b8b1fe85bfabdd 100644 --- a/examples/all-clusters-app/nxp/mw320/main.cpp +++ b/examples/all-clusters-app/nxp/mw320/main.cpp @@ -14,8 +14,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -//#include "FreeRTOS.h" -//#include "task.h" +// #include "FreeRTOS.h" +// #include "task.h" #include @@ -28,7 +28,7 @@ #include #include -//#include //==> rm from TE7.5 +// #include //==> rm from TE7.5 #include #include #include @@ -59,9 +59,9 @@ #include "app/clusters/ota-requestor/DefaultOTARequestor.h" #include "app/clusters/ota-requestor/DefaultOTARequestorDriver.h" #include "app/clusters/ota-requestor/DefaultOTARequestorStorage.h" -//#include +// #include #include "platform/nxp/mw320/OTAImageProcessorImpl.h" -//#include "app/clusters/ota-requestor/OTARequestorDriver.h" +// #include "app/clusters/ota-requestor/OTARequestorDriver.h" // for ota module test #include "mw320_ota.h" @@ -1528,7 +1528,7 @@ static void OnSwitchAttributeChangeCallback(EndpointId endpointId, AttributeId a ReadHandler * phandler = pimEngine->ActiveHandlerAt(i); if (phandler->IsType(chip::app::ReadHandler::InteractionType::Subscribe) && (phandler->IsGeneratingReports() || phandler->IsAwaitingReportResponse())) { - phandler->UnblockUrgentEventDelivery(); + phandler->ForceDirtyState(); do_sendrpt = true; break; } diff --git a/src/app/ReadHandler.cpp b/src/app/ReadHandler.cpp index 1c2511b497b0f2..4a92fcfac91f9c 100644 --- a/src/app/ReadHandler.cpp +++ b/src/app/ReadHandler.cpp @@ -124,10 +124,10 @@ ReadHandler::~ReadHandler() if (IsType(InteractionType::Subscribe)) { InteractionModelEngine::GetInstance()->GetExchangeManager()->GetSessionManager()->SystemLayer()->CancelTimer( - OnUnblockHoldReportCallback, this); + MinIntervalExpiredCallback, this); InteractionModelEngine::GetInstance()->GetExchangeManager()->GetSessionManager()->SystemLayer()->CancelTimer( - OnRefreshSubscribeTimerSyncCallback, this); + MaxIntervalExpiredCallback, this); } if (IsAwaitingReportResponse()) @@ -248,7 +248,7 @@ CHIP_ERROR ReadHandler::OnStatusResponse(Messaging::ExchangeContext * apExchange CHIP_ERROR ReadHandler::SendStatusReport(Protocols::InteractionModel::Status aStatus) { - VerifyOrReturnLogError(IsReportable(), CHIP_ERROR_INCORRECT_STATE); + VerifyOrReturnLogError(IsReportableNow(), CHIP_ERROR_INCORRECT_STATE); if (IsPriming() || IsChunkedReport()) { mSessionHandle.Grab(mExchangeCtx->GetSessionHandle()); @@ -272,7 +272,7 @@ CHIP_ERROR ReadHandler::SendStatusReport(Protocols::InteractionModel::Status aSt CHIP_ERROR ReadHandler::SendReportData(System::PacketBufferHandle && aPayload, bool aMoreChunks) { - VerifyOrReturnLogError(IsReportable(), CHIP_ERROR_INCORRECT_STATE); + VerifyOrReturnLogError(IsReportableNow(), CHIP_ERROR_INCORRECT_STATE); VerifyOrDie(!IsAwaitingReportResponse()); // Should not be reportable! if (IsPriming() || IsChunkedReport()) { @@ -319,10 +319,10 @@ CHIP_ERROR ReadHandler::SendReportData(System::PacketBufferHandle && aPayload, b if (IsType(InteractionType::Subscribe) && !IsPriming()) { - // Ignore the error from RefreshSubscribeSyncTimer. If we've + // Ignore the error from UpdateReportTimer. If we've // successfully sent the message, we need to return success from // this method. - RefreshSubscribeSyncTimer(); + UpdateReportTimer(); } } if (!aMoreChunks) @@ -591,7 +591,7 @@ void ReadHandler::MoveToState(const HandlerState aTargetState) // If we just unblocked sending reports, let's go ahead and schedule the reporting // engine to run to kick that off. // - if (aTargetState == HandlerState::GeneratingReports && IsReportable()) + if (aTargetState == HandlerState::GeneratingReports && IsReportableNow()) { InteractionModelEngine::GetInstance()->GetReportingEngine().ScheduleRun(); } @@ -634,7 +634,7 @@ CHIP_ERROR ReadHandler::SendSubscribeResponse() ReturnErrorOnFailure(writer.Finalize(&packet)); VerifyOrReturnLogError(mExchangeCtx, CHIP_ERROR_INCORRECT_STATE); - ReturnErrorOnFailure(RefreshSubscribeSyncTimer()); + ReturnErrorOnFailure(UpdateReportTimer()); ClearStateFlag(ReadHandlerFlags::PrimingReports); return mExchangeCtx->SendMessage(Protocols::InteractionModel::MsgType::SubscribeResponse, std::move(packet)); @@ -753,42 +753,42 @@ void ReadHandler::PersistSubscription() } } -void ReadHandler::OnUnblockHoldReportCallback(System::Layer * apSystemLayer, void * apAppState) +void ReadHandler::MinIntervalExpiredCallback(System::Layer * apSystemLayer, void * apAppState) { VerifyOrReturn(apAppState != nullptr); ReadHandler * readHandler = static_cast(apAppState); ChipLogDetail(DataManagement, "Unblock report hold after min %d seconds", readHandler->mMinIntervalFloorSeconds); - readHandler->ClearStateFlag(ReadHandlerFlags::HoldReport); + readHandler->ClearStateFlag(ReadHandlerFlags::WaitingUntilMinInterval); InteractionModelEngine::GetInstance()->GetExchangeManager()->GetSessionManager()->SystemLayer()->StartTimer( - System::Clock::Seconds16(readHandler->mMaxInterval - readHandler->mMinIntervalFloorSeconds), - OnRefreshSubscribeTimerSyncCallback, readHandler); + System::Clock::Seconds16(readHandler->mMaxInterval - readHandler->mMinIntervalFloorSeconds), MaxIntervalExpiredCallback, + readHandler); } -void ReadHandler::OnRefreshSubscribeTimerSyncCallback(System::Layer * apSystemLayer, void * apAppState) +void ReadHandler::MaxIntervalExpiredCallback(System::Layer * apSystemLayer, void * apAppState) { VerifyOrReturn(apAppState != nullptr); ReadHandler * readHandler = static_cast(apAppState); - readHandler->ClearStateFlag(ReadHandlerFlags::HoldSync); + readHandler->ClearStateFlag(ReadHandlerFlags::WaitingUntilMaxInterval); ChipLogProgress(DataManagement, "Refresh subscribe timer sync after %d seconds", readHandler->mMaxInterval - readHandler->mMinIntervalFloorSeconds); } -CHIP_ERROR ReadHandler::RefreshSubscribeSyncTimer() +CHIP_ERROR ReadHandler::UpdateReportTimer() { InteractionModelEngine::GetInstance()->GetExchangeManager()->GetSessionManager()->SystemLayer()->CancelTimer( - OnUnblockHoldReportCallback, this); + MinIntervalExpiredCallback, this); InteractionModelEngine::GetInstance()->GetExchangeManager()->GetSessionManager()->SystemLayer()->CancelTimer( - OnRefreshSubscribeTimerSyncCallback, this); + MaxIntervalExpiredCallback, this); if (!IsChunkedReport()) { ChipLogProgress(DataManagement, "Refresh Subscribe Sync Timer with min %d seconds and max %d seconds", mMinIntervalFloorSeconds, mMaxInterval); - SetStateFlag(ReadHandlerFlags::HoldReport); - SetStateFlag(ReadHandlerFlags::HoldSync); + SetStateFlag(ReadHandlerFlags::WaitingUntilMinInterval); + SetStateFlag(ReadHandlerFlags::WaitingUntilMaxInterval); ReturnErrorOnFailure( InteractionModelEngine::GetInstance()->GetExchangeManager()->GetSessionManager()->SystemLayer()->StartTimer( - System::Clock::Seconds16(mMinIntervalFloorSeconds), OnUnblockHoldReportCallback, this)); + System::Clock::Seconds16(mMinIntervalFloorSeconds), MinIntervalExpiredCallback, this)); } return CHIP_NO_ERROR; @@ -800,13 +800,13 @@ void ReadHandler::ResetPathIterator() mAttributeEncoderState = AttributeValueEncoder::AttributeEncodeState(); } -void ReadHandler::SetDirty(const AttributePathParams & aAttributeChanged) +void ReadHandler::AttributePathIsDirty(const AttributePathParams & aAttributeChanged) { ConcreteAttributePath path; mDirtyGeneration = InteractionModelEngine::GetInstance()->GetReportingEngine().GetDirtySetGeneration(); - // We won't reset the path iterator for every SetDirty call to reduce the number of full data reports. + // We won't reset the path iterator for every AttributePathIsDirty call to reduce the number of full data reports. // The iterator will be reset after finishing each report session. // // Here we just reset the iterator to the beginning of the current cluster, if the dirty path affects it. @@ -829,7 +829,7 @@ void ReadHandler::SetDirty(const AttributePathParams & aAttributeChanged) mAttributeEncoderState = AttributeValueEncoder::AttributeEncodeState(); } - if (IsReportable()) + if (IsReportableNow()) { InteractionModelEngine::GetInstance()->GetReportingEngine().ScheduleRun(); } @@ -844,17 +844,17 @@ Transport::SecureSession * ReadHandler::GetSession() const return mSessionHandle->AsSecureSession(); } -void ReadHandler::UnblockUrgentEventDelivery() +void ReadHandler::ForceDirtyState() { SetStateFlag(ReadHandlerFlags::ForceDirty); } void ReadHandler::SetStateFlag(ReadHandlerFlags aFlag, bool aValue) { - bool oldReportable = IsReportable(); + bool oldReportable = IsReportableNow(); mFlags.Set(aFlag, aValue); // If we became reportable, schedule a reporting run. - if (!oldReportable && IsReportable()) + if (!oldReportable && IsReportableNow()) { InteractionModelEngine::GetInstance()->GetReportingEngine().ScheduleRun(); } diff --git a/src/app/ReadHandler.h b/src/app/ReadHandler.h index a933aa76e51389..f460188935223e 100644 --- a/src/app/ReadHandler.h +++ b/src/app/ReadHandler.h @@ -212,15 +212,15 @@ class ReadHandler : public Messaging::ExchangeDelegate enum class ReadHandlerFlags : uint8_t { - // mHoldReport is used to prevent subscription data delivery while we are + // WaitingUntilMinInterval is used to prevent subscription data delivery while we are // waiting for the min reporting interval to elapse. - HoldReport = (1 << 0), + WaitingUntilMinInterval = (1 << 0), - // mHoldSync is used to prevent subscription empty report delivery while we - // are waiting for the max reporting interval to elaps. When mHoldSync + // WaitingUntilMaxInterval is used to prevent subscription empty report delivery while we + // are waiting for the max reporting interval to elaps. When WaitingUntilMaxInterval // becomes false, we are allowed to send an empty report to keep the // subscription alive on the client. - HoldSync = (1 << 1), + WaitingUntilMaxInterval = (1 << 1), // The flag indicating we are in the middle of a series of chunked report messages, this flag will be cleared during // sending last chunked message. @@ -290,13 +290,16 @@ class ReadHandler : public Messaging::ExchangeDelegate bool IsFromSubscriber(Messaging::ExchangeContext & apExchangeContext) const; bool IsIdle() const { return mState == HandlerState::Idle; } - bool IsReportable() const + + /// @brief Returns whether the ReadHandler is in a state where it can immediately send a report. This function + /// is used to determine whether a report generation should be scheduled for the handler. + bool IsReportableNow() const { - // Important: Anything that changes the state IsReportable depends on in - // a way that causes IsReportable to become true must call ScheduleRun + // Important: Anything that changes the state IsReportableNow depends on in + // a way that causes IsReportableNow to become true must call ScheduleRun // on the reporting engine. - return mState == HandlerState::GeneratingReports && !mFlags.Has(ReadHandlerFlags::HoldReport) && - (IsDirty() || !mFlags.Has(ReadHandlerFlags::HoldSync)); + return mState == HandlerState::GeneratingReports && !mFlags.Has(ReadHandlerFlags::WaitingUntilMinInterval) && + (IsDirty() || !mFlags.Has(ReadHandlerFlags::WaitingUntilMaxInterval)); } bool IsGeneratingReports() const { return mState == HandlerState::GeneratingReports; } bool IsAwaitingReportResponse() const { return mState == HandlerState::AwaitingReportResponse; } @@ -323,10 +326,10 @@ class ReadHandler : public Messaging::ExchangeDelegate void GetSubscriptionId(SubscriptionId & aSubscriptionId) const { aSubscriptionId = mSubscriptionId; } AttributePathExpandIterator * GetAttributePathExpandIterator() { return &mAttributePathExpandIterator; } - /** - * Notify the read handler that a set of attribute paths has been marked dirty. - */ - void SetDirty(const AttributePathParams & aAttributeChanged); + /// @brief Notifies the read handler that a set of attribute paths has been marked dirty. This will schedule a reporting engine + /// run if the change to the attribute path makes the ReadHandler reportable. + /// @param aAttributeChanged Path to the attribute that was changed. + void AttributePathIsDirty(const AttributePathParams & aAttributeChanged); bool IsDirty() const { return (mDirtyGeneration > mPreviousReportsBeginGeneration) || mFlags.Has(ReadHandlerFlags::ForceDirty); @@ -349,7 +352,10 @@ class ReadHandler : public Messaging::ExchangeDelegate auto GetTransactionStartGeneration() const { return mTransactionStartGeneration; } - void UnblockUrgentEventDelivery(); + /// @brief Forces the read handler into a dirty state, regardless of what's going on with attributes. + /// This can lead to scheduling of a reporting run immediately, if the min interval has been reached, + /// or after the min interval is reached if it has not yet been reached. + void ForceDirtyState(); const AttributeValueEncoder::AttributeEncodeState & GetAttributeEncodeState() const { return mAttributeEncoderState; } void SetAttributeEncodeState(const AttributeValueEncoder::AttributeEncodeState & aState) { mAttributeEncoderState = aState; } @@ -396,9 +402,12 @@ class ReadHandler : public Messaging::ExchangeDelegate */ void Close(CloseOptions options = CloseOptions::kDropPersistedSubscription); - static void OnUnblockHoldReportCallback(System::Layer * apSystemLayer, void * apAppState); - static void OnRefreshSubscribeTimerSyncCallback(System::Layer * apSystemLayer, void * apAppState); - CHIP_ERROR RefreshSubscribeSyncTimer(); + /// @brief This function is called when the min interval timer has expired, it restarts the timer on a timeout equal to the + /// difference between the max interval and the min interval. + static void MinIntervalExpiredCallback(System::Layer * apSystemLayer, void * apAppState); + static void MaxIntervalExpiredCallback(System::Layer * apSystemLayer, void * apAppState); + /// @brief This function is called when a report is sent and it restarts the min interval timer. + CHIP_ERROR UpdateReportTimer(); CHIP_ERROR SendSubscribeResponse(); CHIP_ERROR ProcessSubscribeRequest(System::PacketBufferHandle && aPayload); CHIP_ERROR ProcessReadRequest(System::PacketBufferHandle && aPayload); @@ -416,8 +425,15 @@ class ReadHandler : public Messaging::ExchangeDelegate void PersistSubscription(); - // Helpers for managing our state flags properly. + /// @brief Modifies a state flag in the read handler. If the read handler went from a + /// non-reportable state to a reportable state, schedules a reporting engine run. + /// @param aFlag Flag to set + /// @param aValue Flag new value void SetStateFlag(ReadHandlerFlags aFlag, bool aValue = true); + + /// @brief This function call SetStateFlag with the flag value set to false, thus possibly emitting a report + /// generation. + /// @param aFlag Flag to clear void ClearStateFlag(ReadHandlerFlags aFlag); // Helpers for continuing the subscription resumption @@ -436,7 +452,7 @@ class ReadHandler : public Messaging::ExchangeDelegate // current generation when we started sending the last set reports that we completed. // // This allows us to reset the iterator to the beginning of the current - // cluster instead of the beginning of the whole report in SetDirty, without + // cluster instead of the beginning of the whole report in AttributePathIsDirty, without // permanently missing dirty any paths. uint64_t mDirtyGeneration = 0; @@ -450,14 +466,14 @@ class ReadHandler : public Messaging::ExchangeDelegate /* * (mDirtyGeneration = b > a, this is a dirty read handler) * +- Start Report -> mCurrentReportsBeginGeneration = c - * | +- SetDirty (Attribute Y) -> mDirtyGeneration = d + * | +- AttributePathIsDirty (Attribute Y) -> mDirtyGeneration = d * | | +- Last Chunk -> mPreviousReportsBeginGeneration = mCurrentReportsBeginGeneration = c * | | | +- (mDirtyGeneration = d) > (mPreviousReportsBeginGeneration = c), this is a dirty read handler * | | | | Attribute X has a dirty generation less than c, Attribute Y has a dirty generation larger than c * | | | | So Y will be included in the report but X will not be inclued in this report. * -a--b--c------d-----e---f---> Generation * | | - * | +- SetDirty (Attribute X) (mDirtyGeneration = b) + * | +- AttributePathIsDirty (Attribute X) (mDirtyGeneration = b) * +- mPreviousReportsBeginGeneration * For read handler, if mDirtyGeneration > mPreviousReportsBeginGeneration, then we regard it as a dirty read handler, and it * should generate report on timeout reached. diff --git a/src/app/reporting/Engine.cpp b/src/app/reporting/Engine.cpp index 0f9d592737ce79..a9853215332fd5 100644 --- a/src/app/reporting/Engine.cpp +++ b/src/app/reporting/Engine.cpp @@ -636,7 +636,7 @@ void Engine::Run() ReadHandler * readHandler = imEngine->ActiveHandlerAt(mCurReadHandlerIdx % (uint32_t) imEngine->mReadHandlers.Allocated()); VerifyOrDie(readHandler != nullptr); - if (readHandler->IsReportable()) + if (readHandler->IsReportableNow()) { mRunningReadHandler = readHandler; CHIP_ERROR err = BuildAndSendSingleReportData(readHandler); @@ -826,16 +826,16 @@ CHIP_ERROR Engine::SetDirty(AttributePathParams & aAttributePath) bool intersectsInterestPath = false; InteractionModelEngine::GetInstance()->mReadHandlers.ForEachActiveObject( [&aAttributePath, &intersectsInterestPath](ReadHandler * handler) { - // We call SetDirty for both read interactions and subscribe interactions, since we may send inconsistent attribute data - // between two chunks. SetDirty will be ignored automatically by read handlers which are waiting for a response to the - // last message chunk for read interactions. + // We call AttributePathIsDirty for both read interactions and subscribe interactions, since we may send inconsistent + // attribute data between two chunks. AttributePathIsDirty will not schedule a new run for read handlers which are + // waiting for a response to the last message chunk for read interactions. if (handler->IsGeneratingReports() || handler->IsAwaitingReportResponse()) { for (auto object = handler->GetAttributePathList(); object != nullptr; object = object->mpNext) { if (object->mValue.Intersects(aAttributePath)) { - handler->SetDirty(aAttributePath); + handler->AttributePathIsDirty(aAttributePath); intersectsInterestPath = true; break; } @@ -937,7 +937,7 @@ CHIP_ERROR Engine::ScheduleEventDelivery(ConcreteEventPath & aPath, uint32_t aBy if (interestedPath->mValue.IsEventPathSupersetOf(aPath) && interestedPath->mValue.mIsUrgentEvent) { isUrgentEvent = true; - handler->UnblockUrgentEventDelivery(); + handler->ForceDirtyState(); break; } } @@ -967,7 +967,7 @@ void Engine::ScheduleUrgentEventDeliverySync(Optional fabricIndex) return Loop::Continue; } - handler->UnblockUrgentEventDelivery(); + handler->ForceDirtyState(); return Loop::Continue; }); diff --git a/src/app/tests/TestReadInteraction.cpp b/src/app/tests/TestReadInteraction.cpp index fe0d2a04e39731..9ec3d59330c216 100644 --- a/src/app/tests/TestReadInteraction.cpp +++ b/src/app/tests/TestReadInteraction.cpp @@ -1587,7 +1587,7 @@ void TestReadInteraction::TestSubscribeRoundtrip(nlTestSuite * apSuite, void * a dirtyPath5.mAttributeId = 4; // Test report with 2 different path - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mGotEventResponse = false; delegate.mNumAttributeResponse = 0; @@ -1604,7 +1604,7 @@ void TestReadInteraction::TestSubscribeRoundtrip(nlTestSuite * apSuite, void * a NL_TEST_ASSERT(apSuite, delegate.mNumAttributeResponse == 2); // Test report with 2 different path, and 1 same path - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; err = engine->GetReportingEngine().SetDirty(dirtyPath1); @@ -1620,7 +1620,7 @@ void TestReadInteraction::TestSubscribeRoundtrip(nlTestSuite * apSuite, void * a NL_TEST_ASSERT(apSuite, delegate.mNumAttributeResponse == 2); // Test report with 3 different path, and one path is overlapped with another - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; err = engine->GetReportingEngine().SetDirty(dirtyPath1); @@ -1636,7 +1636,7 @@ void TestReadInteraction::TestSubscribeRoundtrip(nlTestSuite * apSuite, void * a NL_TEST_ASSERT(apSuite, delegate.mNumAttributeResponse == 2); // Test report with 3 different path, all are not overlapped, one path is not interested for current subscription - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; err = engine->GetReportingEngine().SetDirty(dirtyPath1); @@ -1652,8 +1652,8 @@ void TestReadInteraction::TestSubscribeRoundtrip(nlTestSuite * apSuite, void * a NL_TEST_ASSERT(apSuite, delegate.mNumAttributeResponse == 2); // Test empty report - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldSync, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMaxInterval, false); NL_TEST_ASSERT(apSuite, engine->GetReportingEngine().IsRunScheduled()); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; @@ -1740,12 +1740,13 @@ void TestReadInteraction::TestSubscribeUrgentWildcardEvent(nlTestSuite * apSuite GenerateEvents(apSuite, apContext); - NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::HoldReport)); + NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval)); NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->IsDirty()); delegate.mGotEventResponse = false; delegate.mGotReport = false; - NL_TEST_ASSERT(apSuite, nonUrgentDelegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::HoldReport)); + NL_TEST_ASSERT(apSuite, + nonUrgentDelegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval)); NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsDirty()); nonUrgentDelegate.mGotEventResponse = false; nonUrgentDelegate.mGotReport = false; @@ -1781,13 +1782,14 @@ void TestReadInteraction::TestSubscribeUrgentWildcardEvent(nlTestSuite * apSuite // Since we just sent a report for our urgent subscription, we should have our min interval timer // running again. - NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::HoldReport)); + NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval)); NL_TEST_ASSERT(apSuite, !delegate.mpReadHandler->IsDirty()); delegate.mGotEventResponse = false; // For our non-urgent subscription, we did not send anything, so we // should not have a min interval timer running there. - NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::HoldReport)); + NL_TEST_ASSERT(apSuite, + !nonUrgentDelegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval)); NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsDirty()); // Wait for the min interval timer to fire. @@ -1807,15 +1809,16 @@ void TestReadInteraction::TestSubscribeUrgentWildcardEvent(nlTestSuite * apSuite // min-interval timer should have fired, and our handler should still // not be dirty or even reportable. - NL_TEST_ASSERT(apSuite, !delegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::HoldReport)); + NL_TEST_ASSERT(apSuite, !delegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval)); NL_TEST_ASSERT(apSuite, !delegate.mpReadHandler->IsDirty()); - NL_TEST_ASSERT(apSuite, !delegate.mpReadHandler->IsReportable()); + NL_TEST_ASSERT(apSuite, !delegate.mpReadHandler->IsReportableNow()); // And the non-urgent one should not have changed state either, since // it's waiting for the max-interval. - NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::HoldReport)); + NL_TEST_ASSERT(apSuite, + !nonUrgentDelegate.mpReadHandler->mFlags.Has(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval)); NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsDirty()); - NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsReportable()); + NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsReportableNow()); // There should be no reporting run scheduled. This is very important; // otherwise we can get a false-positive pass below because the run was @@ -1827,11 +1830,11 @@ void TestReadInteraction::TestSubscribeUrgentWildcardEvent(nlTestSuite * apSuite // Urgent read handler should now be dirty, and reportable. NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->IsDirty()); - NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->IsReportable()); + NL_TEST_ASSERT(apSuite, delegate.mpReadHandler->IsReportableNow()); // Non-urgent read handler should not be reportable. NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsDirty()); - NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsReportable()); + NL_TEST_ASSERT(apSuite, !nonUrgentDelegate.mpReadHandler->IsReportableNow()); // Still no reporting should have happened. NL_TEST_ASSERT(apSuite, !delegate.mGotEventResponse); @@ -1914,7 +1917,7 @@ void TestReadInteraction::TestSubscribeWildcard(nlTestSuite * apSuite, void * ap // Set a concrete path dirty { - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; @@ -1935,7 +1938,7 @@ void TestReadInteraction::TestSubscribeWildcard(nlTestSuite * apSuite, void * ap // Set a endpoint dirty { - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; delegate.mNumArrayItems = 0; @@ -2027,7 +2030,7 @@ void TestReadInteraction::TestSubscribePartialOverlap(nlTestSuite * apSuite, voi // Set a partial overlapped path dirty { - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; @@ -2104,7 +2107,7 @@ void TestReadInteraction::TestSubscribeSetDirtyFullyOverlap(nlTestSuite * apSuit // Set a full overlapped path dirty and expect to receive one E2C3A1 { - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; @@ -2225,8 +2228,8 @@ void TestReadInteraction::TestSubscribeInvalidAttributePathRoundtrip(nlTestSuite NL_TEST_ASSERT(apSuite, engine->ActiveHandlerAt(0) != nullptr); delegate.mpReadHandler = engine->ActiveHandlerAt(0); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldSync, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMaxInterval, false); NL_TEST_ASSERT(apSuite, engine->GetReportingEngine().IsRunScheduled()); ctx.DrainAndServiceIO(); @@ -2401,7 +2404,7 @@ void TestReadInteraction::TestPostSubscribeRoundtripStatusReportTimeout(nlTestSu dirtyPath2.mAttributeId = 2; // Test report with 2 different path - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; @@ -2415,8 +2418,8 @@ void TestReadInteraction::TestPostSubscribeRoundtripStatusReportTimeout(nlTestSu NL_TEST_ASSERT(apSuite, delegate.mGotReport); NL_TEST_ASSERT(apSuite, delegate.mNumAttributeResponse == 2); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldSync, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMaxInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; ctx.ExpireSessionBobToAlice(); @@ -2763,8 +2766,8 @@ void TestReadInteraction::TestPostSubscribeRoundtripChunkStatusReportTimeout(nlT dirtyPath1.mEndpointId = Test::kMockEndpoint3; dirtyPath1.mAttributeId = Test::MockAttributeId(4); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldSync, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMaxInterval, false); err = engine->GetReportingEngine().SetDirty(dirtyPath1); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); delegate.mGotReport = false; @@ -2865,8 +2868,8 @@ void TestReadInteraction::TestPostSubscribeRoundtripChunkReportTimeout(nlTestSui dirtyPath1.mEndpointId = Test::kMockEndpoint3; dirtyPath1.mAttributeId = Test::MockAttributeId(4); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); - delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldSync, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); + delegate.mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMaxInterval, false); err = engine->GetReportingEngine().SetDirty(dirtyPath1); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); delegate.mGotReport = false; @@ -4246,7 +4249,7 @@ void TestReadInteraction::TestSubscriptionReportWithDefunctSession(nlTestSuite * NL_TEST_ASSERT(apSuite, SessionHandle(*readHandler->GetSession()) == ctx.GetSessionAliceToBob()); // Test that we send reports as needed. - readHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + readHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; engine->GetReportingEngine().SetDirty(subscribePath); @@ -4262,7 +4265,7 @@ void TestReadInteraction::TestSubscriptionReportWithDefunctSession(nlTestSuite * // Test that if the session is defunct we don't send reports and clean // up properly. readHandler->GetSession()->MarkAsDefunct(); - readHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::HoldReport, false); + readHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::WaitingUntilMinInterval, false); delegate.mGotReport = false; delegate.mNumAttributeResponse = 0; engine->GetReportingEngine().SetDirty(subscribePath);