mirrors/winamp
Archived
1
0
Fork 0
Code
This repository has been archived on 2024-10-17. You can view files and clone it, but cannot push or open issues or pull requests.
86dabceed9
winamp/Src/Components/wac_downloadManager/wac_downloadManager.cpp

873 lines
23 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
#include <string.h>
#include <strsafe.h>
#include <iostream>
#include <cstdio>
#include <QtCore/qglobal.h>
#include <QWebEngineProfile>
#include <QtWebEngineWidgets/QtWebEngineWidgets>
#include <QWebEnginePage>
#include <QWebEngineSettings>
#include "api__wac_downloadManager.h"
#include "wac_downloadManager.h"
#include "wac_download_http_receiver_api.h"
#include "..\wac_network\wac_network_http_receiver_api.h"
#include "api/service/waservicefactory.h"
#include "../nu/threadname.h"
#include "../nu/AutoChar.h"
#include "../nu/threadpool/timerhandle.hpp"
#include "..\WAT\WAT.h"
#include "..\Winamp\buildType.h"
static const GUID internetConfigGroupGUID =
{
0xc0a565dc, 0xcfe, 0x405a, { 0xa2, 0x7c, 0x46, 0x8b, 0xc, 0x8a, 0x3a, 0x5c }
};
#define DOWNLOAD_TIMEOUT_MS 60000 // 60 second timeout
#define DOWNLOAD_SLEEP_MS 50
#define DOWNLOAD_BUFFER_SIZE 1310720 // gives a maximum download rate of 25 mb/sec per file
/**********************************************************************************
**********************************************************************************/
/**********************************************************************************
* PUBLIC *
**********************************************************************************/
wa::Components::WAC_DownloadData::WAC_DownloadData( api_wac_download_manager_http_receiver *p_http, const char *p_url, int p_flags, ifc_downloadManagerCallback *p_callback )
{
_http = p_http;
strcpy_s( this->_url, 1024, p_url );
_flags = p_flags;
_callback = p_callback;
if ( _callback )
_callback->AddRef();
_hFile = INVALID_HANDLE_VALUE;
_filepath[ 0 ] = 0;
_fileext = 0;
int download_method = ( api_downloadManager::DOWNLOADEX_MASK_DOWNLOADMETHOD & _flags );
switch ( download_method )
{
case api_downloadManager::DOWNLOADEX_TEMPFILE:
{
wchar_t temppath[ MAX_PATH - 14 ] = { 0 }; // MAX_PATH-14 'cause MSDN said so
GetTempPathW( MAX_PATH - 14, temppath );
GetTempFileNameW( temppath, L"wdl", 0, _filepath );
_hFile = CreateFileW( _filepath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, CREATE_ALWAYS, 0, 0 );
}
break;
case api_downloadManager::DOWNLOADEX_CALLBACK:
if ( _callback )
_callback->GetLocation( _filepath, MAX_PATH );
break;
}
_source[ 0 ] = 0;
_title[ 0 ] = 0;
if ( _flags & api_downloadManager::DOWNLOADEX_CALLBACK )
{
if ( _callback )
{
_callback->GetSource( _source, 1024 );
_callback->GetTitle( _title, 1024 );
}
}
_connectionStart = _lastDownloadTick = GetTickCount();
_last_status = HTTP_RECEIVER_STATUS_ERROR;
_pending = ( _flags & api_downloadManager::DOWNLOADEX_PENDING ) > 0;
}
wa::Components::WAC_DownloadData::~WAC_DownloadData()
{
ServiceRelease( _http, httpreceiverGUID2 );
_http = NULL;
if ( _fileext )
delete _fileext;
int download_method = ( api_downloadManager::DOWNLOADEX_MASK_DOWNLOADMETHOD & _flags );
if ( download_method == api_downloadManager::DOWNLOADEX_TEMPFILE && _filepath[ 0 ] )
DeleteFileW( _filepath );
if ( _callback )
_callback->Release();
_callback = NULL;
}
void wa::Components::WAC_DownloadData::Retain()
{
this->_refCount.fetch_add( 1 );
}
void wa::Components::WAC_DownloadData::Release()
{
if ( this->_refCount.fetch_sub( 1 ) == 0 )
delete this;
}
void wa::Components::WAC_DownloadData::Close( ifc_downloadManagerCallback **callbackCopy )
{
if ( _hFile != INVALID_HANDLE_VALUE )
CloseHandle( _hFile );
_hFile = INVALID_HANDLE_VALUE;
if ( callbackCopy != NULL )
{
*callbackCopy = _callback;
if ( _callback != NULL )
_callback->AddRef();
}
else if ( _callback != NULL )
{
_callback->Release();
_callback = NULL;
}
// don't want to close http here, because someone might still want to get the headers out of it
}
bool wa::Components::WAC_DownloadData::getExtention()
{
if ( _fileext && *_fileext )
return _fileext;
char l_header_name_content_type[] = "Content-Type";
char *l_content_type = _http->getheader( l_header_name_content_type );
if ( l_content_type && *l_content_type )
{
if ( _CONTENT_TYPES_EXTENSIONS.count( l_content_type ) == 1 )
_fileext = _strdup( _CONTENT_TYPES_EXTENSIONS.find( l_content_type )->second.c_str() );
}
return _fileext;
}
/**********************************************************************************
* PRIVATE *
**********************************************************************************/
/**********************************************************************************
**********************************************************************************/
/**********************************************************************************
* PUBLIC *
**********************************************************************************/
wa::Components::WAC_DownloadManager::WAC_DownloadManager( QObject *parent ) : QNetworkAccessManager( parent )
{
this->setObjectName( "DownloadManagerService" );
this->init();
}
wa::Components::WAC_DownloadManager::~WAC_DownloadManager()
{
disconnect( _connection_authentication_required );
}
DownloadToken wa::Components::WAC_DownloadManager::Download( const char *p_url, ifc_downloadManagerCallback *p_callback )
{
return DownloadEx( p_url, p_callback, api_downloadManager::DOWNLOADEX_TEMPFILE );
}
DownloadToken wa::Components::WAC_DownloadManager::DownloadEx( const char *p_url, ifc_downloadManagerCallback *p_callback, int p_flags )
{
return DownloadToken();
}
/**********************************************************************************
* PRIVATE *
**********************************************************************************/
void wa::Components::WAC_DownloadManager::init()
{
QString l_winamp_user_agent = QString( "%1 Winamp/%2" ).arg( QWebEngineProfile::defaultProfile()->httpUserAgent(), STR_WINAMP_PRODUCTVER ).replace( ",", "." );
QWebEngineProfile::defaultProfile()->setHttpUserAgent( l_winamp_user_agent );
_connection_authentication_required = connect( this, &QNetworkAccessManager::authenticationRequired, this, &wa::Components::WAC_DownloadManager::on_s_authentication_required );
}
QNetworkReply *wa::Components::WAC_DownloadManager::createRequest( Operation p_operation, const QNetworkRequest &p_request, QIODevice *p_outgoing_data )
{
return QNetworkAccessManager::createRequest( p_operation, p_request, p_outgoing_data );
}
/**********************************************************************************
* PRIVATE SLOTS *
**********************************************************************************/
void wa::Components::WAC_DownloadManager::on_s_authentication_required( QNetworkReply *p_reply, QAuthenticator *p_authenticator )
{
Q_UNUSED( p_reply );
Q_UNUSED( p_authenticator );
}
/**********************************************************************************
**********************************************************************************/
DownloadData::DownloadData( api_httpreceiver *p_http, const char *p_url, int p_flags, ifc_downloadManagerCallback *p_callback )
{
flags = p_flags;
http = p_http;
callback = p_callback;
if ( callback )
callback->AddRef();
hFile = INVALID_HANDLE_VALUE;
filepath[ 0 ] = 0;
fileext = 0;
int download_method = ( api_downloadManager::DOWNLOADEX_MASK_DOWNLOADMETHOD & flags );
switch ( download_method )
{
case api_downloadManager::DOWNLOADEX_TEMPFILE:
{
wchar_t temppath[ MAX_PATH - 14 ] = { 0 }; // MAX_PATH-14 'cause MSDN said so
GetTempPathW( MAX_PATH - 14, temppath );
GetTempFileNameW( temppath, L"wdl", 0, filepath );
hFile = CreateFileW( filepath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, CREATE_ALWAYS, 0, 0 );
}
break;
case api_downloadManager::DOWNLOADEX_CALLBACK:
if ( callback )
callback->GetLocation( filepath, MAX_PATH );
break;
}
strcpy_s( this->url, 1024, p_url );
source[ 0 ] = 0;
title[ 0 ] = 0;
if ( flags & api_downloadManager::DOWNLOADEX_CALLBACK )
{
if ( callback )
{
callback->GetSource( source, 1024 );
callback->GetTitle( title, 1024 );
}
}
connectionStart = lastDownloadTick = GetTickCount();
last_status = HTTPRECEIVER_STATUS_ERROR;
pending = ( flags & api_downloadManager::DOWNLOADEX_PENDING ) > 0;
}
DownloadData::~DownloadData()
{
ServiceRelease( http, httpreceiverGUID );
http = NULL;
if ( fileext )
delete fileext;
int download_method = ( api_downloadManager::DOWNLOADEX_MASK_DOWNLOADMETHOD & flags );
if ( download_method == api_downloadManager::DOWNLOADEX_TEMPFILE && filepath[ 0 ] )
DeleteFileW( filepath );
if ( callback )
callback->Release();
callback = NULL;
}
void DownloadData::Retain()
{
this->_refCount.fetch_add( 1 );
}
void DownloadData::Release()
{
if ( this->_refCount.fetch_sub( 1 ) == 0 )
delete this;
}
void DownloadData::Close( ifc_downloadManagerCallback **callbackCopy )
{
if ( hFile != INVALID_HANDLE_VALUE )
CloseHandle( hFile );
hFile = INVALID_HANDLE_VALUE;
if ( callbackCopy != NULL )
{
*callbackCopy = callback;
if ( callback != NULL )
callback->AddRef();
}
else if ( callback != NULL )
{
callback->Release();
callback = NULL;
}
// don't want to close http here, because someone might still want to get the headers out of it
}
bool DownloadData::getExtention()
{
if ( fileext && *fileext )
return fileext;
char l_header_name_content_type[] = "Content-Type";
char *l_content_type = http->getheader( l_header_name_content_type );
if ( l_content_type && *l_content_type )
{
if ( _CONTENT_TYPES_EXTENSIONS.count( l_content_type ) == 1 )
fileext = _strdup( _CONTENT_TYPES_EXTENSIONS.find( l_content_type )->second.c_str() );
}
return fileext;
}
/**********************************************************************************
**********************************************************************************/
/**********************************************************************************
* PUBLIC *
**********************************************************************************/
DownloadManager::DownloadManager()
{
download_thread = NULL;
killswitch = CreateEvent( NULL, TRUE, FALSE, NULL );
InitializeCriticalSection( &downloadsCS );
}
void DownloadManager::Kill()
{
SetEvent( killswitch );
if ( download_thread )
{
WaitForSingleObject( download_thread, 3000 );
CloseHandle( download_thread );
}
DeleteCriticalSection( &downloadsCS );
CloseHandle( killswitch );
}
static void SetUserAgent( api_httpreceiver *p_http )
{
char agent[ 256 ] = { 0 };
StringCchPrintfA( agent, 256, "User-Agent: %S/%S", WASABI_API_APP->main_getAppName(), WASABI_API_APP->main_getVersionNumString() );
p_http->addheader( agent );
//QString l_winamp_user_agent = QString( "User-Agent: %1 Winamp/%2" ).arg( QWebEngineProfile::defaultProfile()->httpUserAgent(), STR_WINAMP_PRODUCTVER ).replace( ",", "." );
//http->addheader( l_winamp_user_agent.toStdString().c_str() );
}
DownloadToken DownloadManager::Download( const char *url, ifc_downloadManagerCallback *callback )
{
return DownloadEx( url, callback, api_downloadManager::DOWNLOADEX_TEMPFILE );
}
DownloadToken DownloadManager::DownloadEx( const char *url, ifc_downloadManagerCallback *callback, int flags )
{
if ( InitDownloadThread() )
{
api_httpreceiver *http = NULL;
ServiceBuild( http, httpreceiverGUID );
if ( http )
{
DownloadData *downloadData = new DownloadData( http, url, flags, callback );
int use_proxy = 1;
bool proxy80 = AGAVE_API_CONFIG->GetBool( internetConfigGroupGUID, L"proxy80", false );
if ( proxy80 && strstr( url, ":" ) && ( !strstr( url, ":80/" ) && strstr( url, ":80" ) != ( url + strlen( url ) - 3 ) ) )
use_proxy = 0;
const wchar_t *proxy = use_proxy ? AGAVE_API_CONFIG->GetString( internetConfigGroupGUID, L"proxy", 0 ) : 0;
http->open( API_DNS_AUTODNS, DOWNLOAD_BUFFER_SIZE, ( proxy && proxy[ 0 ] ) ? (const char *)AutoChar( proxy ) : NULL );
SetUserAgent( http );
if ( callback )
callback->OnInit( downloadData );
if ( downloadData->flags & api_downloadManager::DOWNLOADEX_UI )
{
for ( ifc_downloadManagerCallback *l_status : status_callbacks )
l_status->OnInit( downloadData );
}
//only call http->connect when it is not pending download request
if ( !( flags & DOWNLOADEX_PENDING ) )
http->connect( url, 1 );
//http->run(); // let's get this party started
EnterCriticalSection( &downloadsCS );
downloads.push_back( downloadData );
LeaveCriticalSection( &downloadsCS );
return downloadData;
}
}
return 0;
}
void DownloadManager::ResumePendingDownload( DownloadToken p_token )
{
if ( !p_token )
return;
DownloadData *data = (DownloadData *)p_token;
if ( data->pending )
{
data->pending = false;
data->connectionStart = data->lastDownloadTick = GetTickCount();
data->http->connect( data->url );
}
}
void DownloadManager::CancelDownload( DownloadToken p_token )
{
if ( !p_token )
return;
DownloadData *data = (DownloadData *)p_token;
EnterCriticalSection( &downloadsCS );
if ( downloads.end() != std::find( downloads.begin(), downloads.end(), data ) )
{
ifc_downloadManagerCallback *callback;
data->Close( &callback );
//downloads.eraseObject(p_data);
auto it = std::find( downloads.begin(), downloads.end(), data );
if ( it != downloads.end() )
{
downloads.erase( it );
}
LeaveCriticalSection( &downloadsCS );
if ( callback )
{
callback->OnCancel( p_token );
if ( data->flags & api_downloadManager::DOWNLOADEX_UI )
{
for ( ifc_downloadManagerCallback *l_status : status_callbacks )
l_status->OnCancel( p_token );
}
callback->Release();
}
data->Release();
}
else
LeaveCriticalSection( &downloadsCS );
}
void DownloadManager::RetainDownload( DownloadToken p_token )
{
if ( !p_token )
return;
DownloadData *data = (DownloadData *)p_token;
if ( data )
data->Retain();
}
void DownloadManager::ReleaseDownload( DownloadToken p_token )
{
if ( !p_token )
return;
DownloadData *data = (DownloadData *)p_token;
if ( data )
data->Release();
}
void DownloadManager::RegisterStatusCallback( ifc_downloadManagerCallback *callback )
{
EnterCriticalSection( &downloadsCS );
status_callbacks.push_back( callback );
LeaveCriticalSection( &downloadsCS );
}
void DownloadManager::UnregisterStatusCallback( ifc_downloadManagerCallback *callback )
{
EnterCriticalSection( &downloadsCS );
auto it = std::find( status_callbacks.begin(), status_callbacks.end(), callback );
if ( it != status_callbacks.end() )
status_callbacks.erase( it );
LeaveCriticalSection( &downloadsCS );
}
bool DownloadManager::IsPending( DownloadToken token )
{
DownloadData *data = (DownloadData *)token;
if ( data )
return data->pending;
else
return FALSE;
}
/**********************************************************************************
* PRIVATE *
**********************************************************************************/
bool DownloadManager::DownloadThreadTick()
{
unsigned int i = 0;
char *downloadBuffer = (char *)malloc( DOWNLOAD_BUFFER_SIZE );
while ( WaitForSingleObject( killswitch, 0 ) != WAIT_OBJECT_0 )
{
EnterCriticalSection( &downloadsCS );
if ( downloads.empty() )
{
// TODO: might be nice to dynamically increase the sleep time if this happens
// (maybe to INFINITE and have Download() wake us?)
LeaveCriticalSection( &downloadsCS );
free( downloadBuffer );
return true;
}
if ( i >= downloads.size() )
{
LeaveCriticalSection( &downloadsCS );
free( downloadBuffer );
return true;
}
DownloadData *thisDownload = downloads[ i ];
if ( thisDownload->pending )
{
LeaveCriticalSection( &downloadsCS );
}
else
{
thisDownload->Retain();
LeaveCriticalSection( &downloadsCS );
INT tick = Tick( thisDownload, downloadBuffer, DOWNLOAD_BUFFER_SIZE );
switch ( tick )
{
case TICK_NODATA:
// do nothing
break;
case TICK_CONNECTING:
break;
case TICK_CONNECTED:
if ( thisDownload->callback )
thisDownload->callback->OnConnect( thisDownload );
if ( thisDownload->flags & api_downloadManager::DOWNLOADEX_UI )
{
for ( ifc_downloadManagerCallback *l_status : status_callbacks )
l_status->OnConnect( thisDownload );
}
break;
case TICK_SUCCESS:
if ( thisDownload->callback )
thisDownload->callback->OnTick( thisDownload );
if ( thisDownload->flags & api_downloadManager::DOWNLOADEX_UI )
{
for ( ifc_downloadManagerCallback *l_status : status_callbacks )
l_status->OnTick( thisDownload );
}
// TODO: send out update l_callback
break;
case TICK_FINISHED:
case TICK_FAILURE:
case TICK_TIMEOUT:
case TICK_CANT_CONNECT:
case TICK_WRITE_ERROR:
FinishDownload( thisDownload, tick );
break;
}
thisDownload->Release();
}
i++;
}
free( downloadBuffer );
return false; // we only get here when killswitch is set
}
int DownloadManager::DownloadTickThreadPoolFunc( HANDLE handle, void *user_data, intptr_t id )
{
DownloadManager *dlmgr = (DownloadManager *)user_data;
if ( dlmgr->DownloadThreadTick() )
{
TimerHandle t( handle );
t.Wait( DOWNLOAD_SLEEP_MS );
}
else
{
WASABI_API_THREADPOOL->RemoveHandle( 0, handle );
SetEvent( dlmgr->download_thread );
}
return 0;
}
bool DownloadManager::InitDownloadThread()
{
if ( download_thread == NULL )
{
download_thread = CreateEvent( 0, FALSE, FALSE, 0 );
TimerHandle t;
WASABI_API_THREADPOOL->AddHandle( 0, t, DownloadTickThreadPoolFunc, this, 0, api_threadpool::FLAG_LONG_EXECUTION );
t.Wait( DOWNLOAD_SLEEP_MS );
}
return ( download_thread != NULL );
}
void DownloadManager::FinishDownload( DownloadData *p_data, int code )
{
if ( p_data == NULL )
return;
ifc_downloadManagerCallback *l_callback = NULL;
EnterCriticalSection( &downloadsCS );
p_data->Close( &l_callback );
LeaveCriticalSection( &downloadsCS );
if ( l_callback != NULL )
{
if ( code == TICK_FINISHED )
{
l_callback->OnFinish( p_data );
if ( p_data->flags & api_downloadManager::DOWNLOADEX_UI )
{
for ( ifc_downloadManagerCallback *l_data : status_callbacks )
l_data->OnFinish( p_data );
}
}
else
{
l_callback->OnError( p_data, code );
if ( p_data->flags & api_downloadManager::DOWNLOADEX_UI )
{
for ( ifc_downloadManagerCallback *l_data : status_callbacks )
l_data->OnError( p_data, code );
}
}
l_callback->Release();
}
EnterCriticalSection( &downloadsCS );
auto it = std::find( downloads.begin(), downloads.end(), p_data );
if ( it != downloads.end() )
downloads.erase( it );
LeaveCriticalSection( &downloadsCS );
p_data->Release();
}
int DownloadManager::Tick( DownloadData *thisDownload, void *buffer, int bufferSize )
{
if ( !thisDownload )
return api_downloadManager::TICK_FAILURE;
int state = thisDownload->http->run();
if ( state == HTTPRECEIVER_RUN_ERROR || thisDownload == NULL )
return api_downloadManager::TICK_FAILURE;
if ( !thisDownload->fileext )
thisDownload->getExtention();
int downloaded = thisDownload->http->get_bytes( buffer, bufferSize );
if ( downloaded )
{
switch ( thisDownload->flags & DOWNLOADEX_MASK_DOWNLOADMETHOD )
{
case api_downloadManager::DOWNLOADEX_BUFFER:
{
thisDownload->buffer.reserve( thisDownload->http->content_length() );
thisDownload->buffer.add( buffer, downloaded );
}
break;
case api_downloadManager::DOWNLOADEX_TEMPFILE:
{
DWORD written = 0;
WriteFile( thisDownload->hFile, buffer, downloaded, &written, NULL );
if ( written != downloaded )
return api_downloadManager::TICK_WRITE_ERROR;
}
break;
case api_downloadManager::DOWNLOADEX_CALLBACK:
{
if ( thisDownload->flags & api_downloadManager::DOWNLOADEX_UI )
{
for ( ifc_downloadManagerCallback *l_status : status_callbacks )
l_status->OnData( thisDownload, buffer, downloaded );
}
if ( thisDownload->callback )
thisDownload->callback->OnData( thisDownload, buffer, downloaded );
}
}
thisDownload->lastDownloadTick = GetTickCount();
thisDownload->bytesDownloaded += downloaded;
return api_downloadManager::TICK_SUCCESS;
}
else // nothing in the buffer
{
if ( state == HTTPRECEIVER_RUN_CONNECTION_CLOSED ) // see if the connection is closed
{
return api_downloadManager::TICK_FINISHED; // yay we're done
}
if ( GetTickCount() - thisDownload->lastDownloadTick > DOWNLOAD_TIMEOUT_MS ) // check for timeout
return api_downloadManager::TICK_TIMEOUT;
switch ( thisDownload->http->get_status() )
{
case HTTPRECEIVER_STATUS_CONNECTING:
if ( thisDownload->last_status != HTTPRECEIVER_STATUS_CONNECTING )
{
thisDownload->last_status = HTTPRECEIVER_STATUS_CONNECTING;
return api_downloadManager::TICK_CONNECTING;
}
else
{
return api_downloadManager::TICK_NODATA;
}
case HTTPRECEIVER_STATUS_READING_HEADERS:
if ( thisDownload->last_status != HTTPRECEIVER_STATUS_READING_HEADERS )
{
thisDownload->last_status = HTTPRECEIVER_STATUS_READING_HEADERS;
return api_downloadManager::TICK_CONNECTED;
}
else
{
return api_downloadManager::TICK_NODATA;
}
}
if ( !thisDownload->replyCode )
thisDownload->replyCode = thisDownload->http->getreplycode();
switch ( thisDownload->replyCode )
{
case 0:
case 100:
case 200:
case 201:
case 202:
case 203:
case 204:
case 205:
case 206:
return api_downloadManager::TICK_NODATA;
default:
return api_downloadManager::TICK_CANT_CONNECT;
}
}
}
#define CBCLASS DownloadManager
START_DISPATCH;
CB( API_DOWNLOADMANAGER_DOWNLOAD, Download )
CB( API_DOWNLOADMANAGER_DOWNLOADEX, DownloadEx )
CB( API_DOWNLOADMANAGER_GETRECEIVER, GetReceiver )
CB( API_DOWNLOADMANAGER_GETLOCATION, GetLocation )
VCB( API_DOWNLOADMANAGER_SETLOCATION, SetLocation )
CB( API_DOWNLOADMANAGER_GETEXTENTION, GetExtention )
CB( API_DOWNLOADMANAGER_GETURL, GetUrl )
CB( API_DOWNLOADMANAGER_GETBYTESDOWNLOADED, GetBytesDownloaded );
CB( API_DOWNLOADMANAGER_GETBUFFER, GetBuffer );
VCB( API_DOWNLOADMANAGER_RESUMEPENDINGDOWNLOAD, ResumePendingDownload );
VCB( API_DOWNLOADMANAGER_CANCELDOWNLOAD, CancelDownload );
VCB( API_DOWNLOADMANAGER_RETAINDOWNLOAD, RetainDownload );
VCB( API_DOWNLOADMANAGER_RELEASEDOWNLOAD, ReleaseDownload );
VCB( API_DOWNLOADMANAGER_REGISTERSTATUSCALLBACK, RegisterStatusCallback );
VCB( API_DOWNLOADMANAGER_UNREGISTERSTATUSCALLBACK, UnregisterStatusCallback );
CB( API_DOWNLOADMANAGER_GETSOURCE, GetSource );
CB( API_DOWNLOADMANAGER_GETTITLE, GetTitle );
CB( API_DOWNLOADMANAGER_ISPENDING, IsPending );
END_DISPATCH;
#undef CBCLASS
Copy Permalink