public void TestChangingCallbackAddLocks() { var obj = new DummyLockable(1); var obj2 = new DummyLockable(2); var obj3 = new DummyLockable(3); int callCount = 0; CallbackLock.CallbackLockHandler lockFunc = delegate { if (callCount == 0) { callCount++; return(new ILockable[] { obj2 }); } callCount++; return(new ILockable[] { obj3, obj2 }); }; var lck = new CallbackLock(multiObjectLockFactory).Lock(lockFunc, null, obj); DefaultMultiObjectLock.IsLocked(obj).Should().BeTrue(); DefaultMultiObjectLock.IsLocked(obj2).Should().BeTrue(); DefaultMultiObjectLock.IsLocked(obj3).Should().BeTrue(); lck.UnlockAll(); DefaultMultiObjectLock.IsLocked(obj).Should().BeFalse(); DefaultMultiObjectLock.IsLocked(obj2).Should().BeFalse(); DefaultMultiObjectLock.IsLocked(obj3).Should().BeFalse(); }
/// <summary> /// Update user states exposed to clients, if necessary. /// </summary> /// <param name="callbackLock"> /// Lock used to delay all events until after we exit lock section. /// </param> private void UpdateUserStates(CallbackLock callbackLock) { this.userStatesAccumulator.Clear(); // Add states for tracked users foreach (var trackingId in this.TrackedUserTrackingIds) { this.userStatesAccumulator.Add(trackingId, TrackedStateName); } if (this.EngagedUserTrackingId != SharedConstants.InvalidUserTrackingId) { // Engaged state supersedes all other states this.userStatesAccumulator[this.EngagedUserTrackingId] = EngagedStateName; } if (this.HaveUserStatesChanged()) { var temporaryMap = this.publicUserStates; this.publicUserStates = this.userStatesAccumulator; this.userStatesAccumulator = temporaryMap; var userStatesToSend = GetStateMappingEntryArray(this.publicUserStates); callbackLock.LockExit += () => this.SendUserStateChanged( new UserStatesChangedEventMessage { category = EventCategory, eventType = UserStatesChangedEventType, userStates = userStatesToSend }); } }
/// <summary> /// Resets all state to the initial state, with no users remembered as engaged or tracked. /// </summary> public void Reset() { using (var callbackLock = new CallbackLock(this.lockObject)) { this.activityMeter.Clear(); this.TrackedUserTrackingIds.Clear(); this.EngagedUserTrackingId = SharedConstants.InvalidUserTrackingId; this.SetPrimaryUserTrackingId(SharedConstants.InvalidUserTrackingId, callbackLock); this.UpdateUserStates(callbackLock); } }
public void TestEmptyListFromCallback() { var obj = new DummyLockable(1); CallbackLock.CallbackLockHandler lockFunc = custom => new ILockable[] {}; var lck = new CallbackLock(multiObjectLockFactory).Lock(lockFunc, null, obj); DefaultMultiObjectLock.IsLocked(obj).Should().BeTrue(); lck.UnlockAll(); DefaultMultiObjectLock.IsLocked(obj).Should().BeFalse(); }
public IEnumerator Connect() { var @lock = new CallbackLock(); UM_InAppService.Client.Connect((connectionResult) => { @lock.Unlock(); Assert.IsTrue(connectionResult.IsSucceeded); }); yield return(@lock.WaitToUnlock()); }
/// <summary> /// Update the primary user being tracked. /// </summary> /// <param name="candidateUserInfo"> /// User information collection from which we will choose a primary user. /// </param> /// <param name="callbackLock"> /// Lock used to delay all events until after we exit lock section. /// </param> private void UpdatePrimaryUser(IEnumerable <UserInfo> candidateUserInfo, CallbackLock callbackLock) { int firstPrimaryUserCandidate = SharedConstants.InvalidUserTrackingId; bool currentPrimaryUserStillPrimary = false; bool engagedUserIsPrimary = false; var trackingIdsAvailable = new HashSet <int>(); foreach (var userInfo in candidateUserInfo) { if (userInfo.SkeletonTrackingId == SharedConstants.InvalidUserTrackingId) { continue; } trackingIdsAvailable.Add(userInfo.SkeletonTrackingId); foreach (var handPointer in userInfo.HandPointers) { if (handPointer.IsPrimaryForUser) { if (this.PrimaryUserTrackingId == userInfo.SkeletonTrackingId) { // If the current primary user still has an active hand, we should continue to consider them the primary user. currentPrimaryUserStillPrimary = true; } else if (SharedConstants.InvalidUserTrackingId == firstPrimaryUserCandidate) { // Else if this is the first user with an active hand, they are the alternative candidate for primary user. firstPrimaryUserCandidate = userInfo.SkeletonTrackingId; } if (this.EngagedUserTrackingId == userInfo.SkeletonTrackingId) { engagedUserIsPrimary = true; } } } } // If engaged user has a primary hand, always pick that user as primary user. // If current primary user still has a primary hand, let them remain primary. // Otherwise default to first primary user candidate seen. int primaryUserTrackingId = engagedUserIsPrimary ? this.EngagedUserTrackingId : (currentPrimaryUserStillPrimary ? this.PrimaryUserTrackingId : firstPrimaryUserCandidate); this.SetPrimaryUserTrackingId(primaryUserTrackingId, callbackLock); }
public IEnumerator SuccessfulPurchase() { if (Application.isEditor) { m_transactionLock = new CallbackLock(); m_Observer.OnTransaction += OnSuccessfuTransaction; UM_InAppService.Client.AddPayment(UM_InAppService.TEST_ITEM_PURCHASED); yield return(m_transactionLock.WaitToUnlock()); m_Observer.OnTransaction -= OnSuccessfuTransaction; } yield return(null); }
public IEnumerator SaveScreenshot() { yield return(null); if (Application.isEditor) { var @lock = new CallbackLock(); var gallery = UM_Application.GalleryService; gallery.SaveScreenshot("example_scene.png", (result) => { Assert.IsTrue(result.IsSucceeded); @lock.Unlock(); }); yield return(@lock.WaitToUnlock()); } }
/// <summary> /// Promote candidate user to be the engaged user. /// </summary> /// <param name="candidateTrackingId"> /// Tracking Id of user to be promoted to engaged user. /// If tracking Id does not match the Id of one of the currently tracked users, /// no action is taken. /// </param> /// <returns> /// True if specified candidate could be confirmed as the new engaged user, /// false otherwise. /// </returns> public bool PromoteCandidateToEngaged(int candidateTrackingId) { bool isConfirmed = false; if ((candidateTrackingId != SharedConstants.InvalidUserTrackingId) && this.TrackedUserTrackingIds.Contains(candidateTrackingId)) { using (var callbackLock = new CallbackLock(this.lockObject)) { this.EngagedUserTrackingId = candidateTrackingId; this.UpdateUserStates(callbackLock); } isConfirmed = true; } return(isConfirmed); }
public IEnumerator PickImage() { yield return(null); var @lock = new CallbackLock(); if (Application.isEditor) { var gallery = UM_Application.GalleryService; gallery.PickImage(1024, (result) => { @lock.Unlock(); ValidateResult(result, UM_MediaType.Image); }); } yield return(@lock.WaitToUnlock()); }
public IEnumerator CamptureImage() { yield return(null); var @lock = new CallbackLock(); if (Application.isEditor) { var cameraService = UM_Application.CameraService; cameraService.TakePicture(1024, (result) => { @lock.Unlock(); ValidateResult(result, UM_MediaType.Image); }); } yield return(@lock.WaitToUnlock()); }
public IEnumerator FailedPurchase() { // if (Application.isEditor) // { m_transactionLock = new CallbackLock(); m_Observer.OnTransaction += OnFailedTransaction; UM_InAppService.Client.AddPayment(UM_InAppService.TEST_ITEM_UNAVAILABLE); yield return(m_transactionLock.WaitToUnlock()); m_Observer.OnTransaction -= OnFailedTransaction; // } yield return(null); }
public IEnumerator SaveImage() { yield return(null); if (Application.isEditor) { var @lock = new CallbackLock(); var gallery = UM_Application.GalleryService; var sampleBlackTexture = SA_IconManager.GetIcon(Color.black, 32, 32); gallery.SaveImage(sampleBlackTexture, "sample_black_image.png", (result) => { Assert.IsTrue(result.IsSucceeded); @lock.Unlock(); }); yield return(@lock.WaitToUnlock()); } }
public IEnumerator ShareToWhatsapp() { var @lock = new CallbackLock(); var client = UM_SocialService.SharingClient; var builder = new UM_ShareDialogBuilder(); //Juts generating smaple red tuxture with 32x32 resolution Texture2D sampleRedTexture = SA_IconManager.GetIcon(Color.red, 32, 32); builder.AddImage(sampleRedTexture); client.ShareToWhatsapp(builder, (result) => { @lock.Unlock(); Assert.IsTrue(result.IsSucceeded); }); yield return(@lock.WaitToUnlock()); }
public IEnumerator RetrieveContacts() { var @lock = new CallbackLock(); var client = UM_Application.ContactsService; client.Retrieve((result) => { @lock.Unlock(); Assert.IsTrue(result.IsSucceeded); Assert.IsTrue(result.Contacts.Count > 0); var contact = result.Contacts[0]; Assert.NotNull(contact.Name); Assert.NotNull(contact.Phone); Assert.NotNull(contact.Email); }); yield return(@lock.WaitToUnlock()); }
internal void SetPrimaryUserTrackingId(int newId, CallbackLock callbackLock) { int oldId = this.PrimaryUserTrackingId; this.PrimaryUserTrackingId = newId; if (oldId != newId) { callbackLock.LockExit += () => this.SendUserStateChanged( new UserTrackingIdChangedEventMessage { category = EventCategory, eventType = PrimaryUserChangedEventType, oldValue = oldId, newValue = newId }); } }
public IEnumerator SystemShareDialog() { var @lock = new CallbackLock(); var client = UM_SocialService.SharingClient; var builder = new UM_ShareDialogBuilder(); builder.SetText("Hello world!"); builder.SetUrl("https://stansassets.com/"); //Juts generating smaple red tuxture with 32x32 resolution Texture2D sampleRedTexture = SA_IconManager.GetIcon(Color.red, 32, 32); builder.AddImage(sampleRedTexture); client.SystemSharingDialog(builder, (result) => { @lock.Unlock(); Assert.IsTrue(result.IsSucceeded); }); yield return(@lock.WaitToUnlock()); }
public IEnumerator MailDialog() { var @lock = new CallbackLock(); var client = UM_SocialService.SharingClient; var dialog = new UM_EmailDialogBuilder(); dialog.SetSubject("Subject"); dialog.SetText("Hello World!"); dialog.SetUrl("https://stansassets.com/"); //Juts generating smaple red tuxture with 32x32 resolution Texture2D sampleRedTexture = SA_IconManager.GetIcon(Color.red, 32, 32); dialog.AddImage(sampleRedTexture); dialog.AddRecipient("*****@*****.**"); client.ShowSendMailDialog(dialog, (result) => { @lock.Unlock(); Assert.IsTrue(result.IsSucceeded); }); yield return(@lock.WaitToUnlock()); }
/// <summary> /// Called whenever the set of tracked users has changed. /// </summary> /// <param name="trackedUserInfo"> /// User information from which we'll update the set of tracked users and the primary user. /// </param> /// <param name="timestamp"> /// Interaction frame timestamp corresponding to given user information. /// </param> public void UpdateUserInformation(IEnumerable <UserInfo> trackedUserInfo, long timestamp) { bool foundEngagedUser = false; int firstTrackedUser = SharedConstants.InvalidUserTrackingId; using (var callbackLock = new CallbackLock(this.lockObject)) { this.previousTrackedUserTrackingIds.Clear(); var nextTrackedIds = this.previousTrackedUserTrackingIds; this.previousTrackedUserTrackingIds = this.TrackedUserTrackingIds; this.TrackedUserTrackingIds = nextTrackedIds; var trackedUserInfoArray = trackedUserInfo as UserInfo[] ?? trackedUserInfo.ToArray(); foreach (var userInfo in trackedUserInfoArray) { if (userInfo.SkeletonTrackingId == SharedConstants.InvalidUserTrackingId) { continue; } if (this.EngagedUserTrackingId == userInfo.SkeletonTrackingId) { this.TrackedUserTrackingIds.Add(userInfo.SkeletonTrackingId); foundEngagedUser = true; } else if (HasTrackedHands(userInfo) && (this.previousTrackedUserTrackingIds.Contains(userInfo.SkeletonTrackingId) || this.IsInactive(userInfo, timestamp))) { // Keep track of the non-engaged users we find that have at least one // tracked hand pointer and also either (1) were previously tracked or // (2) are not moving too much this.TrackedUserTrackingIds.Add(userInfo.SkeletonTrackingId); if (firstTrackedUser == SharedConstants.InvalidUserTrackingId) { // Consider the first non-engaged, stationary user as a candidate for engagement firstTrackedUser = userInfo.SkeletonTrackingId; } } } // If engaged user was not found in list of candidate users, engaged user has become invalid. if (!foundEngagedUser) { this.EngagedUserTrackingId = SharedConstants.InvalidUserTrackingId; } // Decide who should be the primary user, if anyone this.UpdatePrimaryUser(trackedUserInfoArray, callbackLock); // If there's a primary user, it is the preferred candidate for engagement. // Otherwise, the first tracked user seen is the preferred candidate. int candidateUserTrackingId = (this.PrimaryUserTrackingId != SharedConstants.InvalidUserTrackingId) ? this.PrimaryUserTrackingId : firstTrackedUser; // If there is a valid candidate user that is not already the engaged user if ((candidateUserTrackingId != SharedConstants.InvalidUserTrackingId) && (candidateUserTrackingId != this.EngagedUserTrackingId)) { // If there is currently no engaged user, or if candidate user is the // primary user controlling interactions while the currently engaged user // is not interacting if ((this.EngagedUserTrackingId == SharedConstants.InvalidUserTrackingId) || (candidateUserTrackingId == this.PrimaryUserTrackingId)) { this.PromoteCandidateToEngaged(candidateUserTrackingId); } } // Update user states as the very last action, to include results from updates // performed so far this.UpdateUserStates(callbackLock); } }