public SettingsFileUserNotifier(SVsServiceProvider sp, INotificationService notifier, SettingsPersister persister, SettingsLocator locator)
 {
     this.locator = locator;
     this.notifier = notifier;
     this.persister = persister;
     dte = (DTE)sp.GetService(typeof(DTE));
 }

        public void Load(IServiceProvider serviceProvider)
        {
            try
            {
                s_traceContext = (ITraceContext)serviceProvider.GetService(typeof(ITraceContext));

                //must have the icelib sdk license to get the session as a service
                s_session = (Session)serviceProvider.GetService(typeof(Session));
                s_connection = new Connection.Connection(s_session);
            }
            catch (ArgumentNullException)
            {
                s_traceContext.Error("unable to get Icelib Session, is the ICELIB SDK License available?");
                Debug.Fail("unable to get service.  Is the ICELIB SDK licence available?");
                throw;
            }

            s_interactionManager = new InteractionManager(s_session, (IQueueService)serviceProvider.GetService(typeof(IQueueService)), s_traceContext);
            s_statusManager = new CicStatusService(s_session, s_traceContext);
            s_notificationService = (INotificationService)serviceProvider.GetService(typeof(INotificationService));

            s_settingsManager = new SettingsManager();
            s_deviceManager = new DeviceManager(s_traceContext, new SpokesDebugLogger(s_traceContext));

            s_statusChanger = new StatusChanger(s_session, s_statusManager, s_deviceManager, s_settingsManager);
            s_notificationServer = new NotificationServer(s_deviceManager, s_settingsManager, s_notificationService);

            s_hookSwitchManager = new InteractionSyncManager(s_interactionManager, s_deviceManager, (IQueueService)serviceProvider.GetService(typeof(IQueueService)), s_traceContext, s_connection);

            s_outboundEventNotificationService = new OutboundEventNotificationService(s_session, s_statusManager, s_deviceManager, s_traceContext);

            s_traceContext.Always("Plantronics AddIn Loaded");
        }

        public AutomationFactory(
            ISchedulerService schedulerService,
            INotificationService notificationService,
            IDateTimeService dateTimeService,
            IDaylightService daylightService,
            IOutdoorTemperatureService outdoorTemperatureService,
            IComponentService componentService,
            ISettingsService settingsService,
            IResourceService resourceService)
        {
            if (schedulerService == null) throw new ArgumentNullException(nameof(schedulerService));
            if (notificationService == null) throw new ArgumentNullException(nameof(notificationService));
            if (dateTimeService == null) throw new ArgumentNullException(nameof(dateTimeService));
            if (daylightService == null) throw new ArgumentNullException(nameof(daylightService));
            if (outdoorTemperatureService == null) throw new ArgumentNullException(nameof(outdoorTemperatureService));
            if (componentService == null) throw new ArgumentNullException(nameof(componentService));
            if (settingsService == null) throw new ArgumentNullException(nameof(settingsService));
            if (resourceService == null) throw new ArgumentNullException(nameof(resourceService));

            _schedulerService = schedulerService;
            _notificationService = notificationService;
            _dateTimeService = dateTimeService;
            _daylightService = daylightService;
            _outdoorTemperatureService = outdoorTemperatureService;
            _componentService = componentService;
            _settingsService = settingsService;
            _resourceService = resourceService;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Window"/> class.
 /// </summary>
 /// <param name="frame">Parent Frame for this Window</param>
 /// <param name="hwnd">Native window handle</param>
 /// <param name="notificationService">Instance of Notification Service</param>
 public Window(Frame frame, IntPtr hwnd, INotificationService notificationService)
 {
     this.cachedStyle = IntPtr.Zero;
     this.notificationService = notificationService;
     this.Frame = frame;
     this.Handle = hwnd;
 }

 /// <summary>
 /// Initializes a new instance of the ContentController class.
 /// </summary>
 /// <param name="contentService">Instance of Content Service</param>
 /// <param name="profileService">Instance of profile Service</param>
 public ContentController(IContentService contentService, IProfileService profileService, INotificationService queueService, ICommunityService communityService)
     : base(profileService)
 {
     _contentService = contentService;
     _notificationService = queueService;
     _communityService = communityService;
 }

 public CustomGalleryViewModel(IDetailService detailService, INotificationService notificationService, IUserFolders userFolders)
 {
     _detailService = detailService;
     _notificationService = notificationService;
     _userFolders = userFolders;
     Title = MenuViewModel.CustomGalleryItemTitle;
 }

 //private readonly IUserProfileService _userProfileService;
 public TransportRequisitionController(
     ITransportRequisitionService transportRequisitionService,
     IWorkflowStatusService workflowStatusService,
     IUserAccountService userAccountService,
     ILog log,
     IAdminUnitService adminUnitService,
     IProgramService programService,
     IReliefRequisitionService reliefRequisitionService,
     IHubAllocationService hubAllocationService,
     IProjectCodeAllocationService projectCodeAllocationService,
     IReliefRequisitionDetailService reliefRequisitionDetailService,
     IRationService rationService, INotificationService notificationService)
 {
     this._transportRequisitionService = transportRequisitionService;
     _workflowStatusService = workflowStatusService;
     _userAccountService = userAccountService;
     _log = log;
     _adminUnitService = adminUnitService;
     _programService = programService;
     _reliefRequisitionService = reliefRequisitionService;
     _hubAllocationService = hubAllocationService;
     _projectCodeAllocationService = projectCodeAllocationService;
     _reliefRequisitionDetailService = reliefRequisitionDetailService;
     _reliefRequisitionService = reliefRequisitionService;
     _rationService = rationService;
     _notificationService = notificationService;
     //_userProfileService = userProfileService;
 }

 public NavigatorService(IEventAggregator eventAggregator, IUrlParameterToObjectsPlateHeater urlParameterToObjectsPlateHeater, ILogService logService, INotificationService notificationService)
 {
     _eventAggregator = eventAggregator;
     this._notificationService = notificationService;
     this._logService = logService;
     _urlParameterToObjectsPlateHeater = urlParameterToObjectsPlateHeater;
 }

        public static void FromLegacy(
            this MembershipRebootConfiguration config, 
            INotificationService notificationService, 
            IPasswordPolicy passwordPolicy)
        {
            if (config == null) throw new ArgumentNullException("config");
            
            if (notificationService != null)
            {
                config.AddEventHandler(new NotificationServiceEventHandler(notificationService));
                if (config.SecuritySettings.RequireAccountVerification)
                {
                    config.AddEventHandler(new NotificationServiceAccountCreatedEventHandler(notificationService));
                }
            }

            if (passwordPolicy != null)
            {
                config.RegisterPasswordValidator(new DelegateValidator(
                    (svc, acct, password) =>
                    {
                        if (!passwordPolicy.ValidatePassword(password))
                        {
                            return new ValidationResult("Invalid password: " + passwordPolicy.PolicyMessage);
                        }
                        return null;
                    }));
            }
        }

 public ProvidersController(IProviderService providerService, INotificationService notificationService, ITemplateService templateService, ISysConfig config)
 {
     this._providerService = providerService;
     _notificationService = notificationService;
     _templateService = templateService;
     _config = config;
 }

 public PackageInstallationService(InstallationTaskQueue pendingInstalls, 
     RunningInstallationTaskList runningInstalls, 
     CompletedInstallationTaskList completedInstalls,
     IDeploymentService deploymentService,
     ILogger logger,
     IHubCommunicator hubCommunicator, 
     ILocalPackageCache agentCache, 
     IInstalledPackageArchive installCache, 
     RunningInstallationTaskList runningTasks, 
     IAgentSettingsManager settingsManager,
     IPackagesList allPackagesList,
     CurrentlyDownloadingList currentlyDownloadingList,
     INotificationService notificationService)
 {
     CompletedInstalls = completedInstalls;
     _deploymentService = deploymentService;
     _logger = logger;
     _hubCommunicator = hubCommunicator;
     _agentCache = agentCache;
     _installCache = installCache;
     _runningTasks = runningTasks;
     _settingsManager = settingsManager;
     _allPackagesList = allPackagesList;
     _currentlyDownloadingList = currentlyDownloadingList;
     _notificationService = notificationService;
     PendingInstalls = pendingInstalls;
     RunningInstalls = runningInstalls;
     TimedTask = new TimedSingleExecutionTask(5000, CheckForNewInstallations, _logger);
 }

 public DashboardController(INotificationService notificationService, IUserAccountService userAccountService)
 {
     _notificationService = notificationService;
     _userAccountService = userAccountService;
     this._dashboardService = new Cats.Services.EarlyWarning.DashboardService();
     this._needAssessmentSummaryService = new Cats.Services.Common.NeedAssessmentSummaryService();
 }

        public void BeforeEach()
        {
            var notificationMock = new Mock<INotificationViewModel>();
            notificationMock.SetupGet(n => n.Id).Returns(_notificationId);
            notificationMock.SetupGet(n => n.SubjectId).Returns(_subjectId);
            notificationMock.SetupGet(n => n.SubjectName).Returns(SubjectName);
            notificationMock.SetupGet(n => n.Message).Returns(Message);

            _itemsSourceMock = new Mock<ICollection<INotificationViewModel>>();
            _itemsSourceMock.Setup(i => i.Add(It.IsAny<INotificationViewModel>())).Callback<INotificationViewModel>(m =>
            {
                _notificationAdded = m;
            });

            _notificationListViewModelMock = new Mock<INotificationListViewModel>();
            _notificationListViewModelMock.SetupGet(l => l.ItemsSource).Returns(_itemsSourceMock.Object).Verifiable();

            _notificationFactoryMock = new Mock<INotificationFactory>();
            _notificationFactoryMock.Setup(f => f.Create(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<string>())).Returns(notificationMock.Object).Verifiable();

            var notificationServiceDependenciesMock = new Mock<INotificationServiceDependencies>();
            notificationServiceDependenciesMock.SetupGet(d => d.NotificationListViewModel)
                .Returns(_notificationListViewModelMock.Object);

            notificationServiceDependenciesMock.SetupGet(d => d.NotificationFactory).Returns(_notificationFactoryMock.Object);

            _notificationService = new NotificationService(notificationServiceDependenciesMock.Object);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DataAccessIntentHandler"/> class.
        /// </summary>
        public DataAccessIntentHandler(IIntentManager intentManager,
            INetworkSearchConfigBuilder networkSearchConfigBuilder,
            IDataSourcesAndSchema dataSourcesAndSchema,
            IExploreConfigBuilder exploreConfigBuilder,
            INotificationService notificationService,
            IExplorationIntentFactory explorationIntentFactory,
            IAcxiomConstants acxiomConstants)
        {
            mIntentManager = intentManager;
            mNetworkSearchConfigBuilder = networkSearchConfigBuilder;
            mDataSourcesAndSchema = dataSourcesAndSchema;
            mExploreConfigBuilder = exploreConfigBuilder;
            mNotificationService = notificationService;
            mExplorationIntentFactory = explorationIntentFactory;
            mAcxiomConstants = acxiomConstants;

            mDataSource = mDataSourcesAndSchema.DataSources.SingleOrDefault(x => x.Id.Equals(mAcxiomConstants.AcxiomDaodExternalContextRoot));

            if (mDataSource == null)
            {
                string extractDataSourceNotFound = string.Format(AcxiomStringResources.ErrorExternalDataSourceNotFound, mAcxiomConstants.AcxiomDaodExternalContextRoot);
                mNotificationService.PresentInformationNotificationWithoutDiagnosticsToTheUser(extractDataSourceNotFound);
                throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
                                                          AcxiomStringResources.ErrorExternalDataSourceNotFound,
                                                          mAcxiomConstants.AcxiomDaodExternalContextRoot));
            }
        }

        public TrackViewModel(Guid guid, SynoTrack synoTrack, IPageSwitchingService pageSwitchingService, AlbumViewModelFactory albumViewModelFactory, IAudioStationSession session, IUrlParameterToObjectsPlateHeater urlParameterToObjectsPlateHeater, ITrackViewModelFactory trackViewModelFactory, INotificationService notificationService)
        {
            if (synoTrack == null)
            {
                throw new ArgumentNullException("synoTrack");
            }

            if (session == null)
            {
                throw new ArgumentNullException("session");
            }
            _trackViewModelFactory = trackViewModelFactory;
            _notificationService = notificationService;

            if (albumViewModelFactory == null) throw new ArgumentNullException("albumViewModelFactory");

            Guid = guid;
            TrackInfo = synoTrack;

            NavigateToContainingAlbumCommand = new DelegateCommand(OnNavigateToContainingAlbum);

            this._session = session;
            this._urlParameterToObjectsPlateHeater = urlParameterToObjectsPlateHeater;
            _albumViewModelFactory = albumViewModelFactory;
            _albumViewModelFactory = albumViewModelFactory;
            _pageSwitchingService = pageSwitchingService;
        }

 public PhobosInitializationAttribute(IUserManagementService userMngSvc, INavigationService navSvc, INotificationService notificationService, IMessageService msgService)
 {
     this.userManagementService = userMngSvc;
     this.navigationService = navSvc;
     this.notificationService = notificationService;
     this.msgService = msgService;
 }

        internal ChangeSignatureDialogViewModel(INotificationService notificationService, ParameterConfiguration parameters, ISymbol symbol, ClassificationTypeMap classificationTypeMap)
        {
            _originalParameterConfiguration = parameters;
            _notificationService = notificationService;
            _classificationTypeMap = classificationTypeMap;

            int startingSelectedIndex = 0;

            if (parameters.ThisParameter != null)
            {
                startingSelectedIndex++;

                _thisParameter = new ParameterViewModel(this, parameters.ThisParameter);
                _disabledParameters.Add(parameters.ThisParameter);
            }

            if (parameters.ParamsParameter != null)
            {
                _paramsParameter = new ParameterViewModel(this, parameters.ParamsParameter);
            }

            _symbol = symbol;
            _declarationParts = symbol.ToDisplayParts(s_symbolDeclarationDisplayFormat);

            _parameterGroup1 = parameters.ParametersWithoutDefaultValues.Select(p => new ParameterViewModel(this, p)).ToList();
            _parameterGroup2 = parameters.RemainingEditableParameters.Select(p => new ParameterViewModel(this, p)).ToList();
            this.SelectedIndex = startingSelectedIndex;
        }

        public PlantronicsManager(IStatusManager statusManager, 
            IInteractionManager interactionManager,
            INotificationService notificationService,
            ITraceContext traceContext)
        {
            _statusManager = statusManager;
            _interactionManager = interactionManager;
            _traceContext = traceContext;
            _notificationService = notificationService;

            m_sessionComManager = new SessionComManagerClass();
            m_sessionManagerEvents = m_sessionComManager as ISessionCOMManagerEvents_Event;
            m_comSession = m_sessionComManager.Register("Interaction Client Plantronics AddIn");

            // Now check if our plugin session was created
            if (m_comSession != null)
            {
                // detect devices added/removed
                m_sessionManagerEvents.DeviceStateChanged += OnDeviceStateChanged;

                //Get current Device
                m_device = m_comSession.ActiveDevice;

                // if we have a device register for events
                if (m_device != null)
                {
                    // Register for device events
                    RegisterEvents();
                }
            }
        }

 public AccountsController(IAccountRepository accountRepository, INotificationService notificationService, IAccountsSettingsService accountsSettingsService, IUserProfileService userProfileService)
 {
     this.accountRepository = accountRepository;
       this.notificationService = notificationService;
       this.accountsSettingsService = accountsSettingsService;
       this.userProfileService = userProfileService;
 }

 public ReliefRequisitionController(
     IReliefRequisitionService reliefRequisitionService, 
     IWorkflowStatusService workflowStatusService, 
     IReliefRequisitionDetailService reliefRequisitionDetailService,
     IUserAccountService userAccountService,
     IRegionalRequestService regionalRequestService,
     IRationService rationService, 
     IDonorService donorService, 
     INotificationService notificationService, 
     IPlanService planService,
     ITransactionService transactionService,
     ICommonService commonService, IRationDetailService rationDetailService)
 {
     this._reliefRequisitionService = reliefRequisitionService;
     this._workflowStatusService = workflowStatusService;
     this._reliefRequisitionDetailService = reliefRequisitionDetailService;
     _userAccountService = userAccountService;
     _rationService = rationService;
     _donorService = donorService;
     _notificationService = notificationService;
     _planService = planService;
     _transactionService = transactionService;
     _commonService = commonService;
     _rationDetailService = rationDetailService;
     _regionalRequestService = regionalRequestService;
 }