public static UInt32 PartyXblLoginToPlayFab(
            PARTY_XBL_CHAT_USER_HANDLE localChatUser,
            Object asyncIdentifier)
        {
            if (localChatUser == null)
            {
                return(PartyError.InvalidArg);
            }

            var asyncId = IntPtr.Zero;

            if (asyncIdentifier != null)
            {
                asyncId = GCHandle.ToIntPtr(GCHandle.Alloc(asyncIdentifier));
            }

            UInt32 err = PartyXblInterop.PartyXblLoginToPlayFab(
                localChatUser.InteropHandle,
                asyncId);

            if (PartyError.FAILED(err))
            {
                if (asyncId != IntPtr.Zero)
                {
                    GCHandle asyncGcHandle = GCHandle.FromIntPtr(asyncId);
                    asyncGcHandle.Free();
                }
            }

            return(err);
        }
        public static UInt32 PartyXblDestroyChatUser(
            PARTY_XBL_HANDLE handle,
            PARTY_XBL_CHAT_USER_HANDLE chatUser)
        {
            if (handle == null || chatUser == null)
            {
                return(PartyError.InvalidArg);
            }

            return(PartyXblInterop.PartyXblDestroyChatUser(handle.InteropHandle, chatUser.InteropHandle));
        }
Beispiel #3
0
 internal static UInt32 WrapAndReturnError(UInt32 error, Interop.PARTY_XBL_CHAT_USER_HANDLE interopHandle, out PARTY_XBL_CHAT_USER_HANDLE handle)
 {
     if (PartyError.SUCCEEDED(error))
     {
         handle = new PARTY_XBL_CHAT_USER_HANDLE(interopHandle);
     }
     else
     {
         handle = default(PARTY_XBL_CHAT_USER_HANDLE);
     }
     return(error);
 }
        public static UInt32 PartyXblChatUserGetXboxUserId(
            PARTY_XBL_CHAT_USER_HANDLE handle,
            out UInt64 xboxUserId)
        {
            xboxUserId = 0;
            if (handle == null)
            {
                return(PartyError.InvalidArg);
            }

            return(PartyXblInterop.PartyXblChatUserGetXboxUserId(
                       handle.InteropHandle,
                       out xboxUserId));
        }
        public static UInt32 PartyXblLocalChatUserGetCrossNetworkCommunicationPrivacySetting(
            PARTY_XBL_CHAT_USER_HANDLE handle,
            out PARTY_XBL_CROSS_NETWORK_COMMUNICATION_PRIVACY_SETTING setting)
        {
            setting = PARTY_XBL_CROSS_NETWORK_COMMUNICATION_PRIVACY_SETTING.PARTY_XBL_CROSS_NETWORK_COMMUNICATION_PRIVACY_SETTING_ALLOWED;
            if (handle == null)
            {
                return(PartyError.InvalidArg);
            }

            return(PartyXblInterop.PartyXblLocalChatUserGetCrossNetworkCommunicationPrivacySetting(
                       handle.InteropHandle,
                       out setting));
        }
        public static UInt32 PartyXblChatUserGetCustomContext(
            PARTY_XBL_CHAT_USER_HANDLE handle,
            out Object customContext)
        {
            if (handle == null)
            {
                customContext = null;
                return(PartyError.InvalidArg);
            }

            return(MarshalHelpers.GetCustomContext <Interop.PARTY_XBL_CHAT_USER_HANDLE>(
                       PartyXblInterop.PartyXblChatUserGetCustomContext,
                       handle.InteropHandle,
                       out customContext));
        }
        public static UInt32 PartyXblCreateRemoteChatUser(
            PARTY_XBL_HANDLE handle,
            UInt64 xboxUserId,
            out PARTY_XBL_CHAT_USER_HANDLE chatUser)
        {
            chatUser = null;
            if (handle == null)
            {
                return(PartyError.InvalidArg);
            }

            Interop.PARTY_XBL_CHAT_USER_HANDLE interopHandle;
            UInt32 err = PartyXblInterop.PartyXblCreateRemoteChatUser(
                handle.InteropHandle,
                xboxUserId,
                out interopHandle);

            return(PARTY_XBL_CHAT_USER_HANDLE.WrapAndReturnError(err, interopHandle, out chatUser));
        }
        public static UInt32 PartyXblCreateLocalChatUser(
            PARTY_XBL_HANDLE handle,
            UInt64 xboxUserId,
            Object asyncIdentifier,
            out PARTY_XBL_CHAT_USER_HANDLE localXboxLiveUser)
        {
            localXboxLiveUser = null;
            if (handle == null)
            {
                return(PartyError.InvalidArg);
            }

            var asyncId = IntPtr.Zero;

            if (asyncIdentifier != null)
            {
                asyncId = GCHandle.ToIntPtr(GCHandle.Alloc(asyncIdentifier));
            }

            Interop.PARTY_XBL_CHAT_USER_HANDLE interopHandle;
            UInt32 err = PartyXblInterop.PartyXblCreateLocalChatUser(
                handle.InteropHandle,
                xboxUserId,
                asyncId,
                out interopHandle);

            if (PartyError.SUCCEEDED(err))
            {
                localXboxLiveUser = new PARTY_XBL_CHAT_USER_HANDLE(interopHandle);
            }
            else
            {
                if (asyncId != IntPtr.Zero)
                {
                    GCHandle asyncGcHandle = GCHandle.FromIntPtr(asyncId);
                    asyncGcHandle.Free();
                }
            }

            return(err);
        }
        public static UInt32 PartyXblLocalChatUserGetAccessibilitySettings(
            PARTY_XBL_CHAT_USER_HANDLE handle,
            out PARTY_XBL_ACCESSIBILITY_SETTINGS settings)
        {
            settings = null;
            if (handle == null)
            {
                return(PartyError.InvalidArg);
            }

            Interop.PARTY_XBL_ACCESSIBILITY_SETTINGS interopStruct;
            UInt32 err = PartyXblInterop.PartyXblLocalChatUserGetAccessibilitySettings(
                handle.InteropHandle,
                out interopStruct);

            if (PartyError.SUCCEEDED(err))
            {
                settings = new PARTY_XBL_ACCESSIBILITY_SETTINGS(interopStruct);
            }

            return(err);
        }
Beispiel #10
0
        public static UInt32 PartyXblChatUserIsLocal(
            PARTY_XBL_CHAT_USER_HANDLE handle,
            out bool isLocal)
        {
            isLocal = false;
            if (handle == null)
            {
                return(PartyError.InvalidArg);
            }

            Byte   isLocalByte;
            UInt32 err = PartyXblInterop.PartyXblChatUserIsLocal(
                handle.InteropHandle,
                out isLocalByte);

            if (PartyError.SUCCEEDED(err))
            {
                isLocal = Convert.ToBoolean(isLocalByte);
            }

            return(err);
        }
Beispiel #11
0
        public static UInt32 PartyXblCreateRemoteChatUser(
            PARTY_XBL_HANDLE handle,
            UInt64 xboxUserId,
            out PARTY_XBL_CHAT_USER_HANDLE chatUser)
        {
            chatUser = null;
            if (handle == null)
            {
                return(PartyError.InvalidArg);
            }

            Interop.PARTY_XBL_CHAT_USER_HANDLE interopHandle;
            UInt32 err = PartyXblInterop.PartyXblCreateRemoteChatUser(
                handle.InteropHandle,
                xboxUserId,
                out interopHandle);

            if (err == PartyErrorXblChatUserAlreadyExists) // if remote chat user already exists, return its handle without an error
            {
                err = PartyError.Success;
            }
            return(PARTY_XBL_CHAT_USER_HANDLE.WrapAndReturnError(err, interopHandle, out chatUser));
        }
Beispiel #12
0
        public static UInt32 PartyXblGetEntityIdsFromXboxLiveUserIds(
            PARTY_XBL_HANDLE handle,
            UInt64[] xboxLiveUserIds,
            PARTY_XBL_CHAT_USER_HANDLE localChatUser,
            Object asyncIdentifier)
        {
            if (handle == null || xboxLiveUserIds == null || localChatUser == null)
            {
                return(PartyError.InvalidArg);
            }

            var asyncId = IntPtr.Zero;

            if (asyncIdentifier != null)
            {
                asyncId = GCHandle.ToIntPtr(GCHandle.Alloc(asyncIdentifier));
            }

            UInt32 err = PartyXblInterop.PartyXblGetEntityIdsFromXboxLiveUserIds(
                handle.InteropHandle,
                (UInt32)xboxLiveUserIds.Length,
                xboxLiveUserIds,
                localChatUser.InteropHandle,
                asyncId);

            if (PartyError.FAILED(err))
            {
                if (asyncId != IntPtr.Zero)
                {
                    GCHandle asyncGcHandle = GCHandle.FromIntPtr(asyncId);
                    asyncGcHandle.Free();
                }
            }

            return(err);
        }
Beispiel #13
0
        public static UInt32 PartyXblLocalChatUserGetRequiredChatPermissionInfo(
            PARTY_XBL_CHAT_USER_HANDLE handle,
            PARTY_XBL_CHAT_USER_HANDLE targetChaUser,
            out PARTY_XBL_CHAT_PERMISSION_INFO chatPermissionInfo)
        {
            chatPermissionInfo = null;
            if (handle == null || targetChaUser == null)
            {
                return(PartyError.InvalidArg);
            }

            Interop.PARTY_XBL_CHAT_PERMISSION_INFO interopStruct;
            UInt32 err = PartyXblInterop.PartyXblLocalChatUserGetRequiredChatPermissionInfo(
                handle.InteropHandle,
                targetChaUser.InteropHandle,
                out interopStruct);

            if (PartyError.SUCCEEDED(err))
            {
                chatPermissionInfo = new PARTY_XBL_CHAT_PERMISSION_INFO(interopStruct);
            }

            return(err);
        }