Example #1
0
        public async Task <Location> GetCurrentLocationAsync()
        {
            if (!LocationTcs.IsNullFinishCanceledOrFaulted())
            {
                return(await LocationTcs.Task);
            }

            LocationTcs = new TaskCompletionSource <Location> ();

            var connected = apiClient.IsConnected ? apiClient.IsConnected : await connect();

            if (connected)
            {
                var lastLocation = LocationServices.FusedLocationApi.GetLastLocation(apiClient);

                if (lastLocation?.CheckLocationTime(15) ?? false)
                {
                    LocationTcs.SetResult(lastLocation);

                    //return await Task.FromResult (lastLocation);
                }

                // pass in a location request and LocationListener
                Context.RunOnUiThread(async() => await LocationServices.FusedLocationApi.RequestLocationUpdates(apiClient, locRequest, this));
            }
            else
            {
                LocationTcs.SetResult(null);

                WriteLine("Unable to connect, returning null");
            }

            return(await LocationTcs.Task);
        }
Example #2
0
        public Task <VerifyResult> Verify(Face face, Person person, PersonGroup personGroup)
        {
            try
            {
                var tcs = new TaskCompletionSource <VerifyResult> ();

                Client.VerifyWithFaceId(face.Id, person.Id, personGroup.Id, (verifyResult, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    var result = new VerifyResult
                    {
                        IsIdentical = verifyResult.IsIdentical,
                        Confidence  = verifyResult.Confidence
                    };

                    tcs.SetResult(result);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #3
0
        public Task <Face> GetFaceForPerson(Person person, PersonGroup group, string persistedFaceId)
        {
            try
            {
                var tcs = new TaskCompletionSource <Face> ();

                Client.GetPersonFaceWithPersonGroupId(group.Id, person.Id, persistedFaceId, (mpoFace, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    var face = mpoFace.ToFace();

                    tcs.SetResult(face);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #4
0
        public Task DeleteFace(Person person, PersonGroup group, Face face)
        {
            try
            {
                var tcs = new TaskCompletionSource <bool> ();

                Client.DeletePersonFaceWithPersonGroupId(group.Id, person.Id, face.Id, error =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    if (person.Faces.Contains(face))
                    {
                        person.Faces.Remove(face);
                    }

                    tcs.SetResult(true);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #5
0
        public Task <List <PersonGroup> > GetGroups(bool forceRefresh = false)
        {
            try
            {
                if (Groups.Count == 0 || forceRefresh)
                {
                    var tcs = new TaskCompletionSource <List <PersonGroup> > ();

                    Client.ListPersonGroupsWithCompletion((groups, error) =>
                    {
                        tcs.FailTaskIfErrored(error.ToException());
                        if (tcs.IsNullFinishCanceledOrFaulted())
                        {
                            return;
                        }

                        Groups = new List <PersonGroup> (
                            groups.Select(g => g.ToPersonGroup())
                            );

                        tcs.SetResult(Groups);
                    }).Resume();

                    return(tcs.Task);
                }

                return(Task.FromResult(Groups));
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #6
0
        public Task UpdatePerson(Person person, PersonGroup group, string personName, string userData = null)
        {
            try
            {
                var tcs = new TaskCompletionSource <bool> ();

                Client.UpdatePersonWithPersonGroupId(group.Id, person.Id, personName, userData, error =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    person.Name     = personName;
                    person.UserData = userData;

                    tcs.SetResult(true);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #7
0
        public Task <Person> CreatePerson(string personName, PersonGroup group, string userData = null)
        {
            try
            {
                var tcs = new TaskCompletionSource <Person> ();

                Client.CreatePersonWithPersonGroupId(group.Id, personName, userData, (result, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    tcs.FailTaskByCondition(string.IsNullOrEmpty(result.PersonId), "CreatePersonResult returned invalid person Id");
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    var person = new Person
                    {
                        Name     = personName,
                        Id       = result.PersonId,
                        UserData = userData
                    };

                    group.People.Add(person);

                    tcs.SetResult(person);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #8
0
        public Task TrainGroup(PersonGroup personGroup)
        {
            try
            {
                var tcs = new TaskCompletionSource <bool> ();

                Client.TrainPersonGroupWithPersonGroupId(personGroup.Id, error =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    tcs.SetResult(true);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #9
0
        public Task <List <FaceGroup> > GroupFaces(List <Face> targetFaces)
        {
            try
            {
                var tcs     = new TaskCompletionSource <List <FaceGroup> > ();
                var faceIds = targetFaces.Select(f => f.Id).ToArray();
                var results = new List <FaceGroup> ();

                Client.GroupWithFaceIds(faceIds, (groupResult, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    //for (var i = 0; i < groupResult.Groups.Count; i++)
                    //{
                    //	var faceGroup = groupResult.Groups [i];

                    //	results.Add (new FaceGroup
                    //	{
                    //		Title = $"Face Group #{i + 1}",
                    //		Faces = targetFaces.Where (f => faceGroup.Contains (f.Id)).ToList ()
                    //	});
                    //}

                    //if (groupResult.MesseyGroup.Length > 0)
                    //{
                    //	results.Add (new FaceGroup
                    //	{
                    //		Title = "Messy Group",
                    //		Faces = targetFaces.Where (f => groupResult.MesseyGroup.Contains (f.Id)).ToList ()
                    //	});
                    //}

                    tcs.SetResult(results);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #10
0
        Task <List <IdentificationResult> > IdentifyInternal(PersonGroup group, Face [] detectedFaces, int maxNumberOfCandidates = 1)
        {
            try
            {
                var results = new List <IdentificationResult> ();
                var tcs     = new TaskCompletionSource <List <IdentificationResult> > ();

                var detectedFaceIds = detectedFaces.Select(f => f.Id).ToArray();

                Client.IdentifyWithPersonGroupId(group.Id, detectedFaceIds, maxNumberOfCandidates, async(identifyResults, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    foreach (MPOIdentifyResult result in identifyResults)
                    {
                        var face = detectedFaces.FirstOrDefault(f => f.Id == result.FaceId);

                        foreach (MPOCandidate candidate in result.Candidates)
                        {
                            var person = await GetPerson(group, candidate.PersonId);

                            var identifyResult = new IdentificationResult
                            {
                                Person     = person,
                                Face       = face,
                                Confidence = candidate.Confidence
                            };

                            results.Add(identifyResult);
                        }
                    }

                    tcs.SetResult(results);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #11
0
        Task <CLAuthorizationStatus> getAuthorizationStatusAsync()
        {
            Log("getAuthorizationStatusAsync");

            if (!ClAuthTcs.IsNullFinishCanceledOrFaulted())
            {
                return(ClAuthTcs.Task);
            }

            ClAuthTcs = new TaskCompletionSource <CLAuthorizationStatus> ();

            ClLocationManager.AuthorizationChanged += handleAuthorizationChanged;

            ClLocationManager.RequestWhenInUseAuthorization();

            return(ClAuthTcs.Task);
        }
Example #12
0
        public async Task <CLLocation> GetCurrentLocationAsync()
        {
            Log("GetCurrentLocationAsync");

            if (!ClLocationTcs.IsNullFinishCanceledOrFaulted())
            {
                return(await ClLocationTcs.Task);
            }

            ClLocationTcs = new TaskCompletionSource <CLLocation> ();

#if __IOS__
            var status = CLLocationManager.Status;

            if (status == CLAuthorizationStatus.NotDetermined)
            {
                status = await getAuthorizationStatusAsync();
            }

            Log($"status: {status}");
#endif


            if (CLLocationManager.LocationServicesEnabled
#if __IOS__
                && status == CLAuthorizationStatus.AuthorizedWhenInUse
#endif
                )
            {
                ClLocationManager.LocationsUpdated += handleLocationsUpdated;

                ClLocationManager.StartUpdatingLocation();

                Log("StartUpdatingLocation");
            }
            else
            {
                ClLocationTcs.SetResult(null);
            }

            return(await ClLocationTcs.Task);
        }
Example #13
0
        Task <bool> connect()
        {
            if (!ConnectTcs.IsNullFinishCanceledOrFaulted())
            {
                return(ConnectTcs.Task);
            }

            ConnectTcs = new TaskCompletionSource <bool> ();

            if (apiClient.IsConnected)
            {
                ConnectTcs.SetResult(true);
            }
            else
            {
                apiClient.Connect();
            }

            return(ConnectTcs.Task);
        }
Example #14
0
        public Task <Person> GetPerson(PersonGroup group, string personId)
        {
            try
            {
                //if people are already loaded for this group try to find it there...
                if (group.People?.Count > 0)
                {
                    var person = group.People.FirstOrDefault(p => p.Id == personId);

                    if (person != null)
                    {
                        return(Task.FromResult(person));
                    }
                }

                var tcs = new TaskCompletionSource <Person> ();

                Client.GetPersonWithPersonGroupId(group.Id, personId, (mpoPerson, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    var person = mpoPerson.ToPerson();

                    //add them to the group?
                    group.People.Add(person);

                    tcs.SetResult(person);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #15
0
        public Task <List <SimilarFaceResult> > FindSimilar(Face targetFace, List <Face> faceList)
        {
            try
            {
                var tcs     = new TaskCompletionSource <List <SimilarFaceResult> > ();
                var faceIds = faceList.Select(f => f.Id).ToArray();
                var results = new List <SimilarFaceResult> ();

                Client.FindSimilarWithFaceId(targetFace.Id, faceIds, (similarFaces, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    foreach (var similarFace in similarFaces)
                    {
                        var face = faceList.FirstOrDefault(f => f.Id == similarFace.FaceId);

                        results.Add(new SimilarFaceResult
                        {
                            Face       = face,
                            FaceId     = similarFace.FaceId,
                            Confidence = similarFace.Confidence
                        });
                    }

                    tcs.SetResult(results);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #16
0
        public Task AddFaceForPerson(Person person, PersonGroup group, Face face, UIImage photo, string userData = null, float quality = .8f)
        {
            var tcs = new TaskCompletionSource <bool> ();

            try
            {
                var faceRect = face.FaceRectangle.ToMPOFaceRect();

                using (var jpgData = photo.AsJPEG(quality))
                {
                    Client.AddPersonFaceWithPersonGroupId(group.Id, person.Id, jpgData, userData, faceRect, (result, error) =>
                    {
                        tcs.FailTaskIfErrored(error.ToException());
                        tcs.FailTaskByCondition(string.IsNullOrEmpty(result?.PersistedFaceId), "AddPersistedFaceResult returned invalid face Id");
                        if (tcs.IsNullFinishCanceledOrFaulted())
                        {
                            return;
                        }

                        face.Id = result.PersistedFaceId;
                        face.UpdatePhotoPath();

                        person.Faces.Add(face);

                        face.SavePhotoFromSource(photo);

                        tcs.SetResult(true);
                    }).Resume();
                }

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #17
0
        public Task <List <Face> > DetectFacesInPhoto(UIImage photo, float quality = .8f, params MPOFaceAttributeType [] attributes)
        {
            try
            {
                List <Face> faces = new List <Face> ();
                var         tcs   = new TaskCompletionSource <List <Face> > ();

                using (var jpgData = photo.AsJPEG(quality))
                {
                    Client.DetectWithData(jpgData, true, true, attributes, (detectedFaces, error) =>
                    {
                        tcs.FailTaskIfErrored(error.ToException());
                        if (tcs.IsNullFinishCanceledOrFaulted())
                        {
                            return;
                        }

                        foreach (var detectedFace in detectedFaces)
                        {
                            var face = detectedFace.ToFace();
                            faces.Add(face);

                            face.SavePhotoFromSource(photo);
                        }

                        tcs.SetResult(faces);
                    }).Resume();
                }

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #18
0
        public Task <List <Person> > GetPeopleForGroup(PersonGroup group, bool forceRefresh = false)
        {
            try
            {
                if (group.People?.Count > 0 && !forceRefresh)
                {
                    return(Task.FromResult(group.People));
                }

                var tcs = new TaskCompletionSource <List <Person> > ();

                Client.ListPersonsWithPersonGroupId(group.Id, (mpoPeople, error) =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    var people = new List <Person> (
                        mpoPeople.Select(p => p.ToPerson())
                        );

                    group.People.Clear();
                    group.People.AddRange(people);

                    tcs.SetResult(people);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }
Example #19
0
        public Task <PersonGroup> CreatePersonGroup(string groupName, string userData = null)
        {
            try
            {
                var tcs = new TaskCompletionSource <PersonGroup> ();

                var personGroupId = Guid.NewGuid().ToString();

                Client.CreatePersonGroupWithId(personGroupId, groupName, userData, error =>
                {
                    tcs.FailTaskIfErrored(error.ToException());
                    if (tcs.IsNullFinishCanceledOrFaulted())
                    {
                        return;
                    }

                    var group = new PersonGroup
                    {
                        Name     = groupName,
                        Id       = personGroupId,
                        UserData = userData
                    };

                    Groups.Add(group);

                    tcs.SetResult(group);
                }).Resume();

                return(tcs.Task);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                throw;
            }
        }