Update rvc app integrate service area

examples/rvc-app/README.md

@@ -20,6 +20,11 @@ must have a `"Name"` key that contains the command name. This name is shown in
 the state machine diagram above. Example
 `echo '{"Name": "Charged"}' > /tmp/chip_rvc_fifo_42`.
 
+### `AreaComplete` message
+
+This indicates that the area currently being serviced as indicated by the
+service area cluster is now complete.
+
 ### `ErrorEvent` message
 
 The error event message requires the additional key `"Error"` which specifies
@@ -37,10 +42,14 @@ and setting up the testing environment, python tests can be executed with
 `./scripts/tests/run_python_test.py --script src/python_testing/<script_name>.py --script-args "--storage-path admin_storage.json --PICS examples/rvc-app/rvc-common/pics/RVC_App_Test_Plan.txt --int-arg <PIXIT_Definitions:1>"`
 
 **Note:** If the testing environment has not been commissioned with the RVC app,
-use chip-tool to switch on the commissioning window
-`chip-tool pairing open-commissioning-window`, and add the following flags to
-the `--script-args` above.
-`--commissioning-method on-network --discriminator XXXX --passcode XXXX`.
+
+1. use chip-tool to switch on the commissioning window
+   `out/debug/chip-tool pairing open-commissioning-window 0x1230 1 180 1000 42`
+2. Get the manual pairing code. This will look something like
+   `Manual pairing code: [01073112097]`.
+3. Run any one of the tests with the `--commission-only` and `--manual-code`
+   flags:
+   `./scripts/tests/run_python_test.py --script src/python_testing/TC_RVCCLEANM_1_2.py --script-args "--commissioning-method on-network --manual-code 01073112097 --commission-only"`
 
 Below are the PIXIT definitions required for the different python tests.
 

examples/rvc-app/linux/RvcAppCommandDelegate.cpp

@@ -83,6 +83,10 @@ void RvcAppCommandHandler::HandleCommand(intptr_t context)
     {
         self->OnActivityCompleteHandler();
     }
+    else if (name == "AreaComplete")
+    {
+        self->OnAreaCompleteHandler();
+    }
     else if (name == "ErrorEvent")
     {
         std::string error = self->mJsonValue["Error"].asString();
@@ -140,6 +144,11 @@ void RvcAppCommandHandler::OnActivityCompleteHandler()
     mRvcDevice->HandleActivityCompleteEvent();
 }
 
+void RvcAppCommandHandler::OnAreaCompleteHandler()
+{
+    mRvcDevice->HandleAreaCompletedEvent();
+}
+
 void RvcAppCommandHandler::OnErrorEventHandler(const std::string & error)
 {
     mRvcDevice->HandleErrorEvent(error);

examples/rvc-app/linux/RvcAppCommandDelegate.h

@@ -55,6 +55,8 @@ class RvcAppCommandHandler
 
     void OnActivityCompleteHandler();
 
+    void OnAreaCompleteHandler();
+
     void OnErrorEventHandler(const std::string & error);
 
     void OnClearErrorHandler();

examples/rvc-app/rvc-common/include/rvc-device.h

@@ -59,6 +59,11 @@ class RvcDevice
         mOperationalStateDelegate.SetPauseCallback(&RvcDevice::HandleOpStatePauseCallback, this);
         mOperationalStateDelegate.SetResumeCallback(&RvcDevice::HandleOpStateResumeCallback, this);
         mOperationalStateDelegate.SetGoHomeCallback(&RvcDevice::HandleOpStateGoHomeCallback, this);
+
+        mServiceAreaDelegate.SetIsSetSelectedAreasAllowedCallback(&RvcDevice::SaIsSetSelectedAreasAllowed, this);
+        mServiceAreaDelegate.SetHandleSkipCurrentAreaCallback(&RvcDevice::SaHandleSkipCurrentArea, this);
+        mServiceAreaDelegate.SetIsSupportedAreasChangeAllowedCallback(&RvcDevice::SaIsSupportedAreasChangeAllowed, this);
+        mServiceAreaDelegate.SetIsSupportedMapChangeAllowedCallback(&RvcDevice::SaIsSupportedMapChangeAllowed, this);
     }
 
     /**
@@ -97,6 +102,14 @@ class RvcDevice
      */
     void HandleOpStateGoHomeCallback(Clusters::OperationalState::GenericOperationalError & err);
 
+    bool SaIsSetSelectedAreasAllowed(MutableCharSpan & statusText);
+
+    bool SaHandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText);
+
+    bool SaIsSupportedAreasChangeAllowed();
+
+    bool SaIsSupportedMapChangeAllowed();
+
     /**
      * Updates the state machine when the device becomes fully-charged.
      */
@@ -112,6 +125,8 @@ class RvcDevice
 
     void HandleActivityCompleteEvent();
 
+    void HandleAreaCompletedEvent();
+
     /**
      * Sets the device to an error state with the error state ID matching the error name given.
      * @param error The error name. Could be one of UnableToStartOrResume, UnableToCompleteOperation, CommandInvalidInState,

examples/rvc-app/rvc-common/include/rvc-service-area-delegate.h

@@ -29,6 +29,10 @@ namespace Clusters {
 
 class RvcDevice;
 
+typedef bool (RvcDevice::*IsSetSelectedAreasAllowedCallback)(MutableCharSpan & statusText);
+typedef bool (RvcDevice::*HandleSkipCurrentAreaCallback)(uint32_t skippedArea, MutableCharSpan & skipStatusText);
+typedef bool (RvcDevice::*IsChangeAllowedSimpleCallback)();
+
 namespace ServiceArea {
 
 class RvcServiceAreaDelegate : public Delegate
@@ -40,16 +44,45 @@ class RvcServiceAreaDelegate : public Delegate
     std::vector<uint32_t> mSelectedAreas;
     std::vector<ServiceArea::Structs::ProgressStruct::Type> mProgressList;
 
+    RvcDevice * mIsSetSelectedAreasAllowedDeviceInstance;
+    IsSetSelectedAreasAllowedCallback mIsSetSelectedAreasAllowedCallback;
+    RvcDevice * mHandleSkipCurrentAreaDeviceInstance;
+    HandleSkipCurrentAreaCallback mHandleSkipCurrentAreaCallback;
+    RvcDevice * mIsSupportedAreasChangeAllowedDeviceInstance;
+    IsChangeAllowedSimpleCallback mIsSupportedAreasChangeAllowedCallback;
+    RvcDevice * mIsSupportedMapChangeAllowedDeviceInstance;
+    IsChangeAllowedSimpleCallback mIsSupportedMapChangeAllowedCallback;
+
+    // hardcoded values for SUPPORTED MAPS.
+    const uint32_t supportedMapId_XX = 3;
+    const uint32_t supportedMapId_YY = 245;
+
+    // hardcoded values for SUPPORTED AREAS.
+    const uint32_t supportedAreaID_A = 7;
+    const uint32_t supportedAreaID_B = 1234567;
+    const uint32_t supportedAreaID_C = 10050;
+    const uint32_t supportedAreaID_D = 0x88888888;
+
+    /**
+     * Set the SupportedMaps and SupportedAreas where the SupportedMaps is not null.
+     */
+    void SetMapTopology();
+
+    /**
+     * Set the SupportedMaps and SupportedAreas where the SupportedMaps is null.
+     */
+    void SetNoMapTopology();
+
 public:
     CHIP_ERROR Init() override;
 
     // command support
-    bool IsSetSelectedAreasAllowed(MutableCharSpan statusText) override;
+    bool IsSetSelectedAreasAllowed(MutableCharSpan & statusText) override;
 
     bool IsValidSelectAreasSet(const ServiceArea::Commands::SelectAreas::DecodableType & req,
-                               ServiceArea::SelectAreasStatus & areaStatus, MutableCharSpan statusText) override;
+                               ServiceArea::SelectAreasStatus & areaStatus, MutableCharSpan & statusText) override;
 
-    bool HandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan skipStatusText) override;
+    bool HandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText) override;
 
     //*************************************************************************
     // Supported Areas accessors
@@ -112,6 +145,50 @@ class RvcServiceAreaDelegate : public Delegate
                                const ServiceArea::Structs::ProgressStruct::Type & modifiedProgressElement) override;
 
     bool ClearProgress() override;
+
+    //*************************************************************************
+    // RVC device callback setters
+
+    void SetIsSetSelectedAreasAllowedCallback(IsSetSelectedAreasAllowedCallback callback, RvcDevice * instance)
+    {
+        mIsSetSelectedAreasAllowedCallback       = callback;
+        mIsSetSelectedAreasAllowedDeviceInstance = instance;
+    }
+
+    void SetHandleSkipCurrentAreaCallback(HandleSkipCurrentAreaCallback callback, RvcDevice * instance)
+    {
+        mHandleSkipCurrentAreaCallback       = callback;
+        mHandleSkipCurrentAreaDeviceInstance = instance;
+    }
+
+    void SetIsSupportedAreasChangeAllowedCallback(IsChangeAllowedSimpleCallback callback, RvcDevice * instance)
+    {
+        mIsSupportedAreasChangeAllowedCallback       = callback;
+        mIsSupportedAreasChangeAllowedDeviceInstance = instance;
+    }
+
+    void SetIsSupportedMapChangeAllowedCallback(IsChangeAllowedSimpleCallback callback, RvcDevice * instance)
+    {
+        mIsSupportedMapChangeAllowedCallback       = callback;
+        mIsSupportedMapChangeAllowedDeviceInstance = instance;
+    }
+
+    //*************************************************************************
+    // Helper methods for setting service area attributes.
+
+    /**
+     * Sets the service area attributes at the start of a clean.
+     * This includes the current area an progress attributes.
+     */
+    void SetAttributesAtCleanStart();
+
+    /**
+     * Go to the next area in the list of selected areas.
+     * @param currentAreaOpState The operational state to be set in the Status field of the Progress attribute for the current area.
+     * This can only be Completed or Skipped.
+     * @param finished true if there are no more areas to clean an we should end the clean.
+     */
+    void GoToNextArea(OperationalStatusEnum currentAreaOpState, bool & finished);
 };
 
 } // namespace ServiceArea

examples/rvc-app/rvc-common/pics/rvc-app-pics-values

@@ -50,3 +50,31 @@ RVCRUNM.S.C01.Tx=1
 RVCRUNM.S.F00=0
 RVCRUNM.S.M.CAN_TEST_MODE_FAILURE=1
 RVCRUNM.S.M.CAN_MANUALLY_CONTROLLED=1
+
+SEAR.S=1
+SEAR.S.F00=0
+SEAR.S.F01=1
+SEAR.S.F02=1
+SEAR.S.A0000=1
+SEAR.S.A0001=1
+SEAR.S.A0002=1
+SEAR.S.A0003=1
+SEAR.S.A0004=1
+SEAR.S.A0005=1
+SEAR.S.C00.Rsp=1
+SEAR.S.C02.Rsp=1
+SEAR.S.C01.Tx=1
+SEAR.S.C03.Tx=1
+SEAR.S.M.REMOVE_AREA=0
+SEAR.S.M.ADD_AREA=0
+SEAR.S.M.REMOVE_MAP=0
+SEAR.S.M.ADD_MAP=0
+SEAR.S.M.INVALID_STATE_FOR_SELECT_AREAS=1
+SEAR.S.M.VALID_STATE_FOR_SELECT_AREAS=1
+SEAR.S.M.SELECT_AREAS_WHILE_NON_IDLE=1
+SEAR.S.M.HAS_MANUAL_SELAREA_STATE_CONTROL=1
+SEAR.S.M.HAS_MANUAL_SKIP_STATE_CONTROL=1
+SEAR.S.M.INVALID_STATE_FOR_SKIP=1
+SEAR.S.M.NO_SELAREA_FOR_SKIP=1
+SEAR.S.M.VALID_STATE_FOR_SKIP=1
+SEAR.S.M.HAS_MANUAL_OPERATING_STATE_CONTROL=1

examples/rvc-app/rvc-common/src/rvc-device.cpp

@@ -52,6 +52,7 @@ void RvcDevice::HandleRvcRunChangeToMode(uint8_t newMode, ModeBase::Commands::Ch
         mDocked   = false;
         mRunModeInstance.UpdateCurrentMode(newMode);
         mOperationalStateInstance.SetOperationalState(to_underlying(OperationalState::OperationalStateEnum::kRunning));
+        mServiceAreaDelegate.SetAttributesAtCleanStart();
         response.status = to_underlying(ModeBase::StatusCode::kSuccess);
         return;
     }
@@ -161,6 +162,55 @@ void RvcDevice::HandleOpStateGoHomeCallback(Clusters::OperationalState::GenericO
     }
 }
 
+bool RvcDevice::SaIsSetSelectedAreasAllowed(MutableCharSpan & statusText)
+{
+    if (mOperationalStateInstance.GetCurrentOperationalState() == to_underlying(OperationalState::OperationalStateEnum::kRunning))
+    {
+        CopyCharSpanToMutableCharSpan("cannot set the Selected Areas while the device is running"_span, statusText);
+        return false;
+    }
+    return true;
+}
+
+bool RvcDevice::SaHandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText)
+{
+    if (mServiceAreaInstance.GetCurrentArea() != skippedArea)
+    {
+        // This device only supports skipping the current location.
+        CopyCharSpanToMutableCharSpan("the skipped area does not match the current area"_span, skipStatusText);
+        return false;
+    }
+
+    if (mOperationalStateInstance.GetCurrentOperationalState() != to_underlying(OperationalState::OperationalStateEnum::kRunning))
+    {
+        // This device only accepts the skip are command while in the running state
+        CopyCharSpanToMutableCharSpan("skip area is only accepted when the device is running"_span, skipStatusText);
+        return false;
+    }
+
+    bool finished;
+    mServiceAreaDelegate.GoToNextArea(ServiceArea::OperationalStatusEnum::kSkipped, finished);
+
+    if (finished)
+    {
+        HandleActivityCompleteEvent();
+    }
+
+    return true;
+}
+
+bool RvcDevice::SaIsSupportedAreasChangeAllowed()
+{
+    return mOperationalStateInstance.GetCurrentOperationalState() !=
+        to_underlying(OperationalState::OperationalStateEnum::kRunning);
+}
+
+bool RvcDevice::SaIsSupportedMapChangeAllowed()
+{
+    return mOperationalStateInstance.GetCurrentOperationalState() !=
+        to_underlying(OperationalState::OperationalStateEnum::kRunning);
+}
+
 void RvcDevice::HandleChargedMessage()
 {
     if (mOperationalStateInstance.GetCurrentOperationalState() !=
@@ -258,6 +308,20 @@ void RvcDevice::HandleActivityCompleteEvent()
     mOperationalStateInstance.OnOperationCompletionDetected(0, a, b);
 
     mOperationalStateInstance.SetOperationalState(to_underlying(RvcOperationalState::OperationalStateEnum::kSeekingCharger));
+
+    mServiceAreaInstance.SetCurrentArea(DataModel::NullNullable);
+    mServiceAreaInstance.SetEstimatedEndTime(DataModel::NullNullable);
+}
+
+void RvcDevice::HandleAreaCompletedEvent()
+{
+    bool finished;
+    mServiceAreaDelegate.GoToNextArea(ServiceArea::OperationalStatusEnum::kCompleted, finished);
+
+    if (finished)
+    {
+        HandleActivityCompleteEvent();
+    }
 }
 
 void RvcDevice::HandleErrorEvent(const std::string & error)
@@ -334,4 +398,9 @@ void RvcDevice::HandleResetMessage()
     mRunModeInstance.UpdateCurrentMode(RvcRunMode::ModeIdle);
     mOperationalStateInstance.SetOperationalState(to_underlying(OperationalState::OperationalStateEnum::kStopped));
     mCleanModeInstance.UpdateCurrentMode(RvcCleanMode::ModeQuick);
+
+    mServiceAreaInstance.ClearSelectedAreas();
+    mServiceAreaInstance.ClearProgress();
+    mServiceAreaInstance.SetCurrentArea(DataModel::NullNullable);
+    mServiceAreaInstance.SetEstimatedEndTime(DataModel::NullNullable);
 }