AppKit.h

Go to the documentation of this file.

/*
 * This is a part of the Uniot project.
 * Copyright (C) 2016-2023 Uniot <contact@uniot.io>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


 
#pragma once
 
#include <CallbackEventListener.h>
#include <CrashStorage.h>
#include <Date.h>
#include <EventBus.h>
#include <IEventBusConnectionKit.h>
#include <ISchedulerConnectionKit.h>
#include <LispDevice.h>
#include <LispPrimitives.h>
#include <Logger.h>
#include <MQTTKit.h>
#include <NetworkController.h>
#include <Singleton.h>
#include <TopDevice.h>
#include <unLisp.h>


namespace uniot {
class AppKit : public ICoreEventBusConnectionKit, public ISchedulerConnectionKit, public Singleton<AppKit> {
  friend class Singleton<AppKit>;
 
 public:
  struct NetworkControllerConfig {
    uint8_t pinBtn = UINT8_MAX;       
    uint8_t activeLevelBtn = LOW;     
    uint8_t pinLed = UINT8_MAX;       
    uint8_t activeLevelLed = HIGH;    
    uint8_t maxRebootCount = 3;       
    uint32_t rebootWindowMs = 10000;  
    bool registerLispBtn = true;      
  };

  unLisp &getLisp() {
    return unLisp::getInstance();
  }

  MQTTKit &getMQTT() {
    return mMQTT;
  }

  const Credentials &getCredentials() {
    return mCredentials;
  }

  bool setWiFiCredentials(const String &ssid, const String &password) {
    return mNetwork.setCredentials(ssid, password);
  }

  bool setUserId(const String &userId) {
    if (!userId.isEmpty()) {
      mCredentials.setOwnerId(userId);
      mCredentials.store();
      return true;
    }
    return false;
  }

  virtual void pushTo(TaskScheduler &scheduler) override {
    scheduler.push(mNetwork);
    scheduler.push(mMQTT);
    scheduler.push("lisp_task", getLisp().getTask());
    scheduler.push("lisp_cleanup", getLisp().getCleanupTask());
 
    mTopDevice.setScheduler(scheduler);
 
    if (mpNetworkDevice) {
      scheduler.push(*mpNetworkDevice);
    } else {
      UNIOT_LOG_WARN("Configure Network Controller before pushing to the scheduler");
    }
  }

  virtual void attach() override {
    _initPrimitives();
    mNetwork.attach();
    mMQTT.attach();
 
    if (mpNetworkDevice) {
      mpNetworkDevice->attach();
    }
 
#if defined(ESP8266)
    analogWriteRange(1023);
#elif defined(ESP32)
    analogWriteResolution(10);
#endif
 
    getLisp().getCleanupTask()->attach(15000);
    mLispDevice.runStoredCode();
  }

  virtual void registerWithBus(CoreEventBus &eventBus) override {
    eventBus.openDataChannel(events::network::Channel::OUT_SSID, 1);
    eventBus.openDataChannel(events::lisp::Channel::OUT_LISP, 5);
    eventBus.openDataChannel(events::lisp::Channel::OUT_LISP_LOG, 10);
    eventBus.openDataChannel(events::lisp::Channel::OUT_LISP_ERR, 1);
    eventBus.openDataChannel(events::lisp::Channel::OUT_EVENT, 10);
    eventBus.openDataChannel(events::lisp::Channel::IN_EVENT, 20);
    eventBus.registerEntity(&Date::getInstance());
    eventBus.registerEntity(&mNetwork);
    eventBus.registerEntity(&mMQTT);
    eventBus.registerEntity(&getLisp());
    eventBus.registerEntity(&mLispDevice);
    eventBus.registerEntity(mpNetworkEventListener
                                ->listenToEvent(events::network::Topic::CONNECTION)
                                ->listenToEvent(events::mqtt::Topic::CONNECTION));
 
    if (mpNetworkDevice) {
      eventBus.registerEntity(mpNetworkDevice.get());
    } else {
      UNIOT_LOG_WARN("Configure Network Controller before registering to the event bus");
    }
  }

  virtual void unregisterFromBus(CoreEventBus &eventBus) override {
    eventBus.closeDataChannel(events::network::Channel::OUT_SSID);
    eventBus.closeDataChannel(events::lisp::Channel::OUT_LISP);
    eventBus.closeDataChannel(events::lisp::Channel::OUT_LISP_LOG);
    eventBus.closeDataChannel(events::lisp::Channel::OUT_LISP_ERR);
    eventBus.closeDataChannel(events::lisp::Channel::OUT_EVENT);
    eventBus.closeDataChannel(events::lisp::Channel::IN_EVENT);
    eventBus.unregisterEntity(&Date::getInstance());
    eventBus.unregisterEntity(&mNetwork);
    eventBus.unregisterEntity(&mMQTT);
    eventBus.unregisterEntity(&getLisp());
    eventBus.unregisterEntity(&mLispDevice);
    eventBus.unregisterEntity(mpNetworkEventListener
                                  ->stopListeningToEvent(events::network::Topic::CONNECTION)
                                  ->stopListeningToEvent(events::mqtt::Topic::CONNECTION));
 
    if (mpNetworkDevice) {
      eventBus.unregisterEntity(mpNetworkDevice.get());
    }
  }

  void configureNetworkController(const NetworkControllerConfig &config) {
    configureNetworkController(config.pinBtn,
                               config.activeLevelBtn,
                               config.pinLed,
                               config.activeLevelLed,
                               config.maxRebootCount,
                               config.rebootWindowMs,
                               config.registerLispBtn);
  }

  void configureNetworkController(uint8_t pinBtn = UINT8_MAX,
                                  uint8_t activeLevelBtn = LOW,
                                  uint8_t pinLed = UINT8_MAX,
                                  uint8_t activeLevelLed = HIGH,
                                  uint8_t maxRebootCount = 3,
                                  uint32_t rebootWindowMs = 10000,
                                  bool registerLispBtn = true) {
    if (mpNetworkDevice) {
      UNIOT_LOG_WARN("Network Controller already configured");
      return;
    }
 
    mpNetworkDevice = MakeUnique<NetworkController>(mNetwork, pinBtn, activeLevelBtn, pinLed, activeLevelLed, maxRebootCount, rebootWindowMs);
    auto ctrlBtn = mpNetworkDevice->getButton();
    if (ctrlBtn && registerLispBtn) {
      PrimitiveExpeditor::getRegisterManager().link(primitive::name::bclicked, ctrlBtn, FOURCC(ctrl));
    }
  }

  void setLispEventInterceptor(LispEventInterceptor interceptor) {
    mLispDevice.setEventInterceptor(interceptor);
  }

  void publishLispEvent(const String &eventID, int32_t value) {
    mLispDevice.publishLispEvent(eventID, value);
  }
 
 private:
  AppKit()
      : mNetwork(mCredentials),
        mMQTT(mCredentials, [this](CBORObject &info) {
          auto obj = info.putMap("primitives");
          getLisp().serializePrimitives(obj);
 
          auto registers = info.putMap("misc").putMap("registers");
          PrimitiveExpeditor::getRegisterManager().serializeRegisters(registers);
 
          // TODO: add uniot core version
          info.put("timestamp", static_cast<int64_t>(Date::now()));
          info.put("creator", mCredentials.getCreatorId().c_str());
          info.put("public_key", mCredentials.getPublicKey().c_str());
          info.put("mqtt_size", MQTT_MAX_PACKET_SIZE);
          info.put("debug", UNIOT_LOG_ENABLED);
          info.put("lisp_heap", UNIOT_LISP_HEAP);
        }),
        mpNetworkDevice(nullptr) {
    _initMqtt();
    _initTasks();
    _initListeners();
  }

  inline void _initMqtt() {
    // TODO: should I move configs to the Credentials class?
    mMQTT.setServer("mqtt.uniot.io", 1883);
    mMQTT.addDevice(mTopDevice);
    mMQTT.addDevice(mLispDevice);
    mTopDevice.syncSubscriptions();
    mLispDevice.syncSubscriptions();
  }

  inline void _initTasks() {
    // TODO: init new tasks here
  }

  inline void _initPrimitives() {
    if (PrimitiveExpeditor::getRegisterManager().getRegisterLength(primitive::name::dwrite)) {
      getLisp().pushPrimitive(primitive::dwrite);
    }
    if (PrimitiveExpeditor::getRegisterManager().getRegisterLength(primitive::name::dread)) {
      getLisp().pushPrimitive(primitive::dread);
    }
    if (PrimitiveExpeditor::getRegisterManager().getRegisterLength(primitive::name::awrite)) {
      getLisp().pushPrimitive(primitive::awrite);
    }
    if (PrimitiveExpeditor::getRegisterManager().getRegisterLength(primitive::name::aread)) {
      getLisp().pushPrimitive(primitive::aread);
    }
    if (PrimitiveExpeditor::getRegisterManager().getRegisterLength(primitive::name::bclicked)) {
      getLisp().pushPrimitive(primitive::bclicked);
    }
  }

  inline void _initListeners() {
    mpNetworkEventListener = MakeUnique<CoreCallbackEventListener>([&](int topic, int msg) {
      if (events::network::Topic::CONNECTION == topic) {
        switch (msg) {
          case events::network::Msg::SUCCESS:
            UNIOT_LOG_DEBUG("AppKit Subscriber, SUCCESS, ip: %s", WiFi.localIP().toString().c_str());
            break;
          case events::network::Msg::ACCESS_POINT:
            UNIOT_LOG_DEBUG("AppKit Subscriber, ACCESS_POINT");
            mpNetworkEventListener->receiveDataFromChannel(events::network::Channel::OUT_SSID, [this](unsigned int id, bool empty, Bytes data) {
              if (!empty) {
                UNIOT_LOG_DEBUG("SSID: %s", data.terminate().c_str());
              }
            });
            break;
 
          case events::network::Msg::CONNECTING:
            UNIOT_LOG_DEBUG("AppKit Subscriber, CONNECTING");
            mpNetworkEventListener->receiveDataFromChannel(events::network::Channel::OUT_SSID, [this](unsigned int id, bool empty, Bytes data) {
              if (!empty) {
                UNIOT_LOG_DEBUG("SSID: %s", data.terminate().c_str());
              }
            });
            break;
 
          case events::network::Msg::DISCONNECTING:
            UNIOT_LOG_DEBUG("AppKit Subscriber, DISCONNECTING");
            break;
 
          case events::network::Msg::DISCONNECTED:
            UNIOT_LOG_DEBUG("AppKit Subscriber, DISCONNECTED");
            break;
 
          case events::network::Msg::AVAILABLE:
            UNIOT_LOG_DEBUG("AppKit Subscriber, AVAILABLE");
            break;
 
          case events::network::Msg::FAILED:
          default:
            UNIOT_LOG_DEBUG("AppKit Subscriber, FAILED");
            break;
        }
        return;
      }
      if (events::mqtt::Topic::CONNECTION == topic) {
        switch (msg) {
          case events::mqtt::Msg::SUCCESS:
            UNIOT_LOG_DEBUG("AppKit Subscriber, MQTT SUCCESS");
            if (mCredentials.isOwnerChanged()) {
              UNIOT_LOG_INFO("Owner changed, renewing subscriptions");
              mMQTT.renewSubscriptions();
              mCredentials.resetOwnerChanged();
            } else {
              UNIOT_LOG_INFO("Owner not changed, do not renew subscriptions");
            }
            break;
          case events::mqtt::Msg::FAILED:
          default:
            UNIOT_LOG_DEBUG("AppKit Subscriber, MQTT FAILED");
            break;
        }
        return;
      }
    });
  }
 
  Credentials mCredentials;   
  NetworkScheduler mNetwork;  
  MQTTKit mMQTT;              
  TopDevice mTopDevice;       
  LispDevice mLispDevice;     
 
  UniquePointer<NetworkController> mpNetworkDevice;                 
  UniquePointer<CoreCallbackEventListener> mpNetworkEventListener;  
};

}  // namespace uniot