Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

807 lines
26 KiB

//========= Copyright (C) 1996-2013, Valve Corporation, All rights reserved. ============//
//
// Purpose: Helper for access to news
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "gc_clientsystem.h"
#include "filesystem.h"
#include "workshop/ugc_utils.h"
#include "econ/econ_controls.h"
#include "ienginevgui.h"
#include "vgui/ISystem.h"
#include "vgui_controls/ImagePanel.h"
#include "vgui_bitmapimage.h"
#include "bitmap/bitmap.h"
#include "imageutils.h"
#include "tier2/fileutils.h"
#include "checksum_sha1.h"
//#include "matchmaking/imatchframework.h"
//#include "engine/inetsupport.h"
#include "rtime.h"
#include "tf_streams.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
// GC hello information
//extern CMsgGCCStrike15_v2_MatchmakingGC2ClientHello g_GC2ClientHello;
ConVar cl_streams_request_url( "cl_streams_request_url",
"https://api.twitch.tv/kraken/streams?game=Team%20Fortress%202&limit=5"
, FCVAR_DEVELOPMENTONLY, "Number of streams requested for display" );
ConVar cl_streams_request_accept( "cl_streams_request_accept", "application/vnd.twitchtv.v3+json", FCVAR_DEVELOPMENTONLY, "Header for api request" );
ConVar cl_streams_image_sfurl( "cl_streams_image_sfurl",
"img://loadjpeg:(320x200):"
, FCVAR_DEVELOPMENTONLY, "Format of Scaleform image representing the stream" );
ConVar cl_streams_request_count( "cl_streams_request_count", "6", FCVAR_DEVELOPMENTONLY, "How many streams are displayed in main menu" );
ConVar cl_streams_refresh_interval( "cl_streams_refresh_interval", "60", FCVAR_DEVELOPMENTONLY, "How often to refresh streams list" );
ConVar cl_streams_write_response_file( "cl_streams_write_response_file", "", FCVAR_DEVELOPMENTONLY, "When set will save streams info file for diagnostics" );
ConVar cl_streams_override_global_version( "cl_streams_override_global_version", "", FCVAR_DEVELOPMENTONLY, "When set will override global API version" );
ConVar cl_streams_mytwitchtv_nolink( "cl_streams_mytwitchtv_nolink", "https://www.twitch.tv/settings/connections", FCVAR_DEVELOPMENTONLY, "Twitch.tv account linking URL" );
ConVar cl_streams_mytwitchtv_channel( "cl_streams_mytwitchtv_channel", "https://www.twitch.tv/", FCVAR_DEVELOPMENTONLY, "Twitch.tv account channel URL" );
static const char *s_pszCacheImagePath = "streams";
//////////////////////////////////////////////////////////////////////////
//
// Files downloader
//
class CHelperStreamDownloadUrlToLocalFile;
static CUtlVector< CHelperStreamDownloadUrlToLocalFile * > s_arrDeleteCHelperStreamDownloadUrlToLocalFile;
class CHelperStreamDownloadUrlToLocalFile
{
public:
CHelperStreamDownloadUrlToLocalFile( char const *szUrlGet, char const *szLocalFile, long lTimeStampLocal, CTFStreamPanel *pStreamPanel )
{
m_sUrlGet = szUrlGet;
m_sLocalFile = szLocalFile;
m_lTimestampLocal = lTimeStampLocal;
m_hHTTPRequestHandle = steamapicontext->SteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, m_sUrlGet.Get() );
SteamAPICall_t hCall = NULL;
if ( m_hHTTPRequestHandle && steamapicontext->SteamHTTP()->SendHTTPRequest( m_hHTTPRequestHandle, &hCall ) && hCall )
{
m_CallbackOnHTTPRequestCompleted.Set( hCall, this, &CHelperStreamDownloadUrlToLocalFile::Steam_OnHTTPRequestCompleted );
}
else
{
if ( m_hHTTPRequestHandle )
steamapicontext->SteamHTTP()->ReleaseHTTPRequest( m_hHTTPRequestHandle );
m_hHTTPRequestHandle = NULL;
}
m_hStreamPanel = pStreamPanel;
}
private:
CUtlString m_sUrlGet;
CUtlString m_sLocalFile;
long m_lTimestampLocal;
HTTPRequestHandle m_hHTTPRequestHandle;
CCallResult< CHelperStreamDownloadUrlToLocalFile, HTTPRequestCompleted_t > m_CallbackOnHTTPRequestCompleted;
DHANDLE<CTFStreamPanel> m_hStreamPanel;
void Steam_OnHTTPRequestCompleted( HTTPRequestCompleted_t *p, bool bError )
{
if ( !m_hHTTPRequestHandle || ( p->m_hRequest != m_hHTTPRequestHandle ) )
return;
uint32 unBytes = 0;
if ( !bError && p && steamapicontext->SteamHTTP()->GetHTTPResponseBodySize( p->m_hRequest, &unBytes ) && unBytes != 0 )
{
DevMsg( "Request for '%s' succeeded (code: %u, size: %u)...\n", m_sUrlGet.Get(), p ? p->m_eStatusCode : 0, unBytes );
CUtlBuffer bufFile;
bufFile.EnsureCapacity( unBytes );
if ( steamapicontext->SteamHTTP()->GetHTTPResponseBodyData( p->m_hRequest,(uint8*)bufFile.Base(), unBytes ) )
{
bufFile.SeekPut( bufFile.SEEK_HEAD, unBytes );
g_pFullFileSystem->WriteFile( m_sLocalFile.Get(), "GAME", bufFile );
UGC_SetFileTime( m_sLocalFile.Get(), m_lTimestampLocal );
}
if ( m_hStreamPanel.Get() )
{
m_hStreamPanel.Get()->InvalidateLayout();
}
}
else
{
DevMsg( "Request for '%s' failed '%s' (code: %u, size: %u)...\n", m_sUrlGet.Get(), bError ? "error" : "ok", p ? p->m_eStatusCode : 0, unBytes );
}
steamapicontext->SteamHTTP()->ReleaseHTTPRequest( p->m_hRequest );
m_hHTTPRequestHandle = NULL;
s_arrDeleteCHelperStreamDownloadUrlToLocalFile.AddToTail( this );
}
};
//////////////////////////////////////////////////////////////////////////
//
// Helper functions
//
static long Helper_ParseUpdatedTimestamp( char const *pchParseUpdatedAt )
{
// Twitch.tv format: "2013-03-04T05:27:27Z"
return CRTime::RTime32FromRFC3339UTCString( pchParseUpdatedAt );
}
static void Helper_ConfigureStreamInfoPreviewImages( CStreamInfo &info, CTFStreamPanel *pStreamPanel )
{
// store global name for the info in the panel to ask for it when the image is ready to be displayed
pStreamPanel->SetGlobalName( info.m_sGlobalName );
char chPreviewImageLocal[ 2*MAX_PATH + 1 ] = {};
char *pchLocalCur = chPreviewImageLocal, *pchLocalEnd = chPreviewImageLocal + Q_ARRAYSIZE( chPreviewImageLocal ) - 1;
for ( char const *pch = info.m_sPreviewImage.Get(); *pch; ++ pch )
{
if ( pchLocalEnd - pchLocalCur < 4 )
break;
if ( ( ( pch[0] >= 'a' ) && ( pch[0] <= 'z' ) ) ||
( ( pch[0] >= 'A' ) && ( pch[0] <= 'Z' ) ) ||
( ( pch[0] >= '0' ) && ( pch[0] <= '9' ) ) ||
( pch[0] == '-' ) || ( pch[0] == '.' ) )
{
* ( pchLocalCur ++ ) = *pch;
}
else
{
* ( pchLocalCur ++ ) = '_';
int iHigh = ( ( ( unsigned char )( *pch ) & 0xF0u ) >> 4 ) & 0xF;
if ( iHigh >= 0 && iHigh <= 9 )
* ( pchLocalCur ++ ) = '0' + iHigh;
else
* ( pchLocalCur ++ ) = 'A' + iHigh;
int iLow = ( ( ( unsigned char )( *pch ) & 0xFu ) );
if ( iLow >= 0 && iLow <= 9 )
* ( pchLocalCur ++ ) = '0' + iLow;
else if ( iLow >= 10 && iLow <= 15 )
* ( pchLocalCur ++ ) = 'A' + iLow - 10;
* ( pchLocalCur ++ ) = '_';
}
}
if ( chPreviewImageLocal[0] )
{
// We might need to download the file, so make sure directory structure is valid
static bool s_bCreateDirHierarchyDone = false;
if ( !s_bCreateDirHierarchyDone )
{
s_bCreateDirHierarchyDone = true;
// Cleanup old cached files
if ( long lDirectoryTime = g_pFullFileSystem->GetFileTime( s_pszCacheImagePath, "GAME" ) )
{
FileFindHandle_t hFind = NULL;
int numRemove = 0;
for ( char const *szFileName = g_pFullFileSystem->FindFirst( CFmtStr( "%s/*", s_pszCacheImagePath ), &hFind );
szFileName && *szFileName; szFileName = g_pFullFileSystem->FindNext( hFind ) )
{
if ( !Q_strcmp( ".", szFileName ) || !Q_strcmp( "..", szFileName ) ) continue;
CFmtStr fmtFilename( "%s/%s", s_pszCacheImagePath, szFileName );
long lFileTime = g_pFullFileSystem->GetFileTime( fmtFilename, "GAME" );
if ( ( lFileTime >= lDirectoryTime - 72*3600 ) && ( lFileTime <= lDirectoryTime + 72*3600 ) )
{
// DevMsg( "Keeping file %s (%u : %u)\n", fmtFilename.Access(), lFileTime, lDirectoryTime );
continue;
}
else
{
++ numRemove;
g_pFullFileSystem->RemoveFile( fmtFilename, "GAME" );
}
}
DevMsg( 2, "Streams preview cache evicted %u files\n", numRemove );
g_pFullFileSystem->FindClose( hFind );
}
g_pFullFileSystem->CreateDirHierarchy( s_pszCacheImagePath, "GAME" );
}
//
// Work with the file cache
//
CFmtStr fmtLocalFile( "%s/%s", s_pszCacheImagePath, chPreviewImageLocal );
info.m_sPreviewImageLocalFile = fmtLocalFile.Access();
CFmtStr fmtPreviewSF( "%sstreams/%s", cl_streams_image_sfurl.GetString(), chPreviewImageLocal );
info.m_sPreviewImageSF = fmtPreviewSF.Access();
// See if we need to download that file
long lFileTime = g_pFullFileSystem->GetFileTime( fmtLocalFile.Access(), "GAME" );
// Parse "updated_at" attribute:
long lUpdatedAtStamp = Helper_ParseUpdatedTimestamp( info.m_sUpdatedAtStamp.Get() );
if ( lFileTime != lUpdatedAtStamp )
{
// Redownload the file
DevMsg( 2, "%s -- Requesting download of preview image (%ld != %ld): %s -> %s\n", info.m_sGlobalName.Get(), lFileTime, lUpdatedAtStamp, info.m_sPreviewImage.Get(), info.m_sPreviewImageLocalFile.Get() );
new CHelperStreamDownloadUrlToLocalFile( info.m_sPreviewImage.Get(), info.m_sPreviewImageLocalFile.Get(), lUpdatedAtStamp, pStreamPanel );
}
else
{
DevMsg( 2, "%s -- Preview image is up to date (%ld): %s -> %s\n", info.m_sGlobalName.Get(), lUpdatedAtStamp, info.m_sPreviewImage.Get(), info.m_sPreviewImageLocalFile.Get() );
pStreamPanel->InvalidateLayout();
}
}
else
{
DevMsg( 2, "%s -- No preview image\n", info.m_sGlobalName.Get() );
info.m_sPreviewImageSF = cl_streams_image_sfurl.GetString();
}
}
//////////////////////////////////////////////////////////////////////////
//
//
static CTFStreamManager g_streamManager;
CTFStreamManager* StreamManager()
{
return &g_streamManager;
}
CTFStreamManager::CTFStreamManager()
{
m_dblTimeStampLastUpdate = 0;
m_hHTTPRequestHandle = NULL;
m_hHTTPRequestHandleTwitchTv = NULL;
m_pLoadingAccount = NULL;
}
CTFStreamManager::~CTFStreamManager()
{
m_vecTwitchTvAccounts.PurgeAndDeleteElements();
}
bool CTFStreamManager::Init()
{
RequestTopStreams();
return true;
}
void CTFStreamManager::Update( float frametime )
{
// Cleanup downloaders
if ( s_arrDeleteCHelperStreamDownloadUrlToLocalFile.Count() )
{
FOR_EACH_VEC( s_arrDeleteCHelperStreamDownloadUrlToLocalFile, iDownloader )
{
delete s_arrDeleteCHelperStreamDownloadUrlToLocalFile[iDownloader];
}
s_arrDeleteCHelperStreamDownloadUrlToLocalFile.RemoveAll();
}
UpdateTwitchTvAccounts();
}
void CTFStreamManager::RequestTopStreams()
{
// Check if it's time to update
if ( !m_dblTimeStampLastUpdate || ( Plat_FloatTime() - m_dblTimeStampLastUpdate > cl_streams_refresh_interval.GetFloat() ) )
{
m_dblTimeStampLastUpdate = Plat_FloatTime();
if ( !m_hHTTPRequestHandle && steamapicontext && steamapicontext->SteamHTTP() )
{
//
// Create HTTP download job
//
m_hHTTPRequestHandle = steamapicontext->SteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, cl_streams_request_url.GetString() );
steamapicontext->SteamHTTP()->SetHTTPRequestHeaderValue( m_hHTTPRequestHandle, "Accept", cl_streams_request_accept.GetString() );
steamapicontext->SteamHTTP()->SetHTTPRequestHeaderValue( m_hHTTPRequestHandle, "Client-ID", "b7816vx0i8sng8bwy9es0dirdcsy3im" );
DevMsg( "Requesting twitch.tv streams update...\n" );
SteamAPICall_t hCall = NULL;
if ( m_hHTTPRequestHandle && steamapicontext->SteamHTTP()->SendHTTPRequest( m_hHTTPRequestHandle, &hCall ) && hCall )
{
m_CallbackOnHTTPRequestCompleted.Set( hCall, this, &CTFStreamManager::Steam_OnHTTPRequestCompletedStreams );
}
else
{
if ( m_hHTTPRequestHandle )
steamapicontext->SteamHTTP()->ReleaseHTTPRequest( m_hHTTPRequestHandle );
m_hHTTPRequestHandle = NULL;
}
}
}
}
static int Helper_SortStreamsByViewersCount( const CStreamInfo *a, const CStreamInfo *b )
{
if ( a->m_numViewers != b->m_numViewers )
return ( a->m_numViewers > b->m_numViewers ) ? -1 : 1;
return Q_stricmp( a->m_sGlobalName.Get(), b->m_sGlobalName.Get() );
}
static void Helper_ConvertLanguageToCountryCode( CUtlString &s )
{
if ( !Q_stricmp(s, "en") )
s = "gb";
}
void CTFStreamManager::Steam_OnHTTPRequestCompletedStreams( HTTPRequestCompleted_t *p, bool bError )
{
if ( !m_hHTTPRequestHandle || ( p->m_hRequest != m_hHTTPRequestHandle ) )
return;
uint32 unBytes = 0;
if ( !bError && p && steamapicontext->SteamHTTP()->GetHTTPResponseBodySize( p->m_hRequest, &unBytes ) && unBytes != 0 )
{
DevMsg( "Request for twitch.tv streams succeeded (code: %u, size: %u)...\n", p ? p->m_eStatusCode : 0, unBytes );
CUtlVector< CStreamInfo > arrStreamInfos;
CUtlBuffer bufFile;
bufFile.EnsureCapacity( unBytes );
if ( steamapicontext->SteamHTTP()->GetHTTPResponseBodyData( p->m_hRequest,(uint8*)bufFile.Base(), unBytes ) )
{
bufFile.SeekPut( bufFile.SEEK_HEAD, unBytes );
if ( cl_streams_write_response_file.GetString()[0] )
{
g_pFullFileSystem->WriteFile( cl_streams_write_response_file.GetString(), "GAME", bufFile );
}
// Parse JSON from the received file
GCSDK::CWebAPIValues *pValues = GCSDK::CWebAPIValues::ParseJSON( bufFile );
if ( pValues )
{
if ( GCSDK::CWebAPIValues *pvStreams = pValues->FindChild( "streams" ) )
{
for ( GCSDK::CWebAPIValues *pvStream = pvStreams->GetFirstChild(); pvStream; pvStream = pvStream->GetNextChild() )
{
#if 0 // this is the code to print JSON output as DevMsgs to figure out which element is where in the response
DevMsg( "----STREAM----\n" );
for ( GCSDK::CWebAPIValues *pTest = pvStream->GetFirstChild(); pTest; pTest = pTest->GetNextChild() )
{
CUtlString sValueText;
pTest->GetStringValue( sValueText );
DevMsg( "child: %s = (%u) %s\n", pTest->GetName(), pTest->GetUInt32Value(), sValueText.Get() );
for ( GCSDK::CWebAPIValues *pTest2 = pTest->GetFirstChild(); pTest2; pTest2 = pTest2->GetNextChild() )
{
pTest2->GetStringValue( sValueText );
DevMsg( " child2: %s = (%u) %s\n", pTest2->GetName(), pTest2->GetUInt32Value(), sValueText.Get() );
}
}
#endif
CStreamInfo info;
info.m_numViewers = pvStream->GetChildUInt32Value( "viewers" );
if ( GCSDK::CWebAPIValues *pChannel = pvStream->FindChild( "channel" ) )
{
pChannel->GetChildStringValue( info.m_sGlobalName, "name", "" );
pChannel->GetChildStringValue( info.m_sDisplayName, "display_name", "" );
pChannel->GetChildStringValue( info.m_sTextDescription, "status", "" );
pChannel->GetChildStringValue( info.m_sLanguage, "language", "" ); // MISSING
Helper_ConvertLanguageToCountryCode( info.m_sLanguage );
info.m_sCountry = info.m_sLanguage; // MISSING
pChannel->GetChildStringValue( info.m_sUpdatedAtStamp, "updated_at", "" );
if ( GCSDK::CWebAPIValues *pPreview = pvStream->FindChild( "preview" ) )
{
if ( pPreview->GetType() == GCSDK::k_EWebAPIValueType_String )
pPreview->GetStringValue( info.m_sPreviewImage );
else
pPreview->GetChildStringValue( info.m_sPreviewImage, "medium", "" );
}
pChannel->GetChildStringValue( info.m_sVideoFeedUrl, "url", "" );
}
if ( ( info.m_numViewers > 0 ) &&
!info.m_sGlobalName.IsEmpty() &&
!info.m_sDisplayName.IsEmpty() &&
!info.m_sTextDescription.IsEmpty() &&
!info.m_sVideoFeedUrl.IsEmpty() )
{
//DevMsg( 2, "Channel: %s (%s, %u viewers) -- %s [[%s]]\n", info.m_sGlobalName.Get(), info.m_sDisplayName.Get(), info.m_numViewers, info.m_sTextDescription.Get(), info.m_sVideoFeedUrl.Get() );
arrStreamInfos.AddToTail( info );
}
}
}
}
delete pValues;
}
if ( arrStreamInfos.Count() )
{
arrStreamInfos.Sort( Helper_SortStreamsByViewersCount );
if ( arrStreamInfos.Count() > cl_streams_request_count.GetInt() )
arrStreamInfos.SetCountNonDestructively( cl_streams_request_count.GetInt() );
m_streamInfoVec.Swap( arrStreamInfos ); // Set the new information live and notify all systems
IGameEvent *event = gameeventmanager->CreateEvent( "top_streams_request_finished" );
if ( event )
{
gameeventmanager->FireEventClientSide( event );
}
}
}
else
{
DevMsg( "Request for twitch.tv streams failed: %s (code: %u, size: %u)...\n",
bError ? "error" : "ok", p ? p->m_eStatusCode : 0, unBytes );
}
steamapicontext->SteamHTTP()->ReleaseHTTPRequest( p->m_hRequest );
m_hHTTPRequestHandle = NULL;
m_dblTimeStampLastUpdate = Plat_FloatTime(); // push the update counter to not update for a little bit
}
CStreamInfo* CTFStreamManager::GetStreamInfoByName( char const *szName )
{
if ( !szName )
return NULL;
for ( int idx = 0; idx < m_streamInfoVec.Count(); ++ idx )
{
if ( !V_strcmp( szName, m_streamInfoVec[idx].m_sGlobalName.Get() ) )
return &m_streamInfoVec[idx];
}
return NULL;
}
TwitchTvAccountInfo_t* CTFStreamManager::GetTwitchTvAccountInfo( uint64 uiSteamID )
{
TwitchTvAccountInfo_t *pInfo = NULL;
FOR_EACH_VEC( m_vecTwitchTvAccounts, i )
{
if ( m_vecTwitchTvAccounts[i]->m_uiSteamID == uiSteamID )
{
pInfo = m_vecTwitchTvAccounts[i];
// Uncomment this if we really need to keep checking twitch status
// info needs update if it's been longer than 300 secs from the last update
/*if ( pInfo->m_dblTimeStampTwitchTvUpdate && ( Plat_FloatTime() - pInfo->m_dblTimeStampTwitchTvUpdate > 300 ) )
{
m_vecTwitchTvAccounts.Remove( i );
pInfo = NULL;
}*/
break;
}
}
// add one if not already on the list
if ( !pInfo )
{
pInfo = new TwitchTvAccountInfo_t;
if ( pInfo )
{
pInfo->m_uiSteamID = uiSteamID;
pInfo->m_eTwitchTvState = k_ETwitchTvState_None;
pInfo->m_dblTimeStampTwitchTvUpdate = 0;
pInfo->m_uiTwitchTvUserId = 0;
pInfo->m_sTwitchTvChannel = cl_streams_mytwitchtv_nolink.GetString();
m_vecTwitchTvAccounts.AddToTail( pInfo );
}
}
return pInfo;
}
void CTFStreamManager::UpdateTwitchTvAccounts()
{
if ( m_pLoadingAccount )
return;
// find the new account in the list to load
FOR_EACH_VEC( m_vecTwitchTvAccounts, i )
{
if ( m_vecTwitchTvAccounts[i]->m_eTwitchTvState == k_ETwitchTvState_None )
{
m_pLoadingAccount = m_vecTwitchTvAccounts[i];
break;
}
}
// nothing needs to be loaded
if ( !m_pLoadingAccount )
return;
// When requesting a refresh reset all known linking state
m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_Loading;
m_pLoadingAccount->m_dblTimeStampTwitchTvUpdate = Plat_FloatTime();
Assert( !m_hHTTPRequestHandleTwitchTv );
if ( m_hHTTPRequestHandleTwitchTv ) return;
//
// Create HTTP download job
//
m_hHTTPRequestHandleTwitchTv = steamapicontext->SteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, CFmtStr( "http://api.twitch.tv/api/steam/%llu", m_pLoadingAccount->m_uiSteamID ) );
steamapicontext->SteamHTTP()->SetHTTPRequestHeaderValue( m_hHTTPRequestHandleTwitchTv, "Accept", cl_streams_request_accept.GetString() );
DevMsg( "Requesting twitch.tv account link...\n" );
SteamAPICall_t hCall = NULL;
if ( m_hHTTPRequestHandleTwitchTv && steamapicontext->SteamHTTP()->SendHTTPRequest( m_hHTTPRequestHandleTwitchTv, &hCall ) && hCall )
{
m_CallbackOnHTTPRequestCompletedTwitchTv.Set( hCall, this, &CTFStreamManager::Steam_OnHTTPRequestCompletedMyTwitchTv );
}
else
{
if ( m_hHTTPRequestHandleTwitchTv )
steamapicontext->SteamHTTP()->ReleaseHTTPRequest( m_hHTTPRequestHandleTwitchTv );
m_hHTTPRequestHandleTwitchTv = NULL;
}
}
void CTFStreamManager::Steam_OnHTTPRequestCompletedMyTwitchTv( HTTPRequestCompleted_t *p, bool bError )
{
if ( !m_hHTTPRequestHandleTwitchTv || ( p->m_hRequest != m_hHTTPRequestHandleTwitchTv ) )
return;
Assert( m_pLoadingAccount->m_eTwitchTvState == k_ETwitchTvState_Loading );
m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_Error;
m_pLoadingAccount->m_sTwitchTvChannel.Clear();
m_pLoadingAccount->m_uiTwitchTvUserId = 0ull;
uint32 unBytes = 0;
if ( !bError && p && steamapicontext->SteamHTTP()->GetHTTPResponseBodySize( p->m_hRequest, &unBytes ) && unBytes != 0 )
{
DevMsg( "Request for twitch.tv account link succeeded (code: %u, size: %u)...\n", p ? p->m_eStatusCode : 0, unBytes );
CUtlBuffer bufFile;
bufFile.EnsureCapacity( unBytes );
if ( steamapicontext->SteamHTTP()->GetHTTPResponseBodyData( p->m_hRequest,(uint8*)bufFile.Base(), unBytes ) )
{
bufFile.SeekPut( bufFile.SEEK_HEAD, unBytes );
if ( cl_streams_write_response_file.GetString()[0] )
{
g_pFullFileSystem->WriteFile( cl_streams_write_response_file.GetString(), "GAME", bufFile );
}
// Parse JSON from the received file
GCSDK::CWebAPIValues *pValues = GCSDK::CWebAPIValues::ParseJSON( bufFile );
if ( pValues )
{
pValues->GetChildStringValue( m_pLoadingAccount->m_sTwitchTvChannel, "name", "" );
m_pLoadingAccount->m_uiTwitchTvUserId = pValues->GetChildUInt64Value( "_id" );
if ( m_pLoadingAccount->m_sTwitchTvChannel.IsEmpty() )
{
m_pLoadingAccount->m_sTwitchTvChannel = cl_streams_mytwitchtv_nolink.GetString();
m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_NoLink;
}
else
{
m_pLoadingAccount->m_sTwitchTvChannel = CFmtStr( "%s%s", cl_streams_mytwitchtv_channel.GetString(), m_pLoadingAccount->m_sTwitchTvChannel.Get() );
m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_Linked;
}
}
delete pValues;
}
}
else
{
DevMsg( "Request for twitch.tv account link failed: %s (code: %u, size: %u)...\n",
bError ? "error" : "ok", p ? p->m_eStatusCode : 0, unBytes );
}
steamapicontext->SteamHTTP()->ReleaseHTTPRequest( p->m_hRequest );
m_hHTTPRequestHandleTwitchTv = NULL;
m_pLoadingAccount->m_dblTimeStampTwitchTvUpdate = Plat_FloatTime(); // push the update counter to not update for a little bit
// done loading
m_pLoadingAccount = NULL;
}
CTFStreamPanel::CTFStreamPanel( Panel *parent, const char *panelName ) : EditablePanel( parent, panelName )
{
vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme");
SetScheme(scheme);
m_pPreviewImage = new ImagePanel( this, "PreviewImage" );
}
void CTFStreamPanel::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "Resource/UI/StreamPanel.res" );
}
void CTFStreamPanel::PerformLayout()
{
BaseClass::PerformLayout();
UpdatePanels();
}
void CTFStreamPanel::OnCommand( const char *command )
{
if ( FStrEq( command, "stream" ) )
{
CStreamInfo *pInfo = GetStreamInfo();
if ( pInfo )
{
vgui::system()->ShellExecute( "open", CFmtStr( "%s%s", cl_streams_mytwitchtv_channel.GetString(), pInfo->m_sDisplayName.Get() ) );
}
}
else
{
BaseClass::OnCommand( command );
}
}
CStreamInfo *CTFStreamPanel::GetStreamInfo() const
{
if ( m_strStreamInfoGlobalName.IsEmpty() )
return NULL;
return g_streamManager.GetStreamInfoByName( m_strStreamInfoGlobalName.Get() );
}
void CTFStreamPanel::UpdatePanels()
{
CStreamInfo *pInfo = GetStreamInfo();
if ( pInfo )
{
SetDialogVariable( "display_name", pInfo->m_sDisplayName.Get() );
SetDialogVariable( "viewer_count", CFmtStr( "%d viewers", pInfo->m_numViewers ) );
SetDialogVariable( "text_description", pInfo->m_sTextDescription.Get() );
SetPreviewImage( pInfo->m_sPreviewImageLocalFile.Get() );
Panel* pLoadingPanel = FindChildByName( "LoadingPanel" );
if ( pLoadingPanel )
{
pLoadingPanel->SetVisible( false );
}
}
else
{
SetDialogVariable( "display_name", "" );
SetDialogVariable( "viewer_count", "" );
SetDialogVariable( "text_description", "" );
SetPreviewImage( NULL );
}
Panel* pStreamButton = FindChildByName( "Stream_URLButton" );
if ( pStreamButton )
{
pStreamButton->SetEnabled( pInfo != NULL );
}
}
void CTFStreamPanel::SetPreviewImage( const char *pszPreviewImageFile )
{
// clean up old image if there's one
m_pPreviewImage->EvictImage();
if ( !pszPreviewImageFile )
{
m_pPreviewImage->SetImage( (vgui::IImage *)0 );
return;
}
char szImageAbsPath[MAX_PATH];
if ( !GenerateFullPath( pszPreviewImageFile, "MOD", szImageAbsPath, ARRAYSIZE( szImageAbsPath ) ) )
{
Warning( "Failed to GenerateFullPath %s\n", pszPreviewImageFile );
return;
}
Bitmap_t image;
ConversionErrorType nErrorCode = ImgUtl_LoadBitmap( szImageAbsPath, image );
if ( nErrorCode != CE_SUCCESS )
{
m_pPreviewImage->SetImage( (vgui::IImage *)0 );
return;
}
int wide, tall;
BitmapImage *pBitmapImage = new BitmapImage;
pBitmapImage->SetBitmap( image );
pBitmapImage->GetSize( wide, tall );
// The ImagePanel needs to know the scaling factor for the BitmapImage, to
// center it when it's going to be rendered, and then the BitmapImage needs
// to know how big it should be rendered.
float flPanelWidthScale = static_cast<float>( m_pPreviewImage->GetWide() ) / wide;
m_pPreviewImage->SetShouldCenterImage( false );
m_pPreviewImage->SetShouldScaleImage( true );
m_pPreviewImage->SetScaleAmount( flPanelWidthScale );
float flSubRectWidthScale = static_cast<float>( wide ) / image.Width();
//float flSubRectHeightScale = static_cast<float>( tall ) / image.Height();
pBitmapImage->SetRenderSize( flSubRectWidthScale * m_pPreviewImage->GetWide(), flSubRectWidthScale * flPanelWidthScale * tall );
m_pPreviewImage->SetImage( pBitmapImage );
float flPanelHeightScale = static_cast<float>( image.Height() ) / image.Width();
m_pPreviewImage->SetSize( m_pPreviewImage->GetWide(), flPanelHeightScale * m_pPreviewImage->GetWide() );
}
CTFStreamListPanel::CTFStreamListPanel( Panel *parent, const char *panelName ) : EditablePanel( parent, panelName )
{
for ( int i=0; i<ARRAYSIZE( m_arrStreamPanels ); ++i )
{
m_arrStreamPanels[i] = new CTFStreamPanel( this, CFmtStr( "Stream%d", i + 1 ) );
}
ListenForGameEvent( "top_streams_request_finished" );
}
void CTFStreamListPanel::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "Resource/UI/StreamListPanel.res" );
}
void CTFStreamListPanel::OnThink()
{
// this will fire "top_streams_request_finished" event when the job is done
g_streamManager.RequestTopStreams();
}
void CTFStreamListPanel::OnCommand( const char *command )
{
if ( FStrEq( command, "hide_streams" ) )
{
SetVisible( false );
}
else if ( FStrEq( command, "view_more" ) )
{
vgui::system()->ShellExecute( "open", "https://www.twitch.tv/directory/game/Team%20Fortress%202" );
}
else
{
BaseClass::OnCommand( command );
}
}
void CTFStreamListPanel::FireGameEvent( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "top_streams_request_finished" ) )
{
// update each stream panel
for ( int i=0; i<ARRAYSIZE( m_arrStreamPanels ); ++i )
{
bool bVisible = i < g_streamManager.GetStreamInfoVec().Count();
m_arrStreamPanels[i]->SetVisible( bVisible );
if ( bVisible )
{
Helper_ConfigureStreamInfoPreviewImages( g_streamManager.GetStreamInfoVec()[i], m_arrStreamPanels[i] );
}
}
}
}