ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Deprecated old internet access method. Adapted my servers_manager and users to the new system.

Browse Source 
git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/branches/uni@13310 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
unitraxx 2013-07-21 17:41:02 +00:00
parent af12be28fa
commit 8360c06b15
16 changed files with 173 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sources.cmake
View File

@ -146,7 +146,6 @@ src/network/race_info_message.cpp
src/network/race_result_message.cpp
src/network/race_state.cpp
src/online/current_user.cpp
src/online/http_connector.cpp
src/online/http_manager.cpp
src/online/messages.cpp
src/online/request.cpp
@ -418,8 +417,6 @@ src/network/race_state.hpp
src/network/remote_kart_info.hpp
src/network/world_loaded_message.hpp
src/online/current_user.hpp
src/online/http_connector.hpp
src/online/http_listener.hpp
src/online/http_manager.hpp
src/online/messages.hpp
src/online/request.hpp

8
src/guiengine/widgets/list_widget.cpp
View File

@ -253,6 +253,14 @@ void ListWidget::renameItem(const int row_index, const irr::core::stringw newNam
renameCell(row_index, 0, newName, icon);
}
// -----------------------------------------------------------------------------
void ListWidget::renameItem(const std::string & internal_name, const irr::core::stringw newName, const int icon)
{
CGUISTKListBox* list = getIrrlichtElement<CGUISTKListBox>();
assert(list != NULL);
renameCell(list->getRowByInternalName(internal_name), 0, newName, icon);
}
// -----------------------------------------------------------------------------
std::string ListWidget::getSelectionInternalName()

1
src/guiengine/widgets/list_widget.hpp
View File

@ -178,6 +178,7 @@ namespace GUIEngine
* renames first cell only
*/
void renameItem(const int row_num, const irr::core::stringw newName, const int icon=-1);
void renameItem(const std::string & internal_name, const irr::core::stringw newName, const int icon=-1);
/**
* \brief rename an item and/or change its icon based on its internal name

11
src/online/current_user.cpp
View File

@ -22,7 +22,6 @@
#include <sstream>
#include <stdlib.h>
#include <assert.h>
#include "online/http_connector.hpp"
#include "config/user_config.hpp"
#include "utils/translation.hpp"
#include "utils/log.hpp"
@ -30,14 +29,6 @@
namespace Online{
static Synchronised<CurrentUser*> user_singleton(NULL);
CurrentUser* CurrentUser::get()
{
CurrentUser* user = user_singleton.getData();
if (user == NULL)
user = new CurrentUser();
return user;
} // get
CurrentUser* CurrentUser::acquire()
{
user_singleton.lock();
@ -97,8 +88,10 @@ namespace Online{
CurrentUser::SignInRequest * CurrentUser::requestSavedSession()
{
SignInRequest * request = NULL;
Log::info("CurrentUser::requestSavedSession","1");
if(m_state != US_SIGNED_IN && UserConfigParams::m_saved_session)
{
Log::info("CurrentUser::requestSavedSession","2");
request = new SignInRequest();
request->setURL((std::string)UserConfigParams::m_server_multiplayer + "client-user.php");
request->setParameter("action",std::string("saved-session"));

12
src/online/current_user.hpp
View File

@ -90,10 +90,12 @@ namespace Online{
CurrentUser();
public:
static CurrentUser* get(); //FIXME To be removed
void signIn (const SignInRequest * input);
void signOut (const SignOutRequest * input);
void createServer (const ServerCreationRequest * input);
//Singleton methods
public:
//Singleton
static CurrentUser* acquire();
static void release();
static void deallocate();
@ -114,10 +116,6 @@ namespace Online{
const irr::core::stringw &email,
bool terms);
void signIn (const SignInRequest * input);
void signOut (const SignOutRequest * input);
void createServer (const ServerCreationRequest * input);
/** Returns the username if signed in. */
irr::core::stringw getUserName() const;
bool isSignedIn() const { return m_state == US_SIGNED_IN; }

88
src/online/http_connector.cpp
View File

@ -1,88 +0,0 @@
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2013 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 "http_connector.hpp"
#include <iostream>
#include <stdio.h>
#include <memory.h>
#include "io/file_manager.hpp"
HTTPConnector::HTTPConnector(const std::string &url){
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(!curl)
Log::error("online/http_functions", "Error while loading cURL library.");
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
if (url.substr(0, 5)!="http:")
{
Log::error("online/http_functions", "Invalid URL.");
}
}
// ============================================================================
HTTPConnector::~HTTPConnector(){
curl_easy_cleanup(curl);
curl_global_cleanup();
}
// ============================================================================
static size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
{
((std::string*)userp)->append((char*)contents, size * nmemb);
return size * nmemb;
}
XMLNode * HTTPConnector::getXMLFromPage()
{
return file_manager->createXMLTreeFromString(getPage());
}
std::string HTTPConnector::getPage()
{
Parameters::iterator iter;
std::string postString = "";
for (iter = m_parameters.begin(); iter != m_parameters.end(); ++iter)
{
if(iter != m_parameters.begin())
postString.append("&");
char * escaped = curl_easy_escape(this->curl , iter->first.c_str(), iter->first.size());
postString.append(escaped);
curl_free(escaped);
postString.append("=");
escaped = curl_easy_escape(this->curl , iter->second.c_str(), iter->second.size());
postString.append(escaped);
curl_free(escaped);
}
curl_easy_setopt(this->curl, CURLOPT_POSTFIELDS, postString.c_str());
std::string readBuffer;
curl_easy_setopt(this->curl, CURLOPT_WRITEFUNCTION, WriteCallback);
curl_easy_setopt(this->curl, CURLOPT_FILE, &readBuffer);
res = curl_easy_perform(this->curl);
if(res != CURLE_OK)
Log::error("online/http_functions", "curl_easy_perform() failed: %s", curl_easy_strerror(res));
else
Log::info("online/http_functions", "Received : %s", readBuffer.c_str());
m_parameters.clear();
return readBuffer;
}

66
src/online/http_connector.hpp
View File

@ -1,66 +0,0 @@
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2013 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 HTTP_CONNECTOR_HPP
#define HTTP_CONNECTOR_HPP
#include <string>
#include "io/xml_node.hpp"
#include <curl/curl.h>
#include <irrString.h>
#include "utils/string_utils.hpp"
/**
* \brief Class to connect with a server over HTTP
* \ingroup online
*/
class HTTPConnector
{
protected:
CURL *curl;
CURLcode res;
typedef std::map<std::string, std::string> Parameters;
Parameters m_parameters;
public:
HTTPConnector(const std::string &url);
~HTTPConnector();
//Execute
std::string getPage();
XMLNode * getXMLFromPage();
//Setting parameters to be send with the next request
void setParameter(const std::string & name, const std::string &value){
m_parameters[name] = value;
};
void setParameter(const std::string & name, const irr::core::stringw &value){
m_parameters[name] = irr::core::stringc(value.c_str()).c_str();
}
template <typename T>
void setParameter(const std::string & name, const T& value){
m_parameters[name] = StringUtils::toString(value);
}
}; //class HTTPConnector
#endif // HTTP_CONNECTOR_HPP
/*EOF*/

7
src/online/messages.cpp
View File

@ -58,6 +58,13 @@ namespace Online
return irr::core::stringw(_("Creating server")) + loadingDots();
}
// ------------------------------------------------------------------------
irr::core::stringw fetchingServers()
{
return irr::core::stringw(_("Fetching servers")) + loadingDots();
}
// ------------------------------------------------------------------------
irr::core::stringw loadingDots(bool spaces, float interval, int max_dots)
{

3
src/online/messages.hpp
View File

@ -29,9 +29,10 @@ namespace Online
irr::core::stringw loadingDots (bool spaces = true, float interval = 0.5f, int max_dots = 3);
irr::core::stringw signingIn ();
irr::core::stringw signingOut ();
irr::core::stringw signingUp ();
irr::core::stringw signingUp ();
irr::core::stringw joiningServer ();
irr::core::stringw creatingServer ();
irr::core::stringw fetchingServers ();
irr::core::stringw signedInAs (const irr::core::stringw & name);
} // namespace Messages
}// namespace Online

83
src/online/servers_manager.cpp
View File

@ -22,56 +22,87 @@
#include <string>
#include <irrString.h>
#include <assert.h>
#include "online/http_connector.hpp"
#include "config/user_config.hpp"
#include "utils/translation.hpp"
#include "utils/time.hpp"
#define SERVER_REFRESH_INTERVAL 5.0f
namespace Online{
static ServersManager* user_singleton = NULL;
static Synchronised<ServersManager*> manager_singleton(NULL);
ServersManager* ServersManager::get()
ServersManager* ServersManager::acquire()
{
if (user_singleton == NULL)
user_singleton = new ServersManager();
return user_singleton;
} // get
manager_singleton.lock();
ServersManager * manager = manager_singleton.getData();
if (manager == NULL)
{
manager_singleton.unlock();
manager = new ServersManager();
manager_singleton.setAtomic(manager);
manager_singleton.lock();
}
return manager;
}
void ServersManager::release()
{
manager_singleton.unlock();
}
void ServersManager::deallocate()
{
delete user_singleton;
user_singleton = NULL;
manager_singleton.lock();
ServersManager* manager = manager_singleton.getData();
delete manager;
manager = NULL;
manager_singleton.unlock();
} // deallocate
// ============================================================================
ServersManager::ServersManager(){
m_servers = new PtrVector<Server>;
refresh();
m_info_message = "";
m_last_load_time = 0.0f;
}
// ============================================================================
void ServersManager::refresh()
ServersManager::RefreshRequest * ServersManager::refreshRequest()
{
HTTPConnector * connector = new HTTPConnector((std::string)UserConfigParams::m_server_multiplayer + "client-user.php");
connector->setParameter("action",std::string("get_server_list"));
const XMLNode * result = connector->getXMLFromPage();
std::string rec_success = "";
if(result->get("success", &rec_success))
RefreshRequest * request = NULL;
if(Time::getRealTime() - m_last_load_time > SERVER_REFRESH_INTERVAL)
{
if (rec_success =="yes")
{
const XMLNode * servers_xml = result->getNode("servers");
m_servers->clearAndDeleteAll();
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
{
m_servers->push_back(new Server(*servers_xml->getNode(i)));
}
}
request = new RefreshRequest();
request->setURL((std::string)UserConfigParams::m_server_multiplayer + "client-user.php");
request->setParameter("action",std::string("get_server_list"));
HTTPManager::get()->addRequest(request);
}
return request;
}
void ServersManager::refresh(const RefreshRequest * input)
{
if (input->isSuccess())
{
const XMLNode * servers_xml = input->getResult()->getNode("servers");
m_servers->clearAndDeleteAll();
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
{
m_servers->push_back(new Server(*servers_xml->getNode(i)));
}
m_last_load_time += Time::getRealTime();
}
m_info_message = input->getInfo();
//FIXME error message
}
void ServersManager::RefreshRequest::callback()
{
ServersManager::acquire()->refresh(this);
ServersManager::release();
}
// ============================================================================
Server * ServersManager::getQuickPlay()
{

55
src/online/servers_manager.hpp
View File

@ -17,10 +17,12 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef HEADER_SERVERS_MANAGER_HPP
#define HEADER_CURRENT_ONLINE_USER_HPP
#define HEADER_SERVERS_MANAGER_HPP
#include "utils/ptr_vector.hpp"
#include "online/server.hpp"
#include "http_manager.hpp"
namespace Online {
@ -31,26 +33,43 @@ namespace Online {
*/
class ServersManager
{
private:
ServersManager();
PtrVector<Server> * m_servers;
bool m_not_fetched;
Server * m_joined_server;
public:
enum RequestType
{
RT_REFRESH = 1
};
class RefreshRequest : public XMLRequest
{
virtual void callback ();
public:
// singleton
static ServersManager* get();
static void deallocate();
RefreshRequest() : XMLRequest(RT_REFRESH) {}
};
void refresh();
PtrVector<Server> * getServers () const { return m_servers; };
int getNumServers () const { return m_servers->size(); };
Server * getServer (int index) const { return m_servers->get(index);};
void sort(bool sort_desc) { m_servers->insertionSort(0, sort_desc); };
void setJoinedServer(Server * server){ m_joined_server = server;};
Server * getJoinedServer(){ return m_joined_server;};
//Returns the best server to join
Server * getQuickPlay();
private:
ServersManager();
PtrVector<Server> * m_servers;
bool m_not_fetched;
Server * m_joined_server;
irr::core::stringw m_info_message;
float m_last_load_time;
void refresh(const RefreshRequest * input);
public:
// Singleton
static ServersManager* acquire();
static void release();
static void deallocate();
RefreshRequest * refreshRequest();
PtrVector<Server> * getServers () const { return m_servers; }
int getNumServers () const { return m_servers->size(); }
Server * getServer (int index) const { return m_servers->get(index); }
void sort(bool sort_desc) { m_servers->insertionSort(0, sort_desc); }
void setJoinedServer(Server * server){ m_joined_server = server; }
Server * getJoinedServer() { return m_joined_server; }
//Returns the best server to join
Server * getQuickPlay();
}; // class ServersManager

3
src/states_screens/networking_lobby.cpp
View File

@ -46,7 +46,8 @@ DEFINE_SCREEN_SINGLETON( NetworkingLobby );
NetworkingLobby::NetworkingLobby() : Screen("online/lobby.stkgui")
{
m_server = ServersManager::get()->getJoinedServer();
m_server = ServersManager::acquire()->getJoinedServer();
ServersManager::release();
} // NetworkingLobby
// ----------------------------------------------------------------------------

6
src/states_screens/networking_lobby_settings.cpp
View File

@ -68,12 +68,6 @@ void NetworkingLobbySettings::loadedFromFile()
} // loadedFromFile
// ----------------------------------------------------------------------------
bool NetworkingLobbySettings::hasLostConnection()
{
return !CurrentUser::get()->isSignedIn();
}
// ----------------------------------------------------------------------------
void NetworkingLobbySettings::beforeAddingWidget()
{

2
src/states_screens/networking_lobby_settings.hpp
View File

@ -46,8 +46,6 @@ private:
GUIEngine::ButtonWidget * m_create_widget;
GUIEngine::ButtonWidget * m_cancel_widget;
/** \brief Checks if the user is still signed in. */
bool hasLostConnection();
/** \brief Sets which widget has to be focused. Depends on the user state. */
void setInitialFocus();

85
src/states_screens/server_selection.cpp
View File

@ -21,13 +21,13 @@
#include <assert.h>
#include "guiengine/modaldialog.hpp"
#include "guiengine/widget.hpp"
#include "states_screens/dialogs/message_dialog.hpp"
#include "states_screens/dialogs/server_info_dialog.hpp"
#include "states_screens/state_manager.hpp"
#include "utils/translation.hpp"
#include "utils/string_utils.hpp"
#include "online/servers_manager.hpp"
#include "online/messages.hpp"
#include "audio/sfx_manager.hpp"
using namespace Online;
@ -38,14 +38,34 @@ DEFINE_SCREEN_SINGLETON( ServerSelection );
ServerSelection::ServerSelection() : Screen("online/server_selection.stkgui")
{
m_selected_index = -1;
m_reload_timer = 0.0f;
m_refresh_request = NULL;
} // ServerSelection
// ----------------------------------------------------------------------------
ServerSelection::~ServerSelection()
{
delete m_refresh_request;
} // ServerSelection
// ----------------------------------------------------------------------------
void ServerSelection::refresh()
{
m_refresh_request = ServersManager::acquire()->refreshRequest();
ServersManager::release();
m_server_list_widget->clear();
m_server_list_widget->addItem("spacer", L"");
m_server_list_widget->addItem("loading", Messages::fetchingServers());
}
// ----------------------------------------------------------------------------
void ServerSelection::loadedFromFile()
{
m_back_widget = getWidget<GUIEngine::IconButtonWidget>("back");
m_reload_widget = getWidget<GUIEngine::IconButtonWidget>("reload");
@ -68,40 +88,24 @@ void ServerSelection::beforeAddingWidget()
void ServerSelection::init()
{
Screen::init();
m_reloading = false;
m_sort_desc = true;
m_reload_widget->setActivated();
// Set the default sort order
Server::setSortOrder(Server::SO_NAME);
loadList();
refresh();
} // init
// ----------------------------------------------------------------------------
void ServerSelection::unloaded()
{
}
// ----------------------------------------------------------------------------
void ServerSelection::tearDown()
{
}
// ----------------------------------------------------------------------------
/** Loads the list of all servers. The gui element will be
* updated.
* \param type Must be 'kart' or 'track'.
*/
void ServerSelection::loadList(bool refresh)
void ServerSelection::loadList()
{
m_server_list_widget->clear();
ServersManager * manager = ServersManager::get();
if (refresh)
manager->refresh();
ServersManager * manager = ServersManager::acquire();
manager->sort(m_sort_desc);
for(int i=0; i < manager->getNumServers(); i++)
{
Server * server = manager->getServer(i);
@ -114,7 +118,7 @@ void ServerSelection::loadList(bool refresh)
row->push_back(new GUIEngine::ListWidget::ListCell(num_players,-1,1,true));
m_server_list_widget->addItem("server", row);
}
ServersManager::release();
} // loadList
// ----------------------------------------------------------------------------
@ -143,19 +147,14 @@ void ServerSelection::eventCallback( GUIEngine::Widget* widget,
else if (name == "reload")
{
if (!m_reloading)
{
m_reloading = true;
m_server_list_widget->clear();
m_server_list_widget->addItem("spacer", L"");
m_server_list_widget->addItem("loading", _("Please wait while the list is being updated."));
}
refresh();
}
else if (name == m_server_list_widget->m_properties[GUIEngine::PROP_ID])
{
m_selected_index = m_server_list_widget->getSelectionID();
new ServerInfoDialog(ServersManager::get()->getServer(m_selected_index));
new ServerInfoDialog(ServersManager::acquire()->getServer(m_selected_index));
ServersManager::release();
}
} // eventCallback
@ -180,18 +179,26 @@ void ServerSelection::setLastSelected()
void ServerSelection::onUpdate(float dt, irr::video::IVideoDriver*)
{
m_reload_timer += dt;
if (m_reloading)
if(m_refresh_request != NULL)
{
m_reloading = false;
if(m_reload_timer > 5000.0f)
if(m_refresh_request->isDone())
{
loadList(true);
m_reload_timer = 0.0f;
if(m_refresh_request->isSuccess())
{
loadList();
}
else
{
sfx_manager->quickSound( "anvil" );
new MessageDialog(m_refresh_request->getInfo());
}
delete m_refresh_request;
m_refresh_request = NULL;
//m_options_widget->setActivated();
}
else
{
loadList(false);
m_server_list_widget->renameItem("loading", Messages::fetchingServers());
}
}
} // onUpdate

17
src/states_screens/server_selection.hpp
View File

@ -19,10 +19,8 @@
#define HEADER_SERVER_SELECTION_HPP
#include "guiengine/screen.hpp"
#include "guiengine/widgets/label_widget.hpp"
#include "guiengine/widgets/ribbon_widget.hpp"
#include "guiengine/widgets/list_widget.hpp"
#include "guiengine/widgets/icon_button_widget.hpp"
#include "guiengine/widgets.hpp"
#include "online/servers_manager.hpp"
namespace GUIEngine { class Widget; }
@ -38,6 +36,7 @@ class ServerSelection : public GUIEngine::Screen,
private:
ServerSelection();
~ServerSelection();
GUIEngine::IconButtonWidget * m_back_widget;
GUIEngine::IconButtonWidget * m_reload_widget;
@ -51,23 +50,20 @@ private:
* addons_loading is being displayed. */
int m_selected_index;
bool m_reloading;
/** \brief To check (and set) if sort order is descending **/
bool m_sort_desc;
float m_reload_timer;
Online::ServersManager::RefreshRequest * m_refresh_request;
void refresh();
public:
/** Load the addons into the main list.*/
void loadList(bool refresh = false);
void loadList();
/** \brief implement callback from parent class GUIEngine::Screen */
virtual void loadedFromFile() OVERRIDE;
virtual void unloaded() OVERRIDE;
/** \brief implement callback from parent class GUIEngine::Screen */
virtual void eventCallback(GUIEngine::Widget* widget, const std::string& name,
const int playerID) OVERRIDE;
@ -78,7 +74,6 @@ public:
virtual void onColumnClicked(int columnId);
virtual void init() OVERRIDE;
virtual void tearDown() OVERRIDE;
/** \brief implement callback from parent class GUIEngine::Screen */
virtual void onUpdate(float dt, irr::video::IVideoDriver*) OVERRIDE;