request_manager.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2010-2015 Lucas Baudin
//            (C) 2011-2015 Joerg Henrichs
//            (C) 2013-2015 Glenn De Jonghe
//
//  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, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef HEADER_REQUEST_MANAGER_HPP
#define HEADER_REQUEST_MANAGER_HPP
 
#include "online/request.hpp"
#include "utils/can_be_deleted.hpp"
#include "utils/synchronised.hpp"
 
#include <irrString.h>
 
#include <string>
#ifdef WIN32
#  define WIN32_LEAN_AND_MEAN
#  include <winsock2.h>
#endif
 
#include <atomic>
#include <condition_variable>
#include <curl/curl.h>
#include <memory>
#include <queue>
#include <thread>
 
namespace Online
{
    class RequestManager : public CanBeDeleted
    {
    public:
        enum InternetPermission
        {
            IPERM_NOT_ASKED   = 0,
            IPERM_ALLOWED     = 1,
            IPERM_NOT_ALLOWED = 2
        };
        static bool m_disable_polling;
    private:
            float                     m_time_since_poll;
 
            std::shared_ptr<Online::Request> m_current_request;
 
            std::condition_variable   m_condition_variable;
 
            Synchronised<bool>        m_abort;
 
            std::atomic_bool m_paused;
 
            float m_game_polling_interval;
 
            float m_menu_polling_interval;
 
            std::thread m_thread;
 
            Synchronised< std::priority_queue <
                                                std::shared_ptr<Online::Request>,
                                                std::vector<std::shared_ptr<Online::Request> >,
                                                Online::Request::Compare
                                               >
                        >  m_request_queue;
 
            Synchronised< std::queue<std::shared_ptr<Online::Request> > >    m_result_queue;
 
            void addResult(std::shared_ptr<Online::Request> request);
            void handleResultQueue();
 
            static void mainLoop(void *obj);
 
            RequestManager(); //const std::string &url
            ~RequestManager();
 
            static RequestManager * m_request_manager;
 
        public:
            static const int HTTP_MAX_PRIORITY = 9999;
 
            // ----------------------------------------------------------------
            static RequestManager* get()
            {
                    if (m_request_manager == NULL)
                    {
                        m_request_manager = new RequestManager();
                    }
                    return m_request_manager;
            }   // get
            // ----------------------------------------------------------------
 
            static void deallocate();
            static bool isRunning();
 
            void addRequest(std::shared_ptr<Online::Request> request);
            void startNetworkThread();
            void stopNetworkThread();
 
            bool getAbort() { return m_abort.getAtomic(); }
            bool getPaused() { return m_paused.load(); }
            void setPaused(bool val) { m_paused.store(val); }
            void update(float dt);
 
            // ----------------------------------------------------------------
            void setMenuPollingInterval(float polling_interval)
            {
                m_menu_polling_interval = polling_interval;
            }   // setPollingInterval
            // ----------------------------------------------------------------
            void setGamePollingInterval(float polling_interval)
            {
                m_game_polling_interval = polling_interval;
            }   // setPollingInterval
 
    }; //class RequestManager
} // namespace Online
#endif // request_manager_HPP