private List <Product> PerformSearch_Swift(string[] searchItems)
        {
            // Update the filtered array based on the search text.
            var searchResults = this.products;

            // Build all the "AND" expressions for each value in searchString.
            var andMatchPredicates = searchItems.Select(searchItem => FindMatches(searchItem)).ToArray();

            // Match up the fields of the Product object.
            var finalCompoundPredicate = NSCompoundPredicate.CreateAndPredicate(andMatchPredicates);
            var filteredResults        = searchResults.Where(searchResult => finalCompoundPredicate.EvaluateWithObject(searchResult));

            return(filteredResults.ToList());
        }
        private void StartQuery(HKQuantityTypeIdentifier quantityTypeIdentifier, NSDate startDate, HKAnchoredObjectUpdateHandler handler)
        {
            var datePredicate   = HKQuery.GetPredicateForSamples(startDate, null, HKQueryOptions.StrictStartDate);
            var devicePredicate = HKQuery.GetPredicateForObjectsFromDevices(new NSSet <HKDevice>(HKDevice.LocalDevice));
            var queryPredicate  = NSCompoundPredicate.CreateAndPredicate(new NSPredicate[] { datePredicate, devicePredicate });

            var quantityType = HKQuantityType.Create(quantityTypeIdentifier);
            var query        = new HKAnchoredObjectQuery(quantityType, queryPredicate, null, HKSampleQuery.NoLimit, handler);

            query.UpdateHandler = handler;
            this.healthStore.ExecuteQuery(query);

            this.activeDataQueries.Add(query);
        }
        NSPredicate CreateLoadNewPostPredicate()
        {
            var len           = tagArray.Length + 1;
            var subPredicates = new NSPredicate[len];

            subPredicates [0] = Utils.CreateAfterPredicate(lastPostSeenOnServer.PostRecord.CreationDate);

            for (int i = 0; i < tagArray.Length; i++)
            {
                subPredicates [i + 1] = Utils.CreateTagPredicate(tagArray [i]);
            }

            // ANDs all subpredicates to make a final predicate
            NSPredicate finalPredicate = NSCompoundPredicate.CreateAndPredicate(subPredicates);

            return(finalPredicate);
        }
        CKQuery CreatePostQuery()
        {
            // Create predicate out of tags. If self.tagArray is empty we should get every post
            NSPredicate[] subPredicates = new NSPredicate[tagArray.Length];
            for (int i = 0; i < tagArray.Length; i++)
            {
                subPredicates [i] = Utils.CreateTagPredicate(tagArray [i]);
            }

            // If our tagArray is empty, create a true predicate (as opposed to a predicate containing "Tags CONTAINS ''"
            NSPredicate finalPredicate = tagArray.Length == 0
                                ? NSPredicate.FromValue(true)
                                : NSCompoundPredicate.CreateAndPredicate(subPredicates);

            CKQuery postQuery = new CKQuery(Post.RecordType, finalPredicate);

            // lastest post on the top
            postQuery.SortDescriptors = Utils.CreateCreationDateDescriptor(ascending: false);

            return(postQuery);
        }
        private void createNewSearchForPredicate(NSPredicate predicate, string title)
        {
            if (predicate == null)
            {
                return;
            }

            // remove the old search results.
            mySearchResults.Remove(mySearchResults.ArrangedObjects());

            // always search for items in the Address Book
            //NSPredicate addrBookPredicate = NSPredicate.FromFormat (" (kMDItemKind == 'Address Book Person Data')",new NSObject[0]);
            NSPredicate addrBookPredicate = NSPredicate.FromFormat(" (kMDItemContentType == 'com.apple.addressbook.person')", new NSObject[0]);

            predicate = NSCompoundPredicate.CreateAndPredicate(new NSPredicate[2] {
                addrBookPredicate, predicate
            });

            // set the query predicate....
            query.Predicate = predicate;

            // and send it off for processing...
            query.StartQuery();
        }
Exemple #6
0
 // returns:  The new `NSCompoundPredicate`, generated from the pending conditions.
 protected NSPredicate NewPredicate()
 {
     return(NSCompoundPredicate.CreateAndPredicate(Conditions.ToArray()));
 }
        public void BeginWorkout(DateTime beginDate)
        {
            // Obtain the `HKObjectType` for active energy burned and the `HKUnit` for kilocalories.
            var activeEnergyType = HKQuantityType.Create(HKQuantityTypeIdentifier.ActiveEnergyBurned);

            if (activeEnergyType == null)
            {
                return;
            }

            var energyUnit = HKUnit.Kilocalorie;

            // Update properties.
            WorkoutBeginDate = beginDate;
            workoutButton.SetTitle("End Workout");

            // Set up a predicate to obtain only samples from the local device starting from `beginDate`.

            var datePredicate = HKQuery.GetPredicateForSamples((NSDate)beginDate, null, HKQueryOptions.None);

            var devices         = new NSSet <HKDevice> (new HKDevice[] { HKDevice.LocalDevice });
            var devicePredicate = HKQuery.GetPredicateForObjectsFromDevices(devices);
            var predicate       = NSCompoundPredicate.CreateAndPredicate(new NSPredicate[] { datePredicate, devicePredicate });

            //Create a results handler to recreate the samples generated by a query of active energy samples so that they can be associated with this app in the move graph.It should be noted that if your app has different heuristics for active energy burned you can generate your own quantities rather than rely on those from the watch.The sum of your sample's quantity values should equal the energy burned value provided for the workout
            Action <List <HKSample> > sampleHandler;

            sampleHandler = (List <HKSample> samples) => {
                DispatchQueue.MainQueue.DispatchAsync(delegate {
                    var accumulatedSamples = new List <HKQuantitySample> ();

                    var initialActivityEnergy = CurrentActiveEnergyQuantity.GetDoubleValue(energyUnit);
                    double accumulatedValue   = initialActivityEnergy;
                    foreach (HKQuantitySample sample in samples)
                    {
                        accumulatedValue = accumulatedValue + sample.Quantity.GetDoubleValue(energyUnit);
                        var ourSample    = HKQuantitySample.FromType(activeEnergyType, sample.Quantity, sample.StartDate, sample.EndDate);
                        accumulatedSamples.Add(ourSample);
                    }

                    // Update the UI.
                    CurrentActiveEnergyQuantity = HKQuantity.FromQuantity(energyUnit, accumulatedValue);
                    activeEnergyBurnedLabel.SetText($"{accumulatedValue}");

                    // Update our samples.
                    ActiveEnergySamples.AddRange(accumulatedSamples);
                });
            };

            // Create a query to report new Active Energy Burned samples to our app.
            var activeEnergyQuery = new HKAnchoredObjectQuery(activeEnergyType, predicate, null, HKSampleQuery.NoLimit, (query, addedObjects, deletedObjects, newAnchor, error) => {
                if (error == null)
                {
                    // NOTE: `deletedObjects` are not considered in the handler as there is no way to delete samples from the watch during a workout
                    ActiveEnergySamples = new List <HKSample>(addedObjects);
                    sampleHandler(ActiveEnergySamples);
                }
                else
                {
                    Console.WriteLine($"An error occured executing the query. In your app, try to handle this gracefully. The error was: {error}.");
                }
            });

            // Assign the same handler to process future samples generated while the query is still active.
            activeEnergyQuery.UpdateHandler = (query, addedObjects, deletedObjects, newAnchor, error) => {
                if (error == null)
                {
                    ActiveEnergySamples = new List <HKSample> (addedObjects);
                    sampleHandler(ActiveEnergySamples);
                }
                else
                {
                    Console.WriteLine($"An error occured executing the query. In your app, try to handle this gracefully. The error was: {error}.");
                }
            };

            // Start Query
            CurrentQuery = activeEnergyQuery;
            HealthStore.ExecuteQuery(activeEnergyQuery);
        }