private static void InternalDidRequestMatchWithOtherPlayersCallback(IntPtr listenerPtr, IntPtr player, IntPtr playersToInvite)
{
var forwarder = FromPointer(listenerPtr);
if (forwarder != null && forwarder.ListenerCount > 0)
{
// GKPlayer.
GKPlayer gkPlayer = InteropObjectFactory <GKPlayer> .FromPointer(player, ptr => new GKPlayer(ptr));
// GKPlayer[].
GKPlayer[] gkPlayersToInvite = null;
if (PInvokeUtil.IsNotNull(playersToInvite))
{
// Creating a one-time usage NSArray binder, no need to use the factory.
using (var nsArray = new NSArray <GKPlayer>(playersToInvite))
{
gkPlayersToInvite = nsArray.ToArray(ptr => InteropObjectFactory <GKPlayer> .FromPointer(ptr, p => new GKPlayer(p)));
}
}
// Invoke consumer delegates.
forwarder.InvokeOnAllListeners(l => l.PlayerDidRequestMatchWithOtherPlayers(gkPlayer, gkPlayersToInvite));
}
}
/// <summary>
/// Fetches a unified contact for the specified contact identifier.
/// </summary>
/// <returns>The contact with identifier.</returns>
/// <param name="identifier">Identifier.</param>
/// <param name="keys">Keys.</param>
/// <param name="error">Error.</param>
public CNContact UnifiedContactWithIdentifier(NSString identifier, NSArray <NSString> keys, out NSError error)
{
Util.NullArgumentTest(identifier);
Util.NullArgumentTest(keys);
IntPtr errorPtr = new IntPtr();
var contactPtr = C.CNContactStore_unifiedContactWithIdentifier(
SelfPtr(),
identifier.ToPointer(),
keys.ToPointer(),
ref errorPtr);
error = null;
if (PInvokeUtil.IsNotNull(errorPtr))
{
error = new NSError(errorPtr);
CFFunctions.CFRelease(errorPtr);
}
CNContact contact = null;
if (PInvokeUtil.IsNotNull(contactPtr))
{
contact = new CNContact(contactPtr);
CFFunctions.CFRelease(contactPtr);
}
return(contact);
}
/// <summary>
/// Fetches all unified contacts matching the specified predicate.
/// </summary>
/// <returns>The contacts matching predicate.</returns>
/// <param name="predicate">Predicate.</param>
/// <param name="keys">Keys.</param>
/// <param name="error">Error.</param>
public NSArray <CNContact> UnifiedContactsMatchingPredicate(NSPredicate predicate, NSArray <NSString> keys, out NSError error)
{
Util.NullArgumentTest(predicate);
Util.NullArgumentTest(keys);
IntPtr errorPtr = new IntPtr();
var contactsPtr = C.CNContactStore_unifiedContactsMatchingPredicate(
SelfPtr(),
predicate.ToPointer(),
keys.ToPointer(),
ref errorPtr);
error = null;
if (PInvokeUtil.IsNotNull(errorPtr))
{
error = new NSError(errorPtr);
CFFunctions.CFRelease(errorPtr);
}
NSArray <CNContact> contacts = null;
if (PInvokeUtil.IsNotNull(contactsPtr))
{
contacts = new NSArray <CNContact>(contactsPtr);
CFFunctions.CFRelease(contactsPtr);
}
return(contacts);
}
/// <summary>
/// Returns a Boolean value that indicates whether the enumeration of
/// all contacts matching a contact fetch request executed successfully.
/// </summary>
/// <returns><c>true</c>, if contacts with fetch request was enumerated, <c>false</c> otherwise.</returns>
/// <param name="fetchRequest">Fetch request.</param>
/// <param name="error">Error.</param>
/// <param name="block">Block.</param>
public bool EnumerateContactsWithFetchRequest(CNContactFetchRequest fetchRequest, out NSError error, EnumerateContactsWithFetchRequestBlock block)
{
Util.NullArgumentTest(fetchRequest);
Util.NullArgumentTest(block);
IntPtr errorPtr = new IntPtr();
bool success = C.CNContactStore_enumerateContactsWithFetchRequest(
SelfPtr(),
fetchRequest.ToPointer(),
ref errorPtr,
InternalEnumerateContactsBlock,
PInvokeCallbackUtil.ToIntPtr((CNContact contact) =>
{
bool shouldStop;
block(contact, out shouldStop);
return(shouldStop);
}));
error = null;
if (PInvokeUtil.IsNotNull(errorPtr))
{
error = new NSError(errorPtr);
CFFunctions.CFRelease(errorPtr); // balance out ref count of a pointer returned directly from native side.
}
return(success);
}
private static void InternalMultipleMatchesCallback(IntPtr matches, IntPtr error, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
GKTurnBasedMatch[] gkMatches = null;
if (PInvokeUtil.IsNotNull(matches))
{
// Creating a one-time usage NSArray binder, no need to use the factory.
using (var nsArray = new NSArray <GKTurnBasedMatch>(matches))
{
gkMatches = nsArray.ToArray(ptr => InteropObjectFactory <GKTurnBasedMatch> .FromPointer(ptr, p => new GKTurnBasedMatch(p)));
}
}
// A new NSError object is always created on native side, so no need
// to check the binder pool for reusing an existing one.
NSError nsError = PInvokeUtil.IsNotNull(error) ? new NSError(error) : null;
// Invoke consumer callback.
PInvokeCallbackUtil.PerformInternalCallback(
"GKTurnBasedMatch#InternalMultipleMatchesCallback",
PInvokeCallbackUtil.Type.Temporary,
gkMatches, nsError, secondaryCallback);
}
private static void GetImageDataHolderFunc(int taskId, int frameCount, int frameWidth, int frameHeight, IntPtr pointerHolder)
{
if (frameCount <= 0 || PInvokeUtil.IsNull(pointerHolder))
{
Debug.LogError("GetImageDataHolderFunc Error: Invalid buffer pointers from native side.");
return;
}
// Create managed buffer for unmanaged code to fill data in.
int frameSize = frameWidth * frameHeight;
var buff = new Color32[frameCount][];
for (int i = 0; i < frameCount; i++)
{
buff[i] = new Color32[frameSize];
}
var gcHandleArray = new GCHandle[frameCount];
var ptrArray = new IntPtr[frameCount];
for (int i = 0; i < buff.Length; i++)
{
gcHandleArray[i] = GCHandle.Alloc(buff[i], GCHandleType.Pinned);
ptrArray[i] = gcHandleArray[i].AddrOfPinnedObject(); // fill the pointers sent by native code with the object pointer we've just pinned.
}
// Copy pointers to unmanaged holder.
C._CopyPointerArray(pointerHolder, ptrArray, frameCount);
// Cache GCHandles.
DecodeTasks[taskId].imageDataHandles = gcHandleArray;
}
private static void InternalLoadMatchDataCallback(IntPtr matchData, IntPtr error, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
byte[] data = null;
if (PInvokeUtil.IsNotNull(matchData))
{
// Creating a one-time usage NSData binder, so no need to use the factory.
using (var nsData = new NSData(matchData))
{
var length = nsData.Length;
if (length > 0)
{
data = nsData.GetBytes(length);
}
}
}
// A new NSError object is always created on native side, so no need
// to check the binder pool for reusing an existing one.
NSError nsError = PInvokeUtil.IsNotNull(error) ? new NSError(error) : null;
PInvokeCallbackUtil.PerformInternalCallback(
"GKTurnBasedMatch#InternalLoadMatchDataCallback",
PInvokeCallbackUtil.Type.Temporary,
data, nsError, secondaryCallback);
}
internal iOSGKSavedGame[] GetFetchedSavedGames()
{
return(PInvokeUtil.ToEnumerable <iOSGKSavedGame>(
EM_FetchSavedGamesResponse_GetData_Length(SelfPtr()),
index =>
iOSGKSavedGame.FromPointer(EM_FetchSavedGamesResponse_GetData_GetElement(SelfPtr(), index))
).Cast <iOSGKSavedGame>().ToArray());
}
internal iOSGKSavedGame[] GetSavedGames()
{
return(PInvokeUtil.ToEnumerable <iOSGKSavedGame>(
_ResolveConflictResponse_GetData_Length(SelfPtr()),
index =>
iOSGKSavedGame.FromPointer(_ResolveConflictResponse_GetData_GetElement(SelfPtr(), index))
).Cast <iOSGKSavedGame>().ToArray());
}
private void Cleanup()
{
if (!PInvokeUtil.IsNull(mSelfPointer))
{
ReleaseHandle(mSelfPointer);
mSelfPointer = new HandleRef(this, IntPtr.Zero);
}
}
public T[] ToArray(Func <IntPtr, T> constructor)
{
return(PInvokeUtil.ToEnumerable <T>(
(int)Count,
index => ObjectAtIndex(
(uint)index,
constructor
)).ToArray());
}
internal iOSNotificationRequest[] GetNotificationRequests()
{
return(PInvokeUtil.ToEnumerable <iOSNotificationRequest>(
iOSNotificationNative._GetPendingNotificationRequestsResponse_GetData_Length(SelfPtr()),
index =>
iOSNotificationRequest.FromPointer(
iOSNotificationNative._GetPendingNotificationRequestsResponse_GetData_GetElement(SelfPtr(), index))
).Cast <iOSNotificationRequest>().ToArray());
}
/// <summary>
/// Returns the data for the specified image in JPEG format.
/// </summary>
/// <returns>The image JPEG representation.</returns>
/// <param name="image">The original image data.</param>
/// <param name="compressionQuality">The quality of the resulting JPEG image,
/// expressed as a value from 0.0 to 1.0. The value 0.0 represents the maximum compression
/// (or lowest quality) while the value 1.0 represents the least compression (or best quality).</param>
public static byte[] UIImageJPEGRepresentation(UIImage image, float compressionQuality)
{
if (image == null)
{
return(null);
}
compressionQuality = UnityEngine.Mathf.Clamp(compressionQuality, 0, 1);
return(PInvokeUtil.GetNativeArray <byte>((buffer, length) =>
C.UIImage_JPEGRepresentation(image.SelfPtr(), compressionQuality, buffer, length)));
}
/// <summary>
/// Returns a new instance that’s a mutable copy of the receiver.
/// </summary>
/// <returns>The copy.</returns>
public CNMutableContact MutableCopy()
{
CNMutableContact mutCopy = null;
var ptr = C.CNContact_mutableCopy(SelfPtr());
if (PInvokeUtil.IsNotNull(ptr))
{
mutCopy = new CNMutableContact(ptr);
CFFunctions.CFRelease(ptr);
}
return(mutCopy);
}
/// <summary>
/// Returns the required key descriptor for the specified formatting style of the contact.
/// </summary>
/// <returns>The for required keys for style.</returns>
/// <param name="style">Style.</param>
public static CNKeyDescriptor DescriptorForRequiredKeysForStyle(CNContactFormatterStyle style)
{
InternalCNKeyDescriptor keyDesc = null;
var ptr = C.CNContactFormatter_descriptorForRequiredKeysForStyle(style);
if (PInvokeUtil.IsNotNull(ptr))
{
keyDesc = new InternalCNKeyDescriptor(ptr);
CFFunctions.CFRelease(ptr);
}
return(keyDesc);
}
/// <summary>
/// Creates and returns a predicate that always evaluates to a given Boolean value.
/// </summary>
/// <returns>The with value.</returns>
/// <param name="value">If set to <c>true</c> value.</param>
public static NSPredicate PredicateWithValue(bool value)
{
NSPredicate predicate = null;
var ptr = C.NSPredicate_predicateWithValue(value);
if (PInvokeUtil.IsNotNull(ptr))
{
predicate = new NSPredicate(ptr);
CFFunctions.CFRelease(ptr);
}
return(predicate);
}
/// <summary>
/// Creates a NSData object from a pointer and release that pointer.
/// </summary>
/// <returns>The NSData object.</returns>
/// <param name="pointer">Pointer.</param>
private static NSData FromPointer(IntPtr pointer)
{
if (PInvokeUtil.IsNotNull(pointer))
{
var obj = new NSData(pointer);
CoreFoundation.CFFunctions.CFRelease(pointer);
return(obj);
}
else
{
return(null);
}
}
private static void InternalChooseBestHostingPlayerCallback(IntPtr player, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
var gkPlayer = InteropObjectFactory <GKPlayer> .FromPointer(player, p => new GKPlayer(p));
PInvokeCallbackUtil.PerformInternalCallback(
"GKMatch#InternalChooseBestHostingPlayerCallback",
PInvokeCallbackUtil.Type.Temporary,
gkPlayer, secondaryCallback);
}
/// <summary>
/// Get the contact property value.
/// </summary>
/// <param name="constructor">Constructor to create object of type <see cref="T"/>.</param>
public T GetValue(Func <IntPtr, T> constructor)
{
if (mValue == null)
{
var ptr = C.CNLabeledValue_value(SelfPtr());
if (PInvokeUtil.IsNotNull(ptr))
{
mValue = constructor(ptr);
CFFunctions.CFRelease(ptr);
}
}
return(mValue);
}
private static void InternalErrorOnlyCallback(IntPtr error, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
NSError nsError = PInvokeUtil.IsNotNull(error) ? new NSError(error) : null;
PInvokeCallbackUtil.PerformInternalCallback(
"GKTurnBasedMatch#InternalErrorOnlyCallback",
PInvokeCallbackUtil.Type.Temporary,
nsError, secondaryCallback);
}
private static void PlayerBoolCallback(
/* InteropGKPlayer */ IntPtr playerPtr, bool boolArg, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
var player = InteropObjectFactory <GKPlayer> .FromPointer(playerPtr, p => new GKPlayer(p));
PInvokeCallbackUtil.PerformInternalCallback(
"GKMatchmaker#PlayerBoolCallback",
PInvokeCallbackUtil.Type.Temporary,
player, boolArg, secondaryCallback);
}
private static void IntErrorCallback(
int intArg, /* InteropNSError */ IntPtr errorPtr, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
var error = PInvokeUtil.IsNotNull(errorPtr) ? new NSError(errorPtr) : null;
PInvokeCallbackUtil.PerformInternalCallback(
"GKMatchmaker#IntErrorCallback",
PInvokeCallbackUtil.Type.Temporary,
intArg, error, secondaryCallback);
}
/// <summary>
/// Creates a NSString object from a pointer and release that pointer if required.
/// </summary>
/// <returns>The pointer.</returns>
/// <param name="ptr">Ptr.</param>
/// <param name="releasePointer">If set to <c>true</c> release pointer.</param>
internal static NSString FromPointer(IntPtr ptr, bool releasePointer)
{
if (PInvokeUtil.IsNull(ptr))
{
return(null);
}
var str = new NSString(ptr);
if (releasePointer)
{
CFFunctions.CFRelease(ptr);
}
return(str);
}
/// <summary>
/// Creates a NSURL object from a pointer and release that pointer if required.
/// </summary>
/// <returns>The NSURL object.</returns>
/// <param name="pointer">Pointer.</param>
/// <param name="releasePointer">If set to <c>true</c> release pointer.</param>
internal static NSURL FromPointer(IntPtr pointer, bool releasePointer)
{
if (PInvokeUtil.IsNotNull(pointer))
{
var newURL = new NSURL(pointer);
if (releasePointer)
{
CFFunctions.CFRelease(pointer);
}
return(newURL);
}
else
{
return(null);
}
}
private static void InternalSingleMatchCallback(IntPtr match, IntPtr error, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
GKTurnBasedMatch gkMatch = InteropObjectFactory <GKTurnBasedMatch> .FromPointer(match, ptr => new GKTurnBasedMatch(ptr));
NSError nsError = PInvokeUtil.IsNotNull(error) ? new NSError(error) : null;
PInvokeCallbackUtil.PerformInternalCallback(
"GKTurnBasedMatch#InternalSingleMatchCallback",
PInvokeCallbackUtil.Type.Temporary,
gkMatch, nsError, secondaryCallback);
}
/// <summary>
/// Creates a UIImage object from a pointer and release the pointer if required.
/// </summary>
/// <returns>The UIImage object.</returns>
/// <param name="pointer">Pointer.</param>
/// <param name="releasePointer">If set to <c>true</c> release pointer.</param>
internal static UIImage FromPointer(IntPtr pointer, bool releasePointer)
{
if (PInvokeUtil.IsNotNull(pointer))
{
var obj = new UIImage(pointer);
if (releasePointer)
{
CoreFoundation.CFFunctions.CFRelease(pointer);
}
return(obj);
}
else
{
return(null);
}
}
/// <summary>
/// Executes a save request and returns success or failure.
/// </summary>
/// <returns><c>true</c>, if save request was executed, <c>false</c> otherwise.</returns>
/// <param name="saveRequest">Save request.</param>
/// <param name="error">Error.</param>
public bool ExecuteSaveRequest(CNSaveRequest saveRequest, out NSError error)
{
Util.NullArgumentTest(saveRequest);
IntPtr errorPtr = new IntPtr();
bool success = C.CNContactStore_executeSaveRequest(SelfPtr(), saveRequest.ToPointer(), ref errorPtr);
error = null;
if (PInvokeUtil.IsNotNull(errorPtr))
{
error = new NSError(errorPtr);
CFFunctions.CFRelease(errorPtr); // balance out ref count of a pointer returned directly from native side.
}
return(success);
}
/// <summary>
/// Creates a NSArray object from a pointer and release the pointer if required.
/// </summary>
/// <returns>The NSArray object.</returns>
/// <param name="pointer">Pointer.</param>
/// <param name="releasePointer">If set to <c>true</c> release pointer.</param>
internal static NSArray <T> FromPointer(IntPtr pointer, bool releasePointer)
{
if (PInvokeUtil.IsNotNull(pointer))
{
var obj = new NSArray <T>(pointer);
if (releasePointer)
{
CFFunctions.CFRelease(pointer);
}
return(obj);
}
else
{
return(null);
}
}
/// <summary>
/// Creates and returns a new predicate formed by creating a new string with a given format and parsing the result.
/// </summary>
/// <returns>The with format.</returns>
/// <param name="predicateFormat">Predicate format.</param>
public static NSPredicate PredicateWithFormat(NSString predicateFormat)
{
if (predicateFormat == null)
{
return(null);
}
NSPredicate predicate = null;
var ptr = C.NSPredicate_predicateWithFormat(predicateFormat.ToPointer());
if (PInvokeUtil.IsNotNull(ptr))
{
predicate = new NSPredicate(ptr);
CFFunctions.CFRelease(ptr);
}
return(predicate);
}
private static void PlayersErrorCallback(
/* InteropNSArray<GKPlayer> */ IntPtr playerArrayPtr, /* InteropNSError */ IntPtr errorPtr, IntPtr secondaryCallback)
{
if (PInvokeUtil.IsNull(secondaryCallback))
{
return;
}
var array = InteropObjectFactory <NSArray <GKPlayer> > .FromPointer(playerArrayPtr, p => new NSArray <GKPlayer>(p));
var error = PInvokeUtil.IsNotNull(errorPtr) ? new NSError(errorPtr) : null;
PInvokeCallbackUtil.PerformInternalCallback(
"GKMatchmaker#PlayersErrorCallback",
PInvokeCallbackUtil.Type.Temporary,
array, error, secondaryCallback);
}
