fixup! defining OTAInterface

Author: andreagilardoni

src/ota/interface/OTAInterface.cpp

@@ -66,6 +66,8 @@ OTACloudProcessInterface::OTACloudProcessInterface(MessageStream *ms)
 , policies(None)
 , state(Resume)
 , previous_state(Resume)
+, report_last_timestamp(0)
+, report_counter(0)
 , context(nullptr) {
 }
 
@@ -76,35 +78,34 @@ OTACloudProcessInterface::~OTACloudProcessInterface() {
 void OTACloudProcessInterface::handleMessage(Message* msg) {
 
   if ((state >= OtaAvailable || state < 0) && previous_state != state) {
-    reportStatus();
+    reportStatus(static_cast<int32_t>(state<0? state : 0));
   }
 
   // this allows to do status report only when the state changes
   previous_state = state;
 
   switch(state) {
-  case Resume:        updateState(resume(msg));    break;
-  case OtaBegin:      updateState(otaBegin());     break;
-  case Idle:          updateState(idle(msg));      break;
-  case OtaAvailable:  updateState(otaAvailable()); break;
-  case StartOTA:      updateState(startOTA());     break;
-  case Fetch:         updateState(fetch());        break;
-  case FlashOTA:      updateState(flashOTA());     break;
-  case Reboot:        updateState(reboot());       break;
-  default:            updateState(fail()); // all the states that are not defined are failures
+  case Resume:         updateState(resume(msg));    break;
+  case OtaBegin:       updateState(otaBegin());     break;
+  case Idle:           updateState(idle(msg));      break;
+  case OtaAvailable:   updateState(otaAvailable()); break;
+  case StartOTA:       updateState(startOTA());     break;
+  case Fetch:          updateState(fetch());        break;
+  case FlashOTA:       updateState(flashOTA());     break;
+  case Reboot:         updateState(reboot());       break;
+  case OTAUnavailable: break;
+  default:             updateState(fail()); // all the states that are not defined are failures
   }
 }
 
 OTACloudProcessInterface::State OTACloudProcessInterface::otaBegin() {
   if(!isOtaCapable()) {
-    // FIXME What do we have to do in this case?
-    DEBUG_WARNING("OTA is not available on this board");
-    return OtaBegin;
+    DEBUG_VERBOSE("OTA is not available on this board");
+    return OTAUnavailable;
   }
 
   struct OtaBeginUp msg = {
     OtaBeginUpId,
-    {}
   };
 
   SHA256 sha256_calc;
@@ -113,12 +114,16 @@ OTACloudProcessInterface::State OTACloudProcessInterface::otaBegin() {
   sha256_calc.finalize(sha256);
   memcpy(msg.params.sha, sha256, SHA256::HASH_SIZE);
 
-  DEBUG_VERBOSE("calculated SHA256: 0x%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
-    this->sha256[0], this->sha256[1], this->sha256[2], this->sha256[3], this->sha256[4], this->sha256[5], this->sha256[6], this->sha256[7], this->sha256[8], this->sha256[9], this->sha256[10], this->sha256[11], this->sha256[12], this->sha256[13], this->sha256[14], this->sha256[15], this->sha256[16], this->sha256[17], this->sha256[18], this->sha256[19], this->sha256[20], this->sha256[21], this->sha256[22], this->sha256[23], this->sha256[24], this->sha256[25], this->sha256[26], this->sha256[27], this->sha256[28], this->sha256[29], this->sha256[30], this->sha256[31]
+  DEBUG_VERBOSE("calculated SHA256: "
+      "0x%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"
+      "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
+      sha256[0],  sha256[1],  sha256[2],  sha256[3],  sha256[4],  sha256[5],  sha256[6],  sha256[7],
+      sha256[8],  sha256[9],  sha256[10], sha256[11], sha256[12], sha256[13], sha256[14], sha256[15],
+      sha256[16], sha256[17], sha256[18], sha256[19], sha256[20], sha256[21], sha256[22], sha256[23],
+      sha256[24], sha256[25], sha256[26], sha256[27], sha256[28], sha256[29], sha256[30], sha256[31]
     );
 
   deliver((Message*)&msg);
-  // TODO msg object do not exist after this call make sure it gets copied somewhere
 
   return Idle;
 }
@@ -148,8 +153,8 @@ OTACloudProcessInterface::State OTACloudProcessInterface::idle(Message* msg) {
     struct OtaUpdateCmdDown* ota_msg = (struct OtaUpdateCmdDown*)msg;
 
     context = new OtaContext(
-      ota_msg->params.id, ota_msg->params.url,
-      ota_msg->params.initialSha256, ota_msg->params.finalSha256
+        ota_msg->params.id, ota_msg->params.url,
+        ota_msg->params.initialSha256, ota_msg->params.finalSha256
       );
 
     // TODO verify that initialSha256 is the sha256 on board
@@ -186,35 +191,31 @@ void OTACloudProcessInterface::clean() {
   }
 }
 
-void OTACloudProcessInterface::reportStatus() {
+void OTACloudProcessInterface::reportStatus(int32_t state_data) {
   if(context == nullptr) {
     // FIXME handle this case: ota not in progress
     return;
   }
-  static uint32_t last_timestamp = getTime();
-  static uint32_t counter = 0;
   uint32_t new_timestamp = getTime();
 
   struct OtaProgressCmdUp msg = {
     OtaProgressCmdUpId,
-    {}
   };
 
   memcpy(msg.params.id, context->id, ID_SIZE);
-  msg.params.state      = state>=0 ? state : State::Fail;
+  msg.params.state        = state>=0 ? state : State::Fail;
 
-  if(new_timestamp == last_timestamp) {
-    msg.params.time       = new_timestamp*1e6 + ++counter;
+  if(new_timestamp == report_last_timestamp) {
+    msg.params.time       = new_timestamp*1e6 + ++report_counter;
   } else {
     msg.params.time       = new_timestamp*1e6;
-    counter = 0;
-    last_timestamp = new_timestamp;
+    report_counter = 0;
+    report_last_timestamp = new_timestamp;
   }
 
-  msg.params.state_data = static_cast<int32_t>(state<0? state : 0);
+  msg.params.state_data   = state_data;
 
   deliver((Message*)&msg);
-  // TODO msg object do not exist after this call make sure it gets copied somewhere
 }
 
 OTACloudProcessInterface::OtaContext::OtaContext(

src/ota/interface/OTAInterface.h

@@ -50,6 +50,7 @@ class OTACloudProcessInterface: public CloudProcess {
     FlashOTA                  = 6,
     Reboot                    = 7,
     Fail                      = 8,
+    OTAUnavailable            = 9,
 
     // Error states that may generically happen on all board
     NoCapableBootloaderFail   = static_cast<State>(ota::OTAError::NoCapableBootloader),
@@ -135,11 +136,9 @@ class OTACloudProcessInterface: public CloudProcess {
   // then we go back to idle state
   virtual State fail();
 
-  // TODO virtual =0 method used to reset the status of the failed ota operation
-  // TODO depending on the state in which we failed we may have different fail context
   virtual void reset() = 0;
 
-  uint16_t policies; // TODO getter and setters for this
+  uint16_t policies;
 
   inline void updateState(State s) {
     if(state!=s) {
@@ -151,7 +150,7 @@ class OTACloudProcessInterface: public CloudProcess {
   }
 
   // This method is called to report the current state of the OtaClass
-  void reportStatus();
+  void reportStatus(int32_t state_data);
 
   // in order to calculate the SHA256 we need to get the start and end address of the Application,
   // The Implementation of this class have to implement them.
@@ -160,7 +159,7 @@ class OTACloudProcessInterface: public CloudProcess {
   virtual uint32_t appSize()      = 0;
 
   // some architecture require to explicitly open the flash in order to read it
-  virtual bool appFlashOpen() = 0;
+  virtual bool appFlashOpen()  = 0;
   virtual bool appFlashClose() = 0;
 
   // sha256 is going to be used in the ota process for validation, avoid calculating it twice
@@ -173,6 +172,8 @@ class OTACloudProcessInterface: public CloudProcess {
 
   State state, previous_state;
 
+  // status report related attributes
+  uint32_t report_last_timestamp, report_counter;
 protected:
   struct OtaContext {
     OtaContext(