Replace LooperExecutor with built-in class in Android AppRTC Demo

webrtc/examples/androidapp/src/org/appspot/apprtc/CpuMonitor.java

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.appspot.apprtc;
 
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.BatteryManager;
 import android.os.SystemClock;
 import android.util.Log;
 
 import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Scanner;
-
-import org.appspot.apprtc.util.LooperExecutor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Simple CPU monitor.  The caller creates a CpuMonitor object which can then
  * be used via sampleCpuUtilization() to collect the percentual use of the
  * cumulative CPU capacity for all CPUs running at their nominal frequency.  3
  * values are generated: (1) getCpuCurrent() returns the use since the last
  * sampleCpuUtilization(), (2) getCpuAvg3() returns the use since 3 prior
  * calls, and (3) getCpuAvgAll() returns the use over all SAMPLE_SAVE_NUMBER
  * calls.
  *
@@ skipping 40 matching lines @@
   private final Context appContext;
   // User CPU usage at current frequency.
   private final MovingAverage userCpuUsage;
   // System CPU usage at current frequency.
   private final MovingAverage systemCpuUsage;
   // Total CPU usage relative to maximum frequency.
   private final MovingAverage totalCpuUsage;
   // CPU frequency in percentage from maximum.
   private final MovingAverage frequencyScale;
 
-  private LooperExecutor executor;
+  private ScheduledExecutorService executor;
   private long lastStatLogTimeMs;
   private long[] cpuFreqMax;
   private int cpusPresent;
   private int actualCpusPresent;
   private boolean initialized;
   private boolean cpuOveruse;
   private String[] maxPath;
   private String[] curPath;
   private double[] curFreqScales;
   private ProcStat lastProcStat;
@@ skipping 53 matching lines @@
 
   public CpuMonitor(Context context) {
     Log.d(TAG, "CpuMonitor ctor.");
     appContext = context.getApplicationContext();
     userCpuUsage = new MovingAverage(MOVING_AVERAGE_SAMPLES);
     systemCpuUsage = new MovingAverage(MOVING_AVERAGE_SAMPLES);
     totalCpuUsage = new MovingAverage(MOVING_AVERAGE_SAMPLES);
     frequencyScale = new MovingAverage(MOVING_AVERAGE_SAMPLES);
     lastStatLogTimeMs = SystemClock.elapsedRealtime();
 
-    executor = new LooperExecutor();
-    executor.requestStart();
     scheduleCpuUtilizationTask();
   }
 
-  public void release() {
-    if (executor != null) {
-      Log.d(TAG, "release");
-      executor.cancelScheduledTasks();
-      executor.requestStop();
-      executor = null;
-    }
-  }
-
   public void pause() {
     if (executor != null) {
       Log.d(TAG, "pause");
-      executor.cancelScheduledTasks();
+      executor.shutdownNow();
+      executor = null;
     }
   }
 
   public void resume() {
-    if (executor != null) {
-      Log.d(TAG, "resume");
-      resetStat();
-      scheduleCpuUtilizationTask();
-    }
+    Log.d(TAG, "resume");
+    resetStat();
+    scheduleCpuUtilizationTask();
   }
 
   public synchronized void reset() {
     if (executor != null) {
       Log.d(TAG, "reset");
       resetStat();
       cpuOveruse = false;
     }
   }
 
   public synchronized int getCpuUsageCurrent() {
     return doubleToPercent(userCpuUsage.getCurrent() + systemCpuUsage.getCurrent());
   }
 
   public synchronized int getCpuUsageAverage() {
     return doubleToPercent(userCpuUsage.getAverage() + systemCpuUsage.getAverage());
   }
 
   public synchronized int getFrequencyScaleAverage() {
     return doubleToPercent(frequencyScale.getAverage());
   }
 
   private void scheduleCpuUtilizationTask() {
-    executor.cancelScheduledTasks();
+    if (executor != null) {
+      executor.shutdownNow();
+      executor = null;
+    }
+
+    executor = Executors.newSingleThreadScheduledExecutor();
     executor.scheduleAtFixedRate(new Runnable() {
       @Override
       public void run() {
         cpuUtilizationTask();
       }
-    }, CPU_STAT_SAMPLE_PERIOD_MS);
+    }, 0, CPU_STAT_SAMPLE_PERIOD_MS, TimeUnit.MILLISECONDS);
   }
 
   private void cpuUtilizationTask() {
     boolean cpuMonitorAvailable = sampleCpuUtilization();
     if (cpuMonitorAvailable
         && SystemClock.elapsedRealtime() - lastStatLogTimeMs >= CPU_STAT_LOG_PERIOD_MS) {
       lastStatLogTimeMs = SystemClock.elapsedRealtime();
       String statString = getStatString();
       Log.d(TAG, statString);
     }
@@ skipping 274 matching lines @@
     } catch (FileNotFoundException e) {
       Log.e(TAG, "Cannot open /proc/stat for reading", e);
       return null;
     } catch (IOException e) {
       Log.e(TAG, "Problems reading /proc/stat", e);
       return null;
     }
     return new ProcStat(userTime, systemTime, idleTime);
   }
 }