?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
!I 1937152 from //dev_game_hunt/consoles_candidate: !B Remove allocations of unnecess...
[CRYENGINE.git] / Code / CryPlugins / CryLobby / Module / PSNOrbis / CryPSN2LobbyUI.cpp
blob338e07fa2536a5a4cd17101f09c87c2b650534ee
1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
2
3 #include "StdAfx.h"
4
5 #if CRY_PLATFORM_ORBIS
6
7 #include "CryPSN2Lobby.h"
8
9 #if USE_PSN
10
11 #include <libsysmodule.h>
12 #include <CryString/StringUtils.h>
13 #include <invitation_dialog.h>
14 #include <np_profile_dialog.h>
15 #include <np_friendlist_dialog.h>
16 #include <np_commerce_dialog.h>
17
18 #include "CryPSN2WebApi_Presence.h"
19 #include "CryPSN2WebApi_RecentPlayers.h"
20 #include "CryPSN2WebApi_FriendsList.h"
21 #include "CryPSN2WebApi_ActivityFeed.h"
22 #include "CryPSN2WebApi_Store.h"
23
24 #define LOBBYUI_PARAM_NPID_LIST 0 //-- mem
25 #define LOBBYUI_PARAM_ONLINEID_LIST 0 //-- mem
26 #define LOBBYUI_PARAM_SESSION_ID 1 //-- mem
27
28 #define LOBBYUI_PARAM_NUM_NPIDS 0 //-- num
29
30 #define LOBBYUI_PARAM_RICHPRESENCE 0 //-- ptr and id
31
32 #define LOBBYUI_PARAM_ADDRECENTPLAYERS 0 //-- ptr and id
33
34 #define LOBBYUI_PARAM_ADDACTIVITYFEED 0 //-- ptr and id
35
36 #define LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST 0 //-- ptr and id
37 #define LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS 1 //-- ptr and id
38
39 #define LOBBYUI_PARAM_GETCONSUMABLEASSETS_REQUEST 0 //-- id only
40 #define LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS 1 //-- ptr and id
41
42 #define LOBBYUI_PARAM_CONSUMEASSET_REQUEST 0 //-- ptr and id
43 #define LOBBYUI_PARAM_CONSUMEASSET_RESULTS 1 //-- number
44
45 #define LOBBYUI_PARAM_SHOWDOWNLOADOFFER_ID 0 //-- ptr
46
47 void CCryPSNLobbyUI::SupportCallback(ECryPSNSupportCallbackEvent ecb, SCryPSNSupportCallbackEventData& data, void* pArg)
48 {
49 CCryPSNLobbyUI* _this = static_cast<CCryPSNLobbyUI*>(pArg);
50
51 switch (ecb)
52 {
53 case eCE_WebApiEvent:
54 {
55 // A WebAPI request completed. Chances are it was triggered by a task in LobbyUI.
56 // Check to see if any running task matches the WebApiJobId.
57 for (uint32 i = 0; i < MAX_LOBBYUI_TASKS; i++)
58 {
59 STask* pTask = &_this->m_task[i];
60
61 if (pTask->used && pTask->running)
62 {
63 switch (pTask->subTask)
64 {
65 case eST_WaitingForRichPresenceCallback:
66 {
67 // running set rich presence task
68 if (data.m_webApiEvent.m_id == pTask->paramsNum[LOBBYUI_PARAM_RICHPRESENCE])
69 {
70 // match! Update the task error state and stop the task running
71 if (data.m_webApiEvent.m_error != PSN_OK)
72 {
73 // some kind of error occurred, but we don't care for rich presence
74 _this->UpdateTaskError(i, eCLE_Success);
75 }
76 _this->StopTaskRunning(i);
77 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
78 }
79 }
80 break;
81 case eST_WaitingForAddRecentPlayersCallback:
82 {
83 // running add recent players task
84 if (data.m_webApiEvent.m_id == pTask->paramsNum[LOBBYUI_PARAM_ADDRECENTPLAYERS])
85 {
86 // match! Update the task error state and stop the task running
87 if (data.m_webApiEvent.m_error != PSN_OK)
88 {
89 // some kind of error occurred.
90 _this->UpdateTaskError(i, eCLE_InternalError);
91 }
92 _this->StopTaskRunning(i);
93 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
94 }
95 }
96 break;
97 case eST_WaitingForAddActivityFeedCallback:
98 {
99 // running add activity feed task
100 if (data.m_webApiEvent.m_id == pTask->paramsNum[LOBBYUI_PARAM_ADDACTIVITYFEED])
101 {
102 // match! Update the task error state and stop the task running
103 if (data.m_webApiEvent.m_error != PSN_OK)
104 {
105 // some kind of error occurred.
106 _this->UpdateTaskError(i, eCLE_InternalError);
107 }
108 _this->StopTaskRunning(i);
109 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
110 }
111 }
112 break;
113 case eST_WaitingForConsumableOffersCallback:
114 {
115 if (data.m_webApiEvent.m_id == pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST])
116 {
117 // match! Update the task error state and stop the task running
118 if (data.m_webApiEvent.m_error == PSN_OK)
119 {
120 _this->EventWebApiGetConsumableOffers(i, data);
121 }
122 else
123 {
124 // some kind of error occurred.
125 _this->UpdateTaskError(i, eCLE_InternalError);
126 }
127 _this->StopTaskRunning(i);
128 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
129 }
130 }
131 break;
132 case eST_WaitingForConsumableAssetsCallback:
133 {
134 if (data.m_webApiEvent.m_id == pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_REQUEST])
135 {
136 // match! Update the task error state and stop the task running
137 if (data.m_webApiEvent.m_error == PSN_OK)
138 {
139 _this->EventWebApiGetConsumableAssets(i, data);
140 }
141 else
142 {
143 // some kind of error occurred.
144 _this->UpdateTaskError(i, eCLE_InternalError);
145 }
146 _this->StopTaskRunning(i);
147 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
148 }
149 }
150 break;
151 case eST_WaitingForConsumeAssetCallback:
152 {
153 if (data.m_webApiEvent.m_id == pTask->paramsNum[LOBBYUI_PARAM_CONSUMEASSET_REQUEST])
154 {
155 // match! Update the task error state and stop the task running
156 if (data.m_webApiEvent.m_error == PSN_OK)
157 {
158 _this->EventWebApiConsumeAsset(i, data);
159 }
160 else
161 {
162 // some kind of error occurred.
163 _this->UpdateTaskError(i, eCLE_InternalError);
164 }
165 _this->StopTaskRunning(i);
166 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
167 }
168 }
169 break;
170 }
171 }
172 }
173 }
174 break;
175
176 case eCE_ErrorEvent:
177 {
178 for (uint32 i = 0; i < MAX_LOBBYUI_TASKS; i++)
179 {
180 STask* pTask = &_this->m_task[i];
181
182 if (pTask->used && pTask->running)
183 {
184 _this->UpdateTaskError(i, MapSupportErrorToLobbyError(data.m_errorEvent.m_error));
185 }
186 }
187 }
188 break;
189 }
190 }
191
192 CCryPSNLobbyUI::CCryPSNLobbyUI(CCryLobby* pLobby, CCryLobbyService* pService, CCryPSNSupport* pSupport) : CCryLobbyUI(pLobby, pService)
193 {
194 m_pPSNSupport = pSupport;
195
196 // Make the CCryLobbyUI base pointers point to our data so we can use the common code in CCryLobbyUI
197 for (uint32 i = 0; i < MAX_LOBBYUI_TASKS; i++)
198 {
199 CCryLobbyUI::m_pTask[i] = &m_task[i];
200 }
201 }
202
203 // TODO: These are for internal tests only during development! Need to be removed later!
204 void TestWebAPIFeature(IConsoleCmdArgs* pArgs)
205 {
206 if (pArgs->GetArgCount() == 2)
207 {
208 INetwork* pNetwork = gEnv->pNetwork;
209 ICryLobbyUI* pLobbyUI = NULL;
210 if (pNetwork != NULL)
211 {
212 ICryLobby* pLobby = pNetwork->GetLobby();
213 if (pLobby != NULL)
214 {
215 ICryLobbyService* pLobbyService = pLobby->GetLobbyService(eCLS_Online);
216 if (pLobbyService != NULL)
217 {
218 pLobbyUI = pLobbyService->GetLobbyUI();
219 }
220 }
221 }
222 if (pLobbyUI)
223 {
224 if (!strcmp(pArgs->GetArg(1), "presence"))
225 {
226 // send idle presence
227 SCryLobbyUserData data;
228 data.m_id = 1;
229 data.m_type = eCLUDT_Int32;
230 data.m_int32 = 4;
231 ECryLobbyError error = pLobbyUI->SetRichPresence(0, &data, 1, NULL, NULL, NULL);
232 }
233 else if (!strcmp(pArgs->GetArg(1), "activity"))
234 {
235 ECryLobbyError error = pLobbyUI->AddActivityFeed(0, NULL, NULL, NULL);
236 }
237 else if (!strcmp(pArgs->GetArg(1), "friendslist"))
238 {
239 ((CCryPSNLobbyService*)(gEnv->pNetwork->GetLobby()->GetLobbyService(eCLS_Online)))->GetFriends()->FriendsGetFriendsList(0, 0, 20, NULL, NULL, NULL);
240 }
241 else if (!strcmp(pArgs->GetArg(1), "showfriends"))
242 {
243 ECryLobbyError error = pLobbyUI->ShowFriends(0, NULL, NULL, NULL);
244 }
245 else if (!strcmp(pArgs->GetArg(1), "recentplayers"))
246 {
247 CryUserID id = new SCryPSNUserID;
248 cry_sprintf(((SCryPSNUserID*)id.get())->npId.handle.data, "CryDerpy");
249 ECryLobbyError error = pLobbyUI->AddRecentPlayers(0, &id, 1, "TestRecentPlayers", NULL, NULL, NULL);
250 }
251 else if (!strcmp(pArgs->GetArg(1), "gamercard"))
252 {
253 CryUserID id = new SCryPSNUserID;
254 cry_sprintf(((SCryPSNUserID*)id.get())->npId.handle.data, "CryDerpy");
255 ECryLobbyError error = pLobbyUI->ShowGamerCard(0, id, NULL, NULL, NULL);
256 }
257 else if (!strcmp(pArgs->GetArg(1), "storeproducts"))
258 {
259 TStoreOfferID offers[2];
260 offers[0].productId = "500CUK0000000000";
261 offers[1].productId = "100CUK0000000000";
262 ECryLobbyError error = pLobbyUI->GetConsumableOffers(0, NULL, offers, 2, NULL, NULL);
263 }
264 else if (!strcmp(pArgs->GetArg(1), "downloadoffer"))
265 {
266 TStoreOfferID offer;
267 offer.productId = "500CUK0000000000";
268 offer.skuId = "E003";
269 ECryLobbyError error = pLobbyUI->ShowDownloadOffer(0, offer, NULL, NULL, NULL);
270 }
271 else if (!strcmp(pArgs->GetArg(1), "storeassets"))
272 {
273 ECryLobbyError error = pLobbyUI->GetConsumableAssets(0, NULL, NULL, NULL);
274 }
275 else if (!strcmp(pArgs->GetArg(1), "consumeasset"))
276 {
277 TStoreAssetID assetId = "500CUK";
278 uint32 quantity = 1;
279 ECryLobbyError error = pLobbyUI->ConsumeAsset(0, assetId, quantity, NULL, NULL, NULL);
280 }
281 }
282 }
283 }
284
285 ECryLobbyError CCryPSNLobbyUI::Initialise()
286 {
287 ECryLobbyError error = CCryLobbyUI::Initialise();
288 if (error == eCLE_Success)
289 {
290 int ret;
291
292 ret = sceSysmoduleLoadModule(SCE_SYSMODULE_NP_PROFILE_DIALOG);
293 if (ret < PSN_OK)
294 {
295 NetLog("sceSysmoduleLoadModule(SCE_SYSMODULE_NP_PROFILE_DIALOG) failed. ret = 0x%x\n", ret);
296 return eCLE_InternalError;
297 }
298 ret = sceSysmoduleLoadModule(SCE_SYSMODULE_NP_FRIEND_LIST_DIALOG);
299 if (ret < PSN_OK)
300 {
301 NetLog("sceSysmoduleLoadModule(SCE_SYSMODULE_NP_FRIEND_LIST_DIALOG) failed. ret = 0x%x\n", ret);
302 return eCLE_InternalError;
303 }
304 ret = sceSysmoduleLoadModule(SCE_SYSMODULE_INVITATION_DIALOG);
305 if (ret < PSN_OK)
306 {
307 NetLog("sceSysmoduleLoadModule(SCE_SYSMODULE_INVITATION_DIALOG) failed. ret = 0x%x\n", ret);
308 return eCLE_InternalError;
309 }
310 ret = sceSysmoduleLoadModule(SCE_SYSMODULE_NP_COMMERCE);
311 if (ret < PSN_OK)
312 {
313 NetLog("sceSysmoduleLoadModule(SCE_SYSMODULE_NP_COMMERCE) failed. ret = 0x%x\n", ret);
314 return eCLE_InternalError;
315 }
316
317 ret = sceCommonDialogInitialize();
318 if (ret < PSN_OK)
319 {
320 NetLog("sceCommonDialogInitialize failed. ret = 0x%x\n", ret);
321 return eCLE_InternalError;
322 }
323 }
324
325 REGISTER_COMMAND("webapi", TestWebAPIFeature, VF_CHEAT, "Debug test a PSN WebAPI feature");
326
327 return error;
328 }
329
330 ECryLobbyError CCryPSNLobbyUI::Terminate()
331 {
332 sceInvitationDialogTerminate();
333 sceNpFriendListDialogTerminate();
334 sceNpProfileDialogTerminate();
335 sceNpCommerceDialogTerminate();
336
337 int ret = sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_COMMERCE);
338 if (ret < PSN_OK)
339 {
340 NetLog("sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_COMMERCE) failed. ret = 0x%x\n", ret);
341 }
342 ret = sceSysmoduleUnloadModule(SCE_SYSMODULE_INVITATION_DIALOG);
343 if (ret < PSN_OK)
344 {
345 NetLog("sceSysmoduleUnloadModule(SCE_SYSMODULE_INVITATION_DIALOG) failed. ret = 0x%x\n", ret);
346 }
347 ret = sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_FRIEND_LIST_DIALOG);
348 if (ret < PSN_OK)
349 {
350 NetLog("sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_FRIEND_LIST_DIALOG) failed. ret = 0x%x\n", ret);
351 }
352 ret = sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_PROFILE_DIALOG);
353 if (ret < PSN_OK)
354 {
355 NetLog("sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_PROFILE_DIALOG) failed. ret = 0x%x\n", ret);
356 }
357
358 return CCryLobbyUI::Terminate();
359 }
360
361 void CCryPSNLobbyUI::Tick(CTimeValue tv)
362 {
363 for (uint32 i = 0; i < MAX_LOBBYUI_TASKS; i++)
364 {
365 STask* pTask = &m_task[i];
366
367 if (pTask->used && pTask->running)
368 {
369 switch (pTask->subTask)
370 {
371 case eT_ShowGamerCard:
372 TickShowGamerCard(i);
373 break;
374 case eT_ShowGameInvite:
375 TickShowGameInvite(i);
376 break;
377 case eT_ShowFriends:
378 TickShowFriends(i);
379 break;
380 case eT_SetRichPresence:
381 TickSetRichPresence(i);
382 break;
383 case eT_AddRecentPlayers:
384 TickAddRecentPlayers(i);
385 break;
386 case eT_AddActivityFeed:
387 TickAddActivityFeed(i);
388 break;
389 case eT_GetConsumableOffers:
390 TickGetConsumableOffers(i);
391 break;
392 case eT_GetConsumableAssets:
393 TickGetConsumableAssets(i);
394 break;
395 case eT_ConsumeAsset:
396 TickConsumeAsset(i);
397 break;
398 case eT_ShowDownloadOffer:
399 TickShowDownloadOffer(i);
400 break;
401 }
402 }
403 }
404 }
405
406 ECryLobbyError CCryPSNLobbyUI::StartTask(ETask etask, bool startRunning, uint32 user, CryLobbyUITaskID* pUITaskID, CryLobbyTaskID* pLTaskID, CryLobbySessionHandle h, void* pCb, void* pCbArg)
407 {
408 CryLobbyUITaskID tmpUITaskID;
409 CryLobbyUITaskID* pUseUITaskID = pUITaskID ? pUITaskID : &tmpUITaskID;
410 ECryLobbyError error = CCryLobbyUI::StartTask(etask, startRunning, pUseUITaskID, pLTaskID, h, pCb, pCbArg);
411 return error;
412 }
413
414 void CCryPSNLobbyUI::StartSubTask(ETask etask, CryLobbyUITaskID sTaskID)
415 {
416 STask* pTask = &m_task[sTaskID];
417
418 pTask->subTask = etask;
419 }
420
421 void CCryPSNLobbyUI::StartTaskRunning(CryLobbyUITaskID uiTaskID)
422 {
423 LOBBY_AUTO_LOCK;
424
425 STask* pTask = &m_task[uiTaskID];
426
427 if (pTask->used)
428 {
429 pTask->running = true;
430
431 switch (pTask->startedTask)
432 {
433 case eT_ShowGamerCard:
434 StartShowGamerCard(uiTaskID);
435 break;
436
437 case eT_ShowGameInvite:
438 StartShowGameInvite(uiTaskID);
439 break;
440
441 case eT_ShowFriends:
442 StartShowFriends(uiTaskID);
443 break;
444
445 case eT_ShowFriendRequest:
446 StartShowFriendRequest(uiTaskID);
447 break;
448
449 case eT_SetRichPresence:
450 StartSetRichPresence(uiTaskID);
451 break;
452
453 case eT_ShowOnlineRetailBrowser:
454 StartShowOnlineRetailBrowser(uiTaskID);
455 break;
456
457 case eT_JoinFriendsGame:
458 StartJoinFriendGame(uiTaskID);
459 break;
460
461 case eT_ShowMessageList:
462 StartShowMessageList(uiTaskID);
463 break;
464
465 case eT_AddRecentPlayers:
466 StartAddRecentPlayers(uiTaskID);
467 break;
468
469 case eT_AddActivityFeed:
470 StartAddActivityFeed(uiTaskID);
471 break;
472
473 case eT_GetConsumableOffers:
474 StartGetConsumableOffers(uiTaskID);
475 break;
476 case eT_GetConsumableAssets:
477 StartGetConsumableAssets(uiTaskID);
478 break;
479 case eT_ConsumeAsset:
480 StartConsumeAsset(uiTaskID);
481 break;
482
483 case eT_ShowDownloadOffer:
484 StartShowDownloadOffer(uiTaskID);
485 break;
486 }
487 }
488 }
489
490 void CCryPSNLobbyUI::EndTask(CryLobbyUITaskID uiTaskID)
491 {
492 LOBBY_AUTO_LOCK;
493
494 STask* pTask = &m_task[uiTaskID];
495
496 if (pTask->used)
497 {
498 if (pTask->pCb)
499 {
500 switch (pTask->startedTask)
501 {
502 case eT_ShowGamerCard:
503 EndShowGamerCard(uiTaskID);
504 break;
505 case eT_ShowFriends:
506 EndShowFriends(uiTaskID);
507 break;
508 case eT_ShowGameInvite:
509 EndShowGameInvite(uiTaskID);
510 break;
511
512 case eT_ShowFriendRequest:
513 case eT_SetRichPresence:
514 case eT_ShowOnlineRetailBrowser:
515 case eT_JoinFriendsGame:
516 case eT_ShowMessageList:
517 case eT_AddRecentPlayers:
518 case eT_AddActivityFeed:
519 ((CryLobbyUICallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->pCbArg);
520 break;
521
522 case eT_CheckOnlineRetailStatus:
523 EndCheckOnlineRetailStatus(uiTaskID);
524 break;
525
526 case eT_GetConsumableOffers:
527 EndGetConsumableOffers(uiTaskID);
528 break;
529 case eT_GetConsumableAssets:
530 EndGetConsumableAssets(uiTaskID);
531 break;
532 case eT_ConsumeAsset:
533 EndConsumeAsset(uiTaskID);
534 break;
535
536 case eT_ShowDownloadOffer:
537 EndShowDownloadOffer(uiTaskID);
538 break;
539 }
540 }
541
542 if (pTask->error != eCLE_Success)
543 {
544 NetLog("[Lobby] LobbyUI EndTask %d (%d) Result %d", pTask->startedTask, pTask->subTask, pTask->error);
545 }
546
547 FreeTask(uiTaskID);
548 }
549 }
550
551 void CCryPSNLobbyUI::StopTaskRunning(CryLobbyUITaskID uiTaskID)
552 {
553 STask* pTask = &m_task[uiTaskID];
554
555 if (pTask->used)
556 {
557 pTask->running = false;
558 TO_GAME_FROM_LOBBY(&CCryPSNLobbyUI::EndTask, this, uiTaskID);
559 }
560 }
561
562 ECryLobbyError CCryPSNLobbyUI::ShowGamerCard(uint32 user, CryUserID userID, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
563 {
564 LOBBY_AUTO_LOCK;
565
566 ECryLobbyError error = eCLE_Success;
567
568 if (userID.IsValid())
569 {
570 CryLobbyUITaskID uiTaskID;
571
572 error = StartTask(eT_ShowGamerCard, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
573
574 if (error == eCLE_Success)
575 {
576 SceNpId npId = ((SCryPSNUserID*)userID.get())->npId;
577
578 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_NPID_LIST, &npId, sizeof(npId));
579
580 if (error == eCLE_Success)
581 {
582 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
583 }
584 else
585 {
586 FreeTask(uiTaskID);
587 }
588 }
589 }
590 else
591 {
592 error = eCLE_InvalidUser;
593 }
594
595 return error;
596 }
597
598 void CCryPSNLobbyUI::StartShowGamerCard(CryLobbyUITaskID uiTaskID)
599 {
600 STask* pTask = &m_task[uiTaskID];
601 SceNpId* pNpId = (SceNpId*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_NPID_LIST]);
602
603 SceUserServiceUserId userId;
604 int ret = sceUserServiceGetInitialUser(&userId);
605 if (ret == PSN_OK)
606 {
607 ret = sceNpProfileDialogInitialize();
608 if ((ret == PSN_OK) || (ret == SCE_COMMON_DIALOG_ERROR_ALREADY_INITIALIZED))
609 {
610 SceNpProfileDialogParam param;
611 sceNpProfileDialogParamInitialize(&param);
612 param.mode = SCE_NP_PROFILE_DIALOG_MODE_NORMAL;
613 param.userId = userId;
614 param.targetOnlineId = pNpId->handle;
615
616 ret = sceNpProfileDialogOpen(&param);
617 if (ret == PSN_OK)
618 {
619 UpdateTaskError(uiTaskID, eCLE_Success);
620 }
621 else
622 {
623 NetLog("sceNpProfileDialogOpen failed. ret = 0x%x\n", ret);
624 UpdateTaskError(uiTaskID, eCLE_InternalError);
625 }
626 }
627 else
628 {
629 NetLog("sceNpProfileDialogInitialize failed. ret = 0x%x\n", ret);
630 UpdateTaskError(uiTaskID, eCLE_InternalError);
631 StopTaskRunning(uiTaskID);
632 }
633 }
634 else
635 {
636 UpdateTaskError(uiTaskID, eCLE_InternalError);
637 }
638
639 if (pTask->error != eCLE_Success)
640 {
641 sceNpProfileDialogTerminate();
642 StopTaskRunning(uiTaskID);
643 }
644 }
645
646 void CCryPSNLobbyUI::TickShowGamerCard(CryLobbyUITaskID uiTaskID)
647 {
648 STask* pTask = &m_task[uiTaskID];
649
650 if (pTask->canceled)
651 {
652 sceNpProfileDialogTerminate();
653 UpdateTaskError(uiTaskID, eCLE_Success);
654 StopTaskRunning(uiTaskID);
655 return;
656 }
657
658 int ret = sceNpProfileDialogUpdateStatus();
659 if (ret == SCE_COMMON_DIALOG_STATUS_FINISHED)
660 {
661 // completed.
662 SceNpProfileDialogResult result;
663 memset(&result, 0, sizeof(result));
664
665 ret = sceNpProfileDialogGetResult(&result);
666 if (ret == PSN_OK)
667 {
668 if (result.result == PSN_OK)
669 {
670 UpdateTaskError(uiTaskID, eCLE_Success);
671 }
672 else
673 {
674 UpdateTaskError(uiTaskID, eCLE_InternalError);
675 }
676 }
677 else
678 {
679 // Error handling
680 UpdateTaskError(uiTaskID, eCLE_InternalError);
681 }
682
683 sceNpProfileDialogTerminate();
684
685 StopTaskRunning(uiTaskID);
686 }
687 }
688
689 void CCryPSNLobbyUI::EndShowGamerCard(CryLobbyUITaskID uiTaskID)
690 {
691 STask* pTask = &m_task[uiTaskID];
692 ((CryLobbyUICallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->pCbArg);
693 }
694
695 ECryLobbyError CCryPSNLobbyUI::ShowGameInvite(uint32 user, CrySessionHandle gh, CryUserID* pUserIDs, uint32 numUserIDs, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
696 {
697 #if USE_CRY_MATCHMAKING
698 LOBBY_AUTO_LOCK;
699
700 ECryLobbyError error = eCLE_Success;
701 CCryMatchMaking* pMatchMaking = (CCryMatchMaking*)m_pLobby->GetMatchMaking();
702
703 if (pMatchMaking)
704 {
705 CryLobbySessionHandle h = pMatchMaking->GetSessionHandleFromGameSessionHandle(gh);
706
707 if (h != CryLobbyInvalidSessionHandle)
708 {
709 CryLobbyUITaskID uiTaskID;
710
711 error = StartTask(eT_ShowGameInvite, false, user, &uiTaskID, pTaskID, h, (void*)cb, pCbArg);
712
713 if (error == eCLE_Success)
714 {
715 STask* pTask = &m_task[uiTaskID];
716
717 pTask->paramsNum[LOBBYUI_PARAM_NUM_NPIDS] = numUserIDs;
718
719 if (numUserIDs > 0)
720 {
721 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_ONLINEID_LIST, NULL, numUserIDs * sizeof(SceNpOnlineId));
722 if (error == eCLE_Success)
723 {
724 SceNpOnlineId* pOnlineIds = (SceNpOnlineId*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_ONLINEID_LIST]);
725
726 for (uint32 i = 0; i < numUserIDs; i++)
727 {
728 if (pUserIDs[i].IsValid())
729 {
730 memcpy(&pOnlineIds[i], &(((SCryPSNUserID*)pUserIDs[i].get())->npId.handle), sizeof(SceNpOnlineId));
731 }
732 else
733 {
734 error = eCLE_InvalidUser;
735 break;
736 }
737 }
738 }
739 }
740
741 if (error == eCLE_Success)
742 {
743 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_SESSION_ID, NULL, sizeof(SceNpSessionId));
744 if (error == eCLE_Success)
745 {
746 SceNpSessionId* pSessionId = (SceNpSessionId*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_SESSION_ID]);
747 CrySessionID id = pMatchMaking->SessionGetCrySessionIDFromCrySessionHandle(gh);
748 if (id != NULL)
749 {
750 memcpy(pSessionId, &(((SCryPSNSessionID*)id.get())->m_sessionId), sizeof(SceNpSessionId));
751 }
752 else
753 {
754 error = eCLE_InvalidSession;
755 }
756 }
757 }
758
759 if (error == eCLE_Success)
760 {
761 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
762 }
763 else
764 {
765 FreeTask(uiTaskID);
766 }
767 }
768 }
769 else
770 {
771 error = eCLE_InvalidSession;
772 }
773 }
774 else
775 {
776 error = eCLE_ServiceNotSupported;
777 }
778
779 return error;
780 #else // USE_CRY_MATCHMAKING
781 return eCLE_ServiceNotSupported;
782 #endif // USE_CRY_MATCHMAKING
783 }
784
785 void CCryPSNLobbyUI::StartShowGameInvite(CryLobbyUITaskID uiTaskID)
786 {
787 #if USE_CRY_MATCHMAKING
788 STask* pTask = &m_task[uiTaskID];
789 uint32 numUserIDs = pTask->paramsNum[LOBBYUI_PARAM_NUM_NPIDS];
790 SceNpOnlineId* pOnlineIds = NULL;
791 if (numUserIDs > 0)
792 {
793 pOnlineIds = (SceNpOnlineId*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_ONLINEID_LIST]);
794 }
795 SceNpSessionId* pSessionId = (SceNpSessionId*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_SESSION_ID]);
796
797 char body[SCE_INVITATION_DIALOG_MAX_USER_MSG_SIZE] = "Undefined";
798
799 SCryLobbyXMBString data;
800 data.m_pStringBuffer = (uint8*)body;
801 data.m_sizeOfStringBuffer = SCE_INVITATION_DIALOG_MAX_USER_MSG_SIZE - 1;
802
803 SConfigurationParams neededInfo = {
804 CLCC_PSN_INVITE_BODY_STRING, { NULL }
805 };
806 neededInfo.m_pData = &data;
807
808 m_pLobby->GetConfigurationInformation(&neededInfo, 1);
809
810 if (data.m_sizeOfStringBuffer >= SCE_INVITATION_DIALOG_MAX_USER_MSG_SIZE)
811 {
812 cry_sprintf(body, "Error: Body text is too long!");
813 }
814
815 body[SCE_INVITATION_DIALOG_MAX_USER_MSG_SIZE - 1] = 0;
816
817 SceUserServiceUserId userId;
818 int ret = sceUserServiceGetInitialUser(&userId);
819 if (ret == PSN_OK)
820 {
821 ret = sceInvitationDialogInitialize();
822 if ((ret == PSN_OK) || (ret == SCE_COMMON_DIALOG_ERROR_ALREADY_INITIALIZED))
823 {
824 SceInvitationDialogDataParam dataParam;
825 memset(&dataParam, 0, sizeof(dataParam));
826 dataParam.SendInfo.sessionId = pSessionId;
827 dataParam.SendInfo.userMessage = body;
828 dataParam.SendInfo.addressParam.addressType = SCE_INVITATION_DIALOG_ADDRESS_TYPE_USERDISABLE;
829 dataParam.SendInfo.addressParam.addressInfo.UserSelectDisableAddress.onlineIdsCount = numUserIDs;
830 dataParam.SendInfo.addressParam.addressInfo.UserSelectDisableAddress.onlineIds = pOnlineIds;
831
832 SceInvitationDialogParam param;
833 sceInvitationDialogParamInitialize(&param);
834 param.userId = userId;
835 param.mode = SCE_INVITATION_DIALOG_MODE_SEND;
836 param.dataParam = &dataParam;
837
838 ret = sceInvitationDialogOpen(&param);
839 if (ret == PSN_OK)
840 {
841 //-- success!
842 NetLog("INVITE OPEN: session %s", pSessionId->data);
843 UpdateTaskError(uiTaskID, eCLE_Success);
844 }
845 else
846 {
847 UpdateTaskError(uiTaskID, eCLE_InternalError);
848 }
849 }
850 else
851 {
852 NetLog("sceInvitationDialogInitialize failed. ret = 0x%x\n", ret);
853 UpdateTaskError(uiTaskID, eCLE_InternalError);
854 }
855 }
856 else
857 {
858 UpdateTaskError(uiTaskID, eCLE_InternalError);
859 }
860
861 if (pTask->error != eCLE_Success)
862 {
863 sceInvitationDialogTerminate();
864 StopTaskRunning(uiTaskID);
865 }
866 #endif // USE_CRY_MATCHMAKING
867 }
868
869 void CCryPSNLobbyUI::TickShowGameInvite(CryLobbyUITaskID uiTaskID)
870 {
871 int ret;
872 STask* pTask = &m_task[uiTaskID];
873
874 if (pTask->canceled)
875 {
876 sceInvitationDialogTerminate();
877 UpdateTaskError(uiTaskID, eCLE_Success);
878 StopTaskRunning(uiTaskID);
879 return;
880 }
881
882 ret = sceInvitationDialogUpdateStatus();
883 if (ret == SCE_COMMON_DIALOG_STATUS_FINISHED)
884 {
885 // completed.
886 SceInvitationDialogResult result;
887 memset(&result, 0, sizeof(result));
888
889 ret = sceInvitationDialogGetResult(&result);
890 if (ret == PSN_OK)
891 {
892 if (result.errorCode == PSN_OK)
893 {
894 if (result.result == SCE_COMMON_DIALOG_RESULT_OK)
895 {
896 NetLog("INVITE SENT");
897 }
898 else
899 {
900 NetLog("INVITE CANCELLED");
901 }
902 }
903 else
904 {
905 UpdateTaskError(uiTaskID, eCLE_InternalError);
906 }
907 }
908 else
909 {
910 // Error handling
911 UpdateTaskError(uiTaskID, eCLE_InternalError);
912 }
913
914 sceInvitationDialogTerminate();
915
916 StopTaskRunning(uiTaskID);
917 }
918 }
919
920 void CCryPSNLobbyUI::EndShowGameInvite(CryLobbyUITaskID uiTaskID)
921 {
922 STask* pTask = &m_task[uiTaskID];
923 ((CryLobbyUICallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->pCbArg);
924 }
925
926 ECryLobbyError CCryPSNLobbyUI::ShowFriends(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
927 {
928 LOBBY_AUTO_LOCK;
929 CryLobbyUITaskID uiTaskID;
930
931 ECryLobbyError error = StartTask(eT_ShowFriends, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
932
933 if (error == eCLE_Success)
934 {
935 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
936 }
937
938 return error;
939 }
940
941 void CCryPSNLobbyUI::StartShowFriends(CryLobbyUITaskID uiTaskID)
942 {
943 STask* pTask = &m_task[uiTaskID];
944
945 SceUserServiceUserId userId;
946 int ret = sceUserServiceGetInitialUser(&userId);
947 if (ret == PSN_OK)
948 {
949 ret = sceNpFriendListDialogInitialize();
950 if ((ret == PSN_OK) || (ret == SCE_COMMON_DIALOG_ERROR_ALREADY_INITIALIZED))
951 {
952 SceNpFriendListDialogParam param;
953 sceNpFriendListDialogParamInitialize(&param);
954 param.mode = SCE_NP_FRIEND_LIST_DIALOG_MODE_FRIEND_LIST;
955 param.userId = userId;
956 param.menuItems = SCE_NP_FRIEND_LIST_DIALOG_MENU_ITEM_ONLINE | SCE_NP_FRIEND_LIST_DIALOG_MENU_ITEM_ALL_FRIENDS;
957
958 ret = sceNpFriendListDialogOpen(&param);
959 if (ret == PSN_OK)
960 {
961 UpdateTaskError(uiTaskID, eCLE_Success);
962 }
963 else
964 {
965 NetLog("sceNpFriendListDialogOpen failed. ret = 0x%x\n", ret);
966 UpdateTaskError(uiTaskID, eCLE_InternalError);
967 }
968 }
969 else
970 {
971 NetLog("sceNpFriendListDialogInitialize failed. ret = 0x%x\n", ret);
972 UpdateTaskError(uiTaskID, eCLE_InternalError);
973 StopTaskRunning(uiTaskID);
974 }
975 }
976 else
977 {
978 UpdateTaskError(uiTaskID, eCLE_InternalError);
979 }
980
981 if (pTask->error != eCLE_Success)
982 {
983 sceNpFriendListDialogTerminate();
984 StopTaskRunning(uiTaskID);
985 }
986 }
987
988 void CCryPSNLobbyUI::TickShowFriends(CryLobbyUITaskID uiTaskID)
989 {
990 int ret;
991 STask* pTask = &m_task[uiTaskID];
992
993 if (pTask->canceled)
994 {
995 sceNpFriendListDialogTerminate();
996 UpdateTaskError(uiTaskID, eCLE_Success);
997 StopTaskRunning(uiTaskID);
998 return;
999 }
1000
1001 ret = sceNpFriendListDialogUpdateStatus();
1002 if (ret == SCE_COMMON_DIALOG_STATUS_FINISHED)
1003 {
1004 // completed.
1005 SceNpFriendListDialogResult result;
1006 memset(&result, 0, sizeof(result));
1007
1008 ret = sceNpFriendListDialogGetResult(&result);
1009 if (ret == PSN_OK)
1010 {
1011 if (result.result == PSN_OK)
1012 {
1013 UpdateTaskError(uiTaskID, eCLE_Success);
1014 }
1015 else
1016 {
1017 UpdateTaskError(uiTaskID, eCLE_InternalError);
1018 }
1019 }
1020 else
1021 {
1022 // Error handling
1023 UpdateTaskError(uiTaskID, eCLE_InternalError);
1024 }
1025
1026 sceNpFriendListDialogTerminate();
1027
1028 StopTaskRunning(uiTaskID);
1029 }
1030 }
1031
1032 void CCryPSNLobbyUI::EndShowFriends(CryLobbyUITaskID uiTaskID)
1033 {
1034 STask* pTask = &m_task[uiTaskID];
1035 ((CryLobbyUICallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->pCbArg);
1036 }
1037
1038 ECryLobbyError CCryPSNLobbyUI::ShowFriendRequest(uint32 user, CryUserID userID, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
1039 {
1040 LOBBY_AUTO_LOCK;
1041
1042 ECryLobbyError error = eCLE_Success;
1043 /*
1044 if (userID.IsValid())
1045 {
1046 CryLobbyUITaskID uiTaskID;
1047
1048 error = StartTask(eT_ShowFriendRequest, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1049 if (error == eCLE_Success)
1050 {
1051 SceNpId npId = ((SCryPSNUserID*)userID.get())->npId;
1052
1053 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_NPID_LIST, &npId, sizeof(npId));
1054 if (error == eCLE_Success)
1055 {
1056 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1057 }
1058 else
1059 {
1060 FreeTask(uiTaskID);
1061 }
1062 }
1063 }
1064 else
1065 {
1066 error = eCLE_InvalidUser;
1067 }
1068 */
1069 return error;
1070 }
1071
1072 void CCryPSNLobbyUI::StartShowFriendRequest(CryLobbyUITaskID uiTaskID)
1073 {
1074 /*
1075 STask* pTask = &m_task[uiTaskID];
1076 SceNpId* pNpId = (SceNpId*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_NPID_LIST]);
1077
1078 char subject[SCE_NP_BASIC_SUBJECT_CHARACTER_MAX] = "Undefined";
1079 char body[SCE_NP_BASIC_BODY_CHARACTER_MAX] = "Undefined";
1080
1081 SCryLobbyXMBString data[2];
1082 data[0].m_pStringBuffer = (uint8*)subject;
1083 data[0].m_sizeOfStringBuffer = SCE_NP_BASIC_SUBJECT_CHARACTER_MAX;
1084 data[1].m_pStringBuffer = (uint8*)body;
1085 data[1].m_sizeOfStringBuffer = SCE_NP_BASIC_BODY_CHARACTER_MAX;
1086
1087 SConfigurationParams neededInfo[2] = {{CLCC_PSN_FRIEND_REQUEST_SUBJECT_STRING, {NULL}},
1088 {CLCC_PSN_FRIEND_REQUEST_BODY_STRING, {NULL}}};
1089 neededInfo[0].m_pData = &data[0];
1090 neededInfo[1].m_pData = &data[1];
1091
1092 m_pLobby->GetConfigurationInformation(neededInfo, 2);
1093
1094 if (data[0].m_sizeOfStringBuffer >= SCE_NP_BASIC_SUBJECT_CHARACTER_MAX)
1095 {
1096 cry_sprintf(subject, "E 0x%x", SCE_NP_BASIC_ERROR_EXCEEDS_MAX);
1097 }
1098 if (data[1].m_sizeOfStringBuffer >= SCE_NP_BASIC_BODY_CHARACTER_MAX)
1099 {
1100 cry_sprintf(body, "E 0x%x", SCE_NP_BASIC_ERROR_EXCEEDS_MAX);
1101 }
1102
1103 subject[SCE_NP_BASIC_SUBJECT_CHARACTER_MAX-1] = 0;
1104 body[SCE_NP_BASIC_BODY_CHARACTER_MAX-1] = 0;
1105
1106 SceNpBasicMessageDetails msg;
1107 memset(&msg, 0, sizeof(msg));
1108
1109 msg.mainType = SCE_NP_BASIC_MESSAGE_MAIN_TYPE_ADD_FRIEND;
1110 msg.subType = SCE_NP_BASIC_MESSAGE_ADD_FRIEND_SUBTYPE_NONE;
1111 msg.msgFeatures = SCE_NP_BASIC_MESSAGE_FEATURES_MULTI_RECEIPIENTS;
1112 msg.npids = pNpId;
1113 msg.count = 1;
1114 msg.subject = subject;
1115 msg.body = body;
1116 msg.data = NULL;
1117 msg.size = 0;
1118
1119 int ret = sceNpBasicSendMessageGui(&msg, SYS_MEMORY_CONTAINER_ID_INVALID);
1120 if (ret == 0)
1121 {
1122 //-- success!
1123 UpdateTaskError(uiTaskID, eCLE_Success);
1124 }
1125 else
1126 {
1127 UpdateTaskError(uiTaskID, eCLE_InternalError);
1128 }
1129 */
1130 UpdateTaskError(uiTaskID, eCLE_ServiceNotSupported);
1131 StopTaskRunning(uiTaskID);
1132 }
1133
1134 ECryLobbyError CCryPSNLobbyUI::SetRichPresence(uint32 user, SCryLobbyUserData* pData, uint32 numData, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
1135 {
1136 LOBBY_AUTO_LOCK;
1137
1138 ECryLobbyError error = eCLE_Success;
1139 CryLobbyUITaskID uiTaskID;
1140
1141 if ((numData > 0) && pData)
1142 {
1143 error = StartTask(eT_SetRichPresence, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1144
1145 if (error == eCLE_Success)
1146 {
1147 STask* pTask = &m_task[uiTaskID];
1148
1149 pTask->paramsNum[LOBBYUI_PARAM_RICHPRESENCE] = INVALID_WEBAPI_JOB_ID;
1150 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_RICHPRESENCE, 0, sizeof(SCryPSNOrbisWebApiSetPresenceInput));
1151 if (error == eCLE_Success)
1152 {
1153 SCryPSNOrbisWebApiSetPresenceInput* pPresenceData = (SCryPSNOrbisWebApiSetPresenceInput*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_RICHPRESENCE]);
1154 memset(pPresenceData, 0, sizeof(SCryPSNOrbisWebApiSetPresenceInput));
1155
1156 SCryLobbyPresenceConverter convert;
1157 convert.m_pData = pData;
1158 convert.m_numData = numData;
1159 convert.m_pStringBuffer = (uint8*)pPresenceData->presence;
1160 convert.m_sizeOfStringBuffer = CRY_WEBAPI_SETPRESENCE_MAX_SIZE;
1161 convert.m_sessionId = CrySessionInvalidID;
1162
1163 SConfigurationParams presenceItem = {
1164 CLCC_CRYLOBBY_PRESENCE_CONVERTER, { NULL }
1165 };
1166 presenceItem.m_pData = &convert;
1167
1168 m_pLobby->GetConfigurationInformation(&presenceItem, 1);
1169
1170 if ((convert.m_sizeOfStringBuffer > 0) && (convert.m_sizeOfStringBuffer < CRY_WEBAPI_SETPRESENCE_MAX_SIZE))
1171 {
1172 pPresenceData->presence[CRY_WEBAPI_SETPRESENCE_MAX_SIZE - 1] = 0;
1173 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1174 }
1175 else
1176 {
1177 error = eCLE_InvalidRequest;
1178 FreeTask(uiTaskID);
1179 }
1180 }
1181 else
1182 {
1183 FreeTask(uiTaskID);
1184 }
1185 }
1186 }
1187 else
1188 {
1189 error = eCLE_InvalidParam;
1190 }
1191
1192 return error;
1193 }
1194
1195 void CCryPSNLobbyUI::StartSetRichPresence(CryLobbyUITaskID uiTaskID)
1196 {
1197 STask* pTask = &m_task[uiTaskID];
1198
1199 if (pTask->paramsMem[LOBBYUI_PARAM_RICHPRESENCE] != TMemInvalidHdl)
1200 {
1201 if (!m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1202 {
1203 UpdateTaskError(uiTaskID, eCLE_Success);
1204 StopTaskRunning(uiTaskID);
1205 }
1206 }
1207 else
1208 {
1209 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1210 StopTaskRunning(uiTaskID);
1211 }
1212 }
1213
1214 void CCryPSNLobbyUI::TickSetRichPresence(CryLobbyUITaskID uiTaskID)
1215 {
1216 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1217 {
1218 STask* pTask = &m_task[uiTaskID];
1219
1220 if (pTask->paramsMem[LOBBYUI_PARAM_RICHPRESENCE] != TMemInvalidHdl)
1221 {
1222 SCryPSNOrbisWebApiSetPresenceInput* pPresenceData = (SCryPSNOrbisWebApiSetPresenceInput*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_RICHPRESENCE]);
1223 memcpy(&pPresenceData->id, &m_pPSNSupport->GetLocalNpId()->handle, sizeof(SceNpOnlineId));
1224
1225 pTask->paramsNum[LOBBYUI_PARAM_RICHPRESENCE] = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::SetPresence, pTask->paramsMem[LOBBYUI_PARAM_RICHPRESENCE]);
1226 if (pTask->paramsNum[LOBBYUI_PARAM_RICHPRESENCE] != INVALID_WEBAPI_JOB_ID)
1227 {
1228 StartSubTask(eST_WaitingForRichPresenceCallback, uiTaskID);
1229 }
1230 else
1231 {
1232 UpdateTaskError(uiTaskID, eCLE_InternalError);
1233 StopTaskRunning(uiTaskID);
1234 }
1235 }
1236 else
1237 {
1238 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1239 StopTaskRunning(uiTaskID);
1240 }
1241 }
1242 else
1243 {
1244 UpdateTaskError(uiTaskID, eCLE_Success);
1245 StopTaskRunning(uiTaskID);
1246 }
1247 }
1248
1249 ECryLobbyError CCryPSNLobbyUI::ShowOnlineRetailBrowser(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
1250 {
1251 LOBBY_AUTO_LOCK;
1252 CryLobbyUITaskID uiTaskID;
1253
1254 ECryLobbyError error = StartTask(eT_ShowOnlineRetailBrowser, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1255 if (error == eCLE_Success)
1256 {
1257 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1258 }
1259
1260 return error;
1261 }
1262
1263 void CCryPSNLobbyUI::StartShowOnlineRetailBrowser(CryLobbyUITaskID uiTaskID)
1264 {
1265 StopTaskRunning(uiTaskID);
1266 }
1267
1268 ECryLobbyError CCryPSNLobbyUI::CheckOnlineRetailStatus(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyUIOnlineRetailStatusCallback cb, void* pCbArg)
1269 {
1270 LOBBY_AUTO_LOCK;
1271
1272 ECryLobbyError error = eCLE_InternalError;
1273 return error;
1274 }
1275
1276 void CCryPSNLobbyUI::EndCheckOnlineRetailStatus(CryLobbyUITaskID uiTaskID)
1277 {
1278 STask* pTask = &m_task[uiTaskID];
1279
1280 SCryLobbyUIOnlineRetailCounts counts;
1281
1282 ((CryLobbyUIOnlineRetailStatusCallback)pTask->pCb)(pTask->lTaskID, pTask->error, &counts, pTask->pCbArg);
1283 }
1284
1285 void CCryPSNLobbyUI::JoinFriendGame(const SceNpId* pNpId)
1286 {
1287 #if USE_CRY_MATCHMAKING
1288 LOBBY_AUTO_LOCK;
1289
1290 ECryLobbyError error = eCLE_Success;
1291 CryLobbyUITaskID uiTaskID;
1292
1293 if (pNpId)
1294 {
1295 error = StartTask(eT_JoinFriendsGame, false, 0, &uiTaskID, NULL, CryLobbyInvalidSessionHandle, NULL, NULL);
1296 if (error == eCLE_Success)
1297 {
1298 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_NPID_LIST, pNpId, sizeof(SceNpId));
1299 if (error == eCLE_Success)
1300 {
1301 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1302 }
1303 else
1304 {
1305 FreeTask(uiTaskID);
1306 }
1307 }
1308 }
1309 #endif // USE_CRY_MATCHMAKING
1310 }
1311
1312 void CCryPSNLobbyUI::StartJoinFriendGame(CryLobbyUITaskID uiTaskID)
1313 {
1314 #if USE_CRY_MATCHMAKING
1315 /*
1316 STask* pTask = &m_task[uiTaskID];
1317 ECryLobbyError error = eCLE_Success;
1318 SceNpBasicPresenceDetails2 details;
1319 SCryPSNSessionID* pSessionInfo = NULL;
1320
1321 memset(&details, 0x00, sizeof(details));
1322 details.struct_size = sizeof(details);
1323
1324 SceNpId* pNpId = (SceNpId*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_NPID_LIST]);
1325
1326 int ret = sceNpBasicGetFriendPresenceByNpId2(pNpId, &details, 0);
1327 if (ret == 0)
1328 {
1329 details.status[SCE_NP_BASIC_PRESENCE_EXTENDED_STATUS_SIZE_MAX-1] = 0;
1330 NetLog("Friend Presence details: %s", details.status);
1331 NetLog("Friend Presence details: looking for %d bytes for session data, got %d bytes.", sizeof(SSynchronisedSessionID), details.size);
1332 if (details.size == sizeof(SSynchronisedSessionID))
1333 {
1334 //-- we should have the sessionId for the invite in our buffer now.
1335 pSessionInfo = new SCryPSNSessionID;
1336 if (pSessionInfo)
1337 {
1338 memcpy(&pSessionInfo->m_sessionInfo, details.data, details.size);
1339 pSessionInfo->m_sessionInfo.m_fromInvite = false;
1340 m_pPSNSupport->PrepareForInviteOrJoin(pSessionInfo);
1341
1342 NetLog("JOIN RECV: server=0x%x, world=0x%x, room=0x%llx", pSessionInfo->m_sessionInfo.m_serverId, pSessionInfo->m_sessionInfo.m_worldId, (uint64)pSessionInfo->m_sessionInfo.m_roomId);
1343 }
1344 else
1345 {
1346 error = eCLE_OutOfMemory;
1347 }
1348 }
1349 else
1350 {
1351 error = eCLE_InvalidJoinFriendData;
1352 }
1353 }
1354 else
1355 {
1356 NetLog("Friend Presence details: error 0x%x returned.", ret);
1357 if (ret == SCE_NP_BASIC_ERROR_BUSY)
1358 {
1359 error = eCLE_SystemIsBusy;
1360 }
1361 else
1362 {
1363 error = eCLE_InvalidJoinFriendData;
1364 }
1365 }
1366
1367 TO_GAME_FROM_LOBBY(&CCryPSNLobbyUI::DispatchJoinEvent, this, CrySessionID(pSessionInfo), error);
1368
1369 UpdateTaskError(uiTaskID, error);
1370 StopTaskRunning(uiTaskID);
1371 */
1372 #endif // USE_CRY_MATCHMAKING
1373 }
1374
1375 ECryLobbyError CCryPSNLobbyUI::ShowMessageList(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
1376 {
1377 LOBBY_AUTO_LOCK;
1378 CryLobbyUITaskID uiTaskID;
1379
1380 ECryLobbyError error = StartTask(eT_ShowMessageList, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1381 if (error == eCLE_Success)
1382 {
1383 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1384 }
1385
1386 return error;
1387 }
1388
1389 void CCryPSNLobbyUI::StartShowMessageList(CryLobbyUITaskID uiTaskID)
1390 {
1391 /*
1392 int ret = sceNpBasicRecvMessageCustom(SCE_NP_BASIC_MESSAGE_MAIN_TYPE_INVITE, SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_INCLUDE_BOOTABLE, SYS_MEMORY_CONTAINER_ID_INVALID);
1393 if (ret == 0)
1394 {
1395 //-- success!
1396 UpdateTaskError(uiTaskID, eCLE_Success);
1397 }
1398 else
1399 {
1400 UpdateTaskError(uiTaskID, eCLE_InternalError);
1401 }
1402 */
1403
1404 UpdateTaskError(uiTaskID, eCLE_ServiceNotSupported);
1405 StopTaskRunning(uiTaskID);
1406 }
1407
1408 void CCryPSNLobbyUI::PostLocalizationChecks()
1409 {
1410 }
1411
1412 ECryLobbyError CCryPSNLobbyUI::AddRecentPlayers(uint32 user, CryUserID* pUserIDs, uint32 numUserIDs, const char* gameModeStr, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
1413 {
1414 LOBBY_AUTO_LOCK;
1415 CryLobbyUITaskID uiTaskID;
1416
1417 ECryLobbyError error = StartTask(eT_AddRecentPlayers, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1418 if (error == eCLE_Success)
1419 {
1420 STask* pTask = &m_task[uiTaskID];
1421 pTask->paramsNum[LOBBYUI_PARAM_ADDRECENTPLAYERS] = INVALID_WEBAPI_JOB_ID;
1422
1423 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_ADDRECENTPLAYERS, NULL, sizeof(SCryPSNOrbisWebApiAddRecentPlayersInput));
1424 if (error == eCLE_Success)
1425 {
1426 SCryPSNOrbisWebApiAddRecentPlayersInput* pRecentPlayersData = (SCryPSNOrbisWebApiAddRecentPlayersInput*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_ADDRECENTPLAYERS]);
1427
1428 sce::Json::Object source;
1429 source["meta"] = sce::Json::String(m_pPSNSupport->GetLocalUserName());
1430 source["type"] = sce::Json::String("ONLINE_ID");
1431
1432 sce::Json::String storyType = sce::Json::String("PLAYED_WITH");
1433
1434 sce::Json::Array targets;
1435 for (uint32 i = 0; i < numUserIDs; ++i)
1436 {
1437 if (pUserIDs[i].IsValid())
1438 {
1439 SceNpOnlineId* pOID = &((SCryPSNUserID*)pUserIDs[i].get())->npId.handle;
1440 sce::Json::Object itarget;
1441 itarget["meta"] = sce::Json::String(pOID->data);
1442 itarget["type"] = sce::Json::String("ONLINE_ID");
1443 targets.push_back(itarget);
1444 }
1445 }
1446 SConfigurationParams titleInfo[1] = {
1447 { CLCC_PSN_TITLE_ID, { NULL }
1448 }
1449 };
1450 m_pPSNSupport->GetLobby()->GetConfigurationInformation(titleInfo, 1);
1451 sce::Json::Object titletarget;
1452 titletarget["meta"] = sce::Json::String((const char*)titleInfo[0].m_pData);
1453 titletarget["type"] = sce::Json::String("TITLE_ID");
1454 targets.push_back(titletarget);
1455 sce::Json::Object desctarget;
1456 desctarget["meta"] = sce::Json::String(gameModeStr);
1457 desctarget["type"] = sce::Json::String("PLAYED_DESCRIPTION");
1458 targets.push_back(desctarget);
1459
1460 sce::Json::Object jsonDoc;
1461 jsonDoc["source"] = source;
1462 jsonDoc["storyType"] = storyType;
1463 jsonDoc["targets"] = targets;
1464
1465 sce::Json::Value jsonRoot;
1466 jsonRoot.clear();
1467 jsonRoot.set(jsonDoc);
1468
1469 sce::Json::String jsonString;
1470 jsonRoot.serialize(jsonString);
1471
1472 cry_sprintf(pRecentPlayersData->feed, jsonString.c_str(), jsonString.length());
1473 }
1474
1475 if (error == eCLE_Success)
1476 {
1477 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1478 }
1479 else
1480 {
1481 FreeTask(uiTaskID);
1482 }
1483 }
1484
1485 return error;
1486 }
1487
1488 void CCryPSNLobbyUI::StartAddRecentPlayers(CryLobbyUITaskID uiTaskID)
1489 {
1490 STask* pTask = &m_task[uiTaskID];
1491
1492 if (pTask->paramsMem[LOBBYUI_PARAM_ADDRECENTPLAYERS] != TMemInvalidHdl)
1493 {
1494 if (!m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1495 {
1496 UpdateTaskError(uiTaskID, eCLE_Success);
1497 StopTaskRunning(uiTaskID);
1498 }
1499 }
1500 else
1501 {
1502 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1503 StopTaskRunning(uiTaskID);
1504 }
1505 }
1506
1507 void CCryPSNLobbyUI::TickAddRecentPlayers(CryLobbyUITaskID uiTaskID)
1508 {
1509 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1510 {
1511 STask* pTask = &m_task[uiTaskID];
1512
1513 if (pTask->paramsMem[LOBBYUI_PARAM_ADDRECENTPLAYERS] != TMemInvalidHdl)
1514 {
1515 pTask->paramsNum[LOBBYUI_PARAM_ADDRECENTPLAYERS] = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::AddRecentPlayers, pTask->paramsMem[LOBBYUI_PARAM_ADDRECENTPLAYERS]);
1516 if (pTask->paramsNum[LOBBYUI_PARAM_ADDRECENTPLAYERS] != INVALID_WEBAPI_JOB_ID)
1517 {
1518 StartSubTask(eST_WaitingForAddRecentPlayersCallback, uiTaskID);
1519 }
1520 else
1521 {
1522 UpdateTaskError(uiTaskID, eCLE_InternalError);
1523 StopTaskRunning(uiTaskID);
1524 }
1525 }
1526 else
1527 {
1528 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1529 StopTaskRunning(uiTaskID);
1530 }
1531 }
1532 else
1533 {
1534 UpdateTaskError(uiTaskID, eCLE_Success);
1535 StopTaskRunning(uiTaskID);
1536 }
1537 }
1538
1539 ECryLobbyError CCryPSNLobbyUI::AddActivityFeed(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
1540 {
1541 LOBBY_AUTO_LOCK;
1542 CryLobbyUITaskID uiTaskID;
1543
1544 ECryLobbyError error = StartTask(eT_AddActivityFeed, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1545 if (error == eCLE_Success)
1546 {
1547 STask* pTask = &m_task[uiTaskID];
1548 pTask->paramsNum[LOBBYUI_PARAM_ADDACTIVITYFEED] = INVALID_WEBAPI_JOB_ID;
1549
1550 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_ADDACTIVITYFEED, NULL, sizeof(SCryPSNOrbisWebApiAddActivityFeedInput));
1551 if (error == eCLE_Success)
1552 {
1553 SCryPSNOrbisWebApiAddActivityFeedInput* pActivityData = (SCryPSNOrbisWebApiAddActivityFeedInput*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_ADDACTIVITYFEED]);
1554
1555 SConfigurationParams titleInfo[1] = {
1556 { CLCC_PSN_TITLE_ID, { NULL }
1557 }
1558 };
1559 m_pPSNSupport->GetLobby()->GetConfigurationInformation(titleInfo, 1);
1560
1561 cry_sprintf(pActivityData->feed, CRY_WEBAPI_ACTIVITYFEED_INGAME_POST_BODY_SAMPLE, m_pPSNSupport->GetLocalUserName(), titleInfo[0].m_pData);
1562 }
1563
1564 if (error == eCLE_Success)
1565 {
1566 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1567 }
1568 else
1569 {
1570 FreeTask(uiTaskID);
1571 }
1572 }
1573
1574 return error;
1575 }
1576
1577 void CCryPSNLobbyUI::StartAddActivityFeed(CryLobbyUITaskID uiTaskID)
1578 {
1579 STask* pTask = &m_task[uiTaskID];
1580
1581 if (pTask->paramsMem[LOBBYUI_PARAM_ADDACTIVITYFEED] != TMemInvalidHdl)
1582 {
1583 if (!m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1584 {
1585 UpdateTaskError(uiTaskID, eCLE_Success);
1586 StopTaskRunning(uiTaskID);
1587 }
1588 }
1589 else
1590 {
1591 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1592 StopTaskRunning(uiTaskID);
1593 }
1594 }
1595
1596 void CCryPSNLobbyUI::TickAddActivityFeed(CryLobbyUITaskID uiTaskID)
1597 {
1598 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1599 {
1600 STask* pTask = &m_task[uiTaskID];
1601
1602 if (pTask->paramsMem[LOBBYUI_PARAM_ADDACTIVITYFEED] != TMemInvalidHdl)
1603 {
1604 pTask->paramsNum[LOBBYUI_PARAM_ADDACTIVITYFEED] = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::PostActivity, pTask->paramsMem[LOBBYUI_PARAM_ADDACTIVITYFEED]);
1605 if (pTask->paramsNum[LOBBYUI_PARAM_ADDACTIVITYFEED] != INVALID_WEBAPI_JOB_ID)
1606 {
1607 StartSubTask(eST_WaitingForAddActivityFeedCallback, uiTaskID);
1608 }
1609 else
1610 {
1611 UpdateTaskError(uiTaskID, eCLE_InternalError);
1612 StopTaskRunning(uiTaskID);
1613 }
1614 }
1615 else
1616 {
1617 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1618 StopTaskRunning(uiTaskID);
1619 }
1620 }
1621 else
1622 {
1623 UpdateTaskError(uiTaskID, eCLE_Success);
1624 StopTaskRunning(uiTaskID);
1625 }
1626 }
1627
1628 ECryLobbyError CCryPSNLobbyUI::GetConsumableOffers(uint32 user, CryLobbyTaskID* pTaskID, const TStoreOfferID* pOfferIDs, uint32 offerIdCount, CryLobbyUIGetConsumableOffersCallback cb, void* pCbArg)
1629 {
1630 LOBBY_AUTO_LOCK;
1631 CryLobbyUITaskID uiTaskID;
1632
1633 ECryLobbyError error = StartTask(eT_GetConsumableOffers, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1634 if (error == eCLE_Success)
1635 {
1636 STask* pTask = &m_task[uiTaskID];
1637 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST] = INVALID_WEBAPI_JOB_ID;
1638 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS] = 0;
1639
1640 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST, NULL, sizeof(SCryPSNOrbisWebApiGetCommerceInput));
1641 if (error == eCLE_Success)
1642 {
1643 SCryPSNOrbisWebApiGetCommerceInput* pData = (SCryPSNOrbisWebApiGetCommerceInput*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST]);
1644 new(pData) SCryPSNOrbisWebApiGetCommerceInput();
1645
1646 pData->numProducts = 0;
1647 for (uint32 i = 0; (i < offerIdCount) && (pData->numProducts < CRY_WEBAPI_COMMERCE_MAX_PRODUCTS); ++i)
1648 {
1649 bool bFound = false;
1650 for (uint32 f = 0; f < pData->numProducts; ++f)
1651 {
1652 if (pData->products[f].productId == pOfferIDs[i].productId)
1653 {
1654 bFound = true;
1655 break;
1656 }
1657 }
1658 if (!bFound)
1659 {
1660 pData->products[pData->numProducts++].productId = pOfferIDs[i].productId;
1661 }
1662 }
1663 }
1664
1665 if (error == eCLE_Success)
1666 {
1667 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1668 }
1669 else
1670 {
1671 FreeTask(uiTaskID);
1672 }
1673 }
1674
1675 return error;
1676 }
1677
1678 void CCryPSNLobbyUI::StartGetConsumableOffers(CryLobbyUITaskID uiTaskID)
1679 {
1680 STask* pTask = &m_task[uiTaskID];
1681
1682 if (pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST] != TMemInvalidHdl)
1683 {
1684 m_pPSNSupport->ResumeTransitioning(ePSNOS_Online);
1685 }
1686 else
1687 {
1688 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1689 StopTaskRunning(uiTaskID);
1690 }
1691 }
1692
1693 void CCryPSNLobbyUI::TickGetConsumableOffers(CryLobbyUITaskID uiTaskID)
1694 {
1695 m_pPSNSupport->ResumeTransitioning(ePSNOS_Online);
1696 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1697 {
1698 STask* pTask = &m_task[uiTaskID];
1699
1700 if (pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST] != TMemInvalidHdl)
1701 {
1702 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST] = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::GetCommerceList, pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST]);
1703 if (pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_REQUEST] != INVALID_WEBAPI_JOB_ID)
1704 {
1705 StartSubTask(eST_WaitingForConsumableOffersCallback, uiTaskID);
1706 }
1707 else
1708 {
1709 UpdateTaskError(uiTaskID, eCLE_InternalError);
1710 StopTaskRunning(uiTaskID);
1711 }
1712 }
1713 else
1714 {
1715 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
1716 StopTaskRunning(uiTaskID);
1717 }
1718 }
1719 }
1720
1721 void CCryPSNLobbyUI::EventWebApiGetConsumableOffers(CryLobbyUITaskID uiTaskID, SCryPSNSupportCallbackEventData& data)
1722 {
1723 STask* pTask = &m_task[uiTaskID];
1724 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS] = 0;
1725
1726 if (data.m_webApiEvent.m_error == PSN_OK)
1727 {
1728 if (data.m_webApiEvent.m_pResponseBody)
1729 {
1730 if (data.m_webApiEvent.m_pResponseBody->eType == SCryPSNWebApiResponseBody::E_JSON)
1731 {
1732 // count json items - annoyingly the "total_results" field in the json document always seems to be 0.
1733 const sce::Json::Value& root = data.m_webApiEvent.m_pResponseBody->jsonTreeRoot;
1734 if (root.getType() == sce::Json::kValueTypeArray)
1735 {
1736 const sce::Json::Array& rootArray = root.getArray();
1737 uint32 offercount = (uint32)rootArray.size();
1738 uint32 skucount = 0;
1739 if (offercount > 0)
1740 {
1741 for (uint32 i = 0; i < offercount; ++i)
1742 {
1743 const sce::Json::Value& offerObj = root[i];
1744 if (offerObj.getType() == sce::Json::kValueTypeObject)
1745 {
1746 const sce::Json::Value& skus = offerObj["skus"];
1747 if (skus.getType() == sce::Json::kValueTypeArray)
1748 {
1749 const sce::Json::Array& skusArray = skus.getArray();
1750 skucount += skusArray.size();
1751 }
1752 }
1753 }
1754
1755 ECryLobbyError error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS, NULL, sizeof(SCryLobbyConsumableOfferData) * skucount);
1756 if (error == eCLE_Success)
1757 {
1758 SCryLobbyConsumableOfferData* pOffers = (SCryLobbyConsumableOfferData*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS]);
1759
1760 for (uint32 i = 0; i < offercount; ++i)
1761 {
1762 const sce::Json::Value& offerObj = root[i];
1763 if (offerObj.getType() == sce::Json::kValueTypeObject)
1764 {
1765 const sce::Json::Value& offerId = offerObj["label"];
1766 const sce::Json::Value& offerName = offerObj["name"];
1767 const sce::Json::Value& offerDesc = offerObj["long_desc"];
1768
1769 const sce::Json::Value& skus = offerObj["skus"];
1770 if (skus.getType() == sce::Json::kValueTypeArray)
1771 {
1772 const sce::Json::Array& skusArray = skus.getArray();
1773 for (uint32 j = 0; j < (uint32)skusArray.size(); ++j)
1774 {
1775 const sce::Json::Value& skuObj = skus[j];
1776 if (skuObj.getType() == sce::Json::kValueTypeObject)
1777 {
1778 SCryLobbyConsumableOfferData* pCurrentOffer = &pOffers[pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS]];
1779 new(pCurrentOffer) SCryLobbyConsumableOfferData();
1780 pCurrentOffer->Clear();
1781
1782 if (offerId.getType() == sce::Json::kValueTypeString)
1783 {
1784 pCurrentOffer->offerID.productId = offerId.toString().c_str();
1785 }
1786 if (offerName.getType() == sce::Json::kValueTypeString)
1787 {
1788 pCurrentOffer->name = CryStringUtils::UTF8ToWStr(offerName.toString().c_str());
1789 }
1790 if (offerDesc.getType() == sce::Json::kValueTypeString)
1791 {
1792 pCurrentOffer->description = CryStringUtils::UTF8ToWStr(offerDesc.toString().c_str());
1793 }
1794
1795 const sce::Json::Value& assetId = skuObj["label"];
1796 if (assetId.getType() == sce::Json::kValueTypeString)
1797 {
1798 pCurrentOffer->assetID = assetId.toString().c_str();
1799 pCurrentOffer->offerID.skuId = assetId.toString().c_str();
1800 }
1801 const sce::Json::Value& price = skuObj["display_price"];
1802 if (price.getType() == sce::Json::kValueTypeString)
1803 {
1804 pCurrentOffer->price = CryStringUtils::UTF8ToWStr(price.toString().c_str());
1805 }
1806 const sce::Json::Value& usecount = skuObj["use_count"];
1807 if (usecount.getType() == sce::Json::kValueTypeUInteger)
1808 {
1809 pCurrentOffer->purchaseQuantity = usecount.getUInteger();
1810 }
1811
1812 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS]++;
1813 }
1814 }
1815 }
1816 }
1817 }
1818
1819 // All finished - success!
1820 UpdateTaskError(uiTaskID, eCLE_Success);
1821 StopTaskRunning(uiTaskID);
1822 return;
1823 }
1824 }
1825 // nothing in array
1826 }
1827 // not an array - fail.
1828 }
1829 // response data not json
1830 }
1831 // response error
1832 }
1833
1834 // if we reach here, the json is bad, or we have failed for some uncaught reason
1835 UpdateTaskError(uiTaskID, eCLE_InternalError);
1836 StopTaskRunning(uiTaskID);
1837 }
1838
1839 void CCryPSNLobbyUI::EndGetConsumableOffers(CryLobbyUITaskID uiTaskID)
1840 {
1841 STask* pTask = &m_task[uiTaskID];
1842 SCryLobbyConsumableOfferData* pOffers = NULL;
1843
1844 if ((pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS] > 0) &&
1845 (pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS] != TMemInvalidHdl))
1846 {
1847 pOffers = (SCryLobbyConsumableOfferData*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS]);
1848 }
1849
1850 ((CryLobbyUIGetConsumableOffersCallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEOFFERS_RESULTS], pOffers, pTask->pCbArg);
1851 }
1852
1853 ECryLobbyError CCryPSNLobbyUI::GetConsumableAssets(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyUIGetConsumableAssetsCallback cb, void* pCbArg)
1854 {
1855 LOBBY_AUTO_LOCK;
1856 CryLobbyUITaskID uiTaskID;
1857
1858 ECryLobbyError error = StartTask(eT_GetConsumableAssets, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1859 if (error == eCLE_Success)
1860 {
1861 STask* pTask = &m_task[uiTaskID];
1862 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_REQUEST] = INVALID_WEBAPI_JOB_ID;
1863 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS] = 0;
1864
1865 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
1866 }
1867
1868 return error;
1869 }
1870
1871 void CCryPSNLobbyUI::StartGetConsumableAssets(CryLobbyUITaskID uiTaskID)
1872 {
1873 m_pPSNSupport->ResumeTransitioning(ePSNOS_Online);
1874 }
1875
1876 void CCryPSNLobbyUI::TickGetConsumableAssets(CryLobbyUITaskID uiTaskID)
1877 {
1878 m_pPSNSupport->ResumeTransitioning(ePSNOS_Online);
1879 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
1880 {
1881 STask* pTask = &m_task[uiTaskID];
1882
1883 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_REQUEST] = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::GetEntitlementList, NULL);
1884 if (pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_REQUEST] != INVALID_WEBAPI_JOB_ID)
1885 {
1886 StartSubTask(eST_WaitingForConsumableAssetsCallback, uiTaskID);
1887 }
1888 else
1889 {
1890 UpdateTaskError(uiTaskID, eCLE_InternalError);
1891 StopTaskRunning(uiTaskID);
1892 }
1893 }
1894 }
1895
1896 void CCryPSNLobbyUI::EventWebApiGetConsumableAssets(CryLobbyUITaskID uiTaskID, SCryPSNSupportCallbackEventData& data)
1897 {
1898 STask* pTask = &m_task[uiTaskID];
1899 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS] = 0;
1900
1901 if (data.m_webApiEvent.m_error == PSN_OK)
1902 {
1903 if (data.m_webApiEvent.m_pResponseBody)
1904 {
1905 if (data.m_webApiEvent.m_pResponseBody->eType == SCryPSNWebApiResponseBody::E_JSON)
1906 {
1907 const sce::Json::Value& num_entitlements = data.m_webApiEvent.m_pResponseBody->jsonTreeRoot["total_results"];
1908 if (num_entitlements.getType() == sce::Json::kValueTypeUInteger)
1909 {
1910 uint32 entitlementCount = num_entitlements.getUInteger();
1911 if (entitlementCount > 0)
1912 {
1913 const sce::Json::Value& entitlements = data.m_webApiEvent.m_pResponseBody->jsonTreeRoot["entitlements"];
1914 if (entitlements.getType() == sce::Json::kValueTypeArray)
1915 {
1916 const sce::Json::Array& entitlementArray = entitlements.getArray();
1917 uint32 numAssets = entitlementArray.size();
1918
1919 ECryLobbyError error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS, NULL, sizeof(SCryLobbyConsumableAssetData) * numAssets);
1920 if (error == eCLE_Success)
1921 {
1922 SCryLobbyConsumableAssetData* pAssets = (SCryLobbyConsumableAssetData*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS]);
1923
1924 for (uint32 i = 0; i < numAssets; ++i)
1925 {
1926 SCryLobbyConsumableAssetData* pCurrentAsset = &pAssets[pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS]];
1927 new(pCurrentAsset) SCryLobbyConsumableAssetData();
1928
1929 const sce::Json::Value& assetObj = entitlements[i];
1930 if (assetObj.getType() == sce::Json::kValueTypeObject)
1931 {
1932 const sce::Json::Value& assetConsumable = assetObj["is_consumable"];
1933 if (assetConsumable.getType() == sce::Json::kValueTypeBoolean)
1934 {
1935 if (assetConsumable.getBoolean() == true)
1936 {
1937 const sce::Json::Value& assetlabel = assetObj["id"];
1938 if (assetlabel.getType() == sce::Json::kValueTypeString)
1939 {
1940 pCurrentAsset->assetID = assetlabel.getString().c_str();
1941 }
1942 const sce::Json::Value& assetUseLimit = assetObj["use_limit"];
1943 if (assetUseLimit.getType() == sce::Json::kValueTypeUInteger)
1944 {
1945 pCurrentAsset->assetQuantity = assetUseLimit.getUInteger();
1946 }
1947
1948 pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS]++;
1949 }
1950 }
1951 }
1952 }
1953 }
1954
1955 // All finished - success!
1956 UpdateTaskError(uiTaskID, eCLE_Success);
1957 StopTaskRunning(uiTaskID);
1958 return;
1959 }
1960 }
1961 // nothing in array
1962 }
1963 // not an array - fail.
1964 }
1965 // response data not json
1966 }
1967 // response error
1968 }
1969
1970 // if we reach here, the json is bad, or we have failed for some uncaught reason
1971 UpdateTaskError(uiTaskID, eCLE_InternalError);
1972 StopTaskRunning(uiTaskID);
1973 }
1974
1975 void CCryPSNLobbyUI::EndGetConsumableAssets(CryLobbyUITaskID uiTaskID)
1976 {
1977 STask* pTask = &m_task[uiTaskID];
1978 SCryLobbyConsumableAssetData* pAssets = NULL;
1979
1980 if ((pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS] > 0) &&
1981 (pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS] != TMemInvalidHdl))
1982 {
1983 pAssets = (SCryLobbyConsumableAssetData*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS]);
1984 }
1985
1986 ((CryLobbyUIGetConsumableAssetsCallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->paramsNum[LOBBYUI_PARAM_GETCONSUMABLEASSETS_RESULTS], pAssets, pTask->pCbArg);
1987 }
1988
1989 ECryLobbyError CCryPSNLobbyUI::ShowDownloadOffer(uint32 user, TStoreOfferID offerId, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
1990 {
1991 LOBBY_AUTO_LOCK;
1992 CryLobbyUITaskID uiTaskID;
1993
1994 ECryLobbyError error = StartTask(eT_ShowDownloadOffer, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
1995 if (error == eCLE_Success)
1996 {
1997 STask* pTask = &m_task[uiTaskID];
1998
1999 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_SHOWDOWNLOADOFFER_ID, NULL, (CRY_LOBBYUI_CONSUMABLE_OFFER_ID_LENGTH + 1 + CRY_LOBBYUI_CONSUMABLE_OFFER_SKU_LENGTH + 1));
2000 if (error == eCLE_Success)
2001 {
2002 char* pOfferString = (char*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_SHOWDOWNLOADOFFER_ID]);
2003 sprintf(pOfferString, "%s-%s", offerId.productId.c_str(), offerId.skuId.c_str());
2004
2005 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
2006 }
2007 else
2008 {
2009 FreeTask(uiTaskID);
2010 }
2011 }
2012
2013 return error;
2014 }
2015
2016 void CCryPSNLobbyUI::StartShowDownloadOffer(CryLobbyUITaskID uiTaskID)
2017 {
2018 STask* pTask = &m_task[uiTaskID];
2019
2020 SceUserServiceUserId userId;
2021 int ret = sceUserServiceGetInitialUser(&userId);
2022 if (ret == PSN_OK)
2023 {
2024 ret = sceNpCommerceDialogInitialize();
2025 if ((ret == PSN_OK) || (ret == SCE_COMMON_DIALOG_ERROR_ALREADY_INITIALIZED))
2026 {
2027 const char* pOffer = (const char*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_SHOWDOWNLOADOFFER_ID]);
2028
2029 SceNpCommerceDialogParam param;
2030 sceNpCommerceDialogParamInitialize(&param);
2031 param.mode = SCE_NP_COMMERCE_DIALOG_MODE_CHECKOUT;
2032 param.userId = userId;
2033 param.targets = &pOffer;
2034 param.numTargets = 1;
2035
2036 ret = sceNpCommerceDialogOpen(&param);
2037 if (ret == PSN_OK)
2038 {
2039 UpdateTaskError(uiTaskID, eCLE_Success);
2040 }
2041 else
2042 {
2043 NetLog("sceNpCommerceDialogOpen failed. ret = 0x%x\n", ret);
2044 UpdateTaskError(uiTaskID, eCLE_InternalError);
2045 }
2046 }
2047 else
2048 {
2049 NetLog("sceNpCommerceDialogInitialize failed. ret = 0x%x\n", ret);
2050 UpdateTaskError(uiTaskID, eCLE_InternalError);
2051 StopTaskRunning(uiTaskID);
2052 }
2053 }
2054 else
2055 {
2056 UpdateTaskError(uiTaskID, eCLE_InternalError);
2057 }
2058
2059 if (pTask->error != eCLE_Success)
2060 {
2061 sceNpCommerceDialogTerminate();
2062 StopTaskRunning(uiTaskID);
2063 }
2064 }
2065
2066 void CCryPSNLobbyUI::TickShowDownloadOffer(CryLobbyUITaskID uiTaskID)
2067 {
2068 int ret;
2069 STask* pTask = &m_task[uiTaskID];
2070
2071 if (pTask->canceled)
2072 {
2073 sceNpCommerceDialogTerminate();
2074 UpdateTaskError(uiTaskID, eCLE_Success);
2075 StopTaskRunning(uiTaskID);
2076 return;
2077 }
2078
2079 ret = sceNpCommerceDialogUpdateStatus();
2080 if (ret == SCE_COMMON_DIALOG_STATUS_FINISHED)
2081 {
2082 // completed.
2083 SceNpCommerceDialogResult result;
2084 memset(&result, 0, sizeof(result));
2085
2086 ret = sceNpCommerceDialogGetResult(&result);
2087 switch (ret)
2088 {
2089 case SCE_COMMON_DIALOG_RESULT_OK:
2090 case SCE_NP_COMMERCE_DIALOG_RESULT_PURCHASED:
2091 {
2092 UpdateTaskError(uiTaskID, eCLE_Success);
2093 }
2094 break;
2095 case SCE_COMMON_DIALOG_RESULT_USER_CANCELED:
2096 {
2097 UpdateTaskError(uiTaskID, eCLE_Cancelled);
2098 }
2099 break;
2100 default:
2101 {
2102 UpdateTaskError(uiTaskID, eCLE_InternalError);
2103 }
2104 break;
2105 }
2106
2107 sceNpCommerceDialogTerminate();
2108
2109 StopTaskRunning(uiTaskID);
2110 }
2111 }
2112
2113 void CCryPSNLobbyUI::EndShowDownloadOffer(CryLobbyUITaskID uiTaskID)
2114 {
2115 STask* pTask = &m_task[uiTaskID];
2116 ((CryLobbyUICallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->pCbArg);
2117 }
2118
2119 ECryLobbyError CCryPSNLobbyUI::ConsumeAsset(uint32 user, TStoreAssetID assetID, uint32 quantity, CryLobbyTaskID* pTaskID, CryLobbyUICallback cb, void* pCbArg)
2120 {
2121 LOBBY_AUTO_LOCK;
2122 CryLobbyUITaskID uiTaskID;
2123
2124 ECryLobbyError error = StartTask(eT_ConsumeAsset, false, user, &uiTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)cb, pCbArg);
2125 if (error == eCLE_Success)
2126 {
2127 STask* pTask = &m_task[uiTaskID];
2128 pTask->paramsNum[LOBBYUI_PARAM_CONSUMEASSET_REQUEST] = INVALID_WEBAPI_JOB_ID;
2129 pTask->paramsNum[LOBBYUI_PARAM_CONSUMEASSET_RESULTS] = 0;
2130
2131 error = CreateTaskParamMem(uiTaskID, LOBBYUI_PARAM_CONSUMEASSET_REQUEST, NULL, sizeof(SCryPSNOrbisWebApiConsumeEntitlementInput));
2132 if (error == eCLE_Success)
2133 {
2134 SCryPSNOrbisWebApiConsumeEntitlementInput* pData = (SCryPSNOrbisWebApiConsumeEntitlementInput*)m_pLobby->MemGetPtr(pTask->paramsMem[LOBBYUI_PARAM_CONSUMEASSET_REQUEST]);
2135 new(pData) SCryPSNOrbisWebApiConsumeEntitlementInput();
2136
2137 pData->entitlementLabel = assetID;
2138 pData->consumption = quantity;
2139
2140 FROM_GAME_TO_LOBBY(&CCryPSNLobbyUI::StartTaskRunning, this, uiTaskID);
2141 }
2142 else
2143 {
2144 FreeTask(uiTaskID);
2145 }
2146 }
2147
2148 return error;
2149 }
2150
2151 void CCryPSNLobbyUI::StartConsumeAsset(CryLobbyUITaskID uiTaskID)
2152 {
2153 STask* pTask = &m_task[uiTaskID];
2154
2155 if (pTask->paramsMem[LOBBYUI_PARAM_CONSUMEASSET_REQUEST] != TMemInvalidHdl)
2156 {
2157 m_pPSNSupport->ResumeTransitioning(ePSNOS_Online);
2158 }
2159 else
2160 {
2161 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
2162 StopTaskRunning(uiTaskID);
2163 }
2164 }
2165
2166 void CCryPSNLobbyUI::TickConsumeAsset(CryLobbyUITaskID uiTaskID)
2167 {
2168 m_pPSNSupport->ResumeTransitioning(ePSNOS_Online);
2169 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Online))
2170 {
2171 STask* pTask = &m_task[uiTaskID];
2172
2173 if (pTask->paramsMem[LOBBYUI_PARAM_CONSUMEASSET_REQUEST] != TMemInvalidHdl)
2174 {
2175 pTask->paramsNum[LOBBYUI_PARAM_CONSUMEASSET_REQUEST] = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::ConsumeEntitlement, pTask->paramsMem[LOBBYUI_PARAM_CONSUMEASSET_REQUEST]);
2176 if (pTask->paramsNum[LOBBYUI_PARAM_CONSUMEASSET_REQUEST] != INVALID_WEBAPI_JOB_ID)
2177 {
2178 StartSubTask(eST_WaitingForConsumeAssetCallback, uiTaskID);
2179 }
2180 else
2181 {
2182 UpdateTaskError(uiTaskID, eCLE_InternalError);
2183 StopTaskRunning(uiTaskID);
2184 }
2185 }
2186 else
2187 {
2188 UpdateTaskError(uiTaskID, eCLE_OutOfMemory);
2189 StopTaskRunning(uiTaskID);
2190 }
2191 }
2192 }
2193
2194 void CCryPSNLobbyUI::EventWebApiConsumeAsset(CryLobbyUITaskID uiTaskID, SCryPSNSupportCallbackEventData& data)
2195 {
2196 STask* pTask = &m_task[uiTaskID];
2197 pTask->paramsNum[LOBBYUI_PARAM_CONSUMEASSET_RESULTS] = 0;
2198
2199 if (data.m_webApiEvent.m_error == PSN_OK)
2200 {
2201 if (data.m_webApiEvent.m_pResponseBody)
2202 {
2203 if (data.m_webApiEvent.m_pResponseBody->eType == SCryPSNWebApiResponseBody::E_JSON)
2204 {
2205 const sce::Json::Value& root = data.m_webApiEvent.m_pResponseBody->jsonTreeRoot;
2206 if (root.getType() == sce::Json::kValueTypeObject)
2207 {
2208 const sce::Json::Value& consumed = root["use_limit"];
2209 if (consumed.getType() == sce::Json::kValueTypeUInteger)
2210 {
2211 pTask->paramsNum[LOBBYUI_PARAM_CONSUMEASSET_RESULTS] = consumed.getUInteger();
2212 }
2213
2214 // All finished - success!
2215 UpdateTaskError(uiTaskID, eCLE_Success);
2216 StopTaskRunning(uiTaskID);
2217 return;
2218 }
2219 // not an object - fail.
2220 }
2221 // response data not json
2222 }
2223 // response error
2224 }
2225
2226 // if we reach here, the json is bad, or we have failed for some uncaught reason
2227 UpdateTaskError(uiTaskID, eCLE_InternalError);
2228 StopTaskRunning(uiTaskID);
2229 }
2230
2231 void CCryPSNLobbyUI::EndConsumeAsset(CryLobbyUITaskID uiTaskID)
2232 {
2233 STask* pTask = &m_task[uiTaskID];
2234 SCryLobbyConsumableOfferData* pOffers = NULL;
2235
2236 ((CryLobbyUICallback)pTask->pCb)(pTask->lTaskID, pTask->error, pTask->pCbArg);
2237 }
2238
2239 #endif // USE_PSN
2240 #endif // CRY_PLATFORM_ORBIS
CRYENGINE is a powerful real-time game development platform created by Crytek.