Imported all from modem-impl2

Author: ed7coyne

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "test/googletest"]
+	path = test/googletest
+	url = https://github.com/google/googletest.git
+[submodule "test/arduino-mock"]
+	path = test/arduino-mock
+	url = https://github.com/ed7coyne/arduino-mock.git

src/FirebaseHttpClient.h

@@ -0,0 +1,41 @@
+#ifndef FIREBASE_HTTP_CLIENT_H
+#define FIREBASE_HTTP_CLIENT_H
+
+#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 String& url) = 0;
+  virtual void begin(const String& host, const String& path) = 0;
+
+  virtual void end() = 0;
+
+  virtual void addHeader(const String& name, const String& value) = 0;
+  virtual void collectHeaders(const char* header_keys[],
+                              const int header_key_count) = 0;
+  virtual String header(const String& name) = 0;
+
+  virtual int sendRequest(const String& method, const String& data) = 0;
+
+  virtual String getString() = 0;
+
+  virtual Stream* getStreamPtr() = 0;
+
+  virtual String errorToString(int error_code) = 0;
+
+ protected:
+  static const uint16_t kFirebasePort = 443;
+};
+
+static const String kFirebaseFingerprint =
+      "7A 54 06 9B DC 7A 25 B3 86 8D 66 53 48 2C 0B 96 42 C7 B3 0A";
+
+#endif  // FIREBASE_HTTP_CLIENT_H

src/FirebaseHttpClient_Esp8266.cpp

@@ -0,0 +1,75 @@
+
+#include "FirebaseHttpClient.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
+
+class FirebaseHttpClientEsp8266 : public FirebaseHttpClient {
+ public:
+  FirebaseHttpClientEsp8266() {}
+
+  void setReuseConnection(bool reuse) override {
+    http_.setReuse(reuse);
+  }
+
+  void begin(const String& url) override {
+    http_.begin(url, kFirebaseFingerprint);
+  }
+
+  void begin(const String& host, const String& path) override {
+    http_.begin(host, kFirebasePort, path, true, kFirebaseFingerprint);
+  }
+
+  void end() override {
+    http_.end();
+  }
+
+  void addHeader(const String& name, const String& value) override {
+    http_.addHeader(name, value);
+  }
+
+  void collectHeaders(const char* header_keys[], const int count) override {
+    http_.collectHeaders(header_keys, count);
+  }
+
+  String header(const String& name) override {
+    return http_.header(name.c_str());
+  }
+
+  int sendRequest(const String& method, const String& data) override {
+    return http_.sendRequest(method.c_str(), (uint8_t*)data.c_str(), data.length());
+  }
+
+  String getString() override {
+    return http_.getString();
+  }
+
+  Stream* getStreamPtr() override {
+    return http_.getStreamPtr();
+  }
+
+  String errorToString(int error_code) override {
+#ifdef USE_ESP_ARDUINO_CORE_2_0_0
+    return  String(error_code);
+#else
+    return HTTPClient::errorToString(error_code);
+#endif
+  }
+
+ private:
+  HTTPClient http_;
+};
+
+FirebaseHttpClient* FirebaseHttpClient::create() {
+  return new FirebaseHttpClientEsp8266();
+}
+

src/SerialTransceiver.h

@@ -0,0 +1,3 @@
+#include "modem/SerialTransceiver.h"
+// Bring them into the base namespace for easier use in arduino ide.
+using firebase::modem::SerialTransceiver;

src/modem/SerialTransceiver.cpp

@@ -0,0 +1,61 @@
+#include "SerialTransceiver.h"
+
+namespace firebase {
+namespace modem {
+
+void SerialTransceiver::begin(Stream* serial) {
+  std::unique_ptr<Firebase> fbase;
+
+  in_.reset(new ArduinoInputStream(serial));
+  out_.reset(new ArduinoOutputStream(serial));
+}
+
+void SerialTransceiver::loop() {
+  String command_name = in_->readStringUntil(' ');
+
+  if (command_name.length() == 0 // Generally means a timeout has occured.
+      || command_name == "\n") {
+    return;
+  }
+
+  if (command_name == "BEGIN") {
+    BeginCommand command;
+    if (command.execute(command_name, in_.get(), out_.get())) {
+      fbase_ = std::move(command.firebase());
+    }
+    return;
+  } else if (!fbase_) {
+    in_->drain();
+    out_->println("-FAIL Must call BEGIN before anything else.");
+    return;
+  }
+
+  std::unique_ptr<Command> command = CreateCommand(command_name, fbase_.get());
+  if (!command) {
+    in_->drain();
+    out_->println(String("-FAIL Invalid command '") + command_name + "'." );
+    return;
+  }
+
+  command->execute(command_name, in_.get(), out_.get());
+}
+
+std::unique_ptr<Command> SerialTransceiver::CreateCommand(const String& text,
+                                                          Firebase* fbase) {
+  std::unique_ptr<Command> command;
+  if (text == "GET") {
+    command.reset(new GetCommand(fbase));
+  } else if (text == "SET") {
+    command.reset(new SetCommand(fbase));
+  } else if (text == "PUSH") {
+    command.reset(new PushCommand(fbase));
+  } else if (text == "REMOVE") {
+    command.reset(new RemoveCommand(fbase));
+  } else if (text == "BEGIN_STREAM") {
+    command.reset(new StreamCommand(fbase));
+  }
+  return command;
+}
+
+}  // modem
+}  // firebase

src/modem/SerialTransceiver.h

@@ -0,0 +1,28 @@
+#ifndef MODEM_SERIAL_TRANSCIEVER_H
+#define MODEM_SERIAL_TRANSCIEVER_H
+
+#include <memory>
+
+#include "Firebase.h"
+#include "modem/commands.h"
+
+namespace firebase {
+namespace modem {
+
+class SerialTransceiver {
+ public:
+  void begin(Stream* serial);
+  void loop();
+
+ private:
+  std::unique_ptr<Command> CreateCommand(const String& name, Firebase* fbase);
+
+  std::unique_ptr<Firebase> fbase_;
+  std::unique_ptr<ArduinoInputStream> in_;
+  std::unique_ptr<ArduinoOutputStream> out_;
+};
+
+}  // modem
+}  // firebase
+
+#endif // MODEM_SERIAL_TRANSCIEVER_H

src/modem/begin-command.cpp

@@ -0,0 +1,50 @@
+#include "modem/commands.h"
+
+namespace firebase {
+namespace modem {
+
+bool BeginCommand::execute(const String& command,
+                         InputStream* in, OutputStream* out) {
+  if (in == nullptr || out == nullptr) {
+    return false;
+  }
+
+  if (command != "BEGIN") {
+    return false;
+  }
+
+  String host;
+  String auth;
+
+  String data(in->readLine());
+
+  int space_index = data.indexOf(' ');
+  if (space_index == -1) {
+    // host only.
+    host = data;
+  } else {
+    // host and auth.
+    host = data.substring(0, space_index);
+    auth = data.substring(space_index + 1);
+  }
+
+  if (host.length() == 0) {
+    out->println("-FAIL Missing host");
+    return false;
+  }
+
+  new_firebase_.reset(new Firebase(host));
+  if (auth.length() != 0) {
+    new_firebase_->auth(auth);
+  }
+
+  out->println("+OK");
+  return true;
+}
+
+std::unique_ptr<Firebase> BeginCommand::firebase() {
+  return std::move(new_firebase_);
+}
+
+}  // modem
+}  // firebase

src/modem/commands.h

@@ -0,0 +1,79 @@
+#ifndef MODEM_COMMAND_H
+#define MODEM_COMMAND_H
+
+#include "Firebase.h"
+#include "modem/output-stream.h"
+#include "modem/input-stream.h"
+
+namespace firebase {
+namespace modem {
+
+class Command {
+ public:
+  Command(Firebase* fbase) : fbase_(fbase) {}
+
+  // Execute command, reading any additional data needed from stream.
+  // Return false if execution failed.
+  virtual bool execute(const String& command,
+                       InputStream* in, OutputStream* out) = 0;
+ protected:
+  Firebase& fbase() {
+    return *fbase_;
+  }
+
+ private:
+  Firebase* fbase_;
+};
+
+class GetCommand : public Command {
+ public:
+  GetCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class SetCommand : public Command {
+ public:
+  SetCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class RemoveCommand : public Command {
+ public:
+  RemoveCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class PushCommand : public Command {
+ public:
+  PushCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class BeginCommand : public Command {
+ public:
+  BeginCommand() : Command(nullptr) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+
+  // This can only be called once.
+  std::unique_ptr<Firebase> firebase();
+
+ private:
+  std::unique_ptr<Firebase> new_firebase_;
+};
+
+class StreamCommand : public Command {
+ public:
+  StreamCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+}  // modem
+}  // firebase
+
+#endif //MODEM_COMMAND_H

src/modem/design.md

@@ -0,0 +1,10 @@
+Overview:
+
+![Design diagram](diagram.png)
+
+We create a SerialTransceiver object that will manage the serial connection. It will read the first word on a line to determine which command is being called and construct the appropriate Command subclass to handle the interaction. Commands will be short lived objects with no state between calls, they will own the serial connection until they hand it back and are responsible for handling all necessary input and leaving the input line in a clean state for the next command.
+
+We will aim to keep the Transceiver/Command interaction generic enough to enable creating additional Protocol Transceivers in the future.
+
+The Transceiver object will also own the Firebase object and present it to each command during construction. The Firebase object is our link to the firebase backend.
+