Example #1
0
        /// <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);
        }
Example #2
0
        /// <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);
        }
Example #3
0
        /// <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);
        }
 internal GKInviteEventListenerForwarder()
     : this(C.GKInviteEventListener_new(
                InternalDidAcceptInviteCallback,
                InternalDidRequestMatchWithRecipientsCallback))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
Example #5
0
        /// <summary>
        /// Returns the object located at the specified index.
        /// </summary>
        /// <returns>The at index.</returns>
        /// <param name="index">Index.</param>
        /// <param name="constructor">Constructor.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public T ObjectAtIndex(uint index, Func <IntPtr, T> constructor)
        {
            IntPtr ptr = C.NSArray_objectAtIndex(SelfPtr(), index);
            T      obj = constructor(ptr);

            CFFunctions.CFRelease(ptr);   // release pointer returned by native method to balance ref count
            return(obj);
        }
Example #6
0
        /// <summary>
        /// Creates and returns an NSMutableArray object with enough allocated memory
        /// to initially hold a given number of objects.
        /// </summary>
        /// <returns>The with capacity.</returns>
        /// <param name="numItems">Number items.</param>
        public static NSMutableArray <T> ArrayWithCapacity(uint numItems)
        {
            var ptr      = C.NSMutableArray_arrayWithCapacity(numItems);
            var mutArray = new NSMutableArray <T>(ptr);

            CFFunctions.CFRelease(ptr);
            return(mutArray);
        }
 internal UIImagePickerControllerDelegateForwarder()
     : this(C.UIImagePickerControllerDelegateForwarder_new(
                InternalUIDidFinishPickingMediaWithInfoCallback,
                InternalUIDidCancelCallback))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
 internal GKTurnBasedMatchmakerViewControllerDelegateForwarder()
     : this(C.GKTurnBasedMatchmakerViewControllerDelegate_new(
                InternalWasCancelledCallback,
                InternalDidFailWithErrorCallback,
                null /* didFindMatch is obsolete so we'll ignore it */))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
Example #9
0
 internal UIAdaptivePresentationControllerDelegateForwarder()
     : this(C.UIAdaptivePresentationControllerDelegate_new(
                InternalPresentationControllerDidAttemptToDismissCallback,
                InternalPresentationControllerShouldDismissCallback,
                InternalPresentationControllerDidDismissCallback,
                InternalPresentationControllerWillDismissCallback))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
 internal GKTurnBasedEventListenerForwarder()
     : this(C.GKTurnBasedEventListener_new(
                InternalDidRequestMatchWithOtherPlayersCallback,
                InternalMatchEndedCallback,
                InternalReceivedTurnEventForMatchCallback,
                InternalWantsToQuitMatchCallback))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
 internal CNContactPickerDelegateForwarder()
     : this(C.CNContactPickerDelegateForwarder_new(
                InternalContactPickerDidCancelCallback,
                InternalContactPickerDidSelectContactCallback,
                InternalContactPickerDidSelectContactPropertyCallback,
                InternalContactPickerDidSelectContactsCallback,
                InternalContactPickerDidSelectContactPropertiesCallback))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
Example #12
0
 internal GKMatchmakerViewControllerDelegateForwarder()
     : this(C.GKMatchmakerViewControllerDelegate_new(
                InternalMatchmakerViewControllerDidFindMatchCallback,
                InternalMatchmakerViewControllerDidFindHostedPlayersCallback,
                InternalMatchmakerViewControllerWasCancelledCallback,
                InternalMatchmakerViewControllerDidFailWithErrorCallback,
                InternalMatchmakerViewControllerHostedPlayerDidAcceptCallback))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
Example #13
0
 internal GKMatchDelegateForwarder()
     : this(C.GKMatchDelegate_new(
                InternalMatchDidReceiveDataForRecipientCallback,
                InternalMatchDidReceiveDataCallback,
                InternalPlayerDidChangeConnectionStateCallback,
                InternalMatchDidFailWithErrorCallback,
                InternalShouldReinviteDisconnectedPlayerCallback))
 {
     // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
     CFFunctions.CFRelease(this.ToPointer());
 }
Example #14
0
        /// <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);
        }
Example #15
0
        /// <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);
        }
Example #16
0
        /// <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);
        }
        internal GKLocalPlayerListenerForwarder(GKInviteEventListenerForwarder inviteEventListenerForwarder,
                                                GKTurnBasedEventListenerForwarder turnBasedEventListenerForwarder)
            : this(C.GKLocalPlayerListener_new(
                       inviteEventListenerForwarder != null ? inviteEventListenerForwarder.ToPointer() : IntPtr.Zero,
                       turnBasedEventListenerForwarder != null ? turnBasedEventListenerForwarder.ToPointer() : IntPtr.Zero))
        {
            // We're using a pointer returned by a native constructor: call CFRelease to balance native ref count
            CFFunctions.CFRelease(this.ToPointer());

            // Store the sub-forwarders.
            this.mInviteEventListenerForwarder    = inviteEventListenerForwarder;
            this.mTurnBasedEventListenerForwarder = turnBasedEventListenerForwarder;
        }
Example #18
0
        /// <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);
        }
Example #19
0
        /// <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);
        }
Example #20
0
 /// <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);
     }
 }
Example #21
0
 /// <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);
     }
 }
Example #22
0
        /// <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);
        }
Example #23
0
        /// <summary>
        /// Returns the delimiter to use between name components.
        /// </summary>
        /// <returns>The for contact.</returns>
        /// <param name="contact">Contact.</param>
        public static NSString DelimiterForContact(CNContact contact)
        {
            if (contact == null)
            {
                return(null);
            }

            NSString str = null;
            var      ptr = C.CNContactFormatter_delimiterForContact(contact.ToPointer());

            if (PInvokeUtil.IsNotNull(ptr))
            {
                str = new NSString(ptr);
                CFFunctions.CFRelease(ptr);
            }
            return(str);
        }
Example #24
0
        /// <summary>
        /// Returns the contact name, formatted with the specified formatter.
        /// </summary>
        /// <returns>The from contact.</returns>
        /// <param name="contact">Contact.</param>
        /// <param name="style">Style.</param>
        public static NSString StringFromContact(CNContact contact, CNContactFormatterStyle style)
        {
            if (contact == null)
            {
                return(null);
            }

            NSString str = null;
            var      ptr = C.CNContactFormatter_stringFromContact(contact.ToPointer(), style);

            if (PInvokeUtil.IsNotNull(ptr))
            {
                str = new NSString(ptr);
                CFFunctions.CFRelease(ptr);
            }
            return(str);
        }
Example #25
0
        /// <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);
        }
Example #26
0
        /// <summary>
        /// Returns a string containing the localized contact property name.
        /// </summary>
        /// <returns>The localized string.</returns>
        /// <param name="key">A string containing the contact property key.</param>
        public NSString LocalizedStringForKey(NSString key)
        {
            if (key == null)
            {
                return(null);
            }

            NSString localizedStr = null;
            var      ptr          = C.CNContact_localizedStringForKey(key.ToPointer());

            if (PInvokeUtil.IsNotNull(ptr))
            {
                localizedStr = new NSString(ptr);
                CFFunctions.CFRelease(ptr);
            }
            return(localizedStr);
        }
Example #27
0
        /// <summary>
        /// Returns the localized name for the property associated with the specified key.
        /// </summary>
        /// <returns>The string for key.</returns>
        /// <param name="key">Key.</param>
        public static NSString LocalizedStringForKey(NSString key)
        {
            if (key == null)
            {
                return(null);
            }

            var      ptr          = C.CNPostalAddress_localizedStringForKey(key.ToPointer());
            NSString localizedStr = null;

            if (PInvokeUtil.IsNotNull(ptr))
            {
                localizedStr = new NSString(ptr);
                CFFunctions.CFRelease(ptr);
            }
            return(localizedStr);
        }
Example #28
0
        /// <summary>
        /// Returns a new labeled value identifier object with the specified label and value.
        /// </summary>
        /// <returns>The value with label.</returns>
        /// <param name="label">Label.</param>
        /// <param name="value">Value.</param>
        public static CNLabeledValue <T> LabeledValueWithLabel(NSString label, T value)
        {
            if (value == null)
            {
                return(null);
            }

            var ptr = C.CNLabeledValue_labeledValueWithLabel(label == null ? IntPtr.Zero : label.ToPointer(), value.ToPointer());
            CNLabeledValue <T> instance = null;

            if (PInvokeUtil.IsNotNull(ptr))
            {
                instance = new CNLabeledValue <T>(ptr);
                CFFunctions.CFRelease(ptr);
            }

            return(instance);
        }
Example #29
0
        /// <summary>
        /// The designated initializer for a fetch request that uses the specified keys.
        /// </summary>
        /// <returns>The with keys to fetch.</returns>
        /// <param name="keysToFetch">Keys to fetch.</param>
        public static CNContactFetchRequest InitWithKeysToFetch(NSArray <NSString> keysToFetch)
        {
            if (keysToFetch == null)
            {
                return(null);
            }

            // This will automatically call alloc on native side before calling the init method.
            var ptr = C.CNContactFetchRequest_initWithKeysToFetch(keysToFetch.ToPointer());
            CNContactFetchRequest request = null;

            if (PInvokeUtil.IsNotNull(ptr))
            {
                request = new CNContactFetchRequest(ptr);
                CFFunctions.CFRelease(ptr);
            }

            return(request);
        }
Example #30
0
        /// <summary>
        /// Returns a new phone number object initialized with the specified phone number string.
        /// </summary>
        /// <returns>The phone number</returns>
        /// <param name="value">A string value with which to initialize phone number object.</param>
        public static CNPhoneNumber PhoneNumberWithStringValue(string value)
        {
            if (string.IsNullOrEmpty(value))
            {
                return(null);
            }

            var ptr = C.CNPhoneNumber_phoneNumberWithStringValue(value);

            if (PInvokeUtil.IsNotNull(ptr))
            {
                var cnPhoneNumber = new CNPhoneNumber(ptr);
                CFFunctions.CFRelease(ptr);   // release pointer returned by the native method.
                return(cnPhoneNumber);
            }
            else
            {
                return(null);
            }
        }