/// <summary> /// Loads a specific match. /// </summary> /// <param name="matchID">Match I.</param> /// <param name="completionHandler">Completion handler.</param> public static void LoadMatchWithID(string matchID, Action <GKTurnBasedMatch, NSError> completionHandler) { C.GKTurnBasedMatch_loadMatchWithID( matchID, InternalSingleMatchCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
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); }
/// <summary> /// Loads the game-specific data associated with a match, including all exchanges. /// </summary> /// <param name="completionHandler">Completion handler.</param> public void LoadMatchData(Action <byte[], NSError> completionHandler) { C.GKTurnBasedMatch_loadMatchData( SelfPtr(), InternalLoadMatchDataCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Loads information from Game Center about a list of players. /// </summary> /// <param name="identifiers">Identifiers.</param> /// <param name="completionHandler">Completion handler.</param> public static void LoadPlayersForIdentifiers(string[] identifiers, Action <GKPlayer[], NSError> completionHandler) { C.GKPlayer_loadPlayersForIdentifiers( identifiers, identifiers.Length, InternalLoadPlayersForIdentifiersCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Enables the matchmaking process to find nearby players through Bluetooth or WiFi (same subnet only). /// </summary> /// <param name="reachableHandler">Reachable handler.</param> public void StartBrowsingForNearbyPlayers(Action <GKPlayer, bool> reachableHandler) { C.GKMatchmaker_startBrowsingForNearbyPlayers( SelfPtr(), PlayerBoolCallback, PInvokeCallbackUtil.ToIntPtr(reachableHandler)); }
/// <summary> /// Initiates a search for activity in all player groups. /// </summary> /// <param name="completionHandler">Completion handler.</param> public void QueryActivity(Action <int, NSError> completionHandler) { C.GKMatchmaker_queryActivity( SelfPtr(), IntErrorCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Programmatically removes a match from Game Center. /// </summary> /// <param name="completionHandler">Completion handler.</param> public void Remove(Action <NSError> completionHandler) { C.GKTurnBasedMatch_remove( SelfPtr(), InternalErrorOnlyCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
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); }
/// <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); }
/// <summary> /// Returns an array of players the local player recently played with. /// </summary> /// <param name="completionHandler">Completion handler.</param> public void LoadRecentPlayers(Action <GKPlayer[], NSError> completionHandler) { C.GKLocalPlayer_loadRecentPlayers( SelfPtr(), InternalLoadRecentPlayersCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Determines the best player in the game to act as the server for a client-server match. /// </summary> /// <param name="completionHandler">Completion handler.</param> public void ChooseBestHostingPlayer(Action <GKPlayer> completionHandler) { C.GKMatch_chooseBestHostingPlayer( SelfPtr(), InternalChooseBestHostingPlayerCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
internal static void InternalSaveGameData(iOSGKSavedGame savedGame, byte[] data, Action <iOSGKSavedGame, string> callback) { Util.NullArgumentTest(savedGame); Util.NullArgumentTest(data); Util.NullArgumentTest(callback); iOSSavedGameNative._SaveGameData( savedGame.ToPointer(), data, data.Length, InternalSaveGameDataCallback, PInvokeCallbackUtil.ToIntPtr <SaveGameDataResponse>( response => { string error = response.GetError(); if (string.IsNullOrEmpty(error)) { callback(response.GetSavedGame(), error); } else { callback(null, error); } }, SaveGameDataResponse.FromPointer ) ); }
/// <summary> /// Create a new turn-based match with the same participants as an existing match. /// </summary> /// <param name="completionHandler">Completion handler.</param> public void Rematch(Action <GKTurnBasedMatch, NSError> completionHandler) { C.GKTurnBasedMatch_rematch( SelfPtr(), InternalSingleMatchCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
private static void InternalGetNotificationResponseCallback(IntPtr response, IntPtr callbackPtr) { PInvokeCallbackUtil.PerformInternalCallback( "iOSNotificationListener#InternalGetNotificationResponseCallback", PInvokeCallbackUtil.Type.Temporary, response, callbackPtr); }
/// <summary> /// Resigns the player from the match when that player is not the current player. This action does not end the match. /// </summary> /// <param name="matchOutcome">Match outcome.</param> /// <param name="completionHandler">Completion handler.</param> public void ParticipantQuitOutOfTurn(GKTurnBasedParticipant.GKTurnBasedMatchOutcome matchOutcome, Action <NSError> completionHandler) { C.GKTurnBasedMatch_participantQuitOutOfTurn( SelfPtr(), ref matchOutcome, InternalErrorOnlyCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
private static void InternalDeleteSavedGameCallback(IntPtr response, IntPtr callbackPtr) { PInvokeCallbackUtil.PerformInternalCallback( "iOSSavedGameClient#DeleteSavedGameCallback", PInvokeCallbackUtil.Type.Temporary, response, callbackPtr); }
private static void InternalGetPendingNotificationRequestsCallback(IntPtr response, IntPtr callbackPtr) { PInvokeCallbackUtil.PerformInternalCallback( "iOSNotificationClient#GetPendingNotificationRequestsCallback", PInvokeCallbackUtil.Type.Temporary, response, callbackPtr); }
/// <summary> /// Requests access to the user's contacts. /// </summary> /// <param name="entityType">Entity type.</param> /// <param name="completionHandler">Completion handler.</param> public void RequestAccessForEntityType(CNEntityType entityType, Action <bool, NSError> completionHandler) { C.CNContactStore_requestAccessForEntityType( SelfPtr(), entityType, InternalRequestAccessForEntityTypeCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
private static void InternalResolveConflictingSavedGamesCallback(IntPtr response, IntPtr callbackPtr) { PInvokeCallbackUtil.PerformInternalCallback( "iOSSavedGameClient#ResolveConflictingSavedGamesCallback", PInvokeCallbackUtil.Type.Temporary, response, callbackPtr); }
/// <summary> /// Loads a photo of this player from Game Center. /// </summary> /// <param name="photoSize">Photo size.</param> /// <param name="callback">Callback.</param> public void LoadPhotoForSize(GKPhotoSize photoSize, Action <UIImage, NSError> completionHandler) { C.GKPlayer_loadPhotoForSize( SelfPtr(), photoSize, InternalLoadPhotoForSizeCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Queries Game Center for the activity in a player group. /// </summary> /// <param name="playerGroup">Player group.</param> /// <param name="completionHandler">Completion handler.</param> public void QueryPlayerGroupActivity(uint playerGroup, Action <int, NSError> completionHandler) { C.GKMatchmaker_queryPlayerGroupActivity( SelfPtr(), playerGroup, IntErrorCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Programmatically searches for a new match to join. /// </summary> /// <param name="request">Request.</param> /// <param name="completionHandler">Completion handler.</param> public static void FindMatchForRequest(GKMatchRequest request, Action <GKTurnBasedMatch, NSError> completionHandler) { Util.NullArgumentTest(request); C.GKTurnBasedMatch_findMatchForRequest( request.ToPointer(), InternalSingleMatchCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Dismisses the view controller that was presented modally by the view controller. /// </summary> /// <param name="animated">If set to <c>true</c> animated.</param> /// <param name="completionHandler">Completion handler.</param> public void DismissViewController(bool animated, Action completionHandler) { C.UIViewController_dismissViewController( SelfPtr(), animated, completionHandler == null ? (C.DismissViewControllerCallback)null : InternalDismissViewControllerCallback, completionHandler == null ? IntPtr.Zero : PInvokeCallbackUtil.ToIntPtr(completionHandler) ); }
/// <summary> /// Adds the specified image to the user’s Camera Roll album. /// </summary> /// <param name="image">Image.</param> /// <param name="completionHandler">Completion handler.</param> public static void UIImageWriteToSavedPhotosAlbum(UIImage image, Action <UIImage, NSError> completionHandler) { Util.NullArgumentTest(image); C.UIKit_UIImageWriteToSavedPhotosAlbum( image.ToPointer(), WriteToSavedPhotosAlbumCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Presents a view controller modally. /// </summary> /// <param name="viewController">View controller.</param> /// <param name="animated">If set to <c>true</c> animated.</param> /// <param name="completionHandler">Completion handler.</param> public void PresentViewController(UIViewController viewController, bool animated, Action completionHandler) { C.UIViewController_presentViewController( SelfPtr(), viewController.ToPointer(), animated, completionHandler == null ? (C.PresentViewControllerCallback)null : InternalPresentViewControllerCallback, completionHandler == null ? IntPtr.Zero : PInvokeCallbackUtil.ToIntPtr(completionHandler) ); }
private static void InternalDismissViewControllerCallback(IntPtr secondaryCallback) { if (secondaryCallback != IntPtr.Zero) { PInvokeCallbackUtil.PerformInternalCallback( "UIViewController#InternalDismissViewControllerCallback", PInvokeCallbackUtil.Type.Temporary, secondaryCallback); } }
/// <summary> /// Initiates a request to find players for a peer-to-peer match. /// </summary> /// <param name="request">Request.</param> /// <param name="completionHandler">Completion handler.</param> public void FindMatchForRequest(GKMatchRequest request, Action <GKMatch, NSError> completionHandler) { Util.NullArgumentTest(request); C.GKMatchmaker_findMatchForRequest( SelfPtr(), request.ToPointer(), MatchErrorCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Initiates a request to find players for a hosted match. /// </summary> /// <param name="request">Request.</param> /// <param name="completionHandler">Completion handler.</param> public void FindPlayersForHostedRequest(GKMatchRequest request, Action <NSArray <GKPlayer>, NSError> completionHandler) { Util.NullArgumentTest(request); C.GKMatchmaker_findPlayersForHostedRequest( SelfPtr(), request.ToPointer(), PlayersErrorCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
/// <summary> /// Creates a match from an accepted invitation. /// </summary> /// <param name="invite">Invite.</param> /// <param name="completionHandler">Completion handler.</param> public void MatchForInvite(GKInvite invite, Action <GKMatch, NSError> completionHandler) { Util.NullArgumentTest(invite); C.GKMatchmaker_matchForInvite( SelfPtr(), invite.ToPointer(), MatchErrorCallback, PInvokeCallbackUtil.ToIntPtr(completionHandler)); }
private static void InternalRequestTrackingAuthorizationCallback(ATTrackingManagerAuthorizationStatus status, IntPtr secondaryCallback) { if (secondaryCallback != IntPtr.Zero) { PInvokeCallbackUtil.PerformInternalCallback( "ATTrackingManager#InternalRequestTrackingAuthorizationCallback", PInvokeCallbackUtil.Type.Temporary, status, secondaryCallback); } }