implement pair/unpair in v6

lib/Udp/V6CctCommandHandler.h

@@ -17,8 +17,8 @@ enum CctCommandIds {
 
 class V6CctCommandHandler : public V6CommandHandler {
 public:
-  V6CctCommandHandler(uint16_t commandId)
-    : V6CommandHandler(commandId)
+  V6CctCommandHandler()
+    : V6CommandHandler(0x0100, MilightCctConfig)
   { }
   
   virtual bool handleCommand(

lib/Udp/V6ComamndHandler.cpp

@@ -6,26 +6,58 @@
 #include <Size.h>
 
 V6CommandHandler* V6CommandHandler::ALL_HANDLERS[] = {
-  new V6RgbCctCommandHandler(0x0800),
-  new V6RgbwCommandHandler(0x0700),
-  new V6RgbCommandHandler(0x0500),
-  new V6CctCommandHandler(0x0100),
+  new V6RgbCctCommandHandler(),
+  new V6RgbwCommandHandler(),
+  new V6RgbCommandHandler(),
+  new V6CctCommandHandler(),
 };
 
 const size_t V6CommandHandler::NUM_HANDLERS = size(ALL_HANDLERS);
+  
+bool V6CommandHandler::handleCommand(MiLightClient* client, 
+  uint16_t deviceId,
+  uint8_t group,
+  uint8_t commandType,
+  uint32_t command,
+  uint32_t commandArg) 
+{
+  client->prepare(radioConfig, deviceId, group);
+  
+  if (commandType == V6_PAIR) {
+    client->pair();
+  } else if (commandType == V6_UNPAIR) {
+    client->unpair();
+  } else if (commandType == V6_COMMAND) {
+    return this->handleCommand(client, deviceId, group, command, commandArg);
+  } else {
+    return false;
+  }
+  
+  return true;
+}
 
 bool V6CommandDemuxer::handleCommand(MiLightClient* client, 
   uint16_t deviceId,
   uint8_t group,
+  uint8_t commandType,
   uint32_t command,
   uint32_t commandArg)
 {
   for (size_t i = 0; i < numHandlers; i++) {
     if (((handlers[i]->commandId & command) == handlers[i]->commandId)
-      && handlers[i]->handleCommand(client, deviceId, group, command, commandArg)) {
+      && handlers[i]->handleCommand(client, deviceId, group, commandType, command, commandArg)) {
       return true;
     }
   }
   
   return false;
+}
+
+bool V6CommandDemuxer::handleCommand(MiLightClient* client, 
+  uint16_t deviceId,
+  uint8_t group,
+  uint32_t command,
+  uint32_t commandArg)
+{
+  return false;
 }

lib/Udp/V6CommandHandler.h

@@ -1,32 +1,52 @@
 #include <MiLightClient.h>
+#include <MiLightRadioConfig.h>
 
 #ifndef _V6_COMMAND_HANDLER_H
 #define _V6_COMMAND_HANDLER_H 
 
+enum V6CommandTypes {
+  V6_PAIR = 0x3D,
+  V6_UNPAIR = 0x3E,
+  V6_COMMAND = 0x31
+};
+
 class V6CommandHandler {
 public:
   static V6CommandHandler* ALL_HANDLERS[];
   static const size_t NUM_HANDLERS;
   
-  V6CommandHandler(uint16_t commandId)
-    : commandId(commandId)
+  V6CommandHandler(uint16_t commandId, MiLightRadioConfig& radioConfig)
+    : commandId(commandId),
+      radioConfig(radioConfig)
   { }
   
   virtual bool handleCommand(
     MiLightClient* client, 
     uint16_t deviceId,
     uint8_t group,
+    uint8_t commandType,
     uint32_t command,
     uint32_t commandArg
-  ) = 0;
+  );
   
   const uint16_t commandId;
+  MiLightRadioConfig& radioConfig;
+  
+protected:
+  
+  virtual bool handleCommand(
+    MiLightClient* client, 
+    uint16_t deviceId,
+    uint8_t group,
+    uint32_t command,
+    uint32_t commandArg
+  ) = 0;
 };
 
 class V6CommandDemuxer : public V6CommandHandler {
 public:
   V6CommandDemuxer(V6CommandHandler* handlers[], size_t numHandlers)
-    : V6CommandHandler(0),  
+    : V6CommandHandler(0, MilightRgbwConfig),  
       handlers(handlers),
       numHandlers(numHandlers)
   { }
@@ -35,6 +55,7 @@ public:
     MiLightClient* client, 
     uint16_t deviceId,
     uint8_t group,
+    uint8_t commandType,
     uint32_t command,
     uint32_t commandArg
   );
@@ -42,6 +63,14 @@ public:
 protected:
   V6CommandHandler** handlers;
   size_t numHandlers;
+  
+  virtual bool handleCommand(
+    MiLightClient* client, 
+    uint16_t deviceId,
+    uint8_t group,
+    uint32_t command,
+    uint32_t commandArg
+  );
 };
 
 #endif

lib/Udp/V6MiLightUdpServer.cpp

@@ -215,15 +215,11 @@ void V6MiLightUdpServer::handleCommand(
       client,
       deviceId,
       group,
+      cmdType,
       cmdHeader,
       cmdArg
     );
   }
-  // else if ((cmdHeader & 0x0800) == 0x0800) {
-  //   handled = handleV2BulbCommand(group, cmdHeader, cmdArg);
-  // } else if ((cmdHeader & 0x0500) == 0x0500) {
-  //   handled = handleRgbBulbCommand(group, cmdHeader, cmdArg);
-  // }
   
   if (handled) {
     size_t len = size(COMMAND_RESPONSE);

lib/Udp/V6RgbCctCommandHandler.h

@@ -22,8 +22,8 @@ enum V2CommandArgIds {
 
 class V6RgbCctCommandHandler : public V6CommandHandler {
 public:
-  V6RgbCctCommandHandler(uint16_t commandId)
-    : V6CommandHandler(commandId)
+  V6RgbCctCommandHandler()
+    : V6CommandHandler(0x0800, MilightRgbCctConfig)
   { }
   
   virtual bool handleCommand(

lib/Udp/V6RgbCommandHandler.h

@@ -18,8 +18,8 @@ enum RgbCommandIds {
 
 class V6RgbCommandHandler : public V6CommandHandler {
 public:
-  V6RgbCommandHandler(uint16_t commandId)
-    : V6CommandHandler(commandId)
+  V6RgbCommandHandler()
+    : V6CommandHandler(0x0500, MilightRgbConfig)
   { }
   
   virtual bool handleCommand(

lib/Udp/V6RgbwCommandHandler.h

@@ -19,8 +19,8 @@ enum RgbwCommandIds {
 
 class V6RgbwCommandHandler : public V6CommandHandler {
 public:
-  V6RgbwCommandHandler(uint16_t commandId)
-    : V6CommandHandler(commandId)
+  V6RgbwCommandHandler()
+    : V6CommandHandler(0x0700, MilightRgbwConfig)
   { }
   
   virtual bool handleCommand(