Manually merge: "Report error when streaming loses connection. FirebaseExtended#179"

Author: kotl

contrib/test/dummies/FirebaseHttpClient_dummy.cpp

@@ -23,6 +23,10 @@ class FirebaseHttpClientDummy : public FirebaseHttpClient {
   void addHeader(const std::string& UNUSED_ARG(name), const std::string& UNUSED_ARG(value)) override {
   }
 
+  bool connected() override {
+    return true;
+  }
+
   void collectHeaders(const char* UNUSED_ARG(header_keys[]), const int UNUSED_ARG(count)) override {
   }
 

src/FirebaseArduino.cpp

@@ -156,6 +156,11 @@ void FirebaseArduino::stream(const String& path) {
 
 bool FirebaseArduino::available() {
   if (stream_http_.get() == nullptr) {
+    error_ = FirebaseError(FIREBASE_ERROR_CODES::STREAM_NOT_INITIALIZED, "HTTP stream is not initialized");
+    return 0;
+  }
+  if (!stream_http_.get()->connected()) {
+    error_ = FirebaseError(FIREBASE_ERROR_CODES::HTTP_CONNECTION_LOST, "Connection Lost");
     return 0;
   }
   auto client = stream_http_.get()->getStreamPtr();

src/FirebaseError.h

@@ -1,6 +1,14 @@
 #ifndef firebase_error_h
 #define firebase_error_h
 
+
+// These error codes are used in addition to regular HTTP error codes.
+// Same error space is shared between HTTP errors and these values. 
+enum FIREBASE_ERROR_CODES {
+  HTTP_CONNECTION_LOST = -5,
+  STREAM_NOT_INITIALIZED = -6
+};
+
 class FirebaseError {
  public:
   // Make it explicit that the empty constructor mean no error.

src/FirebaseHttpClient.h

@@ -33,6 +33,8 @@ class FirebaseHttpClient {
 
   virtual std::string errorToString(int error_code) = 0;
 
+  virtual bool connected() = 0;
+
  protected:
   static const uint16_t kFirebasePort = 443;
 };

src/FirebaseHttpClient.h~

@@ -0,0 +1,45 @@
+#ifndef FIREBASE_HTTP_CLIENT_H
+#define FIREBASE_HTTP_CLIENT_H
+
+#include <string>
+
+#include "Arduino.h"
+#include "Stream.h"
+
+struct HttpStatus {
+  static const int TEMPORARY_REDIRECT = 307;
+};
+
+class FirebaseHttpClient {
+ public:
+  static FirebaseHttpClient* create();
+
+  virtual void setReuseConnection(bool reuse) = 0;
+  virtual void begin(const std::string& url) = 0;
+  virtual void begin(const std::string& host, const std::string& path) = 0;
+
+  virtual void end() = 0;
+
+  virtual void addHeader(const std::string& name, const std::string& value) = 0;
+  virtual void collectHeaders(const char* header_keys[],
+                              const int header_key_count) = 0;
+  virtual std::string header(const std::string& name) = 0;
+
+  virtual int sendRequest(const std::string& method, const std::string& data) = 0;
+
+  virtual std::string getString() = 0;
+
+  virtual Stream* getStreamPtr() = 0;
+
+  virtual std::string errorToString(int error_code) = 0;
+  
+  virtual bool connected() = 0;
+
+ protected:
+  static const uint16_t kFirebasePort = 443;
+};
+
+static const char kFirebaseFingerprint[] =
+      "B8 4F 40 70 0C 63 90 E0 07 E8 7D BD B4 11 D0 4A EA 9C 90 F6";
+
+#endif  // FIREBASE_HTTP_CLIENT_H

src/FirebaseHttpClient_Esp8266.cpp

@@ -83,6 +83,10 @@ class FirebaseHttpClientEsp8266 : public FirebaseHttpClient {
    return HTTPClient::errorToString(error_code).c_str();
   }
 
+  bool connected() override {
+    return http_.connected();
+  }
+
  private:
   ForceReuseHTTPClient http_;
 };

src/FirebaseHttpClient_Esp8266.cpp~

@@ -0,0 +1,97 @@
+
+#include "FirebaseHttpClient.h"
+
+#include <stdio.h>
+
+// The ordering of these includes matters greatly.
+#include <WiFiClientSecure.h>
+#include <ESP8266WiFi.h>
+#include <ESP8266HTTPClient.h>
+
+// Detect whether stable version of HTTP library is installed instead of
+// master branch and patch in missing status and methods.
+#ifndef HTTP_CODE_TEMPORARY_REDIRECT
+#define HTTP_CODE_TEMPORARY_REDIRECT 307
+#define USE_ESP_ARDUINO_CORE_2_0_0
+#endif
+
+// Firebase now returns `Connection: close` after REST streaming redirection.
+//
+// Override the built-in ESP8266HTTPClient to *not* close the
+// connection if forceReuse it set to `true`.
+class ForceReuseHTTPClient : public HTTPClient {
+public:
+  void end() {
+    if (_forceReuse) {
+      _canReuse = true;
+    }
+    HTTPClient::end();
+  }
+  void forceReuse(bool forceReuse) {
+    _forceReuse = forceReuse;
+  }
+protected:
+  bool _forceReuse = false;
+};
+
+class FirebaseHttpClientEsp8266 : public FirebaseHttpClient {
+ public:
+  FirebaseHttpClientEsp8266() {}
+
+  void setReuseConnection(bool reuse) override {
+    http_.setReuse(reuse);
+    http_.forceReuse(reuse);
+  }
+
+  void begin(const std::string& url) override {
+    http_.begin(url.c_str(), kFirebaseFingerprint);
+  }
+
+  void begin(const std::string& host, const std::string& path) override {
+    http_.begin(host.c_str(), kFirebasePort, path.c_str(), kFirebaseFingerprint);
+  }
+
+  void end() override {
+    http_.end();
+  }
+
+  void addHeader(const std::string& name, const std::string& value) override {
+    http_.addHeader(name.c_str(), value.c_str());
+  }
+
+  void collectHeaders(const char* header_keys[], const int count) override {
+    http_.collectHeaders(header_keys, count);
+  }
+
+  std::string header(const std::string& name) override {
+    return http_.header(name.c_str()).c_str();
+  }
+
+  int sendRequest(const std::string& method, const std::string& data) override {
+    return http_.sendRequest(method.c_str(), (uint8_t*)data.c_str(), data.length());
+  }
+
+  std::string getString() override {
+    return http_.getString().c_str();
+  }
+
+  Stream* getStreamPtr() override {
+    return http_.getStreamPtr();
+  }
+
+  std::string errorToString(int error_code) override {
+   return HTTPClient::errorToString(error_code).c_str();
+  }
+
+  bool connected() override {
+    return http_.connected();
+  }
+  
+ private:
+  ForceReuseHTTPClient http_;
+};
+
+FirebaseHttpClient* FirebaseHttpClient::create() {
+  return new FirebaseHttpClientEsp8266();
+}
+