public async Task <object> CreatePluginService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
var service = new PluginLogicService(this);
await service.InitializeAsync(cancellationToken);
return(service);
}
public async Task <object> CreateTidyServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
InvokeTidyService service = new InvokeTidyService(this);
await service.InitializeAsync(cancellationToken);
return(service);
}
public async Task <object> CreateGitService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
sccService = new SccProviderService(this);
await sccService.InitializeAsync(cancellationToken);
return(sccService);
}
private async Task <object> CreateMyServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
var svc = new SolutionRefreshService();
await svc.InitializeAsync(this, cancellationToken);
return(svc);
}
async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == null)
{
return(null);
}
if (serviceType == typeof(IUIProvider))
{
var result = new GitHubServiceProvider(this);
await result.Initialize();
return(result);
}
else if (serviceType == typeof(IMenuProvider))
{
var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
return(new MenuProvider(sp));
}
else if (serviceType == typeof(IUsageTracker))
{
var uiProvider = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
return(new UsageTracker(uiProvider));
}
// go the mef route
else
{
var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
return(sp.TryGetService(serviceType));
}
}
private async Task <object> CreateDoxygenConfigServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
var svc = new DoxygenConfigService();
await svc.InitializeAsync(this, cancellationToken);
return(svc);
}
private async Task <object> CreateReAttachUiAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
var service = new ReAttachUi();
await service.InitializeAsync(this, _history, cancellationToken);
return(service);
}
public async System.Threading.Tasks.Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
STextWriterService service = null;
await System.Threading.Tasks.Task.Run(() => {
service = new TextWriterService(this);
});
return(service);
}
public System.Threading.Tasks.Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == typeof(SVSGestureService))
{
return(System.Threading.Tasks.Task.FromResult <object>(new VSGestureService(this)));
}
throw new Exception("Null Service");
}
private static Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == typeof(TemplateLocator))
{
return(System.Threading.Tasks.Task.FromResult <object>(new TemplateLocator(container as IAsyncServiceProvider2)));
}
return(System.Threading.Tasks.Task.FromResult <object>(null));
}
private Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken token, Type type)
{
if (type == typeof(TimeLog))
{
return(Task.FromResult <object>(new TimeLog(_solService)));
}
return(null);
}
private async Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (typeof(IClassOutlineSettingsProvider) == serviceType)
{
return(this);
}
return(null);
}
private Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (typeof(SPlcncliCommunication) == serviceType)
{
PlcncliProcessCommunication service = new PlcncliProcessCommunication(_locationService);
return(Task.FromResult <object>(service));
}
return(null);
}
private async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
ISGenContextBootstrapService service = null;
await System.Threading.Tasks.Task.Run(() =>
{
service = new GenContextBootstrapService(this);
});
return(service);
}
public async Task <object> CreateNanoDeviceCommServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
NanoDeviceCommService service = null;
await System.Threading.Tasks.Task.Run(() => {
service = new NanoDeviceCommService(this);
});
return(service);
}
private Task <object> CreateServiceAsync(
IAsyncServiceContainer asyncServiceContainer,
CancellationToken cancellationToken, Type serviceType)
{
if (serviceType.IsEquivalentTo(typeof(STraceController)))
{
return(Task.FromResult <object>(traceController));
}
return(null);
}
private async Task <object> CreateRepositoryServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (typeof(SRepositoryService).IsEquivalentTo(serviceType))
{
RepositoryService service = new RepositoryService(this);
// await service.InitializeAsync(cancellationToken);
return(service);
}
Debug.WriteLine("ServicesPackage.CreateService called for an unknown service type.");
return(null);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private async Task <object> CreateDebuggerConnectionServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
//
// Create a service to manage the 'attach' status dialog. As we need to access this via VsDebugLauncher/VsDebugEngine.
//
var launchService = new DebuggerConnectionService();
await launchService.InitializeAsync(this, cancellationToken);
return(launchService);
}
/// <summary>
/// Initializes a new instance of the <see cref="StartTunnelOld"/> class.
/// </summary>
public NgrokExtensionsPackage()
{
// Inside this method you can place any initialization code that does not require
// any Visual Studio service because at this point the package object is created but
// not sited yet inside Visual Studio environment. The place to do all the other
// initialization is the Initialize method.
IAsyncServiceContainer serviceContainer = this;
serviceContainer.AddService(typeof(SLoggerService), CreateLoggerServiceAsync, true);
serviceContainer.AddService(typeof(SRepositoryService), CreateRepositoryServiceAsync, true);
serviceContainer.AddService(typeof(SProcessManagerService), CreateProcessManagerServiceAsync, true);
serviceContainer.AddService(typeof(SWebApplicationsManagerService), CreateWebApplicationsManagerServiceAsync, true);
serviceContainer.AddService(typeof(STunnelManagerService), CreateTunnelManagerServiceAsync, true);
}
async tasks.Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == null)
{
return(null);
}
string contract = AttributedModelServices.GetContractName(serviceType);
var cm = await GetServiceAsync(typeof(SComponentModel)) as IComponentModel;
if (cm == null)
{
return(null);
}
return(await tasks.Task.Run(() => cm.DefaultExportProvider.GetExportedValueOrDefault <object>(contract)));
}
private async Task <object> CreateServiceGeneratePageObjectsServiceAsync(
IAsyncServiceContainer container,
CancellationToken cancellationToken,
Type serviceType)
{
if (typeof(SGeneratePageObjectsService) != serviceType)
{
return(null);
}
var service = new GeneratePageObjectsService();
await service.InitializeServiceAsync(cancellationToken);
return(service);
}
private async Task <object> CreateServiceNopyCopyServiceAsync(
IAsyncServiceContainer container,
CancellationToken cancellationToken,
Type serviceType)
{
if (typeof(SNopyCopyService) == serviceType)
{
var optionsPage = GetDialogPage(typeof(OptionsPage)) as OptionsPage;
var service = new NopyCopyService(this, optionsPage);
await service.InitializeServiceAsync(cancellationToken);
return(service);
}
return(null);
}
private async Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == null)
{
return(null);
}
if (container != this)
{
return(null);
}
if (serviceType == typeof(ISharperCryptoAnalysisServiceProvider))
{
var result = new SharperCryptoAnalysisServiceProvider(this, this);
await result.InitializeAsync();
return(result);
}
if (serviceType == typeof(IToolWindowManager))
{
return(this);
}
if (serviceType == typeof(IConfigurationManager))
{
var settings = await GetServiceAsync(typeof(ISharperCryptoApiAnalysisSettings)) as ISharperCryptoApiAnalysisSettings;
return(new ConfigurationManager(settings));
}
if (serviceType == typeof(IAnalyzerManager))
{
var settings = await GetServiceAsync(typeof(ISharperCryptoApiAnalysisSettings)) as ISharperCryptoApiAnalysisSettings;
return(new AnalyzerManager(settings));
}
if (serviceType == typeof(ISharperCryptoApiAnalysisSettings))
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var dte = new ServiceProvider(VisualStudio.Integration.Services.Dte as Microsoft.VisualStudio.OLE.Interop.IServiceProvider);
return(new SharperCryptoApiAnalysisSettings(dte));
}
var sp = await GetServiceAsync(typeof(ISharperCryptoAnalysisServiceProvider)) as ISharperCryptoAnalysisServiceProvider;
return(sp.TryGetService(serviceType));
}
private Task <object> CreateServiceAsync(IAsyncServiceContainer asyncServiceContainer, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == typeof(SEyetrackerService))
{
return(Task.FromResult((object)_eyetrackerService));
}
if (serviceType == typeof(SKeyboardEventService))
{
return(Task.FromResult((object)_keyboardEventService));
}
if (serviceType == typeof(SScrollVelocityService))
{
return(Task.FromResult((object)_scrollVelocityService));
}
// ???
return(Task.FromResult((object)null));
}
async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == null)
{
return(null);
}
if (container != this)
{
return(null);
}
if (serviceType == typeof(IGitHubServiceProvider))
{
//var sp = await GetServiceAsync(typeof(SVsServiceProvider)) as IServiceProvider;
var result = new GitHubServiceProvider(this, this);
await result.Initialize();
return(result);
}
else if (serviceType == typeof(ILoginManager))
{
var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
var loginCache = serviceProvider.GetService <ILoginCache>();
var twoFaHandler = serviceProvider.GetService <ITwoFactorChallengeHandler>();
return(new LoginManager(
loginCache,
twoFaHandler,
ApiClientConfiguration.ClientId,
ApiClientConfiguration.ClientSecret,
ApiClientConfiguration.AuthorizationNote,
ApiClientConfiguration.MachineFingerprint));
}
else if (serviceType == typeof(IMenuProvider))
{
var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
return(new MenuProvider(sp));
}
else if (serviceType == typeof(IUsageTracker))
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
var usageService = serviceProvider.GetService <IUsageService>();
return(new UsageTracker(serviceProvider, usageService));
}
else if (serviceType == typeof(IUIProvider))
{
var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
return(new UIProvider(sp));
}
else if (serviceType == typeof(IGitHubToolWindowManager))
{
return(this);
}
// go the mef route
else
{
var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
return(sp.TryGetService(serviceType));
}
}
async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == null)
{
return(null);
}
if (container != this)
{
return(null);
}
if (serviceType == typeof(IGitHubServiceProvider))
{
//var sp = await GetServiceAsync(typeof(SVsServiceProvider)) as IServiceProvider;
var result = new GitHubServiceProvider(this, this);
await result.Initialize();
return(result);
}
else if (serviceType == typeof(ILoginManager))
{
// These services are got through MEF and we will take a performance hit if ILoginManager is requested during
// InitializeAsync. TODO: We can probably make LoginManager a normal MEF component rather than a service.
var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
var keychain = serviceProvider.GetService <IKeychain>();
var oauthListener = serviceProvider.GetService <IOAuthCallbackListener>();
// HACK: We need to make sure this is run on the main thread. We really
// shouldn't be injecting a view model concern into LoginManager - this
// needs to be refactored. See #1398.
var lazy2Fa = new Lazy <ITwoFactorChallengeHandler>(() =>
ThreadHelper.JoinableTaskFactory.Run(async() =>
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
return(serviceProvider.GetService <ITwoFactorChallengeHandler>());
}));
return(new LoginManager(
keychain,
lazy2Fa,
oauthListener,
ApiClientConfiguration.ClientId,
ApiClientConfiguration.ClientSecret,
ApiClientConfiguration.RequiredScopes,
ApiClientConfiguration.AuthorizationNote,
ApiClientConfiguration.MachineFingerprint));
}
else if (serviceType == typeof(IMenuProvider))
{
var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
return(new MenuProvider(sp));
}
else if (serviceType == typeof(IUsageService))
{
var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
var environment = new Rothko.Environment();
return(new UsageService(sp, environment));
}
else if (serviceType == typeof(IUsageTracker))
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var usageService = await GetServiceAsync(typeof(IUsageService)) as IUsageService;
var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
return(new UsageTracker(serviceProvider, usageService));
}
else if (serviceType == typeof(IVSGitExt))
{
var vsVersion = ApplicationInfo.GetHostVersionInfo().FileMajorPart;
return(VSGitExtFactory.Create(vsVersion, this));
}
else if (serviceType == typeof(IGitHubToolWindowManager))
{
return(this);
}
// go the mef route
else
{
var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
return(sp.TryGetService(serviceType));
}
}
async Task<object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
if (serviceType == null)
return null;
if (serviceType == typeof(IUIProvider))
{
var result = new GitHubServiceProvider(this);
await result.Initialize();
return result;
}
else if (serviceType == typeof(IMenuProvider))
{
var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
return new MenuProvider(sp);
}
else if (serviceType == typeof(IUsageTracker))
{
var uiProvider = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
return new UsageTracker(uiProvider);
}
// go the mef route
else
{
var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
return sp.TryGetService(serviceType);
}
}
async Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellation, Type serviceType)
{
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellation);
var sp = new ServiceProvider(Services.Dte as Microsoft.VisualStudio.OLE.Interop.IServiceProvider);
Assumes.Present(sp);
if (serviceType == typeof(IPackageSettingsProvider))
{
return(new PackageSettingsProvider(sp));
}
else if (serviceType == typeof(IWindowStateService))
{
return(new WindowStateService(sp, this));
}
else if (serviceType == typeof(ISolutionProvider))
{
return(new SolutionProvider(sp));
}
else if (serviceType == typeof(IBuildOutputLogger))
{
return(new BuildOutputLogger(_parsingErrorsLoggerId, Microsoft.Build.Framework.LoggerVerbosity.Quiet));
}
else if (serviceType == typeof(IErrorNavigationService))
{
return(new ErrorNavigationService(sp));
}
else if (serviceType == typeof(IBuildService))
{
var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation);
return(new BuildService(sp, packageSettingsProvider));
}
else if (serviceType == typeof(IStatusBarNotificationService))
{
var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation);
return(new StatusBarNotificationService(sp, packageSettingsProvider));
}
else if (serviceType == typeof(IBuildMessagesFactory))
{
var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation);
return(new BuildMessagesFactory(packageSettingsProvider));
}
else if (serviceType == typeof(ITaskBarInfoService))
{
var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation);
return(new TaskBarInfoService(packageSettingsProvider));
}
else if (serviceType == typeof(IBuildInformationProvider))
{
var solutionProvider = await GetServiceAsync <ISolutionProvider>(cancellation);
var buildMessagesFactory = await GetServiceAsync <IBuildMessagesFactory>(cancellation);
var buildOutputLogger = await GetServiceAsync <IBuildOutputLogger>(cancellation);
var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation);
var statusBarNotificationService = await GetServiceAsync <IStatusBarNotificationService>(cancellation);
var windowStateService = await GetServiceAsync <IWindowStateService>(cancellation);
var taskBarInfoService = await GetServiceAsync <ITaskBarInfoService>(cancellation);
var buildService = await GetServiceAsync <IBuildService>(cancellation);
var errorNavigationService = await GetServiceAsync <IErrorNavigationService>(cancellation);
return(new BuildInformationProvider(buildOutputLogger, statusBarNotificationService, buildMessagesFactory, windowStateService, packageSettingsProvider, errorNavigationService, solutionProvider, buildService, taskBarInfoService));
}
else
{
throw new Exception("Not found");
}
}
Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationtoken, Type servicetype)
=> servicetype == typeof(NpgsqlProviderObjectFactory)
? Task.FromResult <object>(new NpgsqlProviderObjectFactory())
: throw new ArgumentException($"Can't create service of type '{servicetype.Name}'");
private Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType)
{
return(Task.FromResult((object)new EmbeddedTerminalService(this)));
}
private System.Threading.Tasks.Task <object> CreateVSUIVisualizerServiceAsync(IAsyncServiceContainer container, System.Threading.CancellationToken cancellationToken, Type serviceType)
{
return(System.Threading.Tasks.Task.FromResult <object>(new VSUIVisualizerService()));
}
