internal LeaderboardResult(IntPtr leaderboardResultPtr)
{
pImpl = new LeaderboardResultImpl(leaderboardResultPtr);
LEADERBOARD_RESULT cResult = MarshalingHelpers.PtrToStructure <LEADERBOARD_RESULT>(leaderboardResultPtr);
TotalRowCount = cResult.TotalRowCount;
Columns = new List <LeaderboardColumn>();
if (cResult.ColumnsCount > 0)
{
IntPtr[] cColumns = new IntPtr[cResult.ColumnsCount];
Marshal.Copy(cResult.Columns, cColumns, 0, (int)cResult.ColumnsCount);
for (uint i = 0; i < cResult.ColumnsCount; i++)
{
Columns.Add(new LeaderboardColumn(cColumns[i]));
}
}
Rows = new List <LeaderboardRow>();
if (cResult.RowsCount > 0)
{
IntPtr[] cRows = new IntPtr[cResult.RowsCount];
Marshal.Copy(cResult.Rows, cRows, 0, (int)cResult.RowsCount);
for (uint i = 0; i < cResult.RowsCount; i++)
{
Rows.Add(new LeaderboardRow(cRows[i]));
}
}
}
internal LeaderboardColumn(IntPtr leaderboardColumnPtr)
{
LEADERBOARD_COLUMN cColumn = MarshalingHelpers.PtrToStructure <LEADERBOARD_COLUMN>(leaderboardColumnPtr);
StatisticType = cColumn.StatType;
StatisticName = MarshalingHelpers.Utf8ToString(cColumn.StatName);
}
public IList <XboxSocialUser> GetUsersFromXboxUserIds(IList <string> xboxUserIds)
{
// Allocates memory for returned objects
IntPtr cUsersCount = Marshal.AllocHGlobal(Marshal.SizeOf <Int32>());
IntPtr cUserIds = MarshalingHelpers.StringListToHGlobalUtf8StringArray(xboxUserIds);
// Invokes the c method
IntPtr cUsersPtr = XboxSocialUserGroupGetUsersFromXboxUserIds(m_socialUserGroupPtr, cUserIds, (uint)xboxUserIds.Count, cUsersCount);
// Does local work
uint usersCount = (uint)Marshal.ReadInt32(cUsersCount);
Marshal.FreeHGlobal(cUsersCount);
List <XboxSocialUser> users = new List <XboxSocialUser>();
if (usersCount > 0)
{
IntPtr[] cUsers = new IntPtr[usersCount];
Marshal.Copy(cUsersPtr, cUsers, 0, (int)usersCount);
foreach (IntPtr cUser in cUsers)
{
users.Add(new XboxSocialUser(cUser));
}
}
// Cleans up parameters
MarshalingHelpers.FreeHGlobalUtf8StringArray(cUserIds, xboxUserIds.Count());
return(users.AsReadOnly());
}
/// <summary>
/// Checks if the current user has a specific privilege and if it doesn't, it shows UI
/// </summary>
/// <param name="user">XboxLiveUser that identifies the user to show the UI on behalf of.</param>
/// <param name="privilege">The privilege to check.</param>
/// <param name="friendlyMessage">Text to display in addition to the stock text about the privilege</param>
/// <returns>
/// An interface for tracking the progress of the asynchronous call.
/// The operation completes when the UI is closed.
/// A boolean which is true if the current user has the privilege.
/// </returns>
public static Task <bool> CheckGamingPrivilegeWithUI(XboxLiveUser user, GamingPrivilege privilege, string friendlyMessage)
{
var tcs = new TaskCompletionSource <bool>();
Task.Run(() =>
{
var pFriendlyMessage = MarshalingHelpers.StringToHGlobalUtf8(friendlyMessage);
int contextKey;
var context = XsapiCallbackContext <object, bool> .CreateContext(null, tcs, out contextKey);
context.PointersToFree = new List <IntPtr> {
pFriendlyMessage
};
var result = TCUICheckGamingPrivilegeWithUI(privilege, pFriendlyMessage,
CheckGamingPrivilegeComplete, (IntPtr)contextKey, XboxLive.DefaultTaskGroupId);
if (result != XSAPI_RESULT.XSAPI_RESULT_OK)
{
tcs.SetException(new XboxException(result));
}
});
return(tcs.Task);
}
public void UpdateSocialUserGroup(XboxSocialUserGroup socialGroup, IList <string> users)
{
if (socialGroup == null)
{
throw new ArgumentNullException("socialGroup");
}
if (users == null)
{
throw new ArgumentNullException("users");
}
// Allocates memory for parameters
IntPtr cUserIds = MarshalingHelpers.StringListToHGlobalUtf8StringArray(users);
// Allocates memory for returned objects
IntPtr cErrMessage;
// Invokes the c method
XSAPI_RESULT errCode = SocialManagerUpdateSocialUserGroup(socialGroup.GetPtr(), cUserIds, (uint)users.Count, out cErrMessage);
MarshalingHelpers.FreeHGlobalUtf8StringArray(cUserIds, users.Count);
if (errCode != XSAPI_RESULT.XSAPI_RESULT_OK)
{
throw new XboxException(errCode, cErrMessage);
}
// Does local work
socialGroup.Refresh();
}
public XboxSocialUserGroup CreateSocialUserGroupFromList(XboxLiveUser user, IList <string> xboxUserIdList)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (xboxUserIdList == null)
{
throw new ArgumentNullException("xboxUserIdList");
}
// Allocates memory for parameters
IntPtr cUserIds = MarshalingHelpers.StringListToHGlobalUtf8StringArray(xboxUserIdList);
// Allocates memory for returned objects
IntPtr cGroupPtr;
IntPtr cErrMessage;
// Invokes the c method
XSAPI_RESULT errCode = SocialManagerCreateSocialUserGroupFromList(user.Impl.XboxLiveUserPtr, cUserIds, (uint)xboxUserIdList.Count, out cGroupPtr, out cErrMessage);
MarshalingHelpers.FreeHGlobalUtf8StringArray(cUserIds, xboxUserIdList.Count);
if (errCode != XSAPI_RESULT.XSAPI_RESULT_OK)
{
throw new XboxException(errCode, cErrMessage);
}
// Handles returned objects
XboxSocialUserGroup socialUserGroup = new XboxSocialUserGroup(cGroupPtr);
m_groups.Add(socialUserGroup);
return(socialUserGroup);
}
private void CreateCMetadata()
{
var scid = MarshalingHelpers.StringToHGlobalUtf8(this.ServiceConfigurationId);
var path = MarshalingHelpers.StringToHGlobalUtf8(this.BlobPath);
var xuid = MarshalingHelpers.StringToHGlobalUtf8(this.XboxUserId);
var displayName = MarshalingHelpers.StringToHGlobalUtf8(this.DisplayName);
var etag = MarshalingHelpers.StringToHGlobalUtf8(this.ETag);
IntPtr clientTimePtr = IntPtr.Zero;
if (this.ClientTimeStamp != null)
{
var clientTime = this.ClientTimeStamp.ToUnixTimeSeconds();
clientTimePtr = Marshal.AllocHGlobal(MarshalingHelpers.SizeOf <UInt64>());
Marshal.WriteInt64(clientTimePtr, clientTime);
}
TitleStorageCreateBlobMetadata(scid, StorageType, path, BlobType, xuid, displayName, etag, clientTimePtr, out metadataPtr);
Marshal.FreeHGlobal(scid);
Marshal.FreeHGlobal(path);
Marshal.FreeHGlobal(xuid);
Marshal.FreeHGlobal(displayName);
Marshal.FreeHGlobal(etag);
Marshal.FreeHGlobal(clientTimePtr);
}
private static void GetTokenAndSignatureComplete(XSAPI_RESULT_INFO result, XSAPI_TOKEN_AND_SIGNATURE_RESULT payload, IntPtr context)
{
int contextKey = context.ToInt32();
XsapiCallbackContext <UserImpl, GetTokenAndSignatureResult> contextObject;
if (XsapiCallbackContext <UserImpl, GetTokenAndSignatureResult> .TryRemove(contextKey, out contextObject))
{
if (result.errorCode == XSAPI_RESULT.XSAPI_RESULT_OK)
{
contextObject.TaskCompletionSource.SetResult(new GetTokenAndSignatureResult
{
WebAccountId = MarshalingHelpers.Utf8ToString(payload.WebAccountId),
Privileges = MarshalingHelpers.Utf8ToString(payload.Privileges),
AgeGroup = MarshalingHelpers.Utf8ToString(payload.AgeGroup),
Gamertag = MarshalingHelpers.Utf8ToString(payload.Gamertag),
XboxUserId = MarshalingHelpers.Utf8ToString(payload.XboxUserId),
Signature = MarshalingHelpers.Utf8ToString(payload.Signature),
Token = MarshalingHelpers.Utf8ToString(payload.Token)
});
}
else
{
contextObject.TaskCompletionSource.SetException(new XboxException(result));
}
contextObject.Dispose();
}
}
private void CheckMultiplePermissionsWithMultipleTargetUsersComplete(XSAPI_RESULT_INFO result, IntPtr resultsPtr, UInt32 privacyCheckResultCount, IntPtr contextKey)
{
XsapiCallbackContext <CheckMultiplePermissionsContext, IList <MultiplePermissionsCheckResult> > context;
if (XsapiCallbackContext <CheckMultiplePermissionsContext, IList <MultiplePermissionsCheckResult> > .TryRemove(contextKey.ToInt32(), out context))
{
if (result.errorCode == XSAPI_RESULT.XSAPI_RESULT_OK)
{
var results = new List <MultiplePermissionsCheckResult>();
var structSize = MarshalingHelpers.SizeOf <XSAPI_PRIVACY_MULTIPLE_PERMISSIONS_CHECK_RESULT>();
for (UInt64 i = 0; i < privacyCheckResultCount; ++i)
{
results.Add(new MultiplePermissionsCheckResult(resultsPtr));
resultsPtr = resultsPtr.Increment(structSize);
}
context.TaskCompletionSource.SetResult(results.AsReadOnly());
}
else
{
context.TaskCompletionSource.SetException(new XboxException(result));
}
MarshalingHelpers.FreeHGlobalUtf8StringArray(context.Context.permissionIdsArray, context.Context.permissionIdsLength);
MarshalingHelpers.FreeHGlobalUtf8StringArray(context.Context.targetXboxUserIdsArray, context.Context.targetXboxUserIdsLength);
context.Dispose();
}
}
internal PermissionDenyReason(IntPtr structPtr)
{
var permissionDenyReasonStruct = MarshalingHelpers.PtrToStructure <XSAPI_PRIVACY_PERMISSION_DENY_REASON>(structPtr);
Reason = MarshalingHelpers.Utf8ToString(permissionDenyReasonStruct.reason);
RestrictedSetting = MarshalingHelpers.Utf8ToString(permissionDenyReasonStruct.restrictedSetting);
}
public LeaderboardQuery GetNextQueryImpl()
{
// Allocates memory for returned objects
IntPtr cErrMessage = Marshal.AllocHGlobal(MarshalingHelpers.SizeOf <IntPtr>());
IntPtr cNextQuery = Marshal.AllocHGlobal(MarshalingHelpers.SizeOf <IntPtr>());
// Invokes the c method
XSAPI_RESULT errCode = LeaderboardResultGetNextQuery(m_leaderboardResultPtr, cNextQuery, cErrMessage);
// Handles error
string errMessage = Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(cErrMessage));
Marshal.FreeHGlobal(cErrMessage);
if (errCode != XSAPI_RESULT.XSAPI_RESULT_OK)
{
// todo do something
}
// Does local work
LeaderboardQuery nextQuery = new LeaderboardQuery(Marshal.ReadIntPtr(cNextQuery));
Marshal.FreeHGlobal(cNextQuery);
return(nextQuery);
}
public StatisticValue GetStatistic(XboxLiveUser user, string statName)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
// Allocates memory for returned objects
IntPtr cStatValue;
IntPtr cErrMessage;
IntPtr cStatName = MarshalingHelpers.StringToHGlobalUtf8(statName);
// Invokes the c method
XSAPI_RESULT errCode = StatsManagerGetStat(user.Impl.XboxLiveUserPtr, cStatName, out cStatValue, out cErrMessage);
Marshal.FreeHGlobal(cStatName);
if (errCode != XSAPI_RESULT.XSAPI_RESULT_OK)
{
throw new XboxException(errCode, cErrMessage);
}
// Does local work
StatisticValue statValue = new StatisticValue(cStatValue);
return(statValue);
}
public Task <IList <MultiplePermissionsCheckResult> > CheckMultiplePermissionsWithMultipleTargetUsersAsync(IList <string> permissionIds, IList <string> targetXboxUserIds)
{
var tcs = new TaskCompletionSource <IList <MultiplePermissionsCheckResult> >();
Task.Run(() =>
{
var permissionIdsArray = MarshalingHelpers.StringListToHGlobalUtf8StringArray(permissionIds);
var xuidsArray = MarshalingHelpers.StringListToHGlobalUtf8StringArray(targetXboxUserIds);
int contextKey = XsapiCallbackContext <CheckMultiplePermissionsContext, IList <MultiplePermissionsCheckResult> > .CreateContext(
new CheckMultiplePermissionsContext
{
permissionIdsArray = permissionIdsArray,
permissionIdsLength = permissionIds.Count,
targetXboxUserIdsArray = xuidsArray,
targetXboxUserIdsLength = targetXboxUserIds.Count
}, tcs);
var xsapiResult = PrivacyCheckMultiplePermissionsWithMultipleTargetUsers(
this.pCXboxLiveContext, permissionIdsArray, (UInt32)permissionIds.Count, xuidsArray, (UInt32)targetXboxUserIds.Count,
CheckMultiplePermissionsWithMultipleTargetUsersComplete, (IntPtr)contextKey, XboxLive.DefaultTaskGroupId);
if (xsapiResult != XSAPI_RESULT.XSAPI_RESULT_OK)
{
tcs.SetException(new XboxException(xsapiResult));
}
});
return(tcs.Task);
}
/// <summary>
/// Gets a list of blob metadata objects under a given path for the specified service configuration, storage type and storage ID.
/// </summary>
/// <param name="serviceConfigurationId">The service configuration ID (SCID) of the title</param>
/// <param name="storageType">The storage type to get blob metadata objects for.</param>
/// <param name="blobPath">(Optional) The root path to enumerate. Results will be for blobs contained in this path and all subpaths.</param>
/// <param name="xboxUserId">The Xbox User ID of the title storage to enumerate. Pass nullptr when searching for GlobalStorage type data. (Optional)</param>
/// <param name="skipItems">(Optional) The number of items to skip before returning results. (Optional)</param>
/// <param name="maxItems">(Optional) The maximum number of items to return.</param>
/// <returns>An instance of the <see cref="TitleStorageBlobMetadataResult"/> class containing the list of enumerated blob metadata objects.</returns>
public Task <TitleStorageBlobMetadataResult> GetBlobMetadataAsync(string serviceConfigurationId, TitleStorageType storageType, string blobPath, string xboxUserId, uint skipItems = 0, uint maxItems = 0)
{
var tcs = new TaskCompletionSource <TitleStorageBlobMetadataResult>();
Task.Run(() =>
{
var scid = MarshalingHelpers.StringToHGlobalUtf8(serviceConfigurationId);
var blobPathPtr = MarshalingHelpers.StringToHGlobalUtf8(blobPath);
var xuidPtr = MarshalingHelpers.StringToHGlobalUtf8(xboxUserId);
int contextKey;
var context = XsapiCallbackContext <object, TitleStorageBlobMetadataResult> .CreateContext(null, tcs, out contextKey);
context.PointersToFree = new List <IntPtr> {
scid, blobPathPtr, xuidPtr
};
var xsapiResult = TitleStorageGetBlobMetadata(
this.pCXboxLiveContext, scid, storageType, blobPathPtr, xuidPtr, skipItems, maxItems,
GetBlobMetadataComplete, (IntPtr)contextKey, XboxLive.DefaultTaskGroupId);
if (xsapiResult != XSAPI_RESULT.XSAPI_RESULT_OK)
{
tcs.SetException(new XboxException(xsapiResult));
}
});
return(tcs.Task);
}
/// <summary>
/// Downloads blob data from title storage.
/// </summary>
/// <param name="blobMetadata">The blob metadata for the title storage blob to download.</param>
/// <param name="etagMatchCondition">The ETag match condition used to determine if the blob should be downloaded.</param>
/// <param name="selectQuery">A query string that contains a ConfigStorage filter string or JSONStorage json property name string to filter. (Optional)</param>
/// <param name="preferredDownloadBlockSize">The preferred download block size in bytes for binary blobs. </param>
/// <returns>An instance of the <see cref="TitleStorageBlobResult"/> containing the blob content and an updated
/// <see cref="TitleStorageBlobMetadata"/> object.</returns>
public Task <TitleStorageBlobResult> DownloadBlobAsync(TitleStorageBlobMetadata blobMetadata, TitleStorageETagMatchCondition etagMatchCondition, string selectQuery, uint preferredDownloadBlockSize)
{
var tcs = new TaskCompletionSource <TitleStorageBlobResult>();
Task.Run(() =>
{
int contextKey;
var context = XsapiCallbackContext <TitleStorageBlobMetadata, TitleStorageBlobResult> .CreateContext(blobMetadata, tcs, out contextKey);
var buffer = Marshal.AllocHGlobal((int)blobMetadata.Length);
var select = MarshalingHelpers.StringToHGlobalUtf8(selectQuery);
var pPreferredDownloadBlockSize = GCHandle.Alloc(preferredDownloadBlockSize, GCHandleType.Pinned);
context.PointersToFree = new List <IntPtr> {
buffer, select
};
context.GCHandlesToFree = new List <GCHandle> {
pPreferredDownloadBlockSize
};
var xsapiResult = TitleStorageDownloadBlob(
this.pCXboxLiveContext, blobMetadata.metadataPtr, buffer, (UInt32)blobMetadata.Length, etagMatchCondition, select, GCHandle.ToIntPtr(pPreferredDownloadBlockSize),
DownloadBlobComplete, (IntPtr)contextKey, XboxLive.DefaultTaskGroupId);
if (xsapiResult != XSAPI_RESULT.XSAPI_RESULT_OK)
{
tcs.SetException(new XboxException(xsapiResult));
}
});
return(tcs.Task);
}
public Task <PermissionCheckResult> CheckPermissionWithTargetUserAsync(string permissionId, string targetXboxUserId)
{
var tcs = new TaskCompletionSource <PermissionCheckResult>();
Task.Run(() =>
{
var permissionIdPtr = MarshalingHelpers.StringToHGlobalUtf8(permissionId);
var xuidPtr = MarshalingHelpers.StringToHGlobalUtf8(targetXboxUserId);
int contextKey;
var context = XsapiCallbackContext <object, PermissionCheckResult> .CreateContext(null, tcs, out contextKey);
context.PointersToFree = new List <IntPtr> {
permissionIdPtr, xuidPtr
};
var xsapiResult = PrivacyCheckPermissionWithTargetUser(
this.pCXboxLiveContext, permissionIdPtr, xuidPtr, CheckPermissionWithTargetUserComplete,
(IntPtr)contextKey, XboxLive.DefaultTaskGroupId);
if (xsapiResult != XSAPI_RESULT.XSAPI_RESULT_OK)
{
tcs.SetException(new XboxException(xsapiResult));
}
});
return(tcs.Task);
}
/// <summary>
/// Initialze a TitleStorageQuota from the corresponding C object
/// </summary>
internal TitleStorageQuota(XSAPI_TITLE_STORAGE_QUOTA quotaStruct)
{
QuotaBytes = quotaStruct.QuotaBytes;
UsedBytes = quotaStruct.UsedBytes;
StorageType = quotaStruct.storageType;
XboxUserId = MarshalingHelpers.Utf8ToString(quotaStruct.XboxUserId);
ServiceConfigurationId = MarshalingHelpers.Utf8ToString(quotaStruct.ServiceConfigurationId);
}
internal PreferredColor(IntPtr preferredColorPtr)
{
PREFERRED_COLOR cPreferredColor = MarshalingHelpers.PtrToStructure <PREFERRED_COLOR>(preferredColorPtr);
PrimaryColor = MarshalingHelpers.Utf8ToString(cPreferredColor.PrimaryColor);
SecondaryColor = MarshalingHelpers.Utf8ToString(cPreferredColor.SecondaryColor);
TertiaryColor = MarshalingHelpers.Utf8ToString(cPreferredColor.TertiaryColor);
}
// todo For perf consider if we need an init method and a refresh method seperate
internal void Refresh()
{
var cSocialUserGroup = Marshal.PtrToStructure <XBOX_SOCIAL_USER_GROUP>(m_socialUserGroupPtr);
// Properties
SocialUserGroupType = cSocialUserGroup.SocialUserGroupType;
PresenceFilterOfGroup = cSocialUserGroup.PresenceFilterOfGroup;
RelationshipFilterOfGroup = cSocialUserGroup.RelationshipFilterOfGroup;
// Local User
if (LocalUser == null)
{
var manager = (SocialManager)XboxLive.Instance.SocialManager;
LocalUser = manager.GetUser(cSocialUserGroup.LocalUser);
}
LocalUser.Impl.UpdatePropertiesFromXboxLiveUserPtr();
// Users
// todo: for perf consider not removing everthing, but updating certain things and deleting the rest
m_users.Clear();
if (cSocialUserGroup.UsersCount > 0)
{
IntPtr[] cUsersArray = new IntPtr[cSocialUserGroup.UsersCount];
Marshal.Copy(cSocialUserGroup.Users, cUsersArray, 0, (int)cSocialUserGroup.UsersCount);
for (int i = 0; i < cUsersArray.Count(); i++)
{
var socialUser = new XboxSocialUser(cUsersArray[i]);
m_users[socialUser.XboxUserId] = socialUser;
}
}
// Users Tracked
// todo: for perf consider whether this list is static or dynamic
m_trackedUsers.Clear();
if (cSocialUserGroup.UsersTrackedBySocialUserGroupCount > 0)
{
IntPtr[] cTrackedUsers = new IntPtr[cSocialUserGroup.UsersTrackedBySocialUserGroupCount];
Marshal.Copy(cSocialUserGroup.UsersTrackedBySocialUserGroup, cTrackedUsers, 0, (int)cSocialUserGroup.UsersTrackedBySocialUserGroupCount);
for (int i = 0; i < cTrackedUsers.Count(); i++)
{
var cSocialUser = Marshal.PtrToStructure <SocialManager.XBOX_USER_ID_CONTAINER>(cTrackedUsers[i]);
string xuid = MarshalingHelpers.Utf8ToString(cSocialUser.XboxUserId);
m_trackedUsers.Add(xuid);
}
}
}
internal SocialManagerPresenceTitleRecord(IntPtr titleRecordPtr)
{
SOCIAL_MANAGER_PRESENCE_TITLE_RECORD cTitleRecord = MarshalingHelpers.PtrToStructure <SOCIAL_MANAGER_PRESENCE_TITLE_RECORD>(titleRecordPtr);
IsTitleActive = cTitleRecord.IsTitleActive;
IsBroadcasting = cTitleRecord.IsBroadcasting;
Device = cTitleRecord.DeviceType;
TitleId = cTitleRecord.TitleId;
PresenceText = MarshalingHelpers.Utf8ToString(cTitleRecord.PresenceText);
}
internal StatisticValue(IntPtr statValuePtr)
{
STATISTIC_VALUE cStatValue = MarshalingHelpers.PtrToStructure <STATISTIC_VALUE>(statValuePtr);
Name = MarshalingHelpers.Utf8ToString(cStatValue.Name);
AsNumber = cStatValue.AsNumber;
AsInteger = cStatValue.AsInteger;
AsString = MarshalingHelpers.Utf8ToString(cStatValue.AsString);
DataType = cStatValue.DataType;
}
internal void Refresh()
{
var CStruct = MarshalingHelpers.PtrToStructure <XSAPI_TITLE_STORAGE_BLOB_METADATA>(this.metadataPtr);
this.ServiceConfigurationId = MarshalingHelpers.Utf8ToString(CStruct.serviceConfigurationId);
this.BlobPath = MarshalingHelpers.Utf8ToString(CStruct.blobPath);
this.BlobType = CStruct.blobType;
this.StorageType = CStruct.storageType;
this.DisplayName = MarshalingHelpers.Utf8ToString(CStruct.displayName);
this.ETag = MarshalingHelpers.Utf8ToString(CStruct.ETag);
this.Length = CStruct.length;
this.XboxUserId = MarshalingHelpers.Utf8ToString(CStruct.xboxUserId);
}
public LeaderboardQueryImpl(IntPtr ptr, LeaderboardQuery query)
{
m_leaderboardQueryPtr = ptr;
LEADERBOARD_QUERY cLeaderboardQuery = MarshalingHelpers.PtrToStructure <LEADERBOARD_QUERY>(m_leaderboardQueryPtr);
m_skipResultToMe = cLeaderboardQuery.SkipResultToMe;
m_skipResultToRank = cLeaderboardQuery.SkipResultToRank;
m_maxItems = cLeaderboardQuery.MaxItems;
m_order = cLeaderboardQuery.Order;
query.StatName = MarshalingHelpers.Utf8ToString(cLeaderboardQuery.StatName);
query.SocialGroup = MarshalingHelpers.Utf8ToString(cLeaderboardQuery.SocialGroup);
query.HasNext = cLeaderboardQuery.HasNext;
}
internal PermissionCheckResult(XSAPI_PRIVACY_PERMISSION_CHECK_RESULT permissionCheckResultStruct)
{
IsAllowed = permissionCheckResultStruct.isAllowed;
PermissionRequested = MarshalingHelpers.Utf8ToString(permissionCheckResultStruct.permissionRequested);
Reasons = new List <PermissionDenyReason>((int)permissionCheckResultStruct.denyReasonsCount);
int size = MarshalingHelpers.SizeOf <XSAPI_PRIVACY_PERMISSION_DENY_REASON>();
IntPtr denyReasonPtr = permissionCheckResultStruct.denyReasons;
for (ulong i = 0; i < permissionCheckResultStruct.denyReasonsCount; ++i)
{
Reasons.Add(new PermissionDenyReason(denyReasonPtr));
denyReasonPtr = denyReasonPtr.Increment(size);
}
}
private void CreateCMetadata()
{
var scid = MarshalingHelpers.StringToHGlobalUtf8(this.ServiceConfigurationId);
var path = MarshalingHelpers.StringToHGlobalUtf8(this.BlobPath);
var xuid = MarshalingHelpers.StringToHGlobalUtf8(this.XboxUserId);
var displayName = MarshalingHelpers.StringToHGlobalUtf8(this.DisplayName);
var etag = MarshalingHelpers.StringToHGlobalUtf8(this.ETag);
TitleStorageCreateBlobMetadata(scid, StorageType, path, BlobType, xuid, displayName, etag, IntPtr.Zero, /*TODO client timestamp*/ out metadataPtr);
Marshal.FreeHGlobal(scid);
Marshal.FreeHGlobal(path);
Marshal.FreeHGlobal(xuid);
Marshal.FreeHGlobal(displayName);
Marshal.FreeHGlobal(etag);
}
internal SocialEvent(IntPtr socialEventPtr, IList <XboxSocialUserGroup> groups)
{
SOCIAL_EVENT cSocialEvent = Marshal.PtrToStructure <SOCIAL_EVENT>(socialEventPtr);
EventType = cSocialEvent.EventType;
var manager = (SocialManager)XboxLive.Instance.SocialManager;
User = manager.GetUser(cSocialEvent.User);
try
{
SocialManager.SOCIAL_USER_GROUP_LOADED_ARGS cArgs = Marshal.PtrToStructure <SocialManager.SOCIAL_USER_GROUP_LOADED_ARGS>(cSocialEvent.EventArgs);
foreach (XboxSocialUserGroup group in groups)
{
if (cArgs.SocialUserGroup == group.GetPtr())
{
EventArgs = new SocialUserGroupLoadedEventArgs(group);
break;
}
}
}
catch (Exception)
{
// Event args weren't SocialUserGroupLoadedArgs
}
List <string> usersAffected = new List <string>();
if (cSocialEvent.UsersAffectedCount > 0)
{
IntPtr[] cUsersAffected = new IntPtr[cSocialEvent.UsersAffectedCount];
Marshal.Copy(cSocialEvent.UsersAffected, cUsersAffected, 0, (int)cSocialEvent.UsersAffectedCount);
foreach (IntPtr cXuidPtr in cUsersAffected)
{
SocialManager.XBOX_USER_ID_CONTAINER cXuid = Marshal.PtrToStructure <SocialManager.XBOX_USER_ID_CONTAINER>(cXuidPtr);
string xuid = MarshalingHelpers.Utf8ToString(cXuid.XboxUserId);
usersAffected.Add(xuid);
}
}
UsersAffected = usersAffected.AsReadOnly();
ErrorCode = cSocialEvent.ErrorCode;
ErrorMessge = MarshalingHelpers.Utf8ToString(cSocialEvent.ErrorMessage);
}
private void GetPrivacyUserListComplete(XSAPI_RESULT_INFO result, IntPtr xboxUserIdList, UInt32 count, IntPtr contextKey)
{
XsapiCallbackContext <object, IList <string> > context;
if (XsapiCallbackContext <object, IList <string> > .TryRemove(contextKey.ToInt32(), out context))
{
if (result.errorCode == XSAPI_RESULT.XSAPI_RESULT_OK)
{
context.TaskCompletionSource.SetResult(MarshalingHelpers.Utf8StringArrayToStringList(xboxUserIdList, count));
}
else
{
context.TaskCompletionSource.SetException(new XboxException(result));
}
context.Dispose();
}
}
internal MultiplePermissionsCheckResult(IntPtr multiplePermissionsStructPtr)
{
var multiplePermissionsStruct = MarshalingHelpers.PtrToStructure <XSAPI_PRIVACY_MULTIPLE_PERMISSIONS_CHECK_RESULT>(multiplePermissionsStructPtr);
XboxUserId = MarshalingHelpers.Utf8ToString(multiplePermissionsStruct.xboxUserId);
Items = new List <PermissionCheckResult>((int)multiplePermissionsStruct.itemsCount);
int size = MarshalingHelpers.SizeOf <XSAPI_PRIVACY_PERMISSION_CHECK_RESULT>();
IntPtr permissionStructPtr = multiplePermissionsStruct.items;
for (ulong i = 0; i < multiplePermissionsStruct.itemsCount; ++i)
{
var permissionCheckResultStruct = MarshalingHelpers.PtrToStructure <XSAPI_PRIVACY_PERMISSION_CHECK_RESULT>(permissionStructPtr);
Items.Add(new PermissionCheckResult(permissionCheckResultStruct));
permissionStructPtr = permissionStructPtr.Increment(size);
}
}
internal SocialManagerPresenceRecord(IntPtr socialManagerPresenceRecordPtr)
{
this.m_socialManagerPresenceRecordPtr = socialManagerPresenceRecordPtr;
SOCIAL_MANAGER_PRESENCE_RECORD cPresenceRecord = MarshalingHelpers.PtrToStructure <SOCIAL_MANAGER_PRESENCE_RECORD>(socialManagerPresenceRecordPtr);
UserState = cPresenceRecord.UserState;
m_titleRecords = new List <SocialManagerPresenceTitleRecord>();
if (cPresenceRecord.PresenceTitleRecordsCount > 0)
{
IntPtr[] cTitleRecords = new IntPtr[cPresenceRecord.PresenceTitleRecordsCount];
Marshal.Copy(cPresenceRecord.PresenceTitleRecords, cTitleRecords, 0, (int)cPresenceRecord.PresenceTitleRecordsCount);
foreach (IntPtr cTitleRecord in cTitleRecords)
{
m_titleRecords.Add(new SocialManagerPresenceTitleRecord(cTitleRecord));
}
}
}
public IList <string> GetStatisticNames(XboxLiveUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
IntPtr cStatListPtr;
UInt32 statListCount;
IntPtr cErrMessage;
// Invokes the c method
XSAPI_RESULT errCode = StatsManagerGetStatNames(user.Impl.XboxLiveUserPtr, out cStatListPtr, out statListCount, out cErrMessage);
if (errCode != XSAPI_RESULT.XSAPI_RESULT_OK)
{
throw new XboxException(errCode, cErrMessage);
}
return(MarshalingHelpers.Utf8StringArrayToStringList(cStatListPtr, statListCount));
}
