/// <summary>
 /// Returns <see langword="true"/> if there is a subscriber matching <see cref="SubscriptionToken"/>.
 /// </summary>
 /// <param name="token">The <see cref="SubscriptionToken"/> returned by <see cref="EventBase"/> while subscribing to the event.</param>
 /// <returns><see langword="true"/> if there is a <see cref="SubscriptionToken"/> that matches; otherwise <see langword="false"/>.</returns>
 public virtual bool Contains(SubscriptionToken token)
 {
     lock (Subscriptions) {
         IEventSubscription subscription = Subscriptions.FirstOrDefault(evt => evt.SubscriptionToken == token);
         return subscription != null;
     }
 }

        public void WhenDisposeIsCalledMoreThanOnce_ThenExceptionIsNotThrown()
        {
            SubscriptionToken token = new SubscriptionToken(t => { });

            token.Dispose();
            token.Dispose();
        }

        public void Equals_Should_Return_False_When_Comparing_Different_Instances()
        {
            SubscriptionToken token = new SubscriptionToken();

            object tokenObject = new SubscriptionToken();

            Assert.False(token.Equals(tokenObject));
        }

        public void EqualsShouldReturnFalseWhenComparingDifferentInstances()
        {
            var aToken = new SubscriptionToken();

            object anotherToken = new SubscriptionToken();

            Assert.That(aToken.Equals(anotherToken), Is.False);
        }

        public void HashCodeIsTheSameForSameToken()
        {
            SubscriptionToken token = new SubscriptionToken();
            int hashCode = token.GetHashCode();

            Assert.AreNotEqual(0, hashCode);
            Assert.AreEqual(hashCode, token.GetHashCode());
        }

        public void EqualsShouldReturnFalseWhenComparingDifferentObjectInstances()
        {
            SubscriptionToken token = new SubscriptionToken();

            object tokenObject = new SubscriptionToken();

            Assert.IsFalse(token.Equals(tokenObject));
        }

        public void EqualsShouldReturnTrueWhenComparingSameObjectInstances()
        {
            SubscriptionToken token = new SubscriptionToken();

            object tokenObject = token;

            Assert.IsTrue(token.Equals(tokenObject));
        }

 /// <summary>
 /// Removes the subscriber matching the <seealso cref="SubscriptionToken"/>.
 /// </summary>
 /// <param name="token">The <see cref="SubscriptionToken"/> returned by <see cref="EventBase"/> while subscribing to the event.</param>
 public virtual void Unsubscribe(SubscriptionToken token)
 {
     lock (Subscriptions) {
         IEventSubscription subscription = Subscriptions.FirstOrDefault(evt => evt.SubscriptionToken == token);
         if (subscription != null) {
             Subscriptions.Remove(subscription);
         }
     }
 }

 /// <summary>
 ///     移除符合<seealso cref="T:UniCloud.Domain.Events.SubscriptionToken" />的订阅。
 /// </summary>
 /// <param name="token">
 ///     订阅事件时，由<see cref="T:UniCloud.Domain.Events.EventBase" />返回的
 ///     <see cref="T:UniCloud.Domain.Events.SubscriptionToken" />。
 /// </param>
 public virtual void Unsubscribe(SubscriptionToken token)
 {
     lock (Subscriptions)
     {
         var local0 = Subscriptions.FirstOrDefault(evt => evt.SubscriptionToken == token);
         if (local0 == null)
             return;
         Subscriptions.Remove(local0);
     }
 }

        public void WhenSubscriptionTokenIsDisposed_ThenEventUnSubscribes()
        {
            bool unsubscribed = false;

            SubscriptionToken token = new SubscriptionToken(t => { unsubscribed = true; });

            token.Dispose();

            Assert.IsTrue(unsubscribed);
        }

		public Task<bool> Stop()
		{
			bool returnValue = false;

			try
			{
				// ***
				// *** Unsubscribe from the event
				// ***
				if (_exceptionEventToken != null)
				{
					this.EventAggregator.GetEvent<Events.TemperatureChangedEvent>().Unsubscribe(_exceptionEventToken);
					_exceptionEventToken.Dispose();
					_exceptionEventToken = null;
				}

				// ***
				// *** Release the collection items
				// ***
				this.Items.Clear();

				returnValue = true;
			}
			catch (Exception ex)
			{
				this.EventAggregator.GetEvent<Events.DebugEvent>().Publish(new DebugEventArgs(ex));
				returnValue = false;
			}

			return Task<bool>.FromResult(returnValue);
		}

        public HeadPageViewModel(
            IEventAggregator events,
            MouthViewModel mouth,
            RightEyeViewModel rightEye,
            LeftEyeViewModel leftEye,
            NoseViewModel nose, 
            INavigationService navService,
            MotionActivatedSimpleAnimation animation)
        {
            _events = events;
            _actionFacialCodingEventToken = _events.GetEvent<Events.ActionFacialCodingEvent>().Subscribe((args) =>
            {
                this.OnActionFacialCodingCommand(args);
            }, ThreadOption.UIThread);

            _sensorChangedEventToken = _events.GetEvent<Events.RangeSensorEvent>().Subscribe((args) =>
            {
                this.OnRangeSensorChanged(args);
            }, ThreadOption.UIThread);


            _navService = navService;
            GoBackCommand = new DelegateCommand(_navService.GoBack);
            NavigateControlCommand = new DelegateCommand(() => navService.Navigate("Control", null));
            HideCommand = new DelegateCommand(this.Hide);

            _mouth = mouth;
            _rightEye = rightEye;
            _leftEye = leftEye;
            _nose = nose;
            _animationService = animation;
            Image = new BitmapImage(new Uri(@"ms-appx:///Assets/pumpkinbackground.png", UriKind.RelativeOrAbsolute));

        }

        public ItemListFilter()
        {
            InitializeComponent();
            Init();

            ItemListFilterViewModel = new ItemListFilterViewModel(iEventAggregator, controls.Length);
            this.DataContext = ItemListFilterViewModel;

            propertyChangedMap = new Dictionary<string, Action>()
            {
                { "SelectedControlIndex", () => {
                    SetControlSelected(controls[selectedControlIndex], false);
                    selectedControlIndex = ItemListFilterViewModel.SelectedControlIndex;
                    SetControlSelected(controls[selectedControlIndex], true);
                }},

            };

            ItemListFilterViewModel.PropertyChanged += PropertyChangedHandler;

            eventMap = new Dictionary<string, Action>()
            {
                {"FILTER_SELECT_CONTROL", SelectControl }
            };

            filterActionToken = this.iEventAggregator.GetEvent<PubSubEvent<ViewEventArgs>>().Subscribe(
                (viewEventArgs) =>
                {
                    EventHandler(viewEventArgs);
                }
            );
        }

 App()
 {
     iEventAggregator = Event.EventInstance.EventAggregator;
     viewActionToken = this.iEventAggregator.GetEvent<PubSubEvent<ViewEventArgs>>().Subscribe(
         (viewEventArgs) => { EventHandler(viewEventArgs); }
     );
 }

        public ModuleBWorkspace(IStringCopyService stringCopyService)/*IEventAggregator eventAggregator*/
        {

            // código exclusivo para la recepción de un string a traves de un agregador de eventos.
            var eventAggregator = ServiceLocator.Current.GetInstance<IEventAggregator>();
           // eventAggregator.GetEvent<MyCopyDataAddedEvent>().Subscribe(OnCopyDataReceived, ThreadOption.UIThread);

            var evento = eventAggregator.GetEvent<MyCopyDataAddedEvent>();
            if (subscriptionToken != null)
            {
                evento.Unsubscribe(subscriptionToken);
            }
            subscriptionToken = evento.Subscribe(OnCopyDataReceived, ThreadOption.UIThread, true);

            InitializeComponent();

            //código exclusivo para recepción de un string a traves de un servicio compartido
            stringCopyService.CopyStringEvent += TheStringCopyService_CopyStringEvent;

            //código exclusivo para la recepción de datos atraves del regioncontext.
            // get the region context from the current view 
            // (which is plugged into the region)
            Microsoft.Practices.Prism.ObservableObject<object> regionContexto =
                RegionContext.GetObservableContext(this);

            // set an event handler to run when PropertyChanged event is fired
            regionContexto.PropertyChanged += regionContext_PropertyChanged;

        }

 public SoundQuestionWindowViewModel(IEventAggregator eventAggregator, StandingsService standingsService, InputService inputService)
     : base(eventAggregator, standingsService, inputService)
 {
     _soundToken = ShowEvent.Subscribe(PauseStart);
     _closeEvent = eventAggregator.GetEvent<CloseEvent>();
     _stopToken = _closeEvent.Subscribe((o) => Dispose());
 }

        public SearchGameDataViewModel(string _gameQuery)
        {
            iEventAggregator = Event.EventInstance.EventAggregator;
            SelectedCol = 0;
            SelectedRow = 0;

            TitleBarText = "Searching for " + _gameQuery + "...";

            GameData = GameRetriever.GetGameDataSetLists(_gameQuery);
            GameQuery = _gameQuery;

            eventMap = new Dictionary<string, Action>()
            {
                { "SEARCHGAMEDATA_MOVE_LEFT", () => { SelectedCol = SelectedCol - 1; } },
                { "SEARCHGAMEDATA_MOVE_RIGHT", () => { SelectedCol = SelectedCol + 1; } },
                { "SEARCHGAMEDATA_MOVE_UP", () => { SelectedRow = SelectedRow - 1; } },
                { "SEARCHGAMEDATA_MOVE_DOWN", () => { SelectedRow = SelectedRow + 1; } },
                { "SEARCHGAMEDATA_SELECT", SelectItem }
            };

            searchGameDataActionToken = iEventAggregator.GetEvent<PubSubEvent<SearchGameDataEventArgs>>().Subscribe(
                (viewEventArgs) =>
                {
                    EventHandler(this, viewEventArgs);
                }
            );
        }

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            _trackMenuBarToken = _eventAggregator.GetEvent<TrackCommandBarEvent>().Subscribe(OnTrackMenuBarEvent, true);
            _tracksMenuBarToken = _eventAggregator.GetEvent<TracksCommandBarEvent>().Subscribe(OnTracksMenuBarEvent, true);

            Album = navigationContext.Tag as IAlbum;
        }

 public void OnImportsSatisfied()
 {
     if (_obj == null)
     {
         _obj = _eventAggregator.GetEvent<CompositePresentationEvent<ObservableCollection<IDataItem>>>().Subscribe(dataItemsReceived => DataService.DataItems = dataItemsReceived, true);
     }
 }

        public ItemListFilterViewModel(IEventAggregator iEventAggregator, int _numControls)
        {
            this.iEventAggregator = iEventAggregator;
            buttonActions = new string[] { "FILTER_RESET", "FILTER_TYPE", "FILTER_FILES" };
            Filter = "";
            FilterType = "Contains";
            numControls = _numControls;

            MoveRightCommand = new DelegateCommand(MoveRight, CanMoveRight);
            MoveLeftCommand = new DelegateCommand(MoveLeft, CanMoveLeft);
            RemoveLastCharFromFilterCommand = new DelegateCommand(RemoveLastCharFromFilter, CanRemoveLastCharFromFilter);
            ResetFiltersCommand = new DelegateCommand(ResetFilters, CanResetFilters);

            EventMap = new Dictionary<string, Action>()
            {
                {"FILTER_MOVE_LEFT", () =>
                    {
                        if (MoveLeftCommand.CanExecute())
                        {
                            MoveLeftCommand.Execute();
                        }
                    }
                },
                {"FILTER_MOVE_RIGHT", () =>
                    {
                        if (MoveRightCommand.CanExecute())
                        {
                            MoveRightCommand.Execute();
                        }
                    }
                },
                {"CHAR_BACK", () =>
                    {
                        if (RemoveLastCharFromFilterCommand.CanExecute())
                        {
                            RemoveLastCharFromFilterCommand.Execute();
                        }
                    }
                }

            };

            EventMapParam = new Dictionary<string, Action<string>>()
            {
                {"CHAR_SELECT", AppendToFilter},
                {"VOS_OPTION",  (_filterType) =>
                    {
                        FilterType = _filterType;
                    }
                }
            };

            filterViewToken = this.iEventAggregator.GetEvent<PubSubEvent<ViewEventArgs>>().Subscribe(
                (viewEventArgs) =>
                {
                    EventHandler(viewEventArgs);
                }
            );
        }