feat: support VSCode API: WindowState.active (#4233)

* feat: add windowstate active plugin

* feat: create window-activity-tracker file

* feat: update window-actvity file

* feat: window-inactivityTimer

* feat: modify the TS type

* feat: modify window-activity-timer

* feat: window-activity-timer defined var

* feat: window-activity-timer defined var

Author: quxingkai

packages/extension/src/browser/vscode/api/main.thread.window-state.ts

@@ -1,29 +1,44 @@
 import { Injectable, Optional } from '@opensumi/di';
 import { IRPCProtocol } from '@opensumi/ide-connection';
+import { DisposableCollection } from '@opensumi/ide-core-browser';
 
 import { ExtHostAPIIdentifier, IExtHostWindowState } from '../../../common/vscode';
 
+import { WindowActivityTimer } from './window-activity/window-activity-timer';
+
 @Injectable({ multiple: true })
 export class MainThreadWindowState {
   private readonly proxy: IExtHostWindowState;
   private blurHandler;
   private focusHandler;
+
+  private readonly toDispose = new DisposableCollection();
+
   constructor(@Optional(Symbol()) private rpcProtocol: IRPCProtocol) {
     this.proxy = this.rpcProtocol.getProxy(ExtHostAPIIdentifier.ExtHostWindowState);
 
     this.blurHandler = () => {
-      this.proxy.$setWindowState(false);
+      this.proxy.$onDidChangeWindowFocus(false);
     };
     this.focusHandler = () => {
-      this.proxy.$setWindowState(true);
+      this.proxy.$onDidChangeWindowFocus(true);
     };
     window.addEventListener('blur', this.blurHandler);
 
     window.addEventListener('focus', this.focusHandler);
+
+    const tracker = new WindowActivityTimer(window);
+    this.toDispose.push(tracker.onDidChangeActiveState((isActive) => this.onActiveStateChanged(isActive)));
+    this.toDispose.push(tracker);
+  }
+
+  private onActiveStateChanged(isActive: boolean): void {
+    this.proxy.$onDidChangeWindowActive(isActive);
   }
 
   public dispose() {
     window.removeEventListener('blur', this.blurHandler);
     window.removeEventListener('focus', this.focusHandler);
+    this.toDispose.dispose();
   }
 }

packages/extension/src/browser/vscode/api/window-activity/window-activity-timer.ts

@@ -0,0 +1,108 @@
+import { Disposable, Emitter, Event } from '@opensumi/ide-core-browser';
+
+const MAX_INACTIVITY_COUNT = 30;
+const INACTIVITY_CHECK_INTERVAL = 1000;
+
+export class WindowActivityTimer extends Disposable {
+  private activityCount = 0;
+  private readonly maxInactivityCount: number = MAX_INACTIVITY_COUNT;
+  private readonly inactivityCheckInterval: number = INACTIVITY_CHECK_INTERVAL;
+  private inactivityCheckTimer: ReturnType<typeof setTimeout> | undefined;
+  private isActive = true;
+
+  // Event emitter for active state changes
+  private readonly activeStateChangedEmitter = new Emitter<boolean>();
+
+  // Window instance where the timer is active
+  constructor(private readonly window: Window, inactivityLimit: number = 30, checkInterval: number = 1000) {
+    super();
+    this.maxInactivityCount = inactivityLimit;
+    this.inactivityCheckInterval = checkInterval;
+
+    // Set up event listeners for user activity
+    this.setupActivityListeners();
+  }
+
+  // Getter for event listener
+  get onDidChangeActiveState(): Event<boolean> {
+    return this.activeStateChangedEmitter.event;
+  }
+
+  // Set the current activity state
+  private setActiveState(newState: boolean): void {
+    if (this.isActive !== newState) {
+      this.isActive = newState;
+      this.activeStateChangedEmitter.fire(newState);
+    }
+  }
+
+  // Set up event listeners for detecting user activity
+  private setupActivityListeners(): void {
+    this.window.addEventListener('mousedown', this.resetInactivityTimer, {
+      passive: true,
+      capture: true,
+    } as AddEventListenerOptions);
+    this.window.addEventListener('keydown', this.resetInactivityTimer, {
+      passive: true,
+      capture: true,
+    } as AddEventListenerOptions);
+    this.window.addEventListener('touchstart', this.resetInactivityTimer, {
+      passive: true,
+      capture: true,
+    } as AddEventListenerOptions);
+  }
+
+  // Reset the inactivity timer when activity is detected
+  private resetInactivityTimer = (): void => {
+    this.activityCount = 0;
+    this.setActiveState(true);
+    if (!this.inactivityCheckTimer) {
+      this.startInactivityCheck();
+    }
+  };
+
+  // Check if the user is inactive and update the state
+  private checkInactivity = (): void => {
+    this.activityCount++;
+
+    if (this.activityCount >= this.maxInactivityCount) {
+      this.setActiveState(false);
+      this.stopInactivityCheck();
+    }
+  };
+
+  // Start the inactivity timer
+  private startInactivityCheck(): void {
+    this.stopInactivityCheck();
+    this.inactivityCheckTimer = setInterval(() => {
+      this.checkInactivity();
+    }, this.inactivityCheckInterval);
+  }
+
+  // Stop the inactivity timer
+  private stopInactivityCheck(): void {
+    if (this.inactivityCheckTimer) {
+      clearInterval(this.inactivityCheckTimer);
+      this.inactivityCheckTimer = undefined;
+    }
+  }
+
+  // Clean up event listeners and stop the timer when disposed
+  dispose(): void {
+    this.stopInactivityCheck();
+    this.activeStateChangedEmitter.dispose();
+    super.dispose();
+    this.window.removeEventListener('mousedown', this.resetInactivityTimer, {
+      passive: true,
+      capture: true,
+    } as AddEventListenerOptions);
+    this.window.removeEventListener('keydown', this.resetInactivityTimer, {
+      passive: true,
+      capture: true,
+    } as AddEventListenerOptions);
+    this.window.removeEventListener('touchstart', this.resetInactivityTimer, {
+      passive: true,
+      capture: true,
+    } as AddEventListenerOptions);
+  }
+}

packages/extension/src/common/vscode/ext-types.ts

@@ -1638,6 +1638,7 @@ export interface OutputChannel {
 }
 
 export interface WindowState {
+  active: boolean;
   focused: boolean;
 }
 

packages/extension/src/common/vscode/window.ts

@@ -204,7 +204,8 @@ export interface IExtHostOutput {
 }
 
 export interface IExtHostWindowState {
-  $setWindowState(focused: boolean);
+  $onDidChangeWindowFocus(focused: boolean);
+  $onDidChangeWindowActive(active: boolean);
 
   readonly state: types.WindowState;
 

packages/extension/src/hosted/api/vscode/ext.host.window-state.ts

@@ -12,19 +12,28 @@ export class ExtHostWindowState implements IExtHostWindowState {
 
   public readonly onDidChangeWindowState: Event<types.WindowState> = this._onDidChangeWindowState.event;
 
-  public $setWindowState(focused: boolean) {
+  public $onDidChangeWindowFocus(focused: boolean) {
     if (focused !== this.state.focused) {
       this.state.focused = focused;
       this._onDidChangeWindowState.fire(this.state);
     }
   }
+
+  public $onDidChangeWindowActive(active: boolean): void {
+    if (active !== this.state.active) {
+      this.state.active = active;
+      this._onDidChangeWindowState.fire(this.state);
+    }
+  }
 }
 
 export class WindowStateImpl implements types.WindowState {
   public focused: boolean;
+  public active: boolean;
 
   constructor() {
     // 当插件进程重启时，这里如果默认是 false，会与实际状态不一致，导致依赖该状态的插件处理有问题
     this.focused = true;
+    this.active = true;
   }
 }

packages/types/vscode/typings/vscode.d.ts

@@ -1054,6 +1054,12 @@ declare module 'vscode' {
      * Whether the current window is focused.
      */
     readonly focused: boolean;
+
+    /**
+     * Whether the window has been interacted with recently. This will change
+     * immediately on activity, or after a short time of user inactivity.
+     */
+    readonly active: boolean;
   }
 
   /**