title: Extended execution does not seem to work in Windows 10 Universal JavaScript apps
body: <p>I have a Windows 10 Universal app that's written in JavaScript. The app is a location tracker and needs to run in the background, and I am attempting to use the ExtendedExecution APIs to make that happen. I'm finding, though, that this works as advertised in a C#/XAML app, but does not work in a JavaScript app. </p>
  
  <p>As an experiment, in Visual Studio 2015 I created a new C# project via <code>File -&gt; New -&gt; Project -&gt; Visual C# -&gt; Blank App (Universal Windows)</code> and kitted it out as follows:</p>
  
  <pre><code>/// &lt;summary&gt;
  /// An empty page that can be used on its own or navigated to within a Frame.
  /// &lt;/summary&gt;
  public sealed partial class MainPage : Page
  {
      private Geolocator locator;
      private ObservableCollection&lt;string&gt; coordinates = new ObservableCollection&lt;string&gt;();
      private ExtendedExecutionSession session;
  
      public MainPage()
      {
          this.InitializeComponent();
  
          // Start geo locating
          locator = new Geolocator();
          locator.DesiredAccuracy = PositionAccuracy.High;
          locator.DesiredAccuracyInMeters = 0;
          locator.MovementThreshold = 0;
          locator.PositionChanged += positionChanged;
          coords.ItemsSource = coordinates;
  
          // Request extended execution
          RequestExtendedExecution();
      }
  
      private async void RequestExtendedExecution()
      {
  
          // Request extended execution via the ExtendedExecution API
          session = new ExtendedExecutionSession();
          session.Description = "Location Tracker";
          session.Reason = ExtendedExecutionReason.LocationTracking;
          session.Revoked += ExtendedExecutionSession_Revoked;
          var result = await session.RequestExtensionAsync();
          if (result == ExtendedExecutionResult.Allowed)
              coordinates.Insert(0, "Extended execution SUCCESS");
          else if (result == ExtendedExecutionResult.Denied)
              coordinates.Insert(0, "Extended execution DENIED");
          else
              coordinates.Insert(0, "Extended execution unexpected return code");
      }
  
      private async void EndExtendedExecution()
      {
          if (session != null)
          {
              session.Dispose();
              session = null;
          }
      }
  
      private void ExtendedExecutionSession_Revoked(object sender, ExtendedExecutionRevokedEventArgs args)
      {
          var _ = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =&gt;
          {
              coordinates.Insert(0, "Extended execution REVOKED: " + ((args.Reason == ExtendedExecutionRevokedReason.Resumed) ? "Resumed" : (args.Reason == ExtendedExecutionRevokedReason.SystemPolicy) ? "Resources" : "Unknown reason"));
          });
          EndExtendedExecution();
      }
  
      private void positionChanged(Geolocator sender, PositionChangedEventArgs args)
      {
          var coord = args.Position;
          string position = string.Format("{0},{1}",
              args.Position.Coordinate.Point.Position.Latitude,
              args.Position.Coordinate.Point.Position.Longitude);
          var _ = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =&gt;
          {
              coordinates.Insert(0, position);
          });
      }
  }
  </code></pre>
  
  <p>The markup is simply:</p>
  
  <pre><code>&lt;ListView x:Name="coords" /&gt;
  </code></pre>
  
  <p>This absolutely works as expected. When I request the extended session, I get "Extended execution SUCCESS", when minimized the app continues to add coords to the ListView, and when returned to the foreground I get "Extended execution REVOKED: Resumed". Super duper. Back to Visual Studio 2015, I then created a new JavaScript project via <code>File -&gt; New -&gt; Project -&gt; JavaScript -&gt; Blank App (Universal Windows)</code> and implemented the same features as follows:</p>
  
  <pre><code>(function () {
      "use strict";
  
      var app = WinJS.Application;
      var activation = Windows.ApplicationModel.Activation;
      var extendedExecution = Windows.ApplicationModel.ExtendedExecution;
      var session = null;
      var geolocator = null;
  
      app.onactivated = function (args) {
          if (args.detail.kind === activation.ActivationKind.launch) {
              if (args.detail.previousExecutionState !== activation.ApplicationExecutionState.terminated) {
  
                  // TODO: This application has been newly launched. Initialize your application here.
  
                  // Start geo tracking
                  Windows.Devices.Geolocation.Geolocator.requestAccessAsync().done(
                      function (accessStatus) {
                          switch (accessStatus) {
                              case Windows.Devices.Geolocation.GeolocationAccessStatus.allowed:
                                  geolocator = new Windows.Devices.Geolocation.Geolocator();
                                  geolocator.ReportInterval = 1000;
  
                                  // Subscribe to PositionChanged event to get updated tracking positions
                                  geolocator.addEventListener("positionchanged", function (e) {
                                      var coord = e.position.coordinate;
                                      log("app.onactivated: coord = " + coord.point.position.latitude + ", " + coord.point.position.longitude, false, true, false);
                                  });
                                  break;
  
                              case Windows.Devices.Geolocation.GeolocationAccessStatus.denied:
                                  log("Geolocator.requestAccessAsync: Access to location is denied.", false, true, false);
                                  break;
  
                              case Windows.Devices.Geolocation.GeolocationAccessStatus.unspecified:
                                  log("Geolocator.requestAccessAsync: Unspecified error.", false, true, false);
                                  break;
                          }
                      },
                      function (err) {
                          log("Geolocator.requestAccessAsync: error " + err, false, true, false);
                      }
                  );
  
                  // Request extended execution
                  requestExtendedExecution();
  
              } else {
                  // TODO: This application was suspended and then terminated.
                  // To create a smooth user experience, restore application state here so that it looks like the app never stopped running.
              }
              args.setPromise(WinJS.UI.processAll());
          }
      };
  
      app.oncheckpoint = function (args) {
          // TODO: This application is about to be suspended. Save any state that needs to persist across suspensions here.
          // You might use the WinJS.Application.sessionState object, which is automatically saved and restored across suspension.
          // If you need to complete an asynchronous operation before your application is suspended, call args.setPromise().
          log("app.oncheckpoint: application is about to be suspended");
      };
  
      function requestExtendedExecution() {
  
          // If we already have an extended session, close it before requesting a new one.
          if (session != null) {
              session.close();
              session = null;
          }
  
          // Request extended execution via the ExtendedExecution API
          session = new extendedExecution.ExtendedExecutionSession();
          session.description = "Background location tracking";
          session.reason = extendedExecution.ExtendedExecutionReason.locationTracking;
          session.onrevoked = function (args) {
              log("requestExtendedExecution: Background mode revoked: " + args.reason);
              requestExtendedExecution();
          };
          session.requestExtensionAsync().done(
              function success() {
                  log("requestExtendedExecution: Successfully enabled background mode");
              },
              function error(error) {
                  log("requestExtendedExecution: Could not enable background mode: " + error);
              }
          );      
      }
  
      function log (text) {
          var now = new Date();
          var timestamp = now.toLocaleDateString() + " " + now.toLocaleTimeString();
          var outputDiv = document.getElementById("divOutput");
          outputDiv.innerHTML = timestamp + " " + text + "&lt;br/&gt;" + outputDiv.innerHTML;
      }
  
      app.start();
  })();
  </code></pre>
  
  <p>And the markup is:</p>
  
  <pre><code>&lt;div id="divOutput"&gt;&lt;/div&gt;
  </code></pre>
  
  <p>When I request the extended session, I still get "Extended execution SUCCESS", yay, but when I minimize the app, app.oncheckpoint gets called, the app gets suspended and there is no further activity until it returns to the foreground. I have also tried requesting the extended session from within app.oncheckpoint, but that has no effect either.</p>
  
  <p>Anyone have some insight into this? Thanks in advance.</p>