winamp/Src/Plugins/Library/ml_online/serviceHelper.cpp

1232 lines
28 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
#include "main.h"
#include "./serviceHelper.h"
#include "./navigation.h"
#include "./api__ml_online.h"
#include "./resource.h"
#include "./serviceHost.h"
#include <ifc_omservice.h>
#include <ifc_omfilestorage.h>
#include <ifc_omwebstorage.h>
#include <ifc_omserviceeditor.h>
#include <ifc_omserviceeventmngr.h>
#include <ifc_omservicecommand.h>
#include <ifc_omserviceenum.h>
#include <ifc_omxmlserviceenum.h>
#include <ifc_omservicecopier.h>
#include <ifc_mlnavigationhelper.h>
#include <browserUiCommon.h>
#include <vector>
#include <wininet.h>
#include <strsafe.h>
typedef std::vector<ifc_omstorageasync*> AsyncList;
struct SERVICEHELPER
{
SERVICEHELPER()
: discoverAsync(NULL)
{}
ifc_omstorageasync *discoverAsync;
AsyncList versionChecks;
CRITICAL_SECTION lock;
};
static SERVICEHELPER *serviceHelper = NULL;
static void ServiceHelper_Lock()
{
if (NULL != serviceHelper)
EnterCriticalSection(&serviceHelper->lock);
}
static void ServiceHelper_Unlock()
{
if (NULL != serviceHelper)
LeaveCriticalSection(&serviceHelper->lock);
}
static void CALLBACK ServiceHelper_Uninitialize()
{
if (NULL == serviceHelper)
return;
ServiceHelper_Lock();
ifc_omstorage *storage = NULL;;
if (SUCCEEDED(ServiceHelper_QueryWebStorage(&storage)))
{
if (NULL != serviceHelper->discoverAsync)
{
storage->RequestAbort(serviceHelper->discoverAsync, TRUE);
storage->EndLoad(serviceHelper->discoverAsync, NULL);
serviceHelper->discoverAsync->Release();
serviceHelper->discoverAsync = NULL;
}
size_t index = serviceHelper->versionChecks.size();
while(index--)
{
ifc_omstorageasync *async = serviceHelper->versionChecks[index];
storage->RequestAbort(async, TRUE);
storage->EndLoad(async, NULL);
}
serviceHelper->versionChecks.clear();
storage->Release();
}
ServiceHelper_Unlock();
DeleteCriticalSection(&serviceHelper->lock);
//free(serviceHelper);
delete serviceHelper;
serviceHelper = NULL;
}
HRESULT ServiceHelper_Initialize()
{
if (NULL != serviceHelper)
return S_FALSE;
//serviceHelper = (SERVICEHELPER*)calloc(1, sizeof(SERVICEHELPER));
serviceHelper = new SERVICEHELPER();
if (NULL == serviceHelper)
return E_OUTOFMEMORY;
InitializeCriticalSection(&serviceHelper->lock);
Plugin_RegisterUnloadCallback(ServiceHelper_Uninitialize);
return S_OK;
}
HRESULT ServiceHelper_QueryStorage(ifc_omstorage **storage)
{
if (NULL == storage) return E_POINTER;
if (NULL == OMSERVICEMNGR)
{
*storage = NULL;
return E_UNEXPECTED;
}
return OMSERVICEMNGR->QueryStorage(&SUID_OmStorageIni, storage);
}
HRESULT ServiceHelper_QueryWebStorage(ifc_omstorage **storage)
{
if (NULL == storage) return E_POINTER;
if (NULL == OMSERVICEMNGR)
{
*storage = NULL;
return E_UNEXPECTED;
}
return OMSERVICEMNGR->QueryStorage(&SUID_OmStorageUrl, storage);
}
HRESULT ServiceHelper_Create(UINT serviceId, LPCWSTR pszName, LPCWSTR pszIcon, LPCWSTR pszUrl, UINT flags, UINT generation, BOOL fSave, ifc_omservice **serviceOut)
{
if (NULL == serviceOut)
return E_POINTER;
*serviceOut = NULL;
if (NULL == OMSERVICEMNGR)
return E_UNEXPECTED;
ServiceHost *serviceHost;
if (FAILED(ServiceHost::GetCachedInstance(&serviceHost)))
serviceHost = NULL;
HRESULT hr = OMSERVICEMNGR->CreateService(serviceId, serviceHost, serviceOut);
if (SUCCEEDED(hr))
{
ifc_omserviceeditor *editor;
if (SUCCEEDED((*serviceOut)->QueryInterface(IFC_OmServiceEditor, (void**)&editor)))
{
WCHAR szBuffer[4096] = {0};
editor->BeginUpdate();
if (NULL != pszName && IS_INTRESOURCE(pszName))
{
if (NULL != WASABI_API_LNGSTRINGW_BUF((INT)(INT_PTR)pszName, szBuffer, ARRAYSIZE(szBuffer)))
editor->SetName(szBuffer, FALSE);
}
else
editor->SetName(pszName, FALSE);
if (NULL != pszIcon && IS_INTRESOURCE(pszIcon))
{
if (SUCCEEDED(Plugin_MakeResourcePath(szBuffer, ARRAYSIZE(szBuffer), RT_RCDATA, pszIcon, RESPATH_COMPACT)))
editor->SetIcon(szBuffer, FALSE);
}
else
editor->SetIcon(pszIcon, FALSE);
if (NULL != pszUrl && IS_INTRESOURCE(pszUrl))
{
if (SUCCEEDED(Plugin_MakeResourcePath(szBuffer, ARRAYSIZE(szBuffer), RT_HTML, pszUrl, RESPATH_TARGETIE | RESPATH_COMPACT)))
editor->SetUrl(szBuffer, FALSE);
}
else
editor->SetUrl(pszUrl, FALSE);
editor->SetGeneration(generation);
editor->SetFlags(flags, 0xFFFFFFFF);
if (FALSE != fSave)
{
hr = ServiceHelper_Save(*serviceOut);
if (FAILED(hr))
{
(*serviceOut)->Release();
*serviceOut = NULL;
}
}
else
{
editor->SetModified(0, (UINT)-1);
}
editor->EndUpdate();
editor->Release();
}
}
if (NULL != serviceHost)
serviceHost->Release();
return hr;
}
HRESULT ServiceHelper_Save(ifc_omservice *service)
{
if (NULL == service)
return E_INVALIDARG;
if (NULL == OMSERVICEMNGR)
return E_UNEXPECTED;
if (S_OK == ServiceHelper_IsSpecial(service))
return S_FALSE;
HRESULT hr;
ifc_omstorage *storage;
hr = ServiceHelper_QueryStorage(&storage);
if (SUCCEEDED(hr))
{
UINT serviceFlags;
if (SUCCEEDED(service->GetFlags(&serviceFlags)) && 0 != (SVCF_AUTOUPGRADE & serviceFlags))
{
hr = storage->Save(&service, 1, ifc_omstorage::saveClearModified, NULL);
if (SUCCEEDED(hr))
{
ifc_omserviceeditor *editor;
if (SUCCEEDED(service->QueryInterface(IFC_OmServiceEditor, (void**)&editor)))
{
editor->BeginUpdate();
editor->SetFlags(0, SVCF_AUTOUPGRADE);
editor->SetModified(0, ifc_omserviceeditor::modifiedFlags);
editor->EndUpdate();
editor->Release();
}
}
}
else
{
hr = storage->Save(&service, 1, ifc_omstorage::saveClearModified | ifc_omstorage::saveModifiedOnly, NULL);
}
storage->Release();
}
return hr;
}
HRESULT ServiceHelper_Delete(ifc_omservice *service, UINT flags)
{
if (NULL == service)
return E_INVALIDARG;
if (NULL == OMSERVICEMNGR)
return E_UNEXPECTED;
if (S_OK == ServiceHelper_IsSpecial(service))
return S_FALSE;
HRESULT hr;
if (S_OK == ServiceHelper_IsSubscribed(service))
{
hr = ServiceHelper_Subscribe(service, FALSE, ((SHF_NOTIFY | SHF_VERBAL) & flags));
if (S_OK != hr) return hr;
}
ifc_omstorage *storage = NULL;
hr = ServiceHelper_QueryStorage(&storage);
if (SUCCEEDED(hr) && storage)
{
hr = storage->Delete(&service, 1, NULL);
storage->Release();
}
return hr;
}
HRESULT ServiceHelper_SetFlags(ifc_omservice *service, UINT flags, UINT flagsMask)
{
if (NULL ==service)
return E_INVALIDARG;
UINT serviceFlags;
HRESULT hr = service->GetFlags(&serviceFlags);
if (FAILED(hr)) return hr;
if ((flags & flagsMask) == (serviceFlags & flagsMask))
return S_FALSE;
ifc_omserviceeditor *editor;
hr = service->QueryInterface(IFC_OmServiceEditor, (void**)&editor);
if (SUCCEEDED(hr))
{
editor->SetFlags(flags, flagsMask);
editor->Release();
}
return hr;
}
HRESULT ServiceHelper_IsSpecial(ifc_omservice *service)
{
if (NULL == service) return E_INVALIDARG;
UINT flags;
HRESULT hr = service->GetFlags(&flags);
if (FAILED(hr)) return hr;
return (0 != (SVCF_SPECIAL & flags)) ? S_OK : S_FALSE;
}
HRESULT ServiceHelper_IsSubscribed(ifc_omservice *service)
{
if (NULL == service) return E_INVALIDARG;
//return S_OK;
UINT flags;
HRESULT hr = service->GetFlags(&flags);
if (FAILED(hr)) return hr;
return (0 != (SVCF_SUBSCRIBED & flags)) ? S_OK : S_FALSE;
}
HRESULT ServiceHelper_IsModified(ifc_omservice *service)
{
if (NULL == service) return E_INVALIDARG;
HRESULT hr;
ifc_omserviceeditor *editor;
hr = service->QueryInterface(IFC_OmServiceEditor, (void**)&editor);
if (SUCCEEDED(hr))
{
UINT modified;
hr = editor->GetModified(&modified);
if (SUCCEEDED(hr))
{
hr = (0 == modified) ? S_FALSE : S_OK;
}
editor->Release();
}
return hr;
}
HRESULT ServiceHelper_MarkModified(ifc_omservice *service, UINT modifiedFlag, UINT modifiedMask)
{
if (NULL == service)
return E_INVALIDARG;
HRESULT hr;
ifc_omserviceeditor *editor;
hr = service->QueryInterface(IFC_OmServiceEditor, (void**)&editor);
if (SUCCEEDED(hr))
{
hr = editor->SetModified(modifiedFlag, modifiedMask);
editor->Release();
}
return hr;
}
HRESULT ServiceHelper_Load(ifc_omserviceenum **enumerator)
{
if (NULL == enumerator)
return E_POINTER;
HRESULT hr;
ifc_omstorage *storage;
hr = ServiceHelper_QueryStorage(&storage);
if (SUCCEEDED(hr))
{
ServiceHost *serviceHost;
if (FAILED(ServiceHost::GetCachedInstance(&serviceHost)))
serviceHost = NULL;
hr = storage->Load(L"*.ini", serviceHost, enumerator);
if (NULL != serviceHost)
serviceHost->Release();
storage->Release();
}
if (FAILED(hr))
*enumerator = NULL;
return hr;
}
HRESULT ServiceHelper_UpdateIcon(ifc_omserviceeditor *editor, LPCWSTR pszImage)
{
WCHAR szBuffer[8192];
szBuffer[0] = L'\0';
if (NULL == editor)
return E_INVALIDARG;
ifc_omservice *service;
if (SUCCEEDED(editor->QueryInterface(IFC_OmService, (void**)&service)))
{
if (FAILED(service->GetIcon(szBuffer, ARRAYSIZE(szBuffer))))
szBuffer[0] = L'\0';
service->Release();
}
HRESULT hr = editor->SetIcon(pszImage, FALSE);
if (FAILED(hr) || S_FALSE == hr) return hr;
if (L'\0' != szBuffer)
{
ifc_mlnavigationhelper *navHelper;
if (SUCCEEDED(OMUTILITY->GetMlNavigationHelper(Plugin_GetLibrary(), &navHelper)))
{
navHelper->ReleaseIndex(szBuffer);
navHelper->Release();
}
}
return S_OK;
}
HRESULT ServiceHelper_Find(UINT serviceId, ifc_omservice **serviceOut)
{
if (NULL == serviceOut) return E_POINTER;
*serviceOut = NULL;
if (0 == serviceId)
return E_INVALIDARG;
Navigation *navigation;
if (SUCCEEDED(Plugin_GetNavigation(&navigation)))
{
HNAVITEM hItem = navigation->FindService(serviceId, serviceOut);
navigation->Release();
if (NULL != hItem)
return S_OK;
}
ifc_omserviceenum *enumerator;
HRESULT hr = ServiceHelper_Load(&enumerator);
if (SUCCEEDED(hr))
{
ifc_omservice *service;
hr = S_FALSE;
while (S_OK == enumerator->Next(1, &service, NULL))
{
if (service->GetId() == serviceId)
{
*serviceOut = service;
hr = S_OK;
break;
}
service->Release();
}
enumerator->Release();
}
return hr;
}
HRESULT ServiceHelper_SetRating(ifc_omservice *service, UINT rating, UINT flags)
{
if (NULL == service)
return E_POINTER;
ifc_omserviceeditor *editor;
HRESULT hr;
hr = service->QueryInterface(IFC_OmServiceEditor, (void**)&editor);
if (SUCCEEDED(hr))
{
hr = editor->SetRating(rating);
if (S_OK == hr)
{
if (0 != (SHF_NOTIFY & flags))
{
// send notification
WCHAR szUrl[2048] = {0}, szClient[128] = {0};
if (NULL == OMBROWSERMNGR || FAILED(OMBROWSERMNGR->GetClientId(szClient, ARRAYSIZE(szClient))))
szClient[0] = L'\0';
hr = StringCchPrintf(szUrl, ARRAYSIZE(szUrl),
L"http://services.winamp.com/svc/rating?svc_id=%u&unique_id=%s&rating=%d",
service->GetId(), szClient, rating*2);
if (SUCCEEDED(hr))
{
hr = ServiceHelper_PostNotificationUrl(szUrl);
}
}
if (0 != (SHF_SAVE & flags))
ServiceHelper_Save(service);
}
editor->Release();
}
return hr;
}
HRESULT ServiceHelper_PostNotificationUrl(LPCWSTR pszUrl)
{
HRESULT hr;
ifc_omstorage *storage;
hr = ServiceHelper_QueryWebStorage(&storage);
if (SUCCEEDED(hr))
{
ifc_omstorageasync *async;
hr = storage->BeginLoad(pszUrl, NULL, NULL, NULL, &async);
if(SUCCEEDED(hr))
{
async->Release();
}
storage->Release();
}
return hr;
}
HRESULT ServiceHelper_ResetPermissions(ifc_omservice *service, UINT flags)
{
if (NULL == service)
return E_INVALIDARG;
if (0 != (SHF_VERBAL & flags))
{
WCHAR szText[1024] = {0}, szFormat[512] = {0}, szName[128] = {0};
service->GetName(szName, ARRAYSIZE(szName));
WASABI_API_LNGSTRINGW_BUF(IDS_MESSAGEBOX_POLICYRESET, szFormat, ARRAYSIZE(szFormat));
StringCchPrintf(szText, ARRAYSIZE(szText), szFormat, szName);
if (IDNO == Plugin_MessageBox(szText, MAKEINTRESOURCE(IDS_MESSAGEBOX_POLICYRESET_CAPTION),
MB_ICONQUESTION | MB_YESNO))
{
return S_FALSE;
}
}
if (NULL == AGAVE_API_JSAPI2_SECURITY)
return E_UNEXPECTED;
WCHAR szBuffer[64] = {0};
if (FAILED(StringCchPrintfW(szBuffer, ARRAYSIZE(szBuffer), L"%u", service->GetId())))
return E_FAIL;
AGAVE_API_JSAPI2_SECURITY->ResetAuthorization(szBuffer);
return S_OK;
}
HRESULT ServiceHelper_IsPreAuthorized(ifc_omservice *service)
{
if (NULL == service)
return E_INVALIDARG;
UINT serviceFlags;
HRESULT hr = service->GetFlags(&serviceFlags);
if (SUCCEEDED(hr))
{
hr = (0 != (SVCF_PREAUTHORIZED & serviceFlags)) ? S_OK : S_FALSE;
}
return hr;
}
HRESULT ServiceHelper_Subscribe(ifc_omservice *service, BOOL subscribe, UINT flags)
{
if (NULL == service)
return E_POINTER;
if ((TRUE == subscribe) == (S_OK == ServiceHelper_IsSubscribed(service)))
return S_FALSE;
HRESULT hr;
if (FALSE == subscribe && 0 != (SHF_VERBAL & flags))
{
WCHAR szText[1024] = {0}, szFormat[512] = {0}, szName[128] = {0};
if (FAILED(service->GetName(szName, ARRAYSIZE(szName))))
szName[0] = L'\0';
WASABI_API_LNGSTRINGW_BUF(IDS_MESSAGEBOX_UNSUBSCRIBE, szFormat, ARRAYSIZE(szFormat));
StringCchPrintf(szText,ARRAYSIZE(szText), szFormat, szName);
if (IDNO == Plugin_MessageBox(szText, MAKEINTRESOURCE(IDS_MESSAGEBOX_UNSUBSCRIBE_CAPTION),
MB_ICONQUESTION | MB_YESNO))
{
return S_FALSE;
}
}
ifc_omserviceeditor *editor = NULL;
hr = service->QueryInterface(IFC_OmServiceEditor, (void**)&editor);
if (SUCCEEDED(hr) && editor)
{
hr = editor->SetFlags((FALSE == subscribe) ? 0 : SVCF_SUBSCRIBED, SVCF_SUBSCRIBED);
if (S_OK == hr)
{
if (0 != (SHF_SAVE & flags))
ServiceHelper_Save(service);
}
editor->Release();
if (FALSE == subscribe)
ServiceHelper_Delete(service, 0);
}
if (S_OK == hr)
{
if (NULL == AGAVE_API_JSAPI2_SECURITY)
{
WCHAR szBuffer[64] = {0};
if (SUCCEEDED(StringCchPrintfW(szBuffer, ARRAYSIZE(szBuffer), L"%u", service->GetId())))
{
AGAVE_API_JSAPI2_SECURITY->ResetAuthorization(szBuffer);
}
}
if (0 != (SHF_NOTIFY & flags))
{
LPWSTR pszUrl;
UINT serviceId = service->GetId();
LPCWSTR action = (FALSE != subscribe) ? L"add" : L"remove";;
if (NULL != action && SUCCEEDED(Plugin_BuildActionUrl(&pszUrl, action, &serviceId, 1)))
{
hr = ServiceHelper_PostNotificationUrl(pszUrl);
Plugin_FreeString(pszUrl);
}
}
}
return hr;
}
HRESULT ServiceHelper_ResetSubscription(UINT flags)
{
if (S_OK == ServiceHelper_IsDiscovering())
{
if (0 != (SHF_VERBAL & flags))
{
Plugin_MessageBox(MAKEINTRESOURCE(IDS_MESSAGEBOX_DISCOVERBUSY),
MAKEINTRESOURCE(IDS_MESSAGEBOX_DISCOVERBUSY_CAPTION),
MB_ICONASTERISK | MB_OK);
}
return E_PENDING;
}
if (0 != (SHF_VERBAL & flags))
{
if (IDNO == Plugin_MessageBox(MAKEINTRESOURCE(IDS_MESSAGEBOX_RESETTODEFAULT),
MAKEINTRESOURCE(IDS_MESSAGEBOX_RESETTODEFAULT_CAPTION),
MB_ICONQUESTION | MB_YESNO))
{
return S_FALSE;
}
}
HRESULT hr;
Navigation *navigation;
if (SUCCEEDED(Plugin_GetNavigation(&navigation)))
{
navigation->DeleteAll();
navigation->Release();
}
ifc_omstorage *storage;
hr = ServiceHelper_QueryStorage(&storage);
if (SUCCEEDED(hr))
{
ifc_omserviceenum *enumerator;
hr = ServiceHelper_Load(&enumerator);
if (SUCCEEDED(hr))
{
ifc_omservice *service;
std::vector<UINT> removeList;
while(S_OK == enumerator->Next(1, &service, NULL))
{
if (S_OK == ServiceHelper_IsSubscribed(service))
removeList.push_back(service->GetId());
ServiceHelper_ResetPermissions(service, 0);
storage->Delete(&service, 1, NULL);
service->Release();
}
enumerator->Release();
if (0 != removeList.size())
{
LPWSTR pszUrl;
if (SUCCEEDED(Plugin_BuildActionUrl(&pszUrl, L"remove", removeList.data(), removeList.size())))
{
ServiceHelper_PostNotificationUrl(pszUrl);
Plugin_FreeString(pszUrl);
}
}
}
storage->Release();
}
if (SUCCEEDED(hr))
{
// discover new services
hr = ServiceHelper_BeginDiscover(L"http://services.winamp.com/svc/default.php");
}
return hr;
}
HRESULT ServiceHelper_IsDiscovering()
{
HRESULT hr;
ServiceHelper_Lock();
if (NULL == serviceHelper)
{
hr = E_UNEXPECTED;
}
else
{
hr = (NULL != serviceHelper->discoverAsync) ? S_OK : S_FALSE;
}
ServiceHelper_Unlock();
return hr;
}
static void CALLBACK ServiceHelper_DiscoverComplete(ifc_omstorageasync *result)
{
if (NULL == result)
return;
SERVICEHELPER *helper;
if (FAILED(result->GetData((void**)&helper)) || NULL == helper)
return;
ServiceHelper_Lock();
ifc_omstorage *webStorage;
HRESULT hr = ServiceHelper_QueryWebStorage(&webStorage);
if (SUCCEEDED(hr))
{
ifc_omserviceenum *serviceEnum;
if (SUCCEEDED(webStorage->EndLoad(result, &serviceEnum)))
{
Navigation *navigation;
if (FAILED(Plugin_GetNavigation(&navigation)))
navigation = NULL;
ifc_omstorage *localStorage;
if (SUCCEEDED(ServiceHelper_QueryStorage(&localStorage)))
{
std::vector<UINT> registerList;
ifc_omservice *service;
while(S_OK == serviceEnum->Next(1, &service, NULL))
{
ifc_omserviceeditor *editor;
if (SUCCEEDED(service->QueryInterface(IFC_OmServiceEditor, (void**)&editor)))
{
if (SUCCEEDED(editor->SetFlags(SVCF_SUBSCRIBED, SVCF_SUBSCRIBED)))
registerList.push_back(service->GetId());
editor->Release();
}
if (SUCCEEDED(localStorage->Save(&service, 1, ifc_omstorage::saveClearModified, NULL)))
{
navigation->CreateItemAsync(service);
}
service->Release();
}
if (0 != registerList.size())
{
LPWSTR pszUrl;
if (SUCCEEDED(Plugin_BuildActionUrl(&pszUrl, L"add", registerList.data(), registerList.size())))
{
ServiceHelper_PostNotificationUrl(pszUrl);
Plugin_FreeString(pszUrl);
}
}
}
if (NULL != navigation)
navigation->Release();
serviceEnum->Release();
}
webStorage->Release();
}
if (serviceHelper->discoverAsync == result)
{
serviceHelper->discoverAsync->Release();
serviceHelper->discoverAsync = NULL;
}
ServiceHelper_Unlock();
}
HRESULT ServiceHelper_BeginDiscover(LPCWSTR address)
{
ifc_omstorage *storage;
HRESULT hr = ServiceHelper_QueryWebStorage(&storage);
if (FAILED(hr)) return hr;
ServiceHost *serviceHost;
if (FAILED(ServiceHost::GetCachedInstance(&serviceHost)))
serviceHost = NULL;
ServiceHelper_Lock();
if (NULL == serviceHelper->discoverAsync)
hr = storage->BeginLoad(address, serviceHost, ServiceHelper_DiscoverComplete, serviceHelper, &serviceHelper->discoverAsync);
else
hr = E_PENDING;
ServiceHelper_Unlock();
storage->Release();
if (NULL != serviceHost)
serviceHost->Release();
return hr;
}
HRESULT ServiceHelper_GetDetailsUrl(LPWSTR pszBuffer, UINT cchBufferMax, ifc_omservice *service, BOOL fLite)
{
if (NULL == pszBuffer)
return E_POINTER;
if (0 == service)
return E_INVALIDARG;
HRESULT hr;
size_t remaining = cchBufferMax;
LPWSTR cursor = pszBuffer;
hr = StringCchPrintfEx(cursor, remaining, &cursor, &remaining, STRSAFE_NULL_ON_FAILURE,
L"http://services.winamp.com/svc/details?svc_id=%u", service->GetId());
WCHAR szClient[128] = {0};
if (SUCCEEDED(hr) &&
NULL != OMBROWSERMNGR &&
SUCCEEDED(OMBROWSERMNGR->GetClientId(szClient, ARRAYSIZE(szClient))) &&
L'\0' != szClient[0])
{
hr = StringCchPrintfEx(cursor, remaining, &cursor, &remaining, STRSAFE_NULL_ON_FAILURE,
L"&unique_id=%s", szClient);
}
if (FALSE != fLite && SUCCEEDED(hr))
{
hr = StringCchCopyEx(cursor, remaining, L"&detail=lite", &cursor, &remaining, STRSAFE_NULL_ON_FAILURE);
}
return hr;
}
static void CALLBACK ServiceHelper_VersionCheckComplete(ifc_omstorageasync *result)
{
if (NULL == result)
return;
ifc_omservice *target;
if (FAILED(result->GetData((void**)&target)) || NULL == target)
return;
ServiceHelper_Lock();
size_t index = serviceHelper->versionChecks.size();
while(index--)
{
if (result == serviceHelper->versionChecks[index])
{
auto it = serviceHelper->versionChecks.begin() + index;
if (it < serviceHelper->versionChecks.end())
{
it = serviceHelper->versionChecks.erase(it);
}
break;
}
}
ServiceHelper_Unlock();
UINT originalFlags;
if (FAILED(target->GetFlags(&originalFlags)))
originalFlags = 0;
ifc_omserviceeditor *editor;
if (SUCCEEDED(target->QueryInterface(IFC_OmServiceEditor, (void**)&editor)))
editor->BeginUpdate();
else
editor = NULL;
ifc_omstorage *storage;
HRESULT hr = ServiceHelper_QueryWebStorage(&storage);
if (SUCCEEDED(hr))
{
ifc_omserviceenum *serviceEnum;
if (SUCCEEDED(storage->EndLoad(result, &serviceEnum)))
{
ifc_omservice *source = NULL;
while(S_OK == serviceEnum->Next(1, &source, NULL))
{
if (source->GetId() == target->GetId())
break;
source->Release();
source = NULL;
}
ifc_omxmlserviceenum *xmlServiceEnum;
if (SUCCEEDED(serviceEnum->QueryInterface(IFC_OmXmlServiceEnum, (void**)&xmlServiceEnum)))
{
UINT statusCode;
if (SUCCEEDED(xmlServiceEnum->GetStatusCode(&statusCode)))
{
switch(statusCode)
{
case 410: // force remove
if (NULL != target)
{
WCHAR szText[1024] = {0}, szFormat[512] = {0}, szName[128] = {0};
target->GetName(szName, ARRAYSIZE(szName));
WASABI_API_LNGSTRINGW_BUF(IDS_MESSAGEBOX_FORCEREMOVE, szFormat, ARRAYSIZE(szFormat));
StringCchPrintf(szText,ARRAYSIZE(szText), szFormat, szName);
Plugin_MessageBox(szText, MAKEINTRESOURCE(IDS_MESSAGEBOX_FORCEREMOVE_CAPTION), MB_ICONINFORMATION | MB_OK);
ServiceHelper_Delete(target, 0);
target->Release();
target = NULL;
}
break;
case 200:
if (NULL != source)
{
ifc_omservicecopier *copier;
if (SUCCEEDED(source->QueryInterface(IFC_OmServiceCopier, (void**)&copier)))
{
UINT targetFlags, sourceFlags;
if (FAILED(target->GetFlags(&targetFlags))) targetFlags = 0;
if (SUCCEEDED(source->GetFlags(&sourceFlags)))
targetFlags |= sourceFlags;
copier->CopyTo(target, NULL);
copier->Release();
editor->SetFlags(targetFlags, targetFlags);
}
}
break;
}
}
xmlServiceEnum->Release();
}
if (NULL != source)
source->Release();
serviceEnum->Release();
}
storage->Release();
}
if (NULL != target && NULL != AGAVE_API_JSAPI2_SECURITY)
{
WCHAR szBuffer[64] = {0};
if (SUCCEEDED(StringCchPrintf(szBuffer, ARRAYSIZE(szBuffer), L"%u", target->GetId())))
{
UINT flags = 0;
if (SUCCEEDED(target->GetFlags(&flags)))
{
bool bypassEnabled = (0 != (SVCF_PREAUTHORIZED & flags));
AGAVE_API_JSAPI2_SECURITY->SetBypass(szBuffer, bypassEnabled);
}
}
}
if (NULL != editor)
{
editor->SetFlags(SVCF_VALIDATED, SVCF_VALIDATED | SVCF_VERSIONCHECK);
if (NULL != target)
{
UINT targetFlags;
if (FAILED(target->GetFlags(&targetFlags)))
targetFlags = 0;
if ((targetFlags & ~ifc_omservice::RuntimeFlagsMask) == (originalFlags & ~ifc_omservice::RuntimeFlagsMask))
editor->SetModified(0, ifc_omserviceeditor::modifiedFlags);
}
editor->EndUpdate();
editor->Release();
}
if (NULL != target)
{
ifc_omserviceeventmngr *eventManager;
if (SUCCEEDED(target->QueryInterface(IFC_OmServiceEventMngr, (void**)&eventManager)))
{
eventManager->Signal_CommandStateChange(&CMDGROUP_SERVICE, SVCCOMMAND_BLOCKNAV);
eventManager->Release();
}
ServiceHelper_Save(target);
target->Release();
}
}
HRESULT ServiceHelper_BeginVersionCheck(ifc_omservice *service)
{
if (NULL == service)
return E_INVALIDARG;
if (NULL == serviceHelper)
return E_UNEXPECTED;
HRESULT hr = S_OK;
ServiceHelper_Lock();
size_t index = serviceHelper->versionChecks.size();
while(index--)
{
ifc_omstorageasync *async = serviceHelper->versionChecks[index];
UINT serviceId;
if (SUCCEEDED(async->GetData((void**)&serviceId)))
{
if (serviceId == service->GetId())
{
hr = S_FALSE;
}
}
}
if (S_OK == hr)
{
ifc_omstorage *storage;
HRESULT hr = ServiceHelper_QueryWebStorage(&storage);
if (SUCCEEDED(hr))
{
WCHAR szAddress[2048] = {0};
hr = ServiceHelper_GetDetailsUrl(szAddress, ARRAYSIZE(szAddress), service, TRUE);
if (SUCCEEDED(hr))
{
ServiceHost *serviceHost;
if (FAILED(ServiceHost::GetCachedInstance(&serviceHost)))
serviceHost = NULL;
ifc_omserviceeditor *editor;
if (FAILED(service->QueryInterface(IFC_OmServiceEditor, (void**)&editor)))
editor = NULL;
else
{
editor->BeginUpdate();
editor->SetFlags(SVCF_VERSIONCHECK, SVCF_VERSIONCHECK);
}
service->AddRef();
serviceHelper->versionChecks.push_back(NULL);
//ifc_omstorageasync **pAsync = serviceHelper->versionChecks.end() - 1;
ifc_omstorageasync** pAsync = (serviceHelper->versionChecks.size() ?
&serviceHelper->versionChecks.at(serviceHelper->versionChecks.size() - 1) : 0);
hr = storage->BeginLoad(szAddress, serviceHost, ServiceHelper_VersionCheckComplete, service, pAsync);
if (FAILED(hr))
{
service->Release();
serviceHelper->versionChecks.pop_back();
if (NULL != editor)
editor->SetFlags(0, SVCF_VERSIONCHECK);
}
if (NULL != serviceHost)
serviceHost->Release();
if (NULL != editor)
{
editor->EndUpdate();
editor->Release();
}
}
storage->Release();
}
}
ServiceHelper_Unlock();
return hr;
}
static void CALLBACK ServiceHelper_UpdateOperationInfoApc(ULONG_PTR param)
{
HWND hBrowser = (HWND)param;
if (NULL != hBrowser && IsWindow(hBrowser))
{
ServiceHelper_UpdateOperationInfo(hBrowser);
}
}
HRESULT ServiceHelper_UpdateOperationInfo(HWND hBrowser)
{
if (NULL == hBrowser)
return E_INVALIDARG;
DWORD currentTID = GetCurrentThreadId();
DWORD winampTID = GetWindowThreadProcessId(Plugin_GetWinamp(), NULL);
if (NULL != winampTID && winampTID != currentTID)
{
HRESULT hr;
if (NULL != OMUTILITY)
hr = OMUTILITY->PostMainThreadCallback(ServiceHelper_UpdateOperationInfoApc, (ULONG_PTR)hBrowser);
else
hr = E_FAIL;
return hr;
}
ifc_omservice *service;
if (FALSE == BrowserControl_GetService(hBrowser, &service))
return E_FAIL;
UINT flags;
if (SUCCEEDED(service->GetFlags(&flags)))
{
WCHAR szText[128] = {0}, szTitle[128] = {0};
OPERATIONINFO operation = {0};
operation.cbSize = sizeof(operation);
operation.mask = NBCOM_FLAGS;
if (0 == (SVCF_VERSIONCHECK & flags))
{
operation.flags = NBCOF_HIDEWIDGET;
}
else
{
operation.mask |= (NBCOM_TITLE | NBCOM_TEXT);
operation.flags = NBCOF_SHOWWIDGET;
WASABI_API_LNGSTRINGW_BUF(IDS_SERVICE_CHECKINGVERSION, szTitle, ARRAYSIZE(szTitle));
operation.title = szTitle;
WASABI_API_LNGSTRINGW_BUF(IDS_PLEASE_WAIT, szText, ARRAYSIZE(szText));
operation.text = szText;
}
BrowserControl_ShowOperation(hBrowser, &operation);
}
service->Release();
return S_OK;
}
static void CALLBACK ServiceHelper_ShowWindowTimer(UINT_PTR eventId, DWORD elapsedMs, ULONG_PTR data)
{
Plugin_KillTimer(eventId);
HWND hTarget = (HWND)data;
if (hTarget == Plugin_GetLibrary())
PostMessage(hTarget, WM_ML_IPC, 0, ML_IPC_ENSURE_VISIBLE);
else
ShowWindow(hTarget, SW_SHOWNORMAL);
}
HRESULT ServiceHelper_ShowService(UINT serviceId, UINT showMode)
{
HRESULT hr;
BOOL serviceFound = FALSE;
ifc_omservice *service;
if (0 != serviceId && ROOTSERVICE_ID != serviceId &&
S_OK == ServiceHelper_Find(serviceId, &service) &&
NULL != service)
{
if (S_OK == ServiceHelper_IsSubscribed(service))
serviceFound = TRUE;
service->Release();
}
WCHAR szBuffer[INTERNET_MAX_URL_LENGTH] = {0};
LPCWSTR pszUrl = NULL;
if (FALSE == serviceFound)
{
if (0 != serviceId && ROOTSERVICE_ID != serviceId &&
SUCCEEDED(StringCchPrintfW(szBuffer, ARRAYSIZE(szBuffer),
L"http://client.winamp.com/service/detail/gallery/%u", serviceId)))
{
pszUrl = szBuffer;
}
serviceId = ROOTSERVICE_ID;
}
Navigation *navigation;
hr = Plugin_GetNavigation(&navigation);
if (FAILED(hr)) return hr;
if (SHOWMODE_POPUP == showMode)
{
showMode = SHOWMODE_ENSUREVISIBLE;
if (FALSE != serviceFound)
{
HNAVITEM hItem = navigation->FindService(serviceId, NULL);
if (NULL != hItem)
{
HWND hPopup;
hr = navigation->CreatePopup(hItem, &hPopup);
if (SUCCEEDED(hr))
{
Plugin_SetTimer(100, ServiceHelper_ShowWindowTimer, (ULONG_PTR)hPopup);
showMode = SHOWMODE_POPUP;
}
}
}
}
if (SHOWMODE_POPUP != showMode)
{
hr = navigation->ShowService(serviceId, pszUrl);
if (SUCCEEDED(hr))
{
if (SHOWMODE_ENSUREVISIBLE == showMode)
Plugin_SetTimer(100, ServiceHelper_ShowWindowTimer, (ULONG_PTR)Plugin_GetLibrary());
}
}
navigation->Release();
return hr;
}