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);
}
internal static UInt32 WrapAndReturnError(UInt32 error, Interop.PARTY_XBL_HANDLE interopHandle, out PARTY_XBL_HANDLE handle)
{
if (PartyError.SUCCEEDED(error))
{
handle = new PARTY_XBL_HANDLE(interopHandle);
}
else
{
handle = default(PARTY_XBL_HANDLE);
}
return(error);
}
public static unsafe UInt32 PartyXblStartProcessingStateChanges(
PARTY_XBL_HANDLE handle,
out List <PARTY_XBL_STATE_CHANGE> stateChanges)
{
UInt32 err;
stateChanges = null;
if (handle == null)
{
return(PartyError.InvalidArg);
}
UInt32 stateChangeCount;
IntPtr rawStateChanges;
stateChanges = objectPool.Retrieve <List <PARTY_XBL_STATE_CHANGE> >();
err = PartyXblInterop.PartyXblStartProcessingStateChanges(handle.InteropHandle, out stateChangeCount, out rawStateChanges);
if (PartyError.SUCCEEDED(err) && stateChangeCount > 0)
{
List <PARTY_XBL_STATE_CHANGE> unsupportStateChanges = null;
IntPtr *arrayPtr = (IntPtr *)rawStateChanges.ToPointer();
for (Int32 i = 0; i < stateChangeCount; i++)
{
PARTY_XBL_STATE_CHANGE stateChangeObj = PARTY_XBL_STATE_CHANGE.CreateFromPtr(arrayPtr[i]);
if (stateChangeObj.GetType() != typeof(PARTY_XBL_STATE_CHANGE))
{
stateChanges.Add(stateChangeObj);
}
else
{
// Remove and immediately finish processing state changes that aren't supported by the
// CSharp wrapper, which will all be of the basic PARTY_STATE_CHANGE type
if (unsupportStateChanges == null)
{
unsupportStateChanges = objectPool.Retrieve <List <PARTY_XBL_STATE_CHANGE> >();
}
unsupportStateChanges.Add(stateChangeObj);
}
}
if (unsupportStateChanges != null)
{
err = PartyXblFinishProcessingStateChanges(handle, unsupportStateChanges);
}
}
return(err);
}
public PartyError ToPartyError()
{
PartyError partyError = new PartyError()
{
IsOperationCallback = this.Type == PartyListenerEventType.OPERATION_CALLBACK,
DebugContext = this.StringData,
ErrorCode = this.UintData,
Feature = (BnetFeature)((int)(this.UlongData >> 32)),
FeatureEvent = (BnetFeatureEvent)((uint)(this.UlongData & (ulong)-1)),
PartyId = this.PartyId,
szPartyType = this.StringData2,
StringData = this.StringData
};
return(partyError);
}
public static UInt32 PartyXblGetErrorMessage(
UInt32 error,
out string errorMessage)
{
UTF8StringPtr errorMessagePtr;
UInt32 err = PartyXblInterop.PartyXblGetErrorMessage(
error,
out errorMessagePtr);
if (PartyError.SUCCEEDED(err))
{
errorMessage = errorMessagePtr.GetString();
}
else
{
errorMessage = null;
}
return(err);
}
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);
}
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);
}
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);
}
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);
}
