Merge pull request #39 from twentyTwo/develop

Added Focus Timeout

Author: twentyTwo

README.md

@@ -25,6 +25,7 @@ Simple Coding Time Tracker is a powerful extension for Visual Studio Code that h
 - **Configurable Settings**: 
   - Save Interval: Customize how often your coding time data is saved (default: 5 seconds)
   - Inactivity Timeout: Set how long to wait before stopping the timer when no activity is detected (default: 5 minutes)
+   - Focus Timeout: Set how long to continue tracking after VS Code loses focus (default: 60 seconds)
 
 ## Installation
 

package.json

@@ -19,16 +19,19 @@
   "contributes": {
     "configuration": {
       "title": "Simple Coding Time Tracker",
-      "properties": {
-        "simpleCodingTimeTracker.saveInterval": {
+      "properties": {        "simpleCodingTimeTracker.saveInterval": {
           "type": "number",
           "default": 5,
-          "description": "Interval in seconds to save the current coding session"
+          "description": "How often to save coding time data (in seconds)"
+        },        "simpleCodingTimeTracker.inactivityTimeout": {
+          "type": "number",
+          "default": 150,
+          "description": "Stop tracking after no keyboard/mouse activity (in seconds)"
         },
-        "simpleCodingTimeTracker.inactivityTimeout": {
+        "simpleCodingTimeTracker.focusTimeout": {
           "type": "number",
-          "default": 300,
-          "description": "Time in seconds of inactivity before tracking stops (default: 300 seconds = 5 minutes)"
+          "default": 180,
+          "description": "Continue tracking when switching apps (in seconds)"
         }
       }
     },

src/database.ts

@@ -14,15 +14,16 @@ export interface SummaryData {
 
 export class Database {
     private context: vscode.ExtensionContext;
+    private entries: TimeEntry[] | null = null;
 
     constructor(context: vscode.ExtensionContext) {
         this.context = context;
-        // Log the storage URI path
-        const storagePath = this.context.storageUri?.fsPath;
-        if (storagePath) {
-            console.log('Extension Data Storage Path:', storagePath);
-            //vscode.window.showInformationMessage(`Data is stored at: ${storagePath}`);
+        // Initialize storage if empty
+        if (!this.context.globalState.get('timeEntries')) {
+            this.context.globalState.update('timeEntries', []);
         }
+        // Load entries into memory
+        this.entries = this.context.globalState.get<TimeEntry[]>('timeEntries', []);
     }
 
     private getLocalDateString(date: Date): string {
@@ -34,21 +35,33 @@ export class Database {
     async addEntry(date: Date, project: string, timeSpent: number) {
         const dateString = this.getLocalDateString(date);
         const entries = this.getEntries();
+        
         const existingEntryIndex = entries.findIndex(entry => entry.date === dateString && entry.project === project);
 
         if (existingEntryIndex !== -1) {
-            // Update existing entry
             entries[existingEntryIndex].timeSpent += timeSpent;
         } else {
-            // Add new entry
             entries.push({ date: dateString, project, timeSpent });
         }
 
-        await this.context.globalState.update('timeEntries', entries);
+        try {
+            await this.updateEntries(entries);
+        } catch (error) {
+            console.error('Error saving entry:', error);
+            vscode.window.showErrorMessage('Failed to save time entry');
+        }
     }
 
     getEntries(): TimeEntry[] {
-        return this.context.globalState.get<TimeEntry[]>('timeEntries', []);
+        if (!this.entries) {
+            this.entries = this.context.globalState.get<TimeEntry[]>('timeEntries', []);
+        }
+        return this.entries;
+    }
+
+    private async updateEntries(entries: TimeEntry[]): Promise<void> {
+        this.entries = entries;
+        await this.context.globalState.update('timeEntries', entries);
     }
 
     async getSummaryData(): Promise<SummaryData> {
@@ -83,10 +96,10 @@ export class Database {
         const today = this.getLocalDateString(new Date());
         const entries = this.getEntries();
         const updatedEntries = entries.filter(entry => entry.date !== today);
-        await this.context.globalState.update('timeEntries', updatedEntries);
+        await this.updateEntries(updatedEntries);
     }
 
     async resetAllTime(): Promise<void> {
-        await this.context.globalState.update('timeEntries', []);
+        await this.updateEntries([]);
     }
 }

src/extension.ts

@@ -17,6 +17,15 @@ export function activate(context: vscode.ExtensionContext) {
         })
     );
 
+    // Register configuration change listener
+    context.subscriptions.push(
+        vscode.workspace.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('simpleCodingTimeTracker')) {
+                timeTracker.updateConfiguration();
+            }
+        })
+    );
+
     // Register the existing command
     let disposable = vscode.commands.registerCommand('simpleCodingTimeTracker.showSummary', () => {
         summaryView.show();
@@ -50,11 +59,28 @@ export function activate(context: vscode.ExtensionContext) {
         timeTracker.startTracking();
     }
 
+    // Variable to store the focus timeout handle
+    let focusTimeoutHandle: NodeJS.Timeout | null = null;
+
     vscode.window.onDidChangeWindowState((e: vscode.WindowState) => {
         if (e.focused) {
+            if (focusTimeoutHandle) {
+                clearTimeout(focusTimeoutHandle);
+                focusTimeoutHandle = null;
+            }
             timeTracker.startTracking();
         } else {
-            timeTracker.stopTracking();
+            const config = vscode.workspace.getConfiguration('simpleCodingTimeTracker');
+            const focusTimeoutSeconds = config.get('focusTimeout', 60);
+
+            // Only stop tracking after the focus timeout
+            if (focusTimeoutHandle) {
+                clearTimeout(focusTimeoutHandle);
+            }
+            
+            focusTimeoutHandle = setTimeout(() => {
+                timeTracker.stopTracking();
+            }, focusTimeoutSeconds * 1000);
         }
     });
 

src/timeTracker.ts

@@ -7,17 +7,16 @@ export class TimeTracker implements vscode.Disposable {
     private currentProject: string = '';
     private database: Database;
     private updateInterval: NodeJS.Timeout | null = null;
-    private saveInterval: NodeJS.Timeout | null = null;
-    private saveIntervalSeconds: number;
+    private saveInterval: NodeJS.Timeout | null = null;    private saveIntervalSeconds: number = 5;
     private lastCursorActivity: number = Date.now();
     private cursorInactivityTimeout: NodeJS.Timeout | null = null;
-    private inactivityTimeoutSeconds: number;
+    private inactivityTimeoutSeconds: number = 300;
+    private focusTimeoutHandle: NodeJS.Timeout | null = null;
+    private focusTimeoutSeconds: number = 60;
 
     constructor(database: Database) {
         this.database = database;
-        const config = vscode.workspace.getConfiguration('simpleCodingTimeTracker');
-        this.saveIntervalSeconds = config.get('saveInterval', 5);
-        this.inactivityTimeoutSeconds = config.get('inactivityTimeout', 300); // Default 5 minutes in seconds
+        this.updateConfiguration();
 
         // Track cursor movements
         vscode.window.onDidChangeTextEditorSelection(() => {
@@ -61,11 +60,33 @@ export class TimeTracker implements vscode.Disposable {
         // Track when VS Code window gains focus
         vscode.window.onDidChangeWindowState((e) => {
             if (e.focused) {
-                this.updateCursorActivity();
+                // Clear any pending timeout when focus returns
+                if (this.focusTimeoutHandle) {
+                    clearTimeout(this.focusTimeoutHandle);
+                    this.focusTimeoutHandle = null;
+                }
+                this.startTracking();
+            } else {
+                // Set timeout when focus is lost
+                if (this.focusTimeoutHandle) {
+                    clearTimeout(this.focusTimeoutHandle);
+                }
+                this.focusTimeoutHandle = setTimeout(() => {
+                    if (this.isTracking) {
+                        this.stopTracking();
+                    }
+                }, this.focusTimeoutSeconds * 1000);
             }
         });
     }
 
+    public updateConfiguration() {
+        const config = vscode.workspace.getConfiguration('simpleCodingTimeTracker');
+        this.saveIntervalSeconds = config.get('saveInterval', 5);
+        this.inactivityTimeoutSeconds = config.get('inactivityTimeout', 300); // Default 5 minutes in seconds
+        this.focusTimeoutSeconds = config.get('focusTimeout', 60);
+    }
+
     private setupCursorTracking() {
         if (this.cursorInactivityTimeout) {
             clearTimeout(this.cursorInactivityTimeout);