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)); }