FMCManager.h

/*
 This file is part of Pi-XPlane-FMC-CDU
 A Raspberry Pi-based External FMC for XPlane

 Copyright (C) 2017-2018 shahada abubakar
 <shahada@abubakar.net>

 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 <https://www.gnu.org/licenses/>.

 */

#ifndef FMCMANAGER_H_
#define FMCMANAGER_H_

#include <stdlib.h>
#include <time.h>


#include <XPlaneUDPClient.h>
#include <syslog.h>

#include "AbstractFMC.h"
#include "SplashFMC.h"
#include "MainFMC.h"

#include <XPlaneExtPlaneClient/ExtPlaneClient.h>

class FMCManager {
private:
    // private so it cannot be called publicly
    FMCManager();

    // private so it cannot be called publicly
    FMCManager(FMCManager const &) {};


    // assignment operator is private too
    FMCManager & operator =(FMCManager const &) {
        abort();
    }

    AbstractFMC * currentFMC;

    // here are our utility FMCs
    SplashFMC * splashFMC;
    MainFMC * mainFMC;


    // actual FMCS go here
    std::map<std::string, AbstractFMC *> actualFMCs;


protected:
    static FMCManager * instance;

    time_t timeStarted;

    virtual ~FMCManager();

    void drawCenteredText(int line, std::string text);
    void splash();
    void setCurrentFMC(AbstractFMC * fmc);

    std::string currentConnection;

    XPlaneExtPlaneClient::ExtPlaneClient * xplaneConnection;

    time_t clearKeyPressTime = 0;

public:
    // @brief return pointer to the singleton instance
    static FMCManager * getInstance() {
        if (!instance) {
            instance = new FMCManager();
        };
        return instance;
    }

    void keyPressEvent(int row, int col);
    void keyReleaseEvent(int row, int col);

    void tick();

    void gotoSplashFMC() {
        setCurrentFMC(splashFMC);
    }

    void gotoMainFMC() {
        setCurrentFMC(mainFMC);
    }

    void XPlaneBeaconListener(XPlaneBeaconListener::XPlaneServer server,
            bool exists);


    void connectToServer(std::string host, int port);


    void receiveDataFromServer(std::string type, std::string dataref, std::string value);




    void onExtPlaneConnect ();


    void onExtPlaneDisconnect ();


    void subscribeDataRef (std::string dataref, float accuracy = 0);


    void unsubscribeDataRef (std::string dataref);

    void setDataRef (std::string dataref, std::string value);

    void setCurrentFMC(std::string fmc);


    std::vector<std::string> getActualFMCList ();

    void sendCommand (std::string cmd);

};

#endif /* FMCMANAGER_H_ */