JD2022-TU1/main/extern/Hue/libhuestream/huestream/connect/HueConnect.cpp

/*******************************************************************************
 Copyright © 2017 Philips Lighting Holding B.V.
 All Rights Reserved.
 ********************************************************************************/

#include "HueConnect.h"

using huestream::connectionflow::IConnectionFlowFactory;
using huestream::connectionflow::ConnectionFlowFactoryPtr;
using huestream::connectionflow::DefaultConnectionFlowFactory;

namespace huestream {


HueConnect::HueConnect() :
    _condition(),
    _isFinishedCalled(false),
    _mutex(),
    _result(Uninitialized),
    ConnectionFlow(std::static_pointer_cast<IConnectionFlowFactory>(std::make_shared<DefaultConnectionFlowFactory>(
        HueConfig::GetInstance()->GetHttp(),
        HueConfig::GetInstance()->GetDispatcher(),
        HueConfig::GetInstance()->GetStorageAccessor()))) {
}

void HueConnect::WaitUntilReady() {
  unique_lock<mutex> lock(_mutex);
  _condition.wait(lock, [this]() -> bool { return _state == huestream::connectionflow::Idle && _isFinishedCalled; });
  _isFinishedCalled = false;
  lock.unlock();
}

bool HueConnect::IsReady() {
  bool result = false;
  unique_lock<mutex> lock(_mutex);
  result = _state == huestream::connectionflow::Idle && _isFinishedCalled;
  lock.unlock();
  return result;
}

ConnectResult HueConnect::GetResult() {
  unique_lock<mutex> lock(_mutex);
  auto result = _result;
  if (_state != connectionflow::Idle) {
    result = Busy;
  }
  lock.unlock();
  return result;
}

void HueConnect::ConnectToBridge() {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::ConnectToBridge();
  lock.unlock();
}

void HueConnect::ConnectToBridgeBackground() {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::ConnectToBridgeBackground();
  lock.unlock();
}

void HueConnect::ConnectToBridgeWithIp(const string &ipAddress) {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::ConnectToBridgeWithIp(ipAddress);
  lock.unlock();
}

void HueConnect::Abort() {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::Abort();
  lock.unlock();
}

void HueConnect::SetManual(BridgePtr bridge) {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::SetManual(bridge);
  lock.unlock();
}

void HueConnect::ResetBridge() {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::ResetBridge();
  lock.unlock();
}

void HueConnect::SelectGroup(int id) {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::SelectGroup(id);
  lock.unlock();
}

void HueConnect::Load() {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::Load();
  lock.unlock();
}

void HueConnect::StartStream() {
  unique_lock<mutex> lock(_mutex);
  _isFinishedCalled = false;
  ConnectionFlow::StartStream();
  lock.unlock();
}

void HueConnect::NewMessage(const connectionflow::FeedbackMessage &message) {
  unique_lock<mutex> lock(_mutex);
  if (HueConfig::GetInstance()->GetFeedbackMessageCallback())
  {
    auto c = HueConfig::GetInstance()->GetFeedbackMessageCallback();
    c(message);
  }

  if (HueConfig::GetInstance()->GetCallbackHandler())
  {
    auto c = HueConfig::GetInstance()->GetCallbackHandler();
    c->NewConnectMessage(message);
  }

  if (message.GetId() == connectionflow::DONE_NO_BRIDGE_FOUND) {
    _result = NoBridgeFound;
  }
  if (message.GetId() == connectionflow::DONE_BRIDGE_FOUND) {
    _result = BridgeFound;
  }
  if (message.GetId() == connectionflow::DONE_ACTION_REQUIRED) {
    _result = ActionRequired;
  }
  if (message.GetId() == connectionflow::DONE_COMPLETED) {
    _result = Completed;
  }
  if (message.GetId() == connectionflow::DONE_RESET) {
    _result = Uninitialized;
  }

  if (message.GetId() == connectionflow::PROCEDURE_FINISHED) {
    _isFinishedCalled = true;
    _condition.notify_all();
  }
  lock.unlock();
}

}