Weave Data Management mobile support improvements

-- Add onFlushUpdateComplete callback to notify failed path results to
application, for each flushed path, if systemError is WEAVE_ERROR_STATUS_REPORT_RECEIVED,
application would receive the device Error Exception including status
report, particular path and dataSink object, otherwise, application would receive the
local error exception, particular path and dataSink object. Add objective C, Java, and Python implementation for the above exceptions.
-- Add DeleteData API so that application can delete data in particular
path.
-- Add length check for GetString and GetStringArray.
-- When GetTraitSchemaEngine fails, it means user does not load the
correct profile id, update err with WEAVE_ERROR_INVALID_PROFILE_ID
-- When refresh fails, we use onError to pass the status report and
error.
-- Fix some style issues.
-- Update onFlushUpdateComplete and DeleteData APIs for objective C, Java, Python
-- Clean redundant code in NLGenericTraitUpdatableDataSink
-- Adjust the signature for getString, getBytes, and getStringArray, and
pass val as reference, and return error code for objectice C support.
-- Fix TLV Dump for empty string.

Author: yunhanw-google

src/device-manager/WeaveDataManagementClient.cpp

@@ -498,7 +498,6 @@ WEAVE_ERROR GenericTraitUpdatableDataSink::GetBoolean(const char * apPath, bool
     nl::Weave::TLV::TLVReader reader;
     PacketBuffer * pMsgBuf                = NULL;
     PropertyPathHandle propertyPathHandle = kNullPropertyPathHandle;
-    ;
     std::map<PropertyPathHandle, PacketBuffer *>::iterator it;
 
     err = GetSchemaEngine()->MapPathToHandle(apPath, propertyPathHandle);
@@ -537,7 +536,6 @@ WEAVE_ERROR GenericTraitUpdatableDataSink::GetBytes(const char * apPath, BytesDa
     nl::Weave::TLV::TLVReader reader;
     PacketBuffer * pMsgBuf                = NULL;
     PropertyPathHandle propertyPathHandle = kNullPropertyPathHandle;
-    ;
     std::map<PropertyPathHandle, PacketBuffer *>::iterator it;
 
     err = GetSchemaEngine()->MapPathToHandle(apPath, propertyPathHandle);
@@ -558,8 +556,12 @@ WEAVE_ERROR GenericTraitUpdatableDataSink::GetBytes(const char * apPath, BytesDa
     SuccessOrExit(err);
 
     apBytesData->mDataLen = reader.GetLength();
-    err                   = reader.GetDataPtr(apBytesData->mpDataBuf);
-    SuccessOrExit(err);
+    WeaveLogProgress(DataManagement, "GetBytes with length %d", apBytesData->mDataLen);
+    if (apBytesData->mDataLen != 0)
+    {
+        err = reader.GetDataPtr(apBytesData->mpDataBuf);
+        SuccessOrExit(err);
+    }
 
 exit:
     WeaveLogFunctError(err);
@@ -618,7 +620,6 @@ WEAVE_ERROR GenericTraitUpdatableDataSink::IsNull(const char * apPath, bool & aI
     nl::Weave::TLV::TLVReader reader;
     PacketBuffer * pMsgBuf                = NULL;
     PropertyPathHandle propertyPathHandle = kNullPropertyPathHandle;
-    ;
     std::map<PropertyPathHandle, PacketBuffer *>::iterator it;
 
     err = GetSchemaEngine()->MapPathToHandle(apPath, propertyPathHandle);
@@ -658,7 +659,6 @@ WEAVE_ERROR GenericTraitUpdatableDataSink::GetStringArray(const char * apPath, s
     nl::Weave::TLV::TLVReader reader;
     PacketBuffer * pMsgBuf                = NULL;
     PropertyPathHandle propertyPathHandle = kNullPropertyPathHandle;
-    ;
     TLVType OuterContainerType;
     std::map<PropertyPathHandle, PacketBuffer *>::iterator it;
 
@@ -686,8 +686,13 @@ WEAVE_ERROR GenericTraitUpdatableDataSink::GetStringArray(const char * apPath, s
     {
         int length               = reader.GetLength();
         const uint8_t * pDataBuf = NULL;
-        err                      = reader.GetDataPtr(pDataBuf);
-        SuccessOrExit(err);
+        WeaveLogProgress(DataManagement, "GetStringArray with length %d", length);
+        if (length != 0)
+        {
+            err = reader.GetDataPtr(pDataBuf);
+            SuccessOrExit(err);
+        }
+
         std::string val((char *) pDataBuf, length);
         aValueVector.push_back(val);
     }
@@ -740,6 +745,36 @@ WEAVE_ERROR GenericTraitUpdatableDataSink::Get(const char * apPath, T & aValue)
     return err;
 }
 
+WEAVE_ERROR GenericTraitUpdatableDataSink::DeleteData(const char * apPath)
+{
+    WEAVE_ERROR err = WEAVE_NO_ERROR;
+    nl::Weave::TLV::TLVReader reader;
+    PacketBuffer * pMsgBuf                = NULL;
+    PropertyPathHandle propertyPathHandle = kNullPropertyPathHandle;
+    std::map<PropertyPathHandle, PacketBuffer *>::iterator it;
+
+    err = GetSchemaEngine()->MapPathToHandle(apPath, propertyPathHandle);
+    SuccessOrExit(err);
+
+    it = mPathTlvDataMap.find(propertyPathHandle);
+    VerifyOrExit(it != mPathTlvDataMap.end(), err = WEAVE_ERROR_INVALID_TLV_TAG);
+
+    if (NULL != it->second)
+    {
+        PacketBuffer::Free(it->second);
+        it->second = NULL;
+        WeaveLogProgress(DataManagement, "Deleted data in mPathTlvDataMap for path %s", apPath);
+    }
+
+    mPathTlvDataMap.erase(it);
+
+    err = ClearUpdated(GetSubscriptionClient(), propertyPathHandle);
+
+exit:
+    WeaveLogFunctError(err);
+    return err;
+}
+
 WEAVE_ERROR
 GenericTraitUpdatableDataSink::SetLeafData(PropertyPathHandle aLeafHandle, TLVReader & aReader)
 {
@@ -903,9 +938,9 @@ void WdmClient::ClientEventCallback(void * const aAppState, SubscriptionClient::
 {
     WEAVE_ERROR err              = WEAVE_NO_ERROR;
     WdmClient * const pWdmClient = reinterpret_cast<WdmClient *>(aAppState);
-
-    OpState savedOpState = pWdmClient->mOpState;
-    WeaveLogDetail(DataManagement, "WDM ClientEventCallback: current op is, %d", savedOpState);
+    DeviceStatus * deviceStatus  = NULL;
+    OpState savedOpState         = pWdmClient->mOpState;
+    WeaveLogDetail(DataManagement, "WdmClient ClientEventCallback: current op is, %d, event is %d", savedOpState, aEvent);
 
     switch (aEvent)
     {
@@ -984,31 +1019,46 @@ void WdmClient::ClientEventCallback(void * const aAppState, SubscriptionClient::
     case SubscriptionClient::kEvent_OnSubscriptionTerminated:
         WeaveLogDetail(DataManagement, "Client->kEvent_OnSubscriptionTerminated. Reason: %u, peer = 0x%" PRIX64 "\n",
                        aInParam.mSubscriptionTerminated.mReason, aInParam.mSubscriptionTerminated.mClient->GetPeerNodeId());
-        pWdmClient->mpSubscriptionClient->AbortSubscription();
-        err = WEAVE_ERROR_INCORRECT_STATE;
+        VerifyOrExit(kOpState_RefreshData == savedOpState, err = WEAVE_ERROR_INCORRECT_STATE);
+        deviceStatus                  = new DeviceStatus();
+        deviceStatus->StatusProfileId = aInParam.mSubscriptionTerminated.mStatusProfileId;
+        deviceStatus->StatusCode      = aInParam.mSubscriptionTerminated.mStatusCode;
+        deviceStatus->SystemErrorCode = aInParam.mSubscriptionTerminated.mReason;
+        err                           = aInParam.mSubscriptionTerminated.mReason;
         break;
     case SubscriptionClient::kEvent_OnUpdateComplete:
+        VerifyOrExit(kOpState_FlushUpdate == savedOpState, err = WEAVE_ERROR_INCORRECT_STATE);
         if ((aInParam.mUpdateComplete.mReason == WEAVE_NO_ERROR) &&
             (nl::Weave::Profiles::kWeaveProfile_Common == aInParam.mUpdateComplete.mStatusProfileId) &&
             (nl::Weave::Profiles::Common::kStatus_Success == aInParam.mUpdateComplete.mStatusCode))
         {
-            WeaveLogDetail(DataManagement, "Update: path result: success");
+            WeaveLogDetail(DataManagement, "Update: path result: success, tdh %" PRIu16 ", ph %" PRIu16 ".",
+                           aInParam.mUpdateComplete.mTraitDataHandle, aInParam.mUpdateComplete.mPropertyPathHandle);
         }
         else
         {
-            WeaveLogDetail(DataManagement, "Update: path failed: %s, %s, tdh %" PRIu16 ", will %sretry, discard failed change",
+
+            WeaveLogDetail(DataManagement,
+                           "Update: path failed: %s, %s, tdh %" PRIu16 ", ph %" PRIu16 ", %s, discard failed change",
                            ErrorStr(aInParam.mUpdateComplete.mReason),
                            nl::StatusReportStr(aInParam.mUpdateComplete.mStatusProfileId, aInParam.mUpdateComplete.mStatusCode),
-                           aInParam.mUpdateComplete.mTraitDataHandle, aInParam.mUpdateComplete.mWillRetry ? "" : "not ");
+                           aInParam.mUpdateComplete.mTraitDataHandle, aInParam.mUpdateComplete.mPropertyPathHandle,
+                           aInParam.mUpdateComplete.mWillRetry ? "will retry" : "will not retry");
+
+            err = pWdmClient->UpdateFailedPathResults(
+                pWdmClient, aInParam.mUpdateComplete.mTraitDataHandle, aInParam.mUpdateComplete.mPropertyPathHandle,
+                aInParam.mUpdateComplete.mReason, aInParam.mUpdateComplete.mStatusProfileId, aInParam.mUpdateComplete.mStatusCode);
         }
 
         break;
     case SubscriptionClient::kEvent_OnNoMorePendingUpdates:
-        // TODO: notify application with all status for updated paths
         WeaveLogDetail(DataManagement, "Update: no more pending updates");
         VerifyOrExit(kOpState_FlushUpdate == savedOpState, err = WEAVE_ERROR_INCORRECT_STATE);
         pWdmClient->mpSubscriptionClient->DiscardUpdates();
-        pWdmClient->mOnComplete.General(pWdmClient->mpContext, pWdmClient->mpAppReqState);
+        pWdmClient->mOnComplete.FlushUpdate(pWdmClient->mpContext, pWdmClient->mpAppReqState,
+                                            pWdmClient->mFailedFlushPathStatus.size(), pWdmClient->mFailedFlushPathStatus.data());
+        pWdmClient->mFailedFlushPathStatus.clear();
+        pWdmClient->mFailedPaths.clear();
         pWdmClient->mpContext = NULL;
         pWdmClient->ClearOpState();
         break;
@@ -1021,12 +1071,37 @@ void WdmClient::ClientEventCallback(void * const aAppState, SubscriptionClient::
 exit:
     if (WEAVE_NO_ERROR != err)
     {
-        WeaveLogError(DataManagement, "WDM ClientEventCallback failure: err = %d", err);
-        pWdmClient->mOnError(pWdmClient->mpContext, pWdmClient->mpAppReqState, err, NULL);
+        WeaveLogError(DataManagement, "WdmClient ClientEventCallback failure: err = %d", err);
+
+        if (pWdmClient->mOnError)
+        {
+            pWdmClient->mOnError(pWdmClient->mpContext, pWdmClient->mpAppReqState, err, deviceStatus);
+            pWdmClient->mOnError = NULL;
+        }
+
+        if (kOpState_FlushUpdate == savedOpState)
+        {
+            pWdmClient->mpSubscriptionClient->DiscardUpdates();
+            pWdmClient->mFailedFlushPathStatus.clear();
+            pWdmClient->mFailedPaths.clear();
+        }
+
+        if (kOpState_RefreshData == savedOpState)
+        {
+            pWdmClient->mpSubscriptionClient->AbortSubscription();
+            pWdmClient->mSinkCatalog.Iterate(ClearDataSinkVersion, pWdmClient);
+        }
+
         pWdmClient->mpContext = NULL;
         pWdmClient->ClearOpState();
     }
 
+    if (deviceStatus != NULL)
+    {
+        delete deviceStatus;
+        deviceStatus = NULL;
+    }
+
     return;
 }
 
@@ -1050,6 +1125,8 @@ WEAVE_ERROR WdmClient::Init(WeaveMessageLayer * apMsgLayer, Binding * apBinding)
     State     = kState_Initialized;
     mpContext = NULL;
     ClearOpState();
+    mFailedFlushPathStatus.clear();
+    mFailedPaths.clear();
 
 exit:
     return WEAVE_NO_ERROR;
@@ -1060,14 +1137,48 @@ void WdmClient::SetNodeId(uint64_t aNodeId)
     mSinkCatalog.SetNodeId(aNodeId);
 }
 
+WEAVE_ERROR WdmClient::UpdateFailedPathResults(WdmClient * const apWdmClient, TraitDataHandle mTraitDataHandle,
+                                               PropertyPathHandle mPropertyPathHandle, uint32_t aReason, uint32_t aStatusProfileId,
+                                               uint16_t aStatusCode)
+{
+    TraitDataSink * dataSink = NULL;
+    WEAVE_ERROR err          = WEAVE_NO_ERROR;
+    WdmClientFlushUpdateStatus updateStatus;
+    std::string path;
+
+    err = apWdmClient->mSinkCatalog.Locate(mTraitDataHandle, &dataSink);
+    SuccessOrExit(err);
+
+    err = dataSink->GetSchemaEngine()->MapHandleToPath(mPropertyPathHandle, path);
+    SuccessOrExit(err);
+
+    mFailedPaths.push_back(path);
+    updateStatus.mpPath                     = mFailedPaths.back().c_str();
+    updateStatus.mPathLen                   = mFailedPaths.back().length();
+    updateStatus.mErrorCode                 = aReason;
+    updateStatus.mDevStatus.SystemErrorCode = aReason;
+    updateStatus.mDevStatus.StatusProfileId = aStatusProfileId;
+    updateStatus.mDevStatus.StatusCode      = aStatusCode;
+    updateStatus.mpDataSink                 = dataSink;
+    mFailedFlushPathStatus.push_back(updateStatus);
+    WeaveLogError(DataManagement, "Update: faild path is %s, length is %d", updateStatus.mpPath, updateStatus.mPathLen);
+
+exit:
+    if (WEAVE_NO_ERROR != err)
+    {
+        WeaveLogError(DataManagement, "Fail in UpdateFailedPathResults with err = %d", err);
+    }
+    return err;
+}
+
 WEAVE_ERROR WdmClient::NewDataSink(const ResourceIdentifier & aResourceId, uint32_t aProfileId, uint64_t aInstanceId,
                                    const char * apPath, GenericTraitUpdatableDataSink *& apGenericTraitUpdatableDataSink)
 {
     WEAVE_ERROR err           = WEAVE_NO_ERROR;
     PropertyPathHandle handle = kNullPropertyPathHandle;
 
     const TraitSchemaEngine * pEngine = TraitSchemaDirectory::GetTraitSchemaEngine(aProfileId);
-    VerifyOrExit(pEngine != NULL, err = WEAVE_ERROR_INCORRECT_STATE);
+    VerifyOrExit(pEngine != NULL, err = WEAVE_ERROR_INVALID_PROFILE_ID);
 
     VerifyOrExit(mpSubscriptionClient != NULL, err = WEAVE_ERROR_INCORRECT_STATE);
 
@@ -1093,6 +1204,7 @@ WEAVE_ERROR WdmClient::NewDataSink(const ResourceIdentifier & aResourceId, uint3
     apGenericTraitUpdatableDataSink->SetSubscriptionClient(mpSubscriptionClient);
 
 exit:
+    WeaveLogFunctError(err);
     return err;
 }
 
@@ -1111,15 +1223,19 @@ WEAVE_ERROR WdmClient::GetDataSink(const ResourceIdentifier & aResourceId, uint3
     return err;
 }
 
-WEAVE_ERROR WdmClient::FlushUpdate(void * apAppReqState, DMCompleteFunct onComplete, DMErrorFunct onError)
+WEAVE_ERROR WdmClient::FlushUpdate(void * apAppReqState, DMFlushUpdateCompleteFunct onComplete, DMErrorFunct onError)
 {
     VerifyOrExit(mOpState == kOpState_Idle, WeaveLogError(DataManagement, "FlushUpdate with OpState %d", mOpState));
 
-    mpAppReqState       = apAppReqState;
-    mOnComplete.General = onComplete;
-    mOnError            = onError;
-    mOpState            = kOpState_FlushUpdate;
-    mpContext           = this;
+    mpAppReqState           = apAppReqState;
+    mOnComplete.FlushUpdate = onComplete;
+    mOnError                = onError;
+    mOpState                = kOpState_FlushUpdate;
+    mpContext               = this;
+
+    mFailedFlushPathStatus.clear();
+    mFailedPaths.clear();
+
     mpSubscriptionClient->FlushUpdate(true);
 
 exit:

src/device-manager/WeaveDataManagementClient.h

@@ -38,6 +38,7 @@
 #include <Weave/Profiles/data-management/Current/GenericTraitCatalogImpl.h>
 #include <map>
 #include <vector>
+#include "WeaveDeviceManager.h"
 
 namespace nl {
 namespace Weave {
@@ -69,11 +70,22 @@ class NL_DLL_EXPORT BytesData
 
 class GenericTraitUpdatableDataSink;
 class WdmClient;
-class DeviceStatus;
+
+class WdmClientFlushUpdateStatus
+{
+public:
+    uint32_t mErrorCode;
+    DeviceStatus mDevStatus;
+    const char * mpPath;
+    uint32_t mPathLen;
+    TraitDataSink * mpDataSink;
+};
 
 extern "C" {
 typedef void (*DMCompleteFunct)(void * appState, void * appReqState);
 typedef void (*DMErrorFunct)(void * appState, void * appReqState, WEAVE_ERROR err, DeviceStatus * devStatus);
+typedef void (*DMFlushUpdateCompleteFunct)(void * appState, void * appReqState, uint16_t pathCount,
+                                           WdmClientFlushUpdateStatus * statusResults);
 typedef WEAVE_ERROR (*GetDataHandleFunct)(void * apContext, const TraitCatalogBase<TraitDataSink> * const apCatalog,
                                           TraitDataHandle & aHandle);
 };
@@ -83,6 +95,7 @@ class NL_DLL_EXPORT GenericTraitUpdatableDataSink : public nl::Weave::Profiles::
     friend class WdmClient;
     using nl::Weave::Profiles::DataManagement_Current::TraitDataSink::SetData;
     using nl::Weave::Profiles::DataManagement_Current::TraitUpdatableDataSink::GetData;
+
 private:
     GenericTraitUpdatableDataSink(const nl::Weave::Profiles::DataManagement::TraitSchemaEngine * aEngine, WdmClient * apWdmClient);
     ~GenericTraitUpdatableDataSink(void);
@@ -114,6 +127,8 @@ class NL_DLL_EXPORT GenericTraitUpdatableDataSink : public nl::Weave::Profiles::
     WEAVE_ERROR IsNull(const char * apPath, bool & aIsNull);
     WEAVE_ERROR GetStringArray(const char * apPath, std::vector<std::string> & aValueVector);
 
+    WEAVE_ERROR DeleteData(const char * apPath);
+
     void * mpAppState;
 
 private:
@@ -171,7 +186,7 @@ class NL_DLL_EXPORT WdmClient
     WEAVE_ERROR NewDataSink(const ResourceIdentifier & aResourceId, uint32_t aProfileId, uint64_t aInstanceId, const char * apPath,
                             GenericTraitUpdatableDataSink *& apGenericTraitUpdatableDataSink);
 
-    WEAVE_ERROR FlushUpdate(void * apAppReqState, DMCompleteFunct onComplete, DMErrorFunct onError);
+    WEAVE_ERROR FlushUpdate(void * apAppReqState, DMFlushUpdateCompleteFunct onComplete, DMErrorFunct onError);
 
     WEAVE_ERROR RefreshData(void * apAppReqState, DMCompleteFunct onComplete, DMErrorFunct onError,
                             GetDataHandleFunct getDataHandleCb);
@@ -191,6 +206,7 @@ class NL_DLL_EXPORT WdmClient
     union
     {
         DMCompleteFunct General;
+        DMFlushUpdateCompleteFunct FlushUpdate;
     } mOnComplete;
     DMErrorFunct mOnError;
     GetDataHandleFunct mGetDataHandle;
@@ -210,6 +226,10 @@ class NL_DLL_EXPORT WdmClient
 
     WEAVE_ERROR UnsubscribePublisherTrait(TraitDataSink * apDataSink);
 
+    WEAVE_ERROR UpdateFailedPathResults(WdmClient * const apWdmClient, TraitDataHandle mTraitDataHandle,
+                                        PropertyPathHandle mPropertyPathHandle, uint32_t aReason, uint32_t aStatusProfileId,
+                                        uint16_t aStatusCode);
+
     GenericTraitSinkCatalog mSinkCatalog;
     TraitPath * mpPublisherPathList;
 
@@ -218,6 +238,8 @@ class NL_DLL_EXPORT WdmClient
     void * mpContext;
     void * mpAppReqState;
     OpState mOpState;
+    std::vector<std::string> mFailedPaths;
+    std::vector<WdmClientFlushUpdateStatus> mFailedFlushPathStatus;
 };
 } // namespace DeviceManager
 } // namespace Weave