190 lines
6.3 KiB
C++
190 lines
6.3 KiB
C++
//
|
|
// SuperTuxKart - a fun racing game with go-kart
|
|
// Copyright (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.
|
|
|
|
#include "online/servers_manager.hpp"
|
|
|
|
#include "config/user_config.hpp"
|
|
#include "utils/translation.hpp"
|
|
#include "utils/time.hpp"
|
|
|
|
#include <assert.h>
|
|
#include <irrString.h>
|
|
#include <string>
|
|
|
|
#define SERVER_REFRESH_INTERVAL 5.0f
|
|
|
|
namespace Online
|
|
{
|
|
static ServersManager* manager_singleton(NULL);
|
|
|
|
ServersManager* ServersManager::get()
|
|
{
|
|
if (manager_singleton == NULL)
|
|
manager_singleton = new ServersManager();
|
|
|
|
return manager_singleton;
|
|
} // get
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::deallocate()
|
|
{
|
|
delete manager_singleton;
|
|
manager_singleton = NULL;
|
|
} // deallocate
|
|
|
|
// ========================================================================
|
|
ServersManager::ServersManager()
|
|
{
|
|
m_last_load_time.setAtomic(0.0f);
|
|
m_joined_server.setAtomic(NULL);
|
|
} // ServersManager
|
|
|
|
// ------------------------------------------------------------------------
|
|
ServersManager::~ServersManager()
|
|
{
|
|
cleanUpServers();
|
|
MutexLocker(m_joined_server);
|
|
delete m_joined_server.getData();
|
|
} // ~ServersManager
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::cleanUpServers()
|
|
{
|
|
m_sorted_servers.lock();
|
|
m_sorted_servers.getData().clearAndDeleteAll();
|
|
m_sorted_servers.unlock();
|
|
m_mapped_servers.lock();
|
|
m_mapped_servers.getData().clear();
|
|
m_mapped_servers.unlock();
|
|
} // cleanUpServers
|
|
|
|
// ------------------------------------------------------------------------
|
|
ServersManager::RefreshRequest* ServersManager::refreshRequest(bool request_now) const
|
|
{
|
|
RefreshRequest* request = NULL;
|
|
if(StkTime::getRealTime() - m_last_load_time.getAtomic() > SERVER_REFRESH_INTERVAL)
|
|
{
|
|
request = new RefreshRequest();
|
|
request->setApiURL(API::SERVER_PATH, "get-all");
|
|
|
|
if (request_now)
|
|
RequestManager::get()->addRequest(request);
|
|
}
|
|
|
|
return request;
|
|
} // refreshRequest
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::refresh(bool success, const XMLNode *input)
|
|
{
|
|
if (!success)
|
|
{
|
|
Log::error("Server Manager", "Could not refresh server list");
|
|
return;
|
|
}
|
|
|
|
const XMLNode *servers_xml = input->getNode("servers");
|
|
cleanUpServers();
|
|
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
|
|
{
|
|
addServer(new Server(*servers_xml->getNode(i)));
|
|
}
|
|
m_last_load_time.setAtomic((float)StkTime::getRealTime());
|
|
} // refresh
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::RefreshRequest::callback()
|
|
{
|
|
ServersManager::get()->refresh(isSuccess(), getXMLData());
|
|
} // callback
|
|
|
|
// ------------------------------------------------------------------------
|
|
const Server* ServersManager::getQuickPlay() const
|
|
{
|
|
if(m_sorted_servers.getData().size() > 0)
|
|
return getServerBySort(0);
|
|
|
|
return NULL;
|
|
} // getQuickPlay
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::setJoinedServer(uint32_t id)
|
|
{
|
|
MutexLocker(m_joined_server);
|
|
delete m_joined_server.getData();
|
|
|
|
// It's a copy!
|
|
m_joined_server.getData() = new Server(*getServerByID(id));
|
|
} // setJoinedServer
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::unsetJoinedServer()
|
|
{
|
|
MutexLocker(m_joined_server);
|
|
delete m_joined_server.getData();
|
|
m_joined_server.getData() = NULL;
|
|
} // unsetJoinedServer
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::addServer(Server *server)
|
|
{
|
|
m_sorted_servers.lock();
|
|
m_sorted_servers.getData().push_back(server);
|
|
m_sorted_servers.unlock();
|
|
|
|
m_mapped_servers.lock();
|
|
m_mapped_servers.getData()[server->getServerId()] = server;
|
|
m_mapped_servers.unlock();
|
|
} // addServer
|
|
|
|
// ------------------------------------------------------------------------
|
|
int ServersManager::getNumServers () const
|
|
{
|
|
MutexLocker(m_sorted_servers);
|
|
return m_sorted_servers.getData().size();
|
|
} // getNumServers
|
|
|
|
// ------------------------------------------------------------------------
|
|
const Server* ServersManager::getServerBySort (int index) const
|
|
{
|
|
MutexLocker(m_sorted_servers);
|
|
return m_sorted_servers.getData().get(index);
|
|
} // getServerBySort
|
|
|
|
// ------------------------------------------------------------------------
|
|
const Server* ServersManager::getServerByID (uint32_t id) const
|
|
{
|
|
MutexLocker(m_mapped_servers);
|
|
return m_mapped_servers.getData().at(id);
|
|
} // getServerByID
|
|
|
|
// ------------------------------------------------------------------------
|
|
Server* ServersManager::getJoinedServer() const
|
|
{
|
|
return m_joined_server.getAtomic();
|
|
} // getJoinedServer
|
|
|
|
// ------------------------------------------------------------------------
|
|
void ServersManager::sort(bool sort_desc)
|
|
{
|
|
MutexLocker(m_sorted_servers);
|
|
m_sorted_servers.getData().insertionSort(0, sort_desc);
|
|
} // sort
|
|
|
|
} // namespace Online
|