Present first view according to user setting (#189)

* Present first view according to user setting

Signed-off-by: Rome Li <[email protected]>

* Subscribe to less events

Signed-off-by: Rome Li <[email protected]>

Author: akaroml

package.json

@@ -61,7 +61,30 @@
         "command": "java.gettingStarted",
         "title": "Java: Getting Started"
       }
-    ]
+    ],
+    "configuration":{
+      "title": "Java Extension Pack",
+      "properties": {
+        "java.help.firstView": {
+          "type": [
+            "string"
+          ],
+          "enum": [
+            "auto",
+            "overview",
+            "gettingStarted"
+          ],
+          "enumDescriptions": [
+            "Automatically pick the first experience view",
+            "Present the Java Overview page",
+            "Present the Java Getting Started page"
+          ],
+          "default": "auto",
+          "description": "Sets the default view which is presented during the first use.",
+          "scope": "window"
+        }
+      }
+    }
   },
   "scripts": {
     "vscode:prepublish": "npm run build",

src/extension.ts

@@ -8,9 +8,16 @@ import { initialize as initUtils } from "./utils";
 import { initialize as initCommands } from "./commands";
 import { initialize as initRecommendations } from "./recommendation";
 import { initialize as initMisc, showReleaseNotesOnStart } from "./misc";
-import { showOverviewPageOnActivation, OverviewViewSerializer } from "./overview";
+import { OverviewViewSerializer, showOverviewPageOnActivation } from "./overview";
 import { validateJavaRuntime, JavaRuntimeViewSerializer } from "./java-runtime";
 import { JavaGettingStartedViewSerializer } from "./getting-started";
+import { scheduleAction } from "./utils/scheduler";
+
+enum ViewType {
+  Auto = "auto",
+  Overview = "overview",
+  GettingStarted = "gettingStarted",
+}
 
 export async function activate(context: vscode.ExtensionContext) {
   initializeTelemetry(context);
@@ -27,14 +34,40 @@ async function initializeExtension(operationId: string, context: vscode.Extensio
   context.subscriptions.push(vscode.window.registerWebviewPanelSerializer("java.runtime", new JavaRuntimeViewSerializer()));
   context.subscriptions.push(vscode.window.registerWebviewPanelSerializer("java.gettingStarted", new JavaGettingStartedViewSerializer()));
 
-  await showOverviewPageOnActivation(context);
-  await showReleaseNotesOnStart(context);
+  scheduleAction("showFirstView", true).then(() => {
+    presentFirstView(context);
+  });
+
+  scheduleAction("showReleaseNotes").then(() => {
+    showReleaseNotesOnStart(context);
+  });
 
   if (!await validateJavaRuntime()) {
-    vscode.commands.executeCommand("java.runtime");
+    scheduleAction("showJdkState", true, true).then(() => {
+      vscode.commands.executeCommand("java.runtime");
+    });
+  }
+}
+
+async function presentFirstView(context: vscode.ExtensionContext) {
+  const config = vscode.workspace.getConfiguration("java.help");
+  const firstView = config.get("firstView");
+  if (firstView === ViewType.GettingStarted) {
+    await showGettingStartedView(context);
+  } else {
+    await showOverviewPageOnActivation(context);
   }
 }
 
+async function showGettingStartedView(context: vscode.ExtensionContext, isForce: boolean = false) {
+  if (!!context.globalState.get("isGettingStartedPresented")) {
+    return;
+  }
+
+  await vscode.commands.executeCommand("java.gettingStarted");
+  context.globalState.update("isGettingStartedPresented", true);
+}
+
 function initializeTelemetry(context: vscode.ExtensionContext) {
   const ext = vscode.extensions.getExtension("vscjava.vscode-java-pack");
   const packageInfo = ext ? ext.packageJSON : undefined;

src/java-runtime/assets/index.ts

@@ -58,7 +58,6 @@ declare function acquireVsCodeApi(): any;
 const vscode = acquireVsCodeApi();
 
 function requestJdkInfo(jdkVersion: string, jvmImpl: string) {
-  console.log(`request ${jdkVersion} ${jvmImpl}`);
   vscode.postMessage({
     command: "requestJdkInfo",
     jdkVersion: jdkVersion,

src/utils/idle.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as vscode from "vscode";
+
+// in milliseconds
+let timeElapsed: number = 0;
+const INTERVAL = 1000;
+// reference - https://medium.com/@slhenty/ui-response-times-acec744f3157
+// 5s is when users start to lose focus
+const IDLE_THRESHOLD = 5000;
+
+export function initialize(context: vscode.ExtensionContext) {
+  context.subscriptions.push(vscode.window.onDidChangeActiveTextEditor(vscodeEventHandler)); // switching editor
+  context.subscriptions.push(vscode.window.onDidChangeTextEditorSelection(vscodeEventHandler)); // change cursor position
+  context.subscriptions.push(vscode.window.onDidChangeTextEditorVisibleRanges(vscodeEventHandler)); // scrolling
+
+  setInterval(timerEventHandler, INTERVAL);
+}
+
+function vscodeEventHandler() {
+  timeElapsed = 0;
+}
+
+function timerEventHandler() {
+  timeElapsed += INTERVAL;
+  if (timeElapsed >= IDLE_THRESHOLD) {
+    timeElapsed = 0;
+    _onIdle.fire();
+  }
+}
+
+const _onIdle: vscode.EventEmitter<void> = new vscode.EventEmitter;
+export const onIdle: vscode.Event<void> = _onIdle.event;

src/utils/index.ts

@@ -4,13 +4,17 @@
 import * as vscode from "vscode";
 import { readFile as fsReadFile } from "fs";
 import * as util from "util";
+import { initialize as initializeIdle } from "./idle";
+import { initialize as initializeScheduler } from "./scheduler";
 
 const readFile = util.promisify(fsReadFile);
 
 let extensionContext: vscode.ExtensionContext;
 
 export function initialize(context: vscode.ExtensionContext) {
   extensionContext = context;
+  initializeIdle(context);
+  initializeScheduler(context);
 }
 
 export function getExtensionContext() {

src/utils/scheduler.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as vscode from "vscode";
+import { onIdle } from "./idle";
+import * as _ from "lodash";
+
+interface Action {
+  name: string;
+  resolve: (name: string) => void;
+}
+
+const actionQueue: Action[] = [];
+const pastActions: string[] = [];
+
+export function initialize(context: vscode.ExtensionContext) {
+  context.subscriptions.push(onIdle(() => idleHandler()));
+}
+
+// This is to queue the actions that need attention from users. One thing at a time, only on idle.
+export function scheduleAction(name: string, isImmediate: boolean = false, isOneTime: boolean = false): Promise<string> {
+  const isPastAction = _.some(actionQueue, (action) => action.name === name) || _.some(pastActions, name);
+  if (isOneTime && isPastAction) {
+    return Promise.reject(`Action (${name}) was already scheduled or performed once.`);
+  }
+
+  return new Promise((resolve, reject) => {
+    if (isImmediate) {
+      setImmediate(() => resolve(name));
+      return;
+    }
+
+    actionQueue.push({
+      name: name,
+      resolve: resolve
+    });
+  });
+}
+
+function idleHandler() {
+  if (_.isEmpty(actionQueue)) {
+    return;
+  }
+
+  const action = actionQueue.shift();
+  pastActions.push(action && action.name || "");
+  action && action.resolve(action && action.name);
+}