send status notification when analysis starts and ends

pkg/analysis_server/lib/src/analysis_server.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/analysis_logger.dart';
@@ skipping 90 matching lines @@
   final PackageMapProvider packageMapProvider;
 
   /**
    * A flag indicating whether the server is running.  When false, contexts
    * will no longer be added to [contextWorkQueue], and [performOperation] will
    * discard any tasks it finds on [contextWorkQueue].
    */
   bool running;
 
   /**
+   * A flag indicating the value of the 'analyzing' parameter sent in the last
+   * status message to the client.
+   */
+  bool statusAnalyzing = false;
+
+  /**
    * A list of the request handlers used to handle the requests sent to this
    * server.
    */
   List<RequestHandler> handlers;
 
   /**
    * The current default [DartSdk].
    */
   DartSdk defaultSdk = SHARED_SDK;
 
@@ skipping 219 matching lines @@
   void performOperation() {
     if (!running) {
       // An error has occurred, or the connection to the client has been
       // closed, since this method was scheduled on the event queue.  So
       // don't do anything.  Instead clear the operation queue.
       operationQueue.clear();
       return;
     }
     // prepare next operation
     ServerOperation operation = operationQueue.take();
+    sendStatusNotification(operation);
     // perform the operation
     try {
       operation.perform(this);
     } catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logError("${exception}\n${stackTrace}");
       if (rethrowExceptions) {
         throw new AnalysisException(
             'Unexpected exception during analysis',
             new CaughtException(exception, stackTrace));
       }
     } finally {
       if (!operationQueue.isEmpty) {
         _schedulePerformOperation();
       } else {
         sendStatusNotification(null);
       }
     }
   }
 
   /**
-   * Send status notification to the client. The `contextId` indicates
-   * the current context being analyzed or `null` if analysis is complete.
+   * Send status notification to the client. The `operation` is the operation
+   * being performed or `null` if analysis is complete.
    */
-  void sendStatusNotification(String contextId) {
+  void sendStatusNotification(ServerOperation operation) {
+    // Only send status when it changes
+    bool isAnalyzing = operation != null;
+    if (statusAnalyzing == isAnalyzing) {
+      return;
+    }
+    statusAnalyzing = isAnalyzing;
     Notification notification = new Notification(SERVER_STATUS);
     Map<String, Object> analysis = new Map();
-    if (contextId != null) {
-      analysis['analyzing'] = true;
-      // TODO(danrubel): replace contextId with real analysisTarget
-      analysis['analysisTarget'] = contextId;
-    } else {
-      analysis['analyzing'] = false;
-    }
+    analysis['analyzing'] = isAnalyzing;
     notification.params['analysis'] = analysis;
     channel.sendNotification(notification);
   }
 
   /**
    * Implementation for `analysis.setAnalysisRoots`.
    *
    * TODO(scheglov) implement complete projects/contexts semantics.
    *
    * The current implementation is intentionally simplified and expected
@@ skipping 227 matching lines @@
 /**
  * An enumeration of the services provided by the server domain.
  */
 class ServerService extends Enum2<ServerService> {
   static const ServerService STATUS = const ServerService('STATUS', 0);
 
   static const List<ServerService> VALUES = const [STATUS];
 
   const ServerService(String name, int ordinal) : super(name, ordinal);
 }