diff options
Diffstat (limited to 'Minecraft.Client/PS3/Network/SonyCommerce_PS3.cpp')
| -rw-r--r-- | Minecraft.Client/PS3/Network/SonyCommerce_PS3.cpp | 1513 |
1 files changed, 1513 insertions, 0 deletions
diff --git a/Minecraft.Client/PS3/Network/SonyCommerce_PS3.cpp b/Minecraft.Client/PS3/Network/SonyCommerce_PS3.cpp new file mode 100644 index 00000000..230e0309 --- /dev/null +++ b/Minecraft.Client/PS3/Network/SonyCommerce_PS3.cpp @@ -0,0 +1,1513 @@ +#include "stdafx.h" + +#include "SonyCommerce_PS3.h" +#include "..\PS3Extras\ShutdownManager.h" +#include <sys/event.h> + + +bool SonyCommerce_PS3::m_bCommerceInitialised = false; +SceNpCommerce2SessionInfo SonyCommerce_PS3::m_sessionInfo; +SonyCommerce_PS3::State SonyCommerce_PS3::m_state = e_state_noSession; +int SonyCommerce_PS3::m_errorCode = 0; +LPVOID SonyCommerce_PS3::m_callbackParam = NULL; + +void* SonyCommerce_PS3::m_receiveBuffer = NULL; +SonyCommerce_PS3::Event SonyCommerce_PS3::m_event; +std::queue<SonyCommerce_PS3::Message> SonyCommerce_PS3::m_messageQueue; +std::vector<SonyCommerce_PS3::ProductInfo>* SonyCommerce_PS3::m_pProductInfoList = NULL; +SonyCommerce_PS3::ProductInfoDetailed* SonyCommerce_PS3::m_pProductInfoDetailed = NULL; +SonyCommerce_PS3::ProductInfo* SonyCommerce_PS3::m_pProductInfo = NULL; + +SonyCommerce_PS3::CategoryInfo* SonyCommerce_PS3::m_pCategoryInfo = NULL; +const char* SonyCommerce_PS3::m_pProductID = NULL; +char* SonyCommerce_PS3::m_pCategoryID = NULL; +SonyCommerce_PS3::CheckoutInputParams SonyCommerce_PS3::m_checkoutInputParams; +SonyCommerce_PS3::DownloadListInputParams SonyCommerce_PS3::m_downloadInputParams; + +SonyCommerce_PS3::CallbackFunc SonyCommerce_PS3::m_callbackFunc = NULL; +sys_memory_container_t SonyCommerce_PS3::m_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID; +bool SonyCommerce_PS3::m_bUpgradingTrial = false; + +SonyCommerce_PS3::CallbackFunc SonyCommerce_PS3::m_trialUpgradeCallbackFunc; +LPVOID SonyCommerce_PS3::m_trialUpgradeCallbackParam; + +CRITICAL_SECTION SonyCommerce_PS3::m_queueLock; + + + +uint32_t SonyCommerce_PS3::m_contextId=0; ///< The npcommerce2 context ID +bool SonyCommerce_PS3::m_contextCreated=false; ///< npcommerce2 context ID created? +SonyCommerce_PS3::Phase SonyCommerce_PS3::m_currentPhase = e_phase_stopped; ///< Current commerce2 util +char SonyCommerce_PS3::m_commercebuffer[SCE_NP_COMMERCE2_RECV_BUF_SIZE]; + +C4JThread* SonyCommerce_PS3::m_tickThread = NULL; +bool SonyCommerce_PS3::m_bLicenseChecked=false; // Check the trial/full license for the game + + +SonyCommerce_PS3::ProductInfoDetailed s_trialUpgradeProductInfoDetailed; +void SonyCommerce_PS3::Delete() +{ + m_pProductInfoList=NULL; + m_pProductInfoDetailed=NULL; + m_pProductInfo=NULL; + m_pCategoryInfo = NULL; + m_pProductID = NULL; + m_pCategoryID = NULL; +} +void SonyCommerce_PS3::Init() +{ + int ret; + + assert(m_state == e_state_noSession); + if(!m_bCommerceInitialised) + { + ret = sceNpCommerce2Init(); + if (ret < 0) + { + app.DebugPrintf(4,"sceNpCommerce2Init failed (0x%x)\n", ret); + return; + } + else + { + m_bCommerceInitialised = true; + } + m_pCategoryID=(char *)malloc(sizeof(char) * 100); + InitializeCriticalSection(&m_queueLock); + } + + return ; + +} + + + +void SonyCommerce_PS3::CheckForTrialUpgradeKey_Callback(LPVOID param, bool bFullVersion) +{ + ProfileManager.SetFullVersion(bFullVersion); + if(ProfileManager.IsFullVersion()) + { + StorageManager.SetSaveDisabled(false); + ConsoleUIController::handleUnlockFullVersionCallback(); + // licence has been checked, so we're ok to install the trophies now + ProfileManager.InitialiseTrophies( SQRNetworkManager_PS3::GetSceNpCommsId(), + SQRNetworkManager_PS3::GetSceNpCommsSig()); + + } + m_bLicenseChecked=true; +} + +bool SonyCommerce_PS3::LicenseChecked() +{ + return m_bLicenseChecked; +} + +void SonyCommerce_PS3::CheckForTrialUpgradeKey() +{ + // 4J-PB - If we are the blu ray disc then we are the full version + if(StorageManager.GetBootTypeDisc()) + { + CheckForTrialUpgradeKey_Callback(NULL,true); + } + else + { + StorageManager.CheckForTrialUpgradeKey(CheckForTrialUpgradeKey_Callback, NULL); + } +} + +int SonyCommerce_PS3::Shutdown() +{ + int ret=0; + if (m_contextCreated) + { + ret = sceNpCommerce2DestroyCtx(m_contextId); + if (ret != 0) + { + return ret; + } + + m_contextId = 0; + m_contextCreated = false; + } + + ret = sceNpCommerce2Term(); + m_bCommerceInitialised = false; + if (ret != 0) + { + return ret; + } + delete m_pCategoryID; + DeleteCriticalSection(&m_queueLock); + + return ret; +} + + + +int SonyCommerce_PS3::TickLoop(void* lpParam) +{ + ShutdownManager::HasStarted(ShutdownManager::eCommerceThread); + while( (m_currentPhase != e_phase_stopped) && ShutdownManager::ShouldRun(ShutdownManager::eCommerceThread) ) + { + processEvent(); + processMessage(); + Sleep(16); // sleep for a frame + } + + ShutdownManager::HasFinished(ShutdownManager::eCommerceThread); + + return 0; +} + +int SonyCommerce_PS3::getProductList(std::vector<ProductInfo>* productList, char *categoryId) +{ + int ret = 0; + uint32_t requestId; + size_t bufSize = sizeof(m_commercebuffer); + size_t fillSize = 0; + SceNpCommerce2GetCategoryContentsResult result; + SceNpCommerce2CategoryInfo categoryInfo; + SceNpCommerce2ContentInfo contentInfo; + SceNpCommerce2GameProductInfo productInfo; + SceNpCommerce2GameSkuInfo skuInfo; + ProductInfo tempInfo; + std::vector<ProductInfo> tempProductVec; + + if (!m_contextCreated) + { + ret = createContext(); + if (ret < 0) + { + setError(ret); + return ret; + } + } + + // Create request ID + ret = sceNpCommerce2GetCategoryContentsCreateReq(m_contextId, &requestId); + if (ret < 0) + { + setError(ret); + return ret; + } + + // Obtain category content data + ret = sceNpCommerce2GetCategoryContentsStart(requestId, categoryId, 0, SCE_NP_COMMERCE2_GETCAT_MAX_COUNT); + if (ret < 0) + { + sceNpCommerce2DestroyReq(requestId); + setError(ret); + return ret; + } + + ret = sceNpCommerce2GetCategoryContentsGetResult(requestId, m_commercebuffer, bufSize, &fillSize); + if (ret < 0) + { + sceNpCommerce2DestroyReq(requestId); + setError(ret); + return ret; + } + + ret = sceNpCommerce2DestroyReq(requestId); + if (ret < 0) + { + setError(ret); + return ret; + } + + // We have the initial category content data, + // now to take out the category content information. + ret = sceNpCommerce2InitGetCategoryContentsResult(&result, m_commercebuffer, fillSize); + if (ret < 0) + { + setError(ret); + return ret; + } + + // Get the category information + ret = sceNpCommerce2GetCategoryInfo(&result, &categoryInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + setError(ret); + return ret; + } + + if(categoryInfo.countOfProduct==0) + { + // There is no DLC + return 0; + } + + // Reserve some space + tempProductVec.reserve(categoryInfo.countOfProduct); + + // For each product, obtain information + for (int i = 0; i < result.rangeOfContents.count; i++) + { + ret = sceNpCommerce2GetContentInfo(&result, i, &contentInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + setError(ret); + return ret; + } + + // Only process if it is a product + if (contentInfo.contentType == SCE_NP_COMMERCE2_CONTENT_TYPE_PRODUCT) + { + + // reset tempInfo + memset(&tempInfo, 0x0, sizeof(tempInfo)); + + // Get product info + ret = sceNpCommerce2GetGameProductInfoFromContentInfo(&contentInfo, &productInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + setError(ret); + return ret; + } + + // populate our temp struct + + strncpy(tempInfo.productId, productInfo.productId, SCE_NP_COMMERCE2_PRODUCT_ID_LEN); + strncpy(tempInfo.productName, productInfo.productName, SCE_NP_COMMERCE2_PRODUCT_NAME_LEN); + strncpy(tempInfo.shortDescription, productInfo.productShortDescription, SCE_NP_COMMERCE2_PRODUCT_SHORT_DESCRIPTION_LEN); + if(tempInfo.longDescription[0]!=0) + { + strncpy(tempInfo.longDescription, productInfo.productLongDescription, SCE_NP_COMMERCE2_PRODUCT_LONG_DESCRIPTION_LEN); + } + else + { +#ifdef _DEBUG + strcpy(tempInfo.longDescription,"Missing long description"); +#endif + } + strncpy(tempInfo.spName, productInfo.spName, SCE_NP_COMMERCE2_SP_NAME_LEN); + strncpy(tempInfo.imageUrl, productInfo.imageUrl, SCE_NP_COMMERCE2_URL_LEN); + tempInfo.releaseDate = productInfo.releaseDate; + + if (productInfo.countOfSku == 1) + { + // Get SKU info + ret = sceNpCommerce2GetGameSkuInfoFromGameProductInfo(&productInfo, 0, &skuInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + setError(ret); + return ret; + } + tempInfo.purchasabilityFlag = skuInfo.purchasabilityFlag; + + // Take out the price. Nicely formatted + // but also keep the price as a value in case it's 0 - we need to show "free" for that + tempInfo.ui32Price= skuInfo.price; + ret = sceNpCommerce2GetPrice(m_contextId, tempInfo.price, sizeof(tempInfo.price), skuInfo.price); + + if (ret < 0) + { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + setError(ret); + return ret; + } + } + tempProductVec.push_back(tempInfo); + } + } + + // Set our result + *productList = tempProductVec; + + // Destroy the category contents result + ret = sceNpCommerce2DestroyGetCategoryContentsResult(&result); + if (ret < 0) + { + return ret; + } + + return ret; +} + +int SonyCommerce_PS3::getCategoryInfo(CategoryInfo *pInfo, char *categoryId) +{ + int ret = 0; + uint32_t requestId; + size_t bufSize = sizeof(m_commercebuffer); + size_t fillSize = 0; + SceNpCommerce2GetCategoryContentsResult result; + SceNpCommerce2CategoryInfo categoryInfo; + SceNpCommerce2ContentInfo contentInfo; + //CategoryInfo tempCatInfo; + CategoryInfoSub tempSubCatInfo; + + if (!m_contextCreated) + { + ret = createContext(); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + } + + // Create request ID + ret = sceNpCommerce2GetCategoryContentsCreateReq(m_contextId, &requestId); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + + // Obtain category content data + if (categoryId) + { + ret = sceNpCommerce2GetCategoryContentsStart(requestId, categoryId, 0, SCE_NP_COMMERCE2_GETCAT_MAX_COUNT); + } + else + { + ret = sceNpCommerce2GetCategoryContentsStart(requestId,categoryId, + 0, SCE_NP_COMMERCE2_GETCAT_MAX_COUNT); + } + if (ret < 0) + { + sceNpCommerce2DestroyReq(requestId); + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2GetCategoryContentsGetResult(requestId, m_commercebuffer, bufSize, &fillSize); + if (ret < 0) + { + if(ret==SCE_NP_COMMERCE2_ERROR_SERVER_MAINTENANCE) + { + app.DebugPrintf(4,"\n--- SCE_NP_COMMERCE2_ERROR_SERVER_MAINTENANCE ---\n\n"); + } + sceNpCommerce2DestroyReq(requestId); + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2DestroyReq(requestId); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + + // We have the initial category content data, + // now to take out the category content information. + ret = sceNpCommerce2InitGetCategoryContentsResult(&result, m_commercebuffer, fillSize); + if (ret < 0) { + m_errorCode = ret; + return ret; + } + + // Get the category information + ret = sceNpCommerce2GetCategoryInfo(&result, &categoryInfo); + if (ret < 0) { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + m_errorCode = ret; + return ret; + } + + strcpy(pInfo->current.categoryId, categoryInfo.categoryId); + strcpy(pInfo->current.categoryName, categoryInfo.categoryName); + strcpy(pInfo->current.categoryDescription, categoryInfo.categoryDescription); + strcpy(pInfo->current.imageUrl, categoryInfo.imageUrl); + pInfo->countOfProducts = categoryInfo.countOfProduct; + pInfo->countOfSubCategories = categoryInfo.countOfSubCategory; + + if (categoryInfo.countOfSubCategory > 0) + { + // For each sub category, obtain information + for (int i = 0; i < result.rangeOfContents.count; i++) + { + + ret = sceNpCommerce2GetContentInfo(&result, i, &contentInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + m_errorCode = ret; + return ret; + } + + // Only process if it is a category + if (contentInfo.contentType == SCE_NP_COMMERCE2_CONTENT_TYPE_CATEGORY) + { + + ret = sceNpCommerce2GetCategoryInfoFromContentInfo(&contentInfo, &categoryInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetCategoryContentsResult(&result); + m_errorCode = ret; + return ret; + } + + strcpy(tempSubCatInfo.categoryId, categoryInfo.categoryId); + strcpy(tempSubCatInfo.categoryName, categoryInfo.categoryName); + strcpy(tempSubCatInfo.categoryDescription, categoryInfo.categoryDescription); + strcpy(tempSubCatInfo.imageUrl, categoryInfo.imageUrl); + + // Add to the list + pInfo->subCategories.push_back(tempSubCatInfo); + } + } + } + + // Set our result + //*info = tempCatInfo; + + // Destroy the category contents result + ret = sceNpCommerce2DestroyGetCategoryContentsResult(&result); + if (ret < 0) { + return ret; + } + + return ret; +} + + +int SonyCommerce_PS3::getDetailedProductInfo(ProductInfoDetailed *pInfo, const char *productId, char *categoryId) +{ + int ret = 0; + uint32_t requestId; + size_t bufSize = sizeof(m_commercebuffer); + size_t fillSize = 0; + std::list<SceNpCommerce2ContentRatingDescriptor> ratingDescList; + SceNpCommerce2GetProductInfoResult result; + SceNpCommerce2ContentRatingInfo ratingInfo; + SceNpCommerce2GameProductInfo productInfo; + SceNpCommerce2GameSkuInfo skuInfo; + //ProductInfoDetailed tempInfo; + + if (!m_contextCreated) { + ret = createContext(); + if (ret < 0) { + m_errorCode = ret; + return ret; + } + } + + // Obtain product data + ret = sceNpCommerce2GetProductInfoCreateReq(m_contextId, &requestId); + if (ret < 0) { + m_errorCode = ret; + return ret; + } + + if (categoryId && categoryId[0] != 0) { + ret = sceNpCommerce2GetProductInfoStart(requestId, categoryId, productId); + } else { + ret = sceNpCommerce2GetProductInfoStart(requestId, NULL, productId); + } + if (ret < 0) { + sceNpCommerce2DestroyReq(requestId); + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2GetProductInfoGetResult(requestId, m_commercebuffer, bufSize, &fillSize); + if (ret < 0) { + sceNpCommerce2DestroyReq(requestId); + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2DestroyReq(requestId); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + + // Take Out Game Product Information + ret = sceNpCommerce2InitGetProductInfoResult(&result, m_commercebuffer, fillSize); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2GetGameProductInfo(&result, &productInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + + // Get rating info + ret = sceNpCommerce2GetContentRatingInfoFromGameProductInfo(&productInfo, &ratingInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + + for (int index = 0; index < ratingInfo.countOfContentRatingDescriptor; index++) + { + SceNpCommerce2ContentRatingDescriptor desc; + sceNpCommerce2GetContentRatingDescriptor(&ratingInfo, index, &desc); + ratingDescList.push_back(desc); + } + + // populate our temp struct + pInfo->ratingDescriptors = ratingDescList; + strncpy(pInfo->productId, productInfo.productId, SCE_NP_COMMERCE2_PRODUCT_ID_LEN); + strncpy(pInfo->productName, productInfo.productName, SCE_NP_COMMERCE2_PRODUCT_NAME_LEN); + strncpy(pInfo->shortDescription, productInfo.productShortDescription, SCE_NP_COMMERCE2_PRODUCT_SHORT_DESCRIPTION_LEN); + strncpy(pInfo->longDescription, productInfo.productLongDescription, SCE_NP_COMMERCE2_PRODUCT_LONG_DESCRIPTION_LEN); + strncpy(pInfo->legalDescription, productInfo.legalDescription, SCE_NP_COMMERCE2_PRODUCT_LEGAL_DESCRIPTION_LEN); + strncpy(pInfo->spName, productInfo.spName, SCE_NP_COMMERCE2_SP_NAME_LEN); + strncpy(pInfo->imageUrl, productInfo.imageUrl, SCE_NP_COMMERCE2_URL_LEN); + pInfo->releaseDate = productInfo.releaseDate; + strncpy(pInfo->ratingSystemId, ratingInfo.ratingSystemId, SCE_NP_COMMERCE2_RATING_SYSTEM_ID_LEN); + strncpy(pInfo->ratingImageUrl, ratingInfo.imageUrl, SCE_NP_COMMERCE2_URL_LEN); + + // Get SKU info + if (productInfo.countOfSku == 1) + { + ret = sceNpCommerce2GetGameSkuInfoFromGameProductInfo(&productInfo, 0, &skuInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + strncpy(pInfo->skuId, skuInfo.skuId, SCE_NP_COMMERCE2_SKU_ID_LEN); + pInfo->purchasabilityFlag = skuInfo.purchasabilityFlag; + + // Take out the price. Nicely formatted + // but also keep the price as a value in case it's 0 - we need to show "free" for that + pInfo->ui32Price= skuInfo.price; + ret = sceNpCommerce2GetPrice(m_contextId, pInfo->price, sizeof(pInfo->price), skuInfo.price); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + } + + // Set our result + //*info = tempInfo; + + ret = sceNpCommerce2DestroyGetProductInfoResult(&result); + if (ret < 0) + { + return ret; + } + + return ret; +} + + +int SonyCommerce_PS3::addDetailedProductInfo(ProductInfo *info, const char *productId, char *categoryId) +{ + int ret = 0; + uint32_t requestId; + size_t bufSize = sizeof(m_commercebuffer); + size_t fillSize = 0; + std::list<SceNpCommerce2ContentRatingDescriptor> ratingDescList; + SceNpCommerce2GetProductInfoResult result; + SceNpCommerce2ContentRatingInfo ratingInfo; + SceNpCommerce2GameProductInfo productInfo; + SceNpCommerce2GameSkuInfo skuInfo; + //ProductInfoDetailed tempInfo; + + if (!m_contextCreated) + { + ret = createContext(); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + } + + // Obtain product data + ret = sceNpCommerce2GetProductInfoCreateReq(m_contextId, &requestId); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + + if (categoryId && categoryId[0] != 0) + { + ret = sceNpCommerce2GetProductInfoStart(requestId, categoryId, productId); + } + else + { + ret = sceNpCommerce2GetProductInfoStart(requestId, categoryId, productId); + } + if (ret < 0) { + sceNpCommerce2DestroyReq(requestId); + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2GetProductInfoGetResult(requestId, m_commercebuffer, bufSize, &fillSize); + if (ret < 0) + { + sceNpCommerce2DestroyReq(requestId); + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2DestroyReq(requestId); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + + // Take Out Game Product Information + ret = sceNpCommerce2InitGetProductInfoResult(&result, m_commercebuffer, fillSize); + if (ret < 0) + { + m_errorCode = ret; + return ret; + } + + ret = sceNpCommerce2GetGameProductInfo(&result, &productInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + + // Get rating info + ret = sceNpCommerce2GetContentRatingInfoFromGameProductInfo(&productInfo, &ratingInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + + for (int index = 0; index < ratingInfo.countOfContentRatingDescriptor; index++) + { + SceNpCommerce2ContentRatingDescriptor desc; + sceNpCommerce2GetContentRatingDescriptor(&ratingInfo, index, &desc); + ratingDescList.push_back(desc); + } + + // populate our temp struct +// tempInfo.ratingDescriptors = ratingDescList; +// strncpy(tempInfo.productId, productInfo.productId, SCE_NP_COMMERCE2_PRODUCT_ID_LEN); +// strncpy(tempInfo.productName, productInfo.productName, SCE_NP_COMMERCE2_PRODUCT_NAME_LEN); +// strncpy(tempInfo.shortDescription, productInfo.productShortDescription, SCE_NP_COMMERCE2_PRODUCT_SHORT_DESCRIPTION_LEN); + strncpy(info->longDescription, productInfo.productLongDescription, SCE_NP_COMMERCE2_PRODUCT_LONG_DESCRIPTION_LEN); +// strncpy(tempInfo.legalDescription, productInfo.legalDescription, SCE_NP_COMMERCE2_PRODUCT_LEGAL_DESCRIPTION_LEN); +// strncpy(tempInfo.spName, productInfo.spName, SCE_NP_COMMERCE2_SP_NAME_LEN); +// strncpy(tempInfo.imageUrl, productInfo.imageUrl, SCE_NP_COMMERCE2_URL_LEN); +// tempInfo.releaseDate = productInfo.releaseDate; +// strncpy(tempInfo.ratingSystemId, ratingInfo.ratingSystemId, SCE_NP_COMMERCE2_RATING_SYSTEM_ID_LEN); +// strncpy(tempInfo.ratingImageUrl, ratingInfo.imageUrl, SCE_NP_COMMERCE2_URL_LEN); + + // Get SKU info + if (productInfo.countOfSku == 1) + { + ret = sceNpCommerce2GetGameSkuInfoFromGameProductInfo(&productInfo, 0, &skuInfo); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + strncpy(info->skuId, skuInfo.skuId, SCE_NP_COMMERCE2_SKU_ID_LEN); + info->purchasabilityFlag = skuInfo.purchasabilityFlag; + info->annotation = skuInfo.annotation; + + // Take out the price. Nicely formatted + // but also keep the price as a value in case it's 0 - we need to show "free" for that + info->ui32Price= skuInfo.price; + ret = sceNpCommerce2GetPrice(m_contextId, info->price, sizeof(info->price), skuInfo.price); + if (ret < 0) + { + sceNpCommerce2DestroyGetProductInfoResult(&result); + m_errorCode = ret; + return ret; + } + } + else + { + // 4J-PB - more than one sku id! We have to be able to use the sku id returned for a product, so there is not supposed to be more than 1 + app.DebugPrintf("MORE THAN 1 SKU ID FOR %s\n",info->productName); + } + + // Set our result + //*info = tempInfo; + + ret = sceNpCommerce2DestroyGetProductInfoResult(&result); + if (ret < 0) + { + return ret; + } + + return ret; +} + + +int SonyCommerce_PS3::checkout(CheckoutInputParams ¶ms) +{ + int ret = 0; + const char *skuIdsTemp[SCE_NP_COMMERCE2_SKU_CHECKOUT_MAX]; + std::list<const char *>::iterator iter = params.skuIds.begin(); + std::list<const char *>::iterator iterEnd = params.skuIds.end(); + + if (!m_contextCreated) { + ret = createContext(); + if (ret < 0) { + return ret; + } + } + + for (int i = 0; i < params.skuIds.size(); i++) { + skuIdsTemp[i] = (const char *)(*iter); + iter++; + } + + ret = sceNpCommerce2DoCheckoutStartAsync(m_contextId, skuIdsTemp, params.skuIds.size(), *params.memContainer); + if (ret < 0) { + return ret; + } + + return CELL_OK; +} + + +int SonyCommerce_PS3::downloadList(DownloadListInputParams ¶ms) +{ + int ret = 0; + const char *skuIdsTemp[SCE_NP_COMMERCE2_SKU_CHECKOUT_MAX]; + std::list<const char *>::iterator iter = params.skuIds.begin(); + std::list<const char *>::iterator iterEnd = params.skuIds.end(); + + if (!m_contextCreated) { + ret = createContext(); + if (ret < 0) { + return ret; + } + } + + for (int i = 0; i < params.skuIds.size(); i++) { + skuIdsTemp[i] = (const char *)(*iter); + iter++; + } + ret = sceNpCommerce2DoDlListStartAsync(m_contextId, app.GetCommerceCategory(), skuIdsTemp, params.skuIds.size(), *params.memContainer); + if (ret < 0) { + return ret; + } + + return CELL_OK; +} + +void SonyCommerce_PS3::UpgradeTrialCallback2(LPVOID lpParam,int err) +{ + SonyCommerce* pCommerce = (SonyCommerce*)lpParam; + app.DebugPrintf(4,"SonyCommerce_UpgradeTrialCallback2 : err : 0x%08x\n", err); + pCommerce->CheckForTrialUpgradeKey(); + if(err != CELL_OK) + { + UINT uiIDA[1]; + uiIDA[0]=IDS_CONFIRM_OK; + C4JStorage::EMessageResult result = ui.RequestMessageBox( IDS_PRO_UNLOCKGAME_TITLE, IDS_NO_DLCOFFERS, uiIDA,1,ProfileManager.GetPrimaryPad()); + } + m_trialUpgradeCallbackFunc(m_trialUpgradeCallbackParam, m_errorCode); +} + +void SonyCommerce_PS3::UpgradeTrialCallback1(LPVOID lpParam,int err) +{ + SonyCommerce* pCommerce = (SonyCommerce*)lpParam; + app.DebugPrintf(4,"SonyCommerce_UpgradeTrialCallback1 : err : 0x%08x\n", err); + if(err == CELL_OK) + { + const char* skuID = s_trialUpgradeProductInfoDetailed.skuId; + if(s_trialUpgradeProductInfoDetailed.purchasabilityFlag == SCE_NP_COMMERCE2_SKU_PURCHASABILITY_FLAG_OFF) + { + app.DebugPrintf(4,"UpgradeTrialCallback1 - DownloadAlreadyPurchased\n"); + pCommerce->DownloadAlreadyPurchased(UpgradeTrialCallback2, pCommerce, skuID); + } + else + { + app.DebugPrintf(4,"UpgradeTrialCallback1 - Checkout\n"); + pCommerce->Checkout(UpgradeTrialCallback2, pCommerce, skuID); + } + } + else + { + UINT uiIDA[1]; + uiIDA[0]=IDS_CONFIRM_OK; + C4JStorage::EMessageResult result = ui.RequestMessageBox( IDS_PRO_UNLOCKGAME_TITLE, IDS_NO_DLCOFFERS, uiIDA,1,ProfileManager.GetPrimaryPad()); + m_trialUpgradeCallbackFunc(m_trialUpgradeCallbackParam, m_errorCode); + } +} + + + +// global func, so we can call from the profile lib +void SonyCommerce_UpgradeTrial() +{ + // we're now calling the app function here, which manages pending requests + app.UpgradeTrial(); +} + +void SonyCommerce_PS3::UpgradeTrial(CallbackFunc cb, LPVOID lpParam) +{ + m_trialUpgradeCallbackFunc = cb; + m_trialUpgradeCallbackParam = lpParam; + +// static char szTrialUpgradeSkuID[64]; +// sprintf(szTrialUpgradeSkuID, "%s-TRIALUPGRADE0001", app.GetCommerceCategory());//, szSKUSuffix); + GetDetailedProductInfo(UpgradeTrialCallback1, this, &s_trialUpgradeProductInfoDetailed, app.GetUpgradeKey(), app.GetCommerceCategory()); +} + + +int SonyCommerce_PS3::createContext() +{ + SceNpId npId; + int ret = sceNpManagerGetNpId(&npId); + if(ret < 0) + { + app.DebugPrintf(4,"createContext sceNpManagerGetNpId problem\n"); + return ret; + } + + if (m_contextCreated) { + ret = sceNpCommerce2DestroyCtx(m_contextId); + if (ret < 0) + { + app.DebugPrintf(4,"createContext sceNpCommerce2DestroyCtx problem\n"); + return ret; + } + } + + // Create commerce2 context + ret = sceNpCommerce2CreateCtx(SCE_NP_COMMERCE2_VERSION, &npId, commerce2Handler, NULL, &m_contextId); + if (ret < 0) + { + app.DebugPrintf(4,"createContext sceNpCommerce2CreateCtx problem\n"); + return ret; + } + + m_contextCreated = true; + + return CELL_OK; +} + +int SonyCommerce_PS3::createSession() +{ + int ret = createContext(); + if (ret < 0) { + return ret; + } + + m_currentPhase = e_phase_creatingSessionPhase; + ret = sceNpCommerce2CreateSessionStart(m_contextId); + if (ret < 0) { + return ret; + } + return ret; +} + + +void SonyCommerce_PS3::commerce2Handler(uint32_t contextId, uint32_t subjectId, int event, int errorCode, void *arg) +{ +// Event reply; +// reply.service = Toolkit::NP::commerce; +// + EnterCriticalSection(&m_queueLock); + + switch (event) { + case SCE_NP_COMMERCE2_EVENT_REQUEST_ERROR: + { + m_messageQueue.push(e_message_commerceEnd); + m_errorCode = errorCode; + break; + } + case SCE_NP_COMMERCE2_EVENT_CREATE_SESSION_DONE: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceSessionCreated; + break; + } + case SCE_NP_COMMERCE2_EVENT_CREATE_SESSION_ABORT: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceSessionAborted; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_STARTED: + { + m_currentPhase = e_phase_checkoutPhase; + m_event = e_event_commerceCheckoutStarted; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_SUCCESS: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceCheckoutSuccess; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_BACK: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceCheckoutAborted; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_FINISHED: + { + m_event = e_event_commerceCheckoutFinished; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_STARTED: + { + m_currentPhase = e_phase_downloadListPhase; + m_event = e_event_commerceDownloadListStarted; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_SUCCESS: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceDownloadListSuccess; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_FINISHED: + { + m_event = e_event_commerceDownloadListFinished; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_STARTED: + m_currentPhase = e_phase_productBrowsePhase; + m_event = e_event_commerceProductBrowseStarted; + break; + case SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_SUCCESS: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceProductBrowseSuccess; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_BACK: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceProductBrowseAborted; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_FINISHED: + { + m_event = e_event_commerceProductBrowseFinished; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_OPENED: + break; + case SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_STARTED: + { + m_currentPhase = e_phase_voucherRedeemPhase; + m_event = e_event_commerceVoucherInputStarted; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_SUCCESS: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceVoucherInputSuccess; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_BACK: + { + m_messageQueue.push(e_message_commerceEnd); + m_event = e_event_commerceVoucherInputAborted; + break; + } + case SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_FINISHED: + { + m_event = e_event_commerceVoucherInputFinished; + break; + } + default: + break; + }; + + LeaveCriticalSection(&m_queueLock); +} + + + +void SonyCommerce_PS3::processMessage() +{ + EnterCriticalSection(&m_queueLock); + int ret; + if(m_messageQueue.empty()) + { + LeaveCriticalSection(&m_queueLock); + return; + } + Message msg = m_messageQueue.front(); + m_messageQueue.pop(); + + switch (msg) + { + + case e_message_commerceCreateSession: + ret = createSession(); + if (ret < 0) + { + m_event = e_event_commerceError; + m_errorCode = ret; + } + break; + + case e_message_commerceGetCategoryInfo: + { + ret = getCategoryInfo(m_pCategoryInfo, m_pCategoryID); + if (ret < 0) + { + m_event = e_event_commerceError; + app.DebugPrintf(4,"ERROR - e_event_commerceGotCategoryInfo - %s\n",m_pCategoryID); + m_errorCode = ret; + } + else + { + m_event = e_event_commerceGotCategoryInfo; + app.DebugPrintf(4,"e_event_commerceGotCategoryInfo - %s\n",m_pCategoryID); + } + break; + } + + case e_message_commerceGetProductList: + { + ret = getProductList(m_pProductInfoList, m_pCategoryID); + if (ret < 0) + { + m_event = e_event_commerceError; + } + else + { + m_event = e_event_commerceGotProductList; + app.DebugPrintf(4,"e_event_commerceGotProductList - %s\n",m_pCategoryID); + } + break; + } + + case e_message_commerceGetDetailedProductInfo: + { + ret = getDetailedProductInfo(m_pProductInfoDetailed, m_pProductID, m_pCategoryID); + if (ret < 0) + { + m_event = e_event_commerceError; + m_errorCode = ret; + } + else + { + m_event = e_event_commerceGotDetailedProductInfo; + app.DebugPrintf(4,"e_event_commerceGotDetailedProductInfo - %s\n",m_pCategoryID); + } + break; + } + case e_message_commerceAddDetailedProductInfo: + { + ret = addDetailedProductInfo(m_pProductInfo, m_pProductID, m_pCategoryID); + if (ret < 0) + { + m_event = e_event_commerceError; + m_errorCode = ret; + } + else + { + m_event = e_event_commerceAddedDetailedProductInfo; + } + break; + } + +// +// case e_message_commerceStoreProductBrowse: +// { +// ret = productBrowse(*(ProductBrowseParams *)msg.inputArgs); +// if (ret < 0) { +// m_event = e_event_commerceError; +// m_errorCode = ret; +// } +// _TOOLKIT_NP_DEL (ProductBrowseParams *)msg.inputArgs; +// break; +// } +// +// case e_message_commerceUpgradeTrial: +// { +// ret = upgradeTrial(); +// if (ret < 0) { +// m_event = e_event_commerceError; +// m_errorCode = ret; +// } +// break; +// } +// +// case e_message_commerceRedeemVoucher: +// { +// ret = voucherCodeInput(*(VoucherInputParams *)msg.inputArgs); +// if (ret < 0) { +// m_event = e_event_commerceError; +// m_errorCode = ret; +// } +// _TOOLKIT_NP_DEL (VoucherInputParams *)msg.inputArgs; +// break; +// } +// +// case e_message_commerceGetEntitlementList: +// { +// Job<std::vector<SceNpEntitlement> > tmpJob(static_cast<Future<std::vector<SceNpEntitlement> > *>(msg.output)); +// +// int state = 0; +// int ret = sceNpManagerGetStatus(&state); +// +// // We don't want to process this if we are offline +// if (ret < 0 || state != SCE_NP_MANAGER_STATUS_ONLINE) { +// m_event = e_event_commerceError; +// reply.returnCode = SCE_TOOLKIT_NP_OFFLINE; +// tmpJob.setError(SCE_TOOLKIT_NP_OFFLINE); +// } else { +// getEntitlementList(&tmpJob); +// } +// break; +// } +// +// case e_message_commerceConsumeEntitlement: +// { +// int state = 0; +// int ret = sceNpManagerGetStatus(&state); +// +// // We don't want to process this if we are offline +// if (ret < 0 || state != SCE_NP_MANAGER_STATUS_ONLINE) { +// m_event = e_event_commerceError; +// reply.returnCode = SCE_TOOLKIT_NP_OFFLINE; +// } else { +// +// ret = consumeEntitlement(*(EntitlementToConsume *)msg.inputArgs); +// if (ret < 0) { +// m_event = e_event_commerceError; +// m_errorCode = ret; +// } else { +// m_event = e_event_commerceConsumedEntitlement; +// } +// } +// _TOOLKIT_NP_DEL (EntitlementToConsume *)msg.inputArgs; +// +// break; +// } +// + case e_message_commerceCheckout: + { + ret = checkout(m_checkoutInputParams); + if (ret < 0) { + m_event = e_event_commerceError; + m_errorCode = ret; + } + break; + } + + case e_message_commerceDownloadList: + { + ret = downloadList(m_downloadInputParams); + if (ret < 0) { + m_event = e_event_commerceError; + m_errorCode = ret; + } + break; + } + + case e_message_commerceEnd: + app.DebugPrintf("XXX - e_message_commerceEnd!\n"); + ret = commerceEnd(); + if (ret < 0) + { + m_event = e_event_commerceError; + m_errorCode = ret; + } + // 4J-PB - we don't seem to handle the error code here + else if(m_errorCode!=0) + { + m_event = e_event_commerceError; + } + break; + + default: + break; + } + + LeaveCriticalSection(&m_queueLock); +} + + +void SonyCommerce_PS3::processEvent() +{ + int ret = 0; + + switch (m_event) + { + case e_event_none: + break; + case e_event_commerceSessionCreated: + app.DebugPrintf(4,"Commerce Session Created.\n"); + runCallback(); + break; + case e_event_commerceSessionAborted: + app.DebugPrintf(4,"Commerce Session aborted.\n"); + runCallback(); + break; + case e_event_commerceGotProductList: + app.DebugPrintf(4,"Got product list.\n"); + runCallback(); + break; + case e_event_commerceGotCategoryInfo: + app.DebugPrintf(4,"Got category info\n"); + runCallback(); + break; + case e_event_commerceGotDetailedProductInfo: + app.DebugPrintf(4,"Got detailed product info.\n"); + runCallback(); + break; + case e_event_commerceAddedDetailedProductInfo: + app.DebugPrintf(4,"Added detailed product info.\n"); + runCallback(); + break; + case e_event_commerceProductBrowseStarted: + break; + case e_event_commerceProductBrowseSuccess: + break; + case e_event_commerceProductBrowseAborted: + break; + case e_event_commerceProductBrowseFinished: + assert(0); +// ret = sys_memory_container_destroy(s_memContainer); +// if (ret < 0) { +// printf("Failed to destroy memory container"); +// } +// s_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID; + break; + case e_event_commerceVoucherInputStarted: + break; + case e_event_commerceVoucherInputSuccess: + break; + case e_event_commerceVoucherInputAborted: + break; + case e_event_commerceVoucherInputFinished: + assert(0); +// ret = sys_memory_container_destroy(s_memContainer); +// if (ret < 0) { +// printf("Failed to destroy memory container"); +// } +// s_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID; + break; + case e_event_commerceGotEntitlementList: + break; + case e_event_commerceConsumedEntitlement: + break; + case e_event_commerceCheckoutStarted: + app.DebugPrintf(4,"Checkout Started\n"); + break; + case e_event_commerceCheckoutSuccess: + app.DebugPrintf(4,"Checkout succeeded: 0x%x\n", m_errorCode); + // clear the DLC installed and check again + app.ClearDLCInstalled(); + ui.HandleDLCInstalled(0); + break; + case e_event_commerceCheckoutAborted: + app.DebugPrintf(4,"Checkout aborted: 0x%x\n", m_errorCode); + break; + case e_event_commerceCheckoutFinished: + app.DebugPrintf(4,"Checkout Finished: 0x%x\n", m_errorCode); + ret = sys_memory_container_destroy(m_memContainer); + if (ret < 0) { + app.DebugPrintf(4,"Failed to destroy memory container"); + } + + m_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID; + // 4J-PB - if there's been an error - like dlc already purchased, the runcallback has already happened, and will crash this time + if(m_callbackFunc!=NULL) + { + runCallback(); + } + break; + case e_event_commerceDownloadListStarted: + app.DebugPrintf(4,"Download List Started\n"); + break; + case e_event_commerceDownloadListSuccess: + app.DebugPrintf(4,"Download succeeded: 0x%x\n", m_errorCode); + // 4J-PB - they may or may not have downloaded DLC + // clear the DLC installed and check again + app.ClearDLCInstalled(); + ui.HandleDLCInstalled(0); + break; + case e_event_commerceDownloadListFinished: + app.DebugPrintf(4,"Download Finished: 0x%x\n", m_errorCode); + ret = sys_memory_container_destroy(m_memContainer); + if (ret < 0) { + app.DebugPrintf(4,"Failed to destroy memory container"); + } + + m_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID; + // 4J-PB - if there's been an error - like dlc already purchased, the runcallback has already happened, and will crash this time + if(m_callbackFunc!=NULL) + { + runCallback(); + } + break; + case e_event_commerceError: + app.DebugPrintf(4,"Commerce Error 0x%x\n", m_errorCode); + + if(m_memContainer != SYS_MEMORY_CONTAINER_ID_INVALID) + { + ret = sys_memory_container_destroy(m_memContainer); + if (ret < 0) { + app.DebugPrintf(4,"Failed to destroy memory container"); + } + + m_memContainer = SYS_MEMORY_CONTAINER_ID_INVALID; + } + + runCallback(); + break; + default: + break; + } + m_event = e_event_none; +} + + +int SonyCommerce_PS3::commerceEnd() +{ + int ret = 0; + + if (m_currentPhase == e_phase_voucherRedeemPhase) + ret = sceNpCommerce2DoProductCodeFinishAsync(m_contextId); + else if (m_currentPhase == e_phase_productBrowsePhase) + ret = sceNpCommerce2DoProductBrowseFinishAsync(m_contextId); + else if (m_currentPhase == e_phase_creatingSessionPhase) + ret = sceNpCommerce2CreateSessionFinish(m_contextId, &m_sessionInfo); + else if (m_currentPhase == e_phase_checkoutPhase) + ret = sceNpCommerce2DoCheckoutFinishAsync(m_contextId); + else if (m_currentPhase == e_phase_downloadListPhase) + ret = sceNpCommerce2DoDlListFinishAsync(m_contextId); + + m_currentPhase = e_phase_idle; + + return ret; +} + +void SonyCommerce_PS3::CreateSession( CallbackFunc cb, LPVOID lpParam ) +{ + // 4J-PB - reset any previous error code + // I had this happen when I was offline on Vita, and accepted the PSN sign-in + // the m_errorCode was picked up in the message queue after the commerce init call + if(m_errorCode!=0) + { + app.DebugPrintf("m_errorCode was set!\n"); + m_errorCode=0; + } + Init(); + EnterCriticalSection(&m_queueLock); + setCallback(cb,lpParam); + m_messageQueue.push(e_message_commerceCreateSession); + if(m_tickThread == NULL) + m_tickThread = new C4JThread(TickLoop, NULL, "SonyCommerce_PS3 tick"); + if(m_tickThread->isRunning() == false) + { + m_currentPhase = e_phase_idle; + m_tickThread->Run(); + } + LeaveCriticalSection(&m_queueLock); +} + +void SonyCommerce_PS3::CloseSession() +{ + assert(m_currentPhase == e_phase_idle); + m_currentPhase = e_phase_stopped; + Shutdown(); +} + +void SonyCommerce_PS3::GetProductList( CallbackFunc cb, LPVOID lpParam, std::vector<ProductInfo>* productList, const char *categoryId) +{ + EnterCriticalSection(&m_queueLock); + setCallback(cb,lpParam); + m_pProductInfoList = productList; + strcpy(m_pCategoryID,categoryId); + m_messageQueue.push(e_message_commerceGetProductList); + LeaveCriticalSection(&m_queueLock); +} + +void SonyCommerce_PS3::GetDetailedProductInfo( CallbackFunc cb, LPVOID lpParam, ProductInfoDetailed* productInfo, const char *productId, const char *categoryId ) +{ + EnterCriticalSection(&m_queueLock); + setCallback(cb,lpParam); + m_pProductInfoDetailed = productInfo; + m_pProductID = productId; + strcpy(m_pCategoryID,categoryId); + m_messageQueue.push(e_message_commerceGetDetailedProductInfo); + LeaveCriticalSection(&m_queueLock); +} + +// 4J-PB - fill out the long description and the price for the product +void SonyCommerce_PS3::AddDetailedProductInfo( CallbackFunc cb, LPVOID lpParam, ProductInfo* productInfo, const char *productId, const char *categoryId ) +{ + EnterCriticalSection(&m_queueLock); + setCallback(cb,lpParam); + m_pProductInfo = productInfo; + m_pProductID = productId; + strcpy(m_pCategoryID,categoryId); + m_messageQueue.push(e_message_commerceAddDetailedProductInfo); + LeaveCriticalSection(&m_queueLock); +} +void SonyCommerce_PS3::GetCategoryInfo( CallbackFunc cb, LPVOID lpParam, CategoryInfo *info, const char *categoryId ) +{ + EnterCriticalSection(&m_queueLock); + setCallback(cb,lpParam); + m_pCategoryInfo = info; + strcpy(m_pCategoryID,categoryId); + m_messageQueue.push(e_message_commerceGetCategoryInfo); + LeaveCriticalSection(&m_queueLock); +} + +void SonyCommerce_PS3::Checkout( CallbackFunc cb, LPVOID lpParam, const char* skuID ) +{ + if(m_memContainer != SYS_MEMORY_CONTAINER_ID_INVALID) + { + return; + } + EnterCriticalSection(&m_queueLock); + setCallback(cb,lpParam); + int ret = sys_memory_container_create(&m_memContainer, SCE_NP_COMMERCE2_DO_CHECKOUT_MEMORY_CONTAINER_SIZE); + if (ret < 0) + { + app.DebugPrintf(4,"sys_memory_container_create() failed. ret = 0x%x\n", ret); + } + + m_checkoutInputParams.memContainer = &m_memContainer; + m_checkoutInputParams.skuIds.clear(); + m_checkoutInputParams.skuIds.push_back(skuID); + m_messageQueue.push(e_message_commerceCheckout); + LeaveCriticalSection(&m_queueLock); +} + +void SonyCommerce_PS3::DownloadAlreadyPurchased( CallbackFunc cb, LPVOID lpParam, const char* skuID ) +{ + if(m_memContainer != SYS_MEMORY_CONTAINER_ID_INVALID) + return; + EnterCriticalSection(&m_queueLock); + setCallback(cb,lpParam); + int ret = sys_memory_container_create(&m_memContainer, SCE_NP_COMMERCE2_DO_CHECKOUT_MEMORY_CONTAINER_SIZE); + if (ret < 0) + { + app.DebugPrintf(4,"sys_memory_container_create() failed. ret = 0x%x\n", ret); + } + + m_downloadInputParams.memContainer = &m_memContainer; + m_downloadInputParams.skuIds.clear(); + m_downloadInputParams.skuIds.push_back(skuID); + m_messageQueue.push(e_message_commerceDownloadList); + LeaveCriticalSection(&m_queueLock); +} + + + |