Lazy load the services needed by UsageTracker.

To improve the startup time of the extension.

Author: grokys

src/GitHub.VisualStudio/GitHub.VisualStudio.csproj

@@ -298,6 +298,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Helpers\Browser.cs" />
     <Compile Include="Services\UsageTracker.cs" />
+    <Compile Include="Services\UsageTrackerDispatcher.cs" />
     <Compile Include="Settings\Constants.cs" />
     <Compile Include="Services\ConnectionManager.cs" />
     <Compile Include="Services\Program.cs" />

src/GitHub.VisualStudio/GitHubPackage.cs

@@ -52,8 +52,9 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
             await base.InitializeAsync(cancellationToken, progress);
             await EnsurePackageLoaded(new Guid(ServiceProviderPackage.ServiceProviderPackageId));
 
-            //var usageTracker = await GetServiceAsync(typeof(IUsageTracker)) as IUsageTracker;
-            //usageTracker.IncrementLaunchCount();
+            // Activate the usage tracker by forcing an instance to be created.
+            await GetServiceAsync(typeof(IUsageTracker));
+
             InitializeMenus().Forget();
         }
 
@@ -178,6 +179,11 @@ async Task<object> CreateService(IAsyncServiceContainer container, CancellationT
                 var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
                 return new MenuProvider(sp);
             }
+            else if (serviceType == typeof(IUsageTracker))
+            {
+                var uiProvider = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider;
+                return new UsageTracker(uiProvider);
+            }
             // go the mef route
             else
             {

src/GitHub.VisualStudio/Services/UsageTracker.cs

@@ -14,34 +14,30 @@
 
 namespace GitHub.Services
 {
-    [Export(typeof(IUsageTracker))]
-    [PartCreationPolicy(CreationPolicy.Shared)]
     public class UsageTracker : IUsageTracker
     {
         const string StoreFileName = "ghfvs.usage";
         static readonly Calendar cal = CultureInfo.InvariantCulture.Calendar;
 
+        readonly IUIProvider uiProvider;
+        readonly DispatcherTimer timer;
+
         IMetricsService client;
-        readonly IConnectionManager connectionManager;
+        IConnectionManager connectionManager;
         IPackageSettings userSettings;
-        readonly IVSServices vsservices;
-        readonly DispatcherTimer timer;
-        readonly string storePath;
-        readonly IServiceProvider serviceProvider;
+        IVSServices vsservices;
+        string storePath;
+        bool firstRun = true;
 
         Func<string, bool> fileExists;
         Func<string, Encoding, string> readAllText;
         Action<string, string, Encoding> writeAllText;
         Action<string> dirCreate;
 
         [ImportingConstructor]
-        public UsageTracker(
-            IProgram program,
-            IConnectionManager connectionManager,
-            IVSServices vsservices,
-            [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider)
+        public UsageTracker(IUIProvider uiProvider)
         {
-            this.serviceProvider = serviceProvider;
+            this.uiProvider = uiProvider;
 
             fileExists = (path) => System.IO.File.Exists(path);
             readAllText = (path, encoding) =>
@@ -65,17 +61,11 @@ public UsageTracker(
             };
             dirCreate = (path) => System.IO.Directory.CreateDirectory(path);
 
-            this.connectionManager = connectionManager;
-            this.vsservices = vsservices;
             this.timer = new DispatcherTimer(
-                TimeSpan.FromMinutes(1),
+                TimeSpan.FromMinutes(3),
                 DispatcherPriority.Background,
                 TimerTick,
                 Dispatcher.CurrentDispatcher);
-            this.storePath = System.IO.Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
-                program.ApplicationName,
-                StoreFileName);
 
             RunTimer();
         }
@@ -145,8 +135,29 @@ public void IncrementLoginCount()
             SaveUsage(usage);
         }
 
+        void Initialize()
+        {
+            // The services needed by the usage tracker are loaded when they are first needed to
+            // improve the startup time of the extension.
+            if (userSettings == null)
+            {
+                client = uiProvider.GetService<IMetricsService>();
+                connectionManager = uiProvider.GetService<IConnectionManager>();
+                userSettings = uiProvider.GetService<IPackageSettings>();
+                vsservices = uiProvider.GetService<IVSServices>();
+
+                var program = uiProvider.GetService<IProgram>();
+                storePath = System.IO.Path.Combine(
+                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                    program.ApplicationName,
+                    StoreFileName);
+            }
+        }
+
         UsageStore LoadUsage()
         {
+            Initialize();
+
             var json = fileExists(storePath) ? readAllText(storePath, Encoding.UTF8) : null;
             UsageStore result = null;
             try
@@ -178,7 +189,6 @@ void RunTimer()
         {
             // The timer first ticks after 3 minutes to allow things to settle down after startup.
             // This will be changed to 8 hours after the first tick by the TimerTick method.
-            timer.Interval = TimeSpan.FromMinutes(3);
             timer.Start();
         }
 
@@ -194,21 +204,23 @@ void TimerTick(object sender, EventArgs e)
 
         async Task TimerTick()
         {
-            Debug.Assert(client != null, "TimerTick should not be triggered when there is no IMetricsService");
+            Initialize();
 
-            // Subsequent timer ticks should occur every 8 hours.
-            timer.Interval = TimeSpan.FromHours(8);
+            if (firstRun)
+            {
+                IncrementLaunchCount();
+                timer.Interval = TimeSpan.FromHours(8);
+                firstRun = false;
+            }
 
             if (userSettings == null)
             {
                 await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
-                client = serviceProvider.GetExportedValue<IMetricsService>();
                 if (client == null)
                 {
                     timer.Stop();
                     return;
                 }
-                userSettings = serviceProvider.GetExportedValue<IPackageSettings>();
             }
 
             if (!userSettings.CollectMetrics)

src/GitHub.VisualStudio/Services/UsageTrackerDispatcher.cs

@@ -0,0 +1,29 @@
+using Microsoft.VisualStudio.Shell;
+using System;
+using System.ComponentModel.Composition;
+
+namespace GitHub.Services
+{
+    [Export(typeof(IUsageTracker))]
+    [PartCreationPolicy(CreationPolicy.NonShared)]
+    public class UsageTrackerDispatcher : IUsageTracker
+    {
+        readonly IUsageTracker inner;
+
+        [ImportingConstructor]
+        public UsageTrackerDispatcher([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider)
+        {
+            inner = serviceProvider.GetService(typeof(IUsageTracker)) as IUsageTracker;
+        }
+
+        public void IncrementCloneCount() => inner.IncrementCloneCount();
+        public void IncrementCreateCount() => inner.IncrementCreateCount();
+        public void IncrementCreateGistCount() => inner.IncrementCreateGistCount();
+        public void IncrementLaunchCount() => inner.IncrementLaunchCount();
+        public void IncrementLinkToGitHubCount() => inner.IncrementLinkToGitHubCount();
+        public void IncrementLoginCount() => inner.IncrementLoginCount();
+        public void IncrementOpenInGitHubCount() => inner.IncrementOpenInGitHubCount();
+        public void IncrementPublishCount() => inner.IncrementPublishCount();
+        public void IncrementUpstreamPullRequestCount() => inner.IncrementUpstreamPullRequestCount();
+    }
+}