Network Provisioning: Support for wireless regulatory provisioning

This change implements the feature described in #399.

-- Added three new message types to the Network Provisioning profile:
GetWirelessRegulatoryConfig, GetWirelessRegulatoryConfigComplete and
SetWirelessRegulatoryConfig.

-- Extended the NetworkProvisioningServer and NetworkProvisioningDelegate classes to support
the new provisioning protocol.

-- Created WirelessRegConfig class and associated types to represent wireless regulatory
config in memory and provide functions for encoding/decoding to Weave TLV.

-- Added APIs to C++ WeaveDeviceManager class for getting and setting wireless regulatory
configuration information. Extended the Java and Python (but not Objective-C++) wrappers for
the Device Manager to support the APIs.

-- Added support for wireless regulatory provisioning to the mock device and extended the
WeaveDeviceManager happy test to exercise it.

-- Extended the WeaveDeviceManager JNI tests to exercise the new Java APIs.

Author: Jay Logue

src/device-manager/WeaveDeviceManager.cpp

@@ -1842,6 +1842,77 @@ WEAVE_ERROR WeaveDeviceManager::SetRendezvousMode(uint16_t modeFlags, void* appR
     return err;
 }
 
+WEAVE_ERROR WeaveDeviceManager::GetWirelessRegulatoryConfig(void* appReqState, GetWirelessRegulatoryConfigCompleteFunct onComplete,
+        ErrorFunct onError)
+{
+    WEAVE_ERROR     err     = WEAVE_NO_ERROR;
+    PacketBuffer*   msgBuf  = NULL;
+
+    if (mOpState != kOpState_Idle)
+        return WEAVE_ERROR_INCORRECT_STATE;
+
+    VerifyOrExit(onComplete != NULL && onError != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
+
+    msgBuf = PacketBuffer::New();
+    VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);
+
+    mAppReqState = appReqState;
+    mOnComplete.GetWirelessRegulatoryConfig = onComplete;
+    mOnError = onError;
+    mOpState = kOpState_GetWirelessRegulatoryConfig;
+
+    err = SendRequest(kWeaveProfile_NetworkProvisioning, NetworkProvisioning::kMsgType_GetWirelessRegulatoryConfig, msgBuf,
+            HandleNetworkProvisioningResponse);
+    msgBuf = NULL;
+
+exit:
+    if (msgBuf != NULL)
+        PacketBuffer::Free(msgBuf);
+    if (err != WEAVE_NO_ERROR)
+        ClearOpState();
+    return err;
+}
+
+WEAVE_ERROR WeaveDeviceManager::SetWirelessRegulatoryConfig(const WirelessRegConfig *regConfig, void* appReqState,
+        CompleteFunct onComplete, ErrorFunct onError)
+{
+    WEAVE_ERROR     err     = WEAVE_NO_ERROR;
+    PacketBuffer*   msgBuf  = NULL;
+    TLVWriter       writer;
+
+    if (mOpState != kOpState_Idle)
+        return WEAVE_ERROR_INCORRECT_STATE;
+
+    VerifyOrExit(onComplete != NULL && onError != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
+
+    msgBuf = PacketBuffer::New();
+    VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);
+
+    writer.Init(msgBuf);
+
+    err = regConfig->Encode(writer);
+    SuccessOrExit(err);
+
+    err = writer.Finalize();
+    SuccessOrExit(err);
+
+    mAppReqState = appReqState;
+    mOnComplete.General = onComplete;
+    mOnError = onError;
+    mOpState = kOpState_SetWirelessRegulatoryConfig;
+
+    err = SendRequest(kWeaveProfile_NetworkProvisioning, NetworkProvisioning::kMsgType_SetWirelessRegulatoryConfig, msgBuf,
+            HandleNetworkProvisioningResponse);
+    msgBuf = NULL;
+
+exit:
+    if (msgBuf != NULL)
+        PacketBuffer::Free(msgBuf);
+    if (err != WEAVE_NO_ERROR)
+        ClearOpState();
+    return err;
+}
+
 WEAVE_ERROR WeaveDeviceManager::GetLastNetworkProvisioningResult(void* appReqState, CompleteFunct onComplete, ErrorFunct onError)
 {
     WEAVE_ERROR     err     = WEAVE_NO_ERROR;
@@ -3968,6 +4039,20 @@ void WeaveDeviceManager::HandleNetworkProvisioningResponse(ExchangeContext *ec,
         delete[] netInfoList;
     }
 
+    else if (profileId == kWeaveProfile_NetworkProvisioning && msgType == NetworkProvisioning::kMgrType_GetWirelessRegulatoryConfigComplete)
+    {
+        VerifyOrExit(opState == kOpState_GetWirelessRegulatoryConfig, err = WEAVE_ERROR_INVALID_MESSAGE_TYPE);
+
+        WirelessRegConfig regConfig;
+
+        regConfig.Init();
+
+        err = regConfig.DecodeInPlace(payload);
+        SuccessOrExit(err);
+
+        devMgr->mOnComplete.GetWirelessRegulatoryConfig(devMgr, devMgr->mAppReqState, &regConfig);
+    }
+
     else if (profileId == kWeaveProfile_Common && msgType == nl::Weave::Profiles::Common::kMsgType_StatusReport)
     {
         DeviceStatus devStatus;

src/device-manager/WeaveDeviceManager.h

@@ -35,6 +35,7 @@
 #include <Weave/Profiles/device-description/DeviceDescription.h>
 #include <Weave/Profiles/network-provisioning/NetworkProvisioning.h>
 #include <Weave/Profiles/network-provisioning/NetworkInfo.h>
+#include <Weave/Profiles/network-provisioning/WirelessRegConfig.h>
 #include <Weave/Profiles/security/WeaveSecurity.h>
 #include <Weave/Profiles/security/WeaveCASE.h>
 #include <Weave/Profiles/security/WeaveSig.h>
@@ -89,6 +90,7 @@ typedef void (*ConnectionClosedFunc)(WeaveDeviceManager *deviceMgr, void *appReq
 typedef void (*PairTokenCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const uint8_t *tokenPairingBundle, uint32_t tokenPairingBunldeLen);
 typedef void (*UnpairTokenCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState);
 typedef void (*GetCameraAuthDataCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const char *macAddress, const char *authData);
+typedef void (*GetWirelessRegulatoryConfigCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const WirelessRegConfig *regConfig);
 };
 
 class NL_DLL_EXPORT WeaveDeviceManager : private Security::CASE::WeaveCASEAuthDelegate
@@ -209,6 +211,8 @@ class NL_DLL_EXPORT WeaveDeviceManager : private Security::CASE::WeaveCASEAuthDe
             ErrorFunct onError);
     WEAVE_ERROR GetRendezvousMode(void* appReqState, GetRendezvousModeCompleteFunct onComplete, ErrorFunct onError);
     WEAVE_ERROR SetRendezvousMode(uint16_t modeFlags, void* appReqState, CompleteFunct onComplete, ErrorFunct onError);
+    WEAVE_ERROR GetWirelessRegulatoryConfig(void* appReqState, GetWirelessRegulatoryConfigCompleteFunct onComplete, ErrorFunct onError);
+    WEAVE_ERROR SetWirelessRegulatoryConfig(const WirelessRegConfig *regConfig, void* appReqState, CompleteFunct onComplete, ErrorFunct onError);
     WEAVE_ERROR GetLastNetworkProvisioningResult(void* appReqState, CompleteFunct onComplete, ErrorFunct onError);
 
     // ----- Fabric Provisioning -----
@@ -300,36 +304,38 @@ class NL_DLL_EXPORT WeaveDeviceManager : private Security::CASE::WeaveCASEAuthDe
         kOpState_UnpairToken                            = 41,
         kOpState_GetCameraAuthData                      = 42,
         kOpState_EnumerateDevices                       = 43,
-        kOpState_RemotePassiveRendezvousTimedOut        = 44
+        kOpState_RemotePassiveRendezvousTimedOut        = 44,
+        kOpState_GetWirelessRegulatoryConfig            = 45,
+        kOpState_SetWirelessRegulatoryConfig            = 46,
     };
 
     enum ConnectionState
     {
-        kConnectionState_NotConnected                             = 0,
-        kConnectionState_WaitDeviceConnect                        = 1,
-        kConnectionState_IdentifyDevice                           = 2,
-        kConnectionState_ConnectDevice                            = 3,
-        kConnectionState_StartSession                             = 4,
-        kConnectionState_ReenableConnectionMonitor                = 5,
-        kConnectionState_Connected                                = 6,
-        kConnectionState_IdentifyRemoteDevice                     = 7
+        kConnectionState_NotConnected                    = 0,
+        kConnectionState_WaitDeviceConnect               = 1,
+        kConnectionState_IdentifyDevice                  = 2,
+        kConnectionState_ConnectDevice                   = 3,
+        kConnectionState_StartSession                    = 4,
+        kConnectionState_ReenableConnectionMonitor       = 5,
+        kConnectionState_Connected                       = 6,
+        kConnectionState_IdentifyRemoteDevice            = 7
     };
 
     enum
     {
-        kMaxPairingCodeLength                   = 16,
+        kMaxPairingCodeLength                            = 16,
 
-        kConRetryInterval                       = 500,  // ms
-        kEnumerateDevicesRetryInterval          = 500, // ms
-        kSessionRetryInterval                   = 1000, // ms
-        kMaxSessionRetryCount                   = 20,
+        kConRetryInterval                                = 500,  // ms
+        kEnumerateDevicesRetryInterval                   = 500, // ms
+        kSessionRetryInterval                            = 1000, // ms
+        kMaxSessionRetryCount                            = 20,
     };
 
     enum
     {
-        kAuthType_None                          = 0,
-        kAuthType_PASEWithPairingCode           = 1,
-        kAuthType_CASEWithAccessToken           = 2
+        kAuthType_None                                   = 0,
+        kAuthType_PASEWithPairingCode                    = 1,
+        kAuthType_CASEWithAccessToken                    = 2
     };
 
     enum
@@ -370,6 +376,7 @@ class NL_DLL_EXPORT WeaveDeviceManager : private Security::CASE::WeaveCASEAuthDe
         UnpairTokenCompleteFunct UnpairToken;
         GetCameraAuthDataCompleteFunct GetCameraAuthData;
         DeviceEnumerationResponseFunct DeviceEnumeration;
+        GetWirelessRegulatoryConfigCompleteFunct GetWirelessRegulatoryConfig;
     } mOnComplete;
     CompleteFunct mOnRemotePassiveRendezvousComplete;
     ErrorFunct mOnError;