sync status

src/vs/workbench/contrib/userData/common/userData.contribution.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions';
-import { IUserIdentityService, IUserDataProviderService, IUserIdentity } from 'vs/workbench/services/userData/common/userData';
+import { IUserIdentityService, IUserDataProviderService, IUserIdentity, IUserDataSyncService, SyncStatus } from 'vs/workbench/services/userData/common/userData';
 import { IStatusbarService, StatusbarAlignment, IStatusbarEntryAccessor } from 'vs/platform/statusbar/common/statusbar';
 import { localize } from 'vs/nls';
 import { Disposable } from 'vs/base/common/lifecycle';
@@ -37,21 +37,24 @@ Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration)
 		}
 	});
 
-class UserDataExtensionActivationContribution extends Disposable implements IWorkbenchContribution {
+class AutoSyncUserDataContribution extends Disposable implements IWorkbenchContribution {
 
 	constructor(
 		@IConfigurationService private readonly configurationService: IConfigurationService,
 		@IUserIdentityService private readonly userIdentityService: IUserIdentityService,
+		@IUserDataSyncService private readonly userDataSyncService: IUserDataSyncService,
 		@IExtensionService private readonly extensionService: IExtensionService,
 	) {
 		super();
-		this.activateUserDataExtensionsOnAutoSync();
-		this._register(Event.any<any>(this.userIdentityService.onDidDeregisterUserIdentities, this.configurationService.onDidChangeConfiguration)(() => this.activateUserDataExtensionsOnAutoSync()));
+		this.autoSync();
+		this._register(Event.any<any>(this.userIdentityService.onDidDeregisterUserIdentities, this.configurationService.onDidChangeConfiguration)(() => this.autoSync()));
 	}
 
-	private activateUserDataExtensionsOnAutoSync(): void {
+	private async autoSync(): Promise<void> {
 		if (this.configurationService.getValue<boolean>('userData.autoSync')) {
-			this.userIdentityService.getUserIndetities().forEach(({ identity }) => this.extensionService.activateByEvent(`onUserData:${identity}`));
+			const userIdentity = this.userIdentityService.getUserIndetities()[0];
+			await this.extensionService.activateByEvent(`onUserData:${userIdentity.identity}`);
+			this.userDataSyncService.synchronise();
 		}
 	}
 
@@ -63,7 +66,8 @@ class UserDataSyncStatusContribution extends Disposable implements IWorkbenchCon
 
 	constructor(
 		@IUserIdentityService private userIdentityService: IUserIdentityService,
-		@IStatusbarService private statusbarService: IStatusbarService
+		@IStatusbarService private statusbarService: IStatusbarService,
+		@IUserDataSyncService private userDataSyncService: IUserDataSyncService,
 	) {
 		super();
 		this.userDataSyncStatusAccessor = this.statusbarService.addEntry({
@@ -73,7 +77,8 @@ class UserDataSyncStatusContribution extends Disposable implements IWorkbenchCon
 		this.updateUserDataSyncStatusAccessor();
 		this._register(Event.any<any>(
 			this.userIdentityService.onDidRegisterUserIdentities, this.userIdentityService.onDidDeregisterUserIdentities,
-			this.userIdentityService.onDidRegisterUserLoginProvider, this.userIdentityService.onDidDeregisterUserLoginProvider)
+			this.userIdentityService.onDidRegisterUserLoginProvider, this.userIdentityService.onDidDeregisterUserLoginProvider,
+			this.userDataSyncService.onDidChangeSyncStatus)
 			(() => this.updateUserDataSyncStatusAccessor()));
 		this._register(this.userIdentityService.onDidRegisterUserLoginProvider((identity => this.onDidRegisterUserLoginProvider(identity))));
 	}
@@ -104,7 +109,8 @@ class UserDataSyncStatusContribution extends Disposable implements IWorkbenchCon
 			return userIdentity.iconText ? `${userIdentity.iconText} ${signinText}` : signinText;
 		}
 		if (userIdentity.iconText) {
-			return `${userIdentity.iconText} ${localize('sync user data', "{0}: Sync", userIdentity.title)}`;
+			const syncText = this.userDataSyncService.syncStatus === SyncStatus.Syncing ? localize('syncing', "{0}: Synchronosing...", userIdentity.title) : localize('sync user data', "{0}: Sync", userIdentity.title);
+			return `${userIdentity.iconText} ${syncText}`;
 		}
 		return userIdentity.title;
 	}
@@ -112,7 +118,7 @@ class UserDataSyncStatusContribution extends Disposable implements IWorkbenchCon
 
 const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench);
 workbenchRegistry.registerWorkbenchContribution(UserDataSyncStatusContribution, LifecyclePhase.Starting);
-workbenchRegistry.registerWorkbenchContribution(UserDataExtensionActivationContribution, LifecyclePhase.Ready);
+workbenchRegistry.registerWorkbenchContribution(AutoSyncUserDataContribution, LifecyclePhase.Ready);
 
 export class ShowUserDataSyncActions extends Action {
 

src/vs/workbench/services/userData/common/userData.ts

@@ -89,10 +89,19 @@ export interface IUserDataExtension {
 	version?: string;
 }
 
+export enum SyncStatus {
+	Syncing = 1,
+	SyncDone
+}
+
 export interface IUserDataSyncService {
 
 	_serviceBrand: any;
 
+	readonly syncStatus: SyncStatus;
+
+	readonly onDidChangeSyncStatus: Event<SyncStatus>;
+
 	synchronise(): Promise<void>;
 
 	getExtensions(): Promise<IUserDataExtension[]>;

src/vs/workbench/services/userData/common/userDataSyncService.ts

@@ -3,22 +3,41 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IUserDataSyncService, IUserDataProviderService, IUserDataExtension } from 'vs/workbench/services/userData/common/userData';
+import { IUserDataSyncService, IUserDataProviderService, IUserDataExtension, SyncStatus } from 'vs/workbench/services/userData/common/userData';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { Emitter, Event } from 'vs/base/common/event';
+import { timeout } from 'vs/base/common/async';
 
 export class UserDataSyncService extends Disposable implements IUserDataSyncService {
 
 	_serviceBrand: any;
 
+	private _onDidChangeSyncStatus: Emitter<SyncStatus> = this._register(new Emitter<SyncStatus>());
+	readonly onDidChangeSyncStatus: Event<SyncStatus> = this._onDidChangeSyncStatus.event;
+
+	private _syncStatus: SyncStatus = SyncStatus.SyncDone;
+	get syncStatus(): SyncStatus {
+		return this._syncStatus;
+	}
+	set syncStatus(status: SyncStatus) {
+		if (this._syncStatus !== status) {
+			this._syncStatus = status;
+			this._onDidChangeSyncStatus.fire(status);
+		}
+	}
+
 	constructor(
 		@IUserDataProviderService private readonly userDataProviderService: IUserDataProviderService
 	) {
 		super();
 	}
 
-	synchronise(): Promise<void> {
-		return Promise.resolve();
+
+	async synchronise(): Promise<void> {
+		this.syncStatus = SyncStatus.Syncing;
+		await timeout(5000);
+		this.syncStatus = SyncStatus.SyncDone;
 	}
 
 	getExtensions(): Promise<IUserDataExtension[]> {