AccountLogin Login/Logout command support

examples/tv-app/android/App/content-app/src/main/java/com/example/contentapp/CommandResponseHolder.java

@@ -31,6 +31,14 @@ private CommandResponseHolder() {
         Clusters.AccountLogin.Id,
         Clusters.AccountLogin.Commands.GetSetupPIN.ID,
         "{\"0\":\"20202021\"}");
+    setResponseValue(
+        Clusters.AccountLogin.Id,
+        Clusters.AccountLogin.Commands.Login.ID,
+        "0");
+    setResponseValue(
+        Clusters.AccountLogin.Id,
+        Clusters.AccountLogin.Commands.Logout.ID,
+        "0");
   };
 
   public static CommandResponseHolder getInstance() {

examples/tv-app/android/include/account-login/AccountLoginManager.cpp

@@ -24,38 +24,99 @@
 #include <lib/core/DataModelTypes.h>
 
 using namespace std;
+using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::AccountLogin;
 using Status = chip::Protocols::InteractionModel::Status;
 
+namespace {
+
+const auto loginTempAccountIdentifierFieldId = to_string(chip::to_underlying(AccountLogin::Commands::Login::Fields::kTempAccountIdentifier));
+const auto loginSetupPINFieldId = to_string(chip::to_underlying(AccountLogin::Commands::Login::Fields::kSetupPIN));
+const auto loginNodeFieldId = to_string(chip::to_underlying(AccountLogin::Commands::Login::Fields::kNode));
+const auto logoutNodeFieldId = to_string(chip::to_underlying(AccountLogin::Commands::Logout::Fields::kNode));
+
+string charSpanToString(const CharSpan& charSpan) {
+    return { charSpan.data(), charSpan.size() };
+}
+
+std::string serializeLoginCommand(AccountLogin::Commands::Login::Type cmd) {
+    return
+        R"({")" + loginTempAccountIdentifierFieldId + R"(":")" + charSpanToString(cmd.tempAccountIdentifier) + R"(",)" +
+        R"(")" + loginSetupPINFieldId + R"(":")" + charSpanToString(cmd.setupPIN) + R"(",)" +
+        R"(")" + loginNodeFieldId + R"(":")" + to_string(cmd.node.Value()) + R"("})";
+}
+
+std::string serializeLogoutCommand(AccountLogin::Commands::Logout::Type cmd) {
+    return R"({")" + logoutNodeFieldId + R"(":")" + to_string(cmd.node.Value()) + R"("})";
+}
+
+}
+
 AccountLoginManager::AccountLoginManager(ContentAppCommandDelegate * commandDelegate, const char * setupPin) :
     mCommandDelegate(commandDelegate)
 {
     CopyString(mSetupPin, sizeof(mSetupPin), setupPin);
 }
 
-bool AccountLoginManager::HandleLogin(const CharSpan & tempAccountIdentifier, const CharSpan & setupPin,
+bool AccountLoginManager::HandleLogin(const CharSpan & tempAccountId, const CharSpan & setupPIN,
                                       const chip::Optional<chip::NodeId> & nodeId)
 {
     ChipLogProgress(DeviceLayer, "AccountLoginManager::HandleLogin called for endpoint %d", mEndpointId);
-    string tempAccountIdentifierString(tempAccountIdentifier.data(), tempAccountIdentifier.size());
-    string setupPinString(setupPin.data(), setupPin.size());
 
-    if (strcmp(mSetupPin, setupPinString.c_str()) == 0)
+    if (mCommandDelegate == nullptr)
     {
-        ChipLogProgress(Zcl, "AccountLoginManager::HandleLogin success");
-        return true;
+        ChipLogError(Zcl, "CommandDelegate not found");
+        return false;
     }
-    else
-    {
-        ChipLogProgress(Zcl, "AccountLoginManager::HandleLogin failed expected pin %s", mSetupPin);
+
+    if (tempAccountIdentifier.empty() || setupPIN.empty() || !nodeId.HasValue()) {
+        ChipLogError(Zcl, "Invalid parameters");
         return false;
     }
+
+    Json::Value response;
+    bool commandHandled = true;
+    AccountLogin::Commands::Login::Type cmd = { tempAccountId, setupPIN, nodeId };
+
+    // Deliberately ignore returned status
+    mCommandDelegate->InvokeCommand(mEndpointId, AccountLogin::Id,
+                                    AccountLogin::Commands::Login::Id,
+                                    serializeLoginCommand(cmd), commandHandled, response);
+
+    Status status = mCommandDelegate->FormatStatusResponse(response);
+    ChipLogProgress(Zcl, "AccountLoginManager::HandleLogin command returned with status: %d", chip::to_underlying(status));
+
+    return status == chip::Protocols::InteractionModel::Status::Success;
 }
 
 bool AccountLoginManager::HandleLogout(const chip::Optional<chip::NodeId> & nodeId)
 {
-    // TODO: Insert your code here to send logout request
-    return true;
+    ChipLogProgress(DeviceLayer, "AccountLoginManager::HandleLogout called for endpoint %d", mEndpointId);
+
+    if (mCommandDelegate == nullptr)
+    {
+        ChipLogError(Zcl, "CommandDelegate not found");
+        return false;
+    }
+
+    if (!nodeId.HasValue()) {
+        ChipLogError(Zcl, "Invalid parameters");
+        return false;
+    }
+
+    Json::Value response;
+    bool commandHandled = true;
+    AccountLogin::Commands::Logout::Type cmd = { nodeId };
+
+    // Deliberately ignore returned status
+    mCommandDelegate->InvokeCommand(mEndpointId, AccountLogin::Id,
+                                    AccountLogin::Commands::Logout::Id,
+                                    serializeLogoutCommand(cmd), commandHandled, response);
+
+    Status status = mCommandDelegate->FormatStatusResponse(response);
+    ChipLogProgress(Zcl, "AccountLoginManager::HandleLogout command returned with status: %d", chip::to_underlying(status));
+
+    return status == chip::Protocols::InteractionModel::Status::Success;
 }
 
 void AccountLoginManager::HandleGetSetupPin(CommandResponseHelper<GetSetupPINResponse> & helper,

examples/tv-app/android/java/ContentAppCommandDelegate.cpp

@@ -39,13 +39,6 @@
 namespace chip {
 namespace AppPlatform {
 
-using CommandHandlerInterface    = chip::app::CommandHandlerInterface;
-using LaunchResponseType         = chip::app::Clusters::ContentLauncher::Commands::LauncherResponse::Type;
-using PlaybackResponseType       = chip::app::Clusters::MediaPlayback::Commands::PlaybackResponse::Type;
-using NavigateTargetResponseType = chip::app::Clusters::TargetNavigator::Commands::NavigateTargetResponse::Type;
-using GetSetupPINResponseType    = chip::app::Clusters::AccountLogin::Commands::GetSetupPINResponse::Type;
-using Status                     = chip::Protocols::InteractionModel::Status;
-
 const std::string FAILURE_KEY        = "PlatformError";
 const std::string FAILURE_STATUS_KEY = "Status";
 
@@ -107,6 +100,7 @@ void ContentAppCommandDelegate::InvokeCommand(CommandHandlerInterface::HandlerCo
 Status ContentAppCommandDelegate::InvokeCommand(EndpointId epId, ClusterId clusterId, CommandId commandId, std::string payload,
                                                 bool & commandHandled, Json::Value & value)
 {
+    // Q1: It seems like this InvokeCommand *never* returns success status.
     if (epId >= FIXED_ENDPOINT_COUNT)
     {
         JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -153,6 +147,7 @@ Status ContentAppCommandDelegate::InvokeCommand(EndpointId epId, ClusterId clust
             return chip::Protocols::InteractionModel::Status::Failure;
         }
 
+        // Q: It would seem that this is the successfull return case (?)
         return chip::Protocols::InteractionModel::Status::UnsupportedEndpoint;
     }
     else
@@ -231,20 +226,30 @@ void ContentAppCommandDelegate::FormatResponseData(CommandHandlerInterface::Hand
     }
 
     case app::Clusters::AccountLogin::Id: {
-        if (app::Clusters::AccountLogin::Commands::GetSetupPIN::Id != handlerContext.mRequestPath.mCommandId)
-        {
-            // No response for other commands in this cluster
-            break;
-        }
-        Status status;
-        GetSetupPINResponseType getSetupPINresponse = FormatGetSetupPINResponse(value, status);
-        if (status != chip::Protocols::InteractionModel::Status::Success)
-        {
-            handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, status);
-        }
-        else
-        {
-            handlerContext.mCommandHandler.AddResponse(handlerContext.mRequestPath, getSetupPINresponse);
+        switch (handlerContext.mRequestPath.mCommandId) {
+            case app::Clusters::AccountLogin::Commands::GetSetupPIN::Id: {
+                Status status;
+                GetSetupPINResponseType getSetupPINresponse = FormatGetSetupPINResponse(value, status);
+                if (status != chip::Protocols::InteractionModel::Status::Success)
+                {
+                    handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, status);
+                }
+                else
+                {
+                    handlerContext.mCommandHandler.AddResponse(handlerContext.mRequestPath, getSetupPINresponse);
+                }
+                break;
+            }
+            case app::Clusters::AccountLogin::Commands::Login::Id: {
+                handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, FormatStatusResponse(value));
+                break;
+            }
+            case app::Clusters::AccountLogin::Commands::Logout::Id: {
+                handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, FormatStatusResponse(value));
+                break;
+            }
+            default:
+                break;
         }
         break;
     }
@@ -342,5 +347,16 @@ GetSetupPINResponseType ContentAppCommandDelegate::FormatGetSetupPINResponse(Jso
     return getSetupPINresponse;
 }
 
+Status ContentAppCommandDelegate::FormatStatusResponse(Json::Value value)
+{
+    if (value.isUInt()) {
+        return static_cast<Protocols::InteractionModel::Status>(value.asUInt());
+    }
+    else
+    {
+        return chip::Protocols::InteractionModel::Status::Failure;
+    }
+}
+
 } // namespace AppPlatform
 } // namespace chip

examples/tv-app/android/java/ContentAppCommandDelegate.h

@@ -29,6 +29,7 @@
 #include <json/json.h>
 #include <lib/core/DataModelTypes.h>
 #include <lib/support/JniReferences.h>
+#include <protocols/interaction_model/StatusCode.h>
 
 #include <string>
 
@@ -75,6 +76,7 @@ class ContentAppCommandDelegate : public CommandHandlerInterface
     LaunchResponseType FormatContentLauncherResponse(Json::Value value, Status & status);
     NavigateTargetResponseType FormatNavigateTargetResponse(Json::Value value, Status & status);
     PlaybackResponseType FormatMediaPlaybackResponse(Json::Value value, Status & status);
+    Status FormatStatusResponse(Json::Value value);
 
 private:
     void InitializeJNIObjects(jobject manager)

examples/tv-app/android/java/TVApp-JNI.cpp

@@ -252,13 +252,13 @@ SampleTvAppInstallationService gSampleTvAppInstallationService;
 
 class MyPostCommissioningListener : public PostCommissioningListener
 {
-    void CommissioningCompleted(uint16_t vendorId, uint16_t productId, NodeId nodeId, Messaging::ExchangeManager & exchangeMgr,
-                                const SessionHandle & sessionHandle) override
+    void CommissioningCompleted(uint16_t vendorId, uint16_t productId, NodeId nodeId, std::string rotatingId, uint32_t passcode,
+                                Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle) override
     {
         // read current binding list
         chip::Controller::ClusterBase cluster(exchangeMgr, sessionHandle, kTargetBindingClusterEndpointId);
 
-        cacheContext(vendorId, productId, nodeId, exchangeMgr, sessionHandle);
+        cacheContext(vendorId, productId, nodeId, std::move(rotatingId), passcode, exchangeMgr, sessionHandle);
 
         CHIP_ERROR err =
             cluster.ReadAttribute<Binding::Attributes::Binding::TypeInfo>(this, OnReadSuccessResponse, OnReadFailureResponse);
@@ -342,17 +342,19 @@ class MyPostCommissioningListener : public PostCommissioningListener
 
         Optional<SessionHandle> opt   = mSecureSession.Get();
         SessionHandle & sessionHandle = opt.Value();
-        ContentAppPlatform::GetInstance().ManageClientAccess(*mExchangeMgr, sessionHandle, mVendorId, mProductId, localNodeId,
+        ContentAppPlatform::GetInstance().ManageClientAccess(*mExchangeMgr, sessionHandle, mVendorId, mProductId, localNodeId, mRotatingId, mPasscode,
                                                              bindings, OnSuccessResponse, OnFailureResponse);
         clearContext();
     }
 
-    void cacheContext(uint16_t vendorId, uint16_t productId, NodeId nodeId, Messaging::ExchangeManager & exchangeMgr,
+    void cacheContext(uint16_t vendorId, uint16_t productId, NodeId nodeId, std::string rotatingId, uint32_t passcode, Messaging::ExchangeManager & exchangeMgr,
                       const SessionHandle & sessionHandle)
     {
         mVendorId    = vendorId;
         mProductId   = productId;
         mNodeId      = nodeId;
+        mRotatingId  = std::move(rotatingId);
+        mPasscode    = passcode;
         mExchangeMgr = &exchangeMgr;
         mSecureSession.ShiftToSession(sessionHandle);
     }
@@ -368,6 +370,8 @@ class MyPostCommissioningListener : public PostCommissioningListener
     uint16_t mVendorId                        = 0;
     uint16_t mProductId                       = 0;
     NodeId mNodeId                            = 0;
+    std::string mRotatingId;
+    uint32_t mPasscode                         = 0;
     Messaging::ExchangeManager * mExchangeMgr = nullptr;
     SessionHolder mSecureSession;
 };

examples/tv-app/tv-common/src/AppTv.cpp

@@ -158,13 +158,13 @@ MyAppInstallationService gMyAppInstallationService;
 
 class MyPostCommissioningListener : public PostCommissioningListener
 {
-    void CommissioningCompleted(uint16_t vendorId, uint16_t productId, NodeId nodeId, Messaging::ExchangeManager & exchangeMgr,
-                                const SessionHandle & sessionHandle) override
+    void CommissioningCompleted(uint16_t vendorId, uint16_t productId, NodeId nodeId, std::string rotatingId, uint32_t passcode,
+                                Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle) override
     {
         // read current binding list
         chip::Controller::ClusterBase cluster(exchangeMgr, sessionHandle, kTargetBindingClusterEndpointId);
 
-        cacheContext(vendorId, productId, nodeId, exchangeMgr, sessionHandle);
+        cacheContext(vendorId, productId, nodeId, std::move(rotatingId), passcode, exchangeMgr, sessionHandle);
 
         CHIP_ERROR err =
             cluster.ReadAttribute<Binding::Attributes::Binding::TypeInfo>(this, OnReadSuccessResponse, OnReadFailureResponse);
@@ -248,17 +248,19 @@ class MyPostCommissioningListener : public PostCommissioningListener
 
         Optional<SessionHandle> opt   = mSecureSession.Get();
         SessionHandle & sessionHandle = opt.Value();
-        ContentAppPlatform::GetInstance().ManageClientAccess(*mExchangeMgr, sessionHandle, mVendorId, mProductId, localNodeId,
+        ContentAppPlatform::GetInstance().ManageClientAccess(*mExchangeMgr, sessionHandle, mVendorId, mProductId, localNodeId, rotatingId, passcode,
                                                              bindings, OnSuccessResponse, OnFailureResponse);
         clearContext();
     }
 
-    void cacheContext(uint16_t vendorId, uint16_t productId, NodeId nodeId, Messaging::ExchangeManager & exchangeMgr,
-                      const SessionHandle & sessionHandle)
+    void cacheContext(uint16_t vendorId, uint16_t productId, NodeId nodeId, std::string rotatingId, uint32_t passcode,
+                      Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle)
     {
         mVendorId    = vendorId;
         mProductId   = productId;
         mNodeId      = nodeId;
+        mRotatingId  = std::move(rotatingId);
+        mPassocde    = passcode;
         mExchangeMgr = &exchangeMgr;
         mSecureSession.ShiftToSession(sessionHandle);
     }
@@ -274,6 +276,8 @@ class MyPostCommissioningListener : public PostCommissioningListener
     uint16_t mVendorId                        = 0;
     uint16_t mProductId                       = 0;
     NodeId mNodeId                            = 0;
+    std::string rotatingId;
+    uint32_t passcode                         = 0;
     Messaging::ExchangeManager * mExchangeMgr = nullptr;
     SessionHolder mSecureSession;
 };

src/app/app-platform/ContentAppPlatform.cpp

@@ -609,6 +609,7 @@ CHIP_ERROR ContentAppPlatform::GetACLEntryIndex(size_t * foundIndex, FabricIndex
 // and create bindings on the given client so that it knows what it has access to.
 CHIP_ERROR ContentAppPlatform::ManageClientAccess(Messaging::ExchangeManager & exchangeMgr, SessionHandle & sessionHandle,
                                                   uint16_t targetVendorId, uint16_t targetProductId, NodeId localNodeId,
+                                                  const std::string& rotatingId, uint32_t passcode,
                                                   std::vector<Binding::Structs::TargetStruct::Type> bindings,
                                                   Controller::WriteResponseSuccessCallback successCb,
                                                   Controller::WriteResponseFailureCallback failureCb)
@@ -755,6 +756,19 @@ CHIP_ERROR ContentAppPlatform::ManageClientAccess(Messaging::ExchangeManager & e
             {
                 // notify content app about this nodeId
                 app->AddClientNode(subjectNodeId);
+
+                auto tempAccountId = CharSpan::fromCharString(rotatingId.c_str());
+                auto setupPIN = CharSpan::fromCharString(std::to_string(passcode).c_str());
+                auto nodeId = MakeOptional(subjectNodeId); // Q: Is subjectNodeId correct NodeId to use?
+
+                // send login command to content app
+                if (!tempAccountId.empty() && !setupPIN.empty()) {
+                    // Q: Should we only do this if (commissioner) passcode is not 0, e.g when user was shown PIN prompt?
+                    auto status = app->GetAccountLoginDelegate()->HandleLogin(tempAccountId, setupPIN, nodeId);
+                    ChipLogProgress(Controller, "AccountLogin::Login command sent and returned with status: %d", status);
+                } else {
+                    ChipLogError(Controller, "Failed to get tempAccountId or setupPIN to set AccountLogin::Login command");
+                }
             }
         }
     }

src/app/app-platform/ContentAppPlatform.h

@@ -176,6 +176,8 @@ class DLL_EXPORT ContentAppPlatform
      * @param[in] targetVendorId  Vendor ID for the target device.
      * @param[in] targetProductId Product ID for the target device.
      * @param[in] localNodeId     The NodeId for the local device.
+     * @param[in] rotatingId      The rotating account ID to handle account login.
+     * @param[in] passcode        The passcode to handle account login.
      * @param[in] bindings        Any additional bindings to include. This may include current bindings.
      * @param[in] successCb       The function to be called on success of adding the binding.
      * @param[in] failureCb       The function to be called on failure of adding the binding.
@@ -184,6 +186,7 @@ class DLL_EXPORT ContentAppPlatform
      */
     CHIP_ERROR ManageClientAccess(Messaging::ExchangeManager & exchangeMgr, SessionHandle & sessionHandle, uint16_t targetVendorId,
                                   uint16_t targetProductId, NodeId localNodeId,
+                                  const std::string& rotatingId, uint32_t passcode,
                                   std::vector<app::Clusters::Binding::Structs::TargetStruct::Type> bindings,
                                   Controller::WriteResponseSuccessCallback successCb,
                                   Controller::WriteResponseFailureCallback failureCb);