public async Task <ICollaborationService> CreateServiceAsync(CollaborationSession session, CancellationToken cancellationToken)
{
var languageServerHostService = session.GetService(typeof(ILanguageServerHostService)) as ILanguageServerHostService;
if (languageServerHostService == null)
{
return(null);
}
var pythonClient = new PythonLanguageClient(_serviceProvider);
await pythonClient.InitializeAsync(languageServerHostService);
return(pythonClient);
}
public Task <ICollaborationService> CreateServiceAsync(CollaborationSession session, CancellationToken cancellationToken)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
var serializer = (JsonSerializer)session.GetService(typeof(JsonSerializer));
serializer.Converters.RegisterRazorLiveShareConverters();
var razorLanguageServices = _workspace.Services.GetLanguageServices(RazorLanguage.Name);
var projectSnapshotManager = razorLanguageServices.GetRequiredService <ProjectSnapshotManager>();
var service = new DefaultProjectSnapshotManagerProxy(session, _foregroundDispatcher, projectSnapshotManager, _joinableTaskContext.Factory);
return(Task.FromResult <ICollaborationService>(service));
}
public async Task <ICollaborationService> CreateServiceAsync(CollaborationSession sessionContext, CancellationToken cancellationToken)
{
// This collaboration service depends on these serializers being immediately available so we need to register these now so the
// guest project snapshot manager can retrieve the hosts project state.
var serializer = (JsonSerializer)sessionContext.GetService(typeof(JsonSerializer));
serializer.Converters.RegisterRazorLiveShareConverters();
var languageServices = _workspace.Services.GetLanguageServices(RazorLanguage.Name);
var projectManager = (ProjectSnapshotManagerBase)languageServices.GetRequiredService <ProjectSnapshotManager>();
var projectSnapshotManagerProxy = await sessionContext.GetRemoteServiceAsync <IProjectSnapshotManagerProxy>(typeof(IProjectSnapshotManagerProxy).Name, cancellationToken);
var synchronizationService = new ProjectSnapshotSynchronizationService(
_joinableTaskContext.Factory,
sessionContext,
projectSnapshotManagerProxy,
projectManager);
await synchronizationService.InitializeAsync(cancellationToken);
return(synchronizationService);
}
public Task <ICollaborationService> CreateServiceAsync(CollaborationSession collaborationSession, CancellationToken cancellationToken)
{
var languageServerGuestService = (LS.ILanguageServerGuestService)collaborationSession.GetService(typeof(LS.ILanguageServerGuestService));
collaborationSession.RemoteServicesChanged += (sender, e) =>
{
// VS will expose a roslyn LSP server.
var roslynLspServerProviderName = LanguageServicesUtils.GetLanguageServerProviderServiceName(StringConstants.RoslynProviderName);
// Newer versions of VS will expose language specific LSP servers for Roslyn.
var languageSpecificLspServerProviderName = LanguageServicesUtils.GetLanguageServerProviderServiceName(LanguageSpecificProviderName);
// VSCode will expose a "any" LSP provider and both support roslyn languages.
var anyLspServerProviderName = LanguageServicesUtils.GetLanguageServerProviderServiceName(StringConstants.AnyProviderName);
// For VS, Preferentially use the language specific server when it's available, otherwise fall back to the generic roslyn server.
if (collaborationSession.RemoteServiceNames.Contains(languageSpecificLspServerProviderName))
{
ActiveLanguageServerClient = languageServerGuestService.CreateLanguageServerClient(languageSpecificLspServerProviderName);
}
else if (collaborationSession.RemoteServiceNames.Contains(roslynLspServerProviderName))
{
ActiveLanguageServerClient = languageServerGuestService.CreateLanguageServerClient(roslynLspServerProviderName);
}
else if (collaborationSession.RemoteServiceNames.Contains(anyLspServerProviderName))
{
ActiveLanguageServerClient = languageServerGuestService.CreateLanguageServerClient(anyLspServerProviderName);
}
};
// Register Roslyn supported capabilities
languageServerGuestService.RegisterClientMetadata(
new string[] { StringConstants.TypeScriptLanguageName },
new LS.LanguageServerClientMetadata(
true,
JObject.FromObject(new ServerCapabilities
{
// Uses Roslyn client.
DocumentSymbolProvider = true,
// Uses LSP SDK client.
DocumentLinkProvider = null,
RenameProvider = false,
DocumentOnTypeFormattingProvider = null,
DocumentRangeFormattingProvider = false,
DocumentFormattingProvider = false,
CodeLensProvider = null,
CodeActionProvider = false,
ExecuteCommandProvider = null,
WorkspaceSymbolProvider = false,
DocumentHighlightProvider = false,
ReferencesProvider = false,
DefinitionProvider = false,
SignatureHelpProvider = null,
CompletionProvider = null,
HoverProvider = false,
TextDocumentSync = null,
})));
languageServerGuestService.RegisterClientMetadata(
new string[] { StringConstants.CSharpLspContentTypeName, StringConstants.VBLspLanguageName },
new LS.LanguageServerClientMetadata(
true,
JObject.FromObject(new ServerCapabilities
{
// Uses Roslyn client.
DocumentOnTypeFormattingProvider = new DocumentOnTypeFormattingOptions(),
DocumentRangeFormattingProvider = true,
DocumentFormattingProvider = true,
DocumentSymbolProvider = true,
CodeActionProvider = true,
ExecuteCommandProvider = new ExecuteCommandOptions(),
DocumentHighlightProvider = true,
ReferencesProvider = true,
DefinitionProvider = true,
SignatureHelpProvider = new SignatureHelpOptions()
{
},
CompletionProvider = new CompletionOptions(),
ImplementationProvider = true,
// Uses LSP SDK client.
DocumentLinkProvider = null,
RenameProvider = false,
CodeLensProvider = null,
WorkspaceSymbolProvider = false,
HoverProvider = false,
TextDocumentSync = null,
})));
var lifeTimeService = LspClientLifeTimeService;
lifeTimeService.Disposed += (s, e) =>
{
ActiveLanguageServerClient?.Dispose();
ActiveLanguageServerClient = null;
};
return(Task.FromResult <ICollaborationService>(lifeTimeService));
}
