salmanoff/smocore/marionette/salmanoff.cpp

#include <iostream>
#include <deviceManager/deviceManager.h>
#include <senseApis/senseApiManager.h>
#include <asynchronousContinuation.h>
#include <salmanoff.h>


namespace smo {

class InitializeSalmanoffReq
:	public AsynchronousContinuation<initializeSalmanoffCbFn>
{
public:
	InitializeSalmanoffReq(initializeSalmanoffCbFn cb)
	:	AsynchronousContinuation(std::move(cb))
	{}

	// Callback methods for the initialization sequence
	void initializeSalmanoffReq1(
		std::shared_ptr<InitializeSalmanoffReq> context,
		smo::AsynchronousLoop &results
		)
	{
		std::cout << __func__ << ": Done. " << results.nSucceeded
			<< " succeeded, " << results.nFailed << " failed." << std::endl;
		context->originalCbFn(true);
	}
};

void initializeSalmanoff(
	initializeSalmanoffCbFn callback)
{
	std::cout << __func__ << ": Entered." << std::endl;

	std::shared_ptr<ComponentThread> mrntt = ComponentThread::getMrntt();
	auto request = std::make_shared<InitializeSalmanoffReq>(
		std::move(callback));

	device::DeviceManager::getInstance().collateAllDapSpecs();
	device::DeviceManager::getInstance().parseAllDapSpecs();
	std::cout << device::DeviceManager::stringifyDeviceSpecs() << std::endl;

	/**	EXPLANATION:
	 * The ComponentThread instance we pass in here is the one that will be used
	 * by Senseapi libs to perform device-independent background operations.
	 * For example, liblivoxProto1's BroadcastListener will use this thread to
	 * listen for UDP broadcast dgrams from Livox devices.
	 *
	 * Right now we use Marionette, but there's a strong argument for using
	 * Body instead since it's meant to handle device-management operations.
	 */
	sense_api::SenseApiManager::getInstance().loadAllSenseApiLibsFromOptions(
		mrntt);

	std::cout << sense_api::SenseApiManager::getInstance().stringifyLibs()
		<< std::endl;

	if (OptionParser::getOptions().verbose) {
		std::cout << __func__ << ": About to initializeAllSenseApiLibs" << '\n';
	}
	sense_api::SenseApiManager::getInstance().initializeAllSenseApiLibs();

	if (OptionParser::getOptions().verbose) {
		std::cout << __func__ << ": About to attachAllSenseDevicesFromSpecs" << '\n';
	}
	sense_api::SenseApiManager::getInstance().attachAllSenseDevicesFromSpecsReq(
		std::bind(
			&InitializeSalmanoffReq::initializeSalmanoffReq1,
			request.get(), request,
			std::placeholders::_1));
}

class ShutdownSalmanoffReq
:	public InitializeSalmanoffReq
{
public:
	using InitializeSalmanoffReq::InitializeSalmanoffReq;

	// Callback methods for the shutdown sequence
	void shutdownSalmanoffReq1(
		std::shared_ptr<ShutdownSalmanoffReq> context,
		smo::AsynchronousLoop &results
		)
	{
		sense_api::SenseApiManager::getInstance().finalizeAllSenseApiLibs();
		std::cout << __func__ << ": Done. " << results.nSucceeded
			<< " succeeded, " << results.nFailed << " failed." << std::endl;
		context->originalCbFn(true);
	}
};

void shutdownSalmanoff(shutdownSalmanoffCbFn callback)
{
	std::cout << __func__ << ": Entered." << std::endl;

	// Create the shutdown request object to hold state and callbacks
	auto request = std::make_shared<ShutdownSalmanoffReq>(std::move(callback));

	sense_api::SenseApiManager::getInstance().detachAllSenseDevicesReq(
		std::bind(
			&ShutdownSalmanoffReq::shutdownSalmanoffReq1,
			request.get(), request,
			std::placeholders::_1));
}

} // namespace smo