diff --git a/src/com/android/loganalysis/item/InterruptItem.java b/src/com/android/loganalysis/item/InterruptItem.java
index 1169004e85de527ef62f4f928753f36ba44ffe5e..4ff7662fe8b01464e10ae5eaf3ab855abe72de17 100644
--- a/src/com/android/loganalysis/item/InterruptItem.java
+++ b/src/com/android/loganalysis/item/InterruptItem.java
@@ -124,6 +124,13 @@ public class InterruptItem implements IItem {
return interrupts;
}
+ /**
+ * Get a list of {@link InterruptInfoItem} objects
+ */
+ public List<InterruptInfoItem> getInterrupts() {
+ return (List<InterruptInfoItem>) mInterrupts;
+ }
+
/**
* {@inheritDoc}
*/
diff --git a/src/com/android/loganalysis/parser/InterruptParser.java b/src/com/android/loganalysis/parser/InterruptParser.java
index 26417c481bc7218f0630cc8c53297673bdb800ce..27ccc4c07424cf75187dfa7f26706349f097b765 100644
--- a/src/com/android/loganalysis/parser/InterruptParser.java
+++ b/src/com/android/loganalysis/parser/InterruptParser.java
@@ -70,7 +70,7 @@ public class InterruptParser implements IParser {
}
private InterruptCategory getInterruptCategory(String interruptName) {
- if (interruptName.contains("bcmsdh_sdmmc")) {
+ if (interruptName.contains("bcmsdh_sdmmc") || interruptName.contains("msm_pcie_wake")) {
return InterruptCategory.WIFI_INTERRUPT;
} else if (interruptName.contains("smd-modem") ||
interruptName.contains("smsm-modem")) {
diff --git a/src/com/android/loganalysis/rule/InterruptRule.java b/src/com/android/loganalysis/rule/InterruptRule.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab8e678f8c9631aaa9863859b08c2b1b8ac5fce6
--- /dev/null
+++ b/src/com/android/loganalysis/rule/InterruptRule.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.loganalysis.rule;
+
+import com.android.loganalysis.item.BugreportItem;
+import com.android.loganalysis.item.InterruptItem;
+import com.android.loganalysis.item.InterruptItem.InterruptInfoItem;
+import com.android.loganalysis.item.InterruptItem.InterruptCategory;
+
+import java.util.concurrent.TimeUnit;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Rules definition for Interrupt rule
+ */
+public class InterruptRule extends AbstractPowerRule {
+
+ private static final String INTERRUPT_ANALYSIS = "INTERRUPT_ANALYSIS";
+ private static final long INTERRUPT_THRESHOLD_MS = 120000;
+
+ private List<InterruptInfoItem> mOffendingInterruptsList;
+
+ public InterruptRule (BugreportItem bugreportItem) {
+ super(bugreportItem);
+ }
+
+ @Override
+ public void applyRule() {
+ mOffendingInterruptsList = new ArrayList<InterruptInfoItem>();
+ InterruptItem interruptItem = getDetailedAnalysisItem().getInterruptItem();
+ if (interruptItem == null || getTimeOnBattery() < 0) {
+ return;
+ }
+ for (InterruptInfoItem interrupts : interruptItem.getInterrupts()) {
+ final long interruptsPerMs = getTimeOnBattery()/interrupts.getInterruptCount();
+ if (interruptsPerMs < INTERRUPT_THRESHOLD_MS) {
+ mOffendingInterruptsList.add(interrupts);
+ }
+ }
+ }
+
+ @Override
+ public JSONObject getAnalysis() {
+ JSONObject interruptAnalysis = new JSONObject();
+ StringBuilder analysis = new StringBuilder();
+ if (mOffendingInterruptsList == null || mOffendingInterruptsList.size() <= 0) {
+ analysis.append(String.format(
+ "No interrupts woke up device more frequent than %d secs.",
+ TimeUnit.MILLISECONDS.toSeconds(INTERRUPT_THRESHOLD_MS)));
+ } else {
+ for (InterruptInfoItem interrupts : mOffendingInterruptsList) {
+ if (interrupts.getCategory() != InterruptCategory.UNKNOWN_INTERRUPT) {
+ analysis.append(String.format("Frequent interrupts from %s (%s). ",
+ interrupts.getCategory(),
+ interrupts.getName()));
+ } else {
+ analysis.append(String.format("Frequent interrupts from %s. ",
+ interrupts.getName()));
+ }
+ }
+ }
+ try {
+ interruptAnalysis.put(INTERRUPT_ANALYSIS, analysis.toString().trim());
+ } catch (JSONException e) {
+ // do nothing
+ }
+ return interruptAnalysis;
+ }
+}
diff --git a/src/com/android/loganalysis/rule/LocationUsageRule.java b/src/com/android/loganalysis/rule/LocationUsageRule.java
index 71defa235b1bff7d0fb1bf4cfd59fadb1453ffab..ad208aa58cd6c7a14928812d5d7eb76f8b7b098d 100644
--- a/src/com/android/loganalysis/rule/LocationUsageRule.java
+++ b/src/com/android/loganalysis/rule/LocationUsageRule.java
@@ -21,13 +21,15 @@ import com.android.loganalysis.item.LocationDumpsItem;
import com.android.loganalysis.item.LocationDumpsItem.LocationInfoItem;
import java.util.concurrent.TimeUnit;
+import java.util.ArrayList;
+import java.util.List;
import org.json.JSONException;
import org.json.JSONObject;
/**
- * Rules definition for Process usage
+ * Rules definition for Location usage
*/
public class LocationUsageRule extends AbstractPowerRule {
@@ -36,48 +38,58 @@ public class LocationUsageRule extends AbstractPowerRule {
// GSA requests for location every 285 seconds, anything more frequent is an issue
private static final int LOCATION_INTERVAL_THRESHOLD = 285;
- private StringBuffer mAnalysisBuffer;
-
- private BugreportItem mBugreportItem = null;
+ private List<LocationInfoItem> mOffendingLocationRequestList;
+ private BugreportItem mBugreportItem;
public LocationUsageRule (BugreportItem bugreportItem) {
super(bugreportItem);
mBugreportItem = bugreportItem;
}
-
@Override
public void applyRule() {
- mAnalysisBuffer = new StringBuffer();
+ mOffendingLocationRequestList = new ArrayList<LocationInfoItem>();
+ if (mBugreportItem.getActivityService() == null || getTimeOnBattery() <= 0) {
+ return;
+ }
LocationDumpsItem locationDumpsItem = mBugreportItem.getActivityService()
.getLocationDumps();
+ if (locationDumpsItem == null) {
+ return;
+ }
final long locationRequestThresholdMs = (long) (getTimeOnBattery() *
LOCATION_REQUEST_DURATION_THRESHOLD);
- if (locationDumpsItem != null) {
- for (LocationInfoItem locationClient : locationDumpsItem.getLocationClients()) {
- final String packageName = locationClient.getPackage();
- final String priority = locationClient.getPriority();
- final int effectiveIntervalSec = locationClient.getEffectiveInterval();
- if (effectiveIntervalSec < LOCATION_INTERVAL_THRESHOLD &&
- !priority.equals("PRIORITY_NO_POWER") &&
- (TimeUnit.MINUTES.toMillis(locationClient.getDuration()) >
- locationRequestThresholdMs)) {
- mAnalysisBuffer.append(String.format("Package %s is requesting for location "
- + "updates every %d secs with priority %s", packageName,
- effectiveIntervalSec, priority));
- }
+
+ for (LocationInfoItem locationClient : locationDumpsItem.getLocationClients()) {
+ final String priority = locationClient.getPriority();
+ final int effectiveIntervalSec = locationClient.getEffectiveInterval();
+ if (effectiveIntervalSec < LOCATION_INTERVAL_THRESHOLD &&
+ !priority.equals("PRIORITY_NO_POWER") &&
+ (TimeUnit.MINUTES.toMillis(locationClient.getDuration()) >
+ locationRequestThresholdMs)) {
+ mOffendingLocationRequestList.add(locationClient);
}
}
}
@Override
public JSONObject getAnalysis() {
- JSONObject usageAnalysis = new JSONObject();
+ JSONObject locationAnalysis = new JSONObject();
+ StringBuilder analysis = new StringBuilder();
+ if (mOffendingLocationRequestList == null || mOffendingLocationRequestList.size() <= 0) {
+ analysis.append("No apps requested for frequent location updates. ");
+ } else {
+ for (LocationInfoItem locationClient : mOffendingLocationRequestList) {
+ analysis.append(String.format("Package %s is requesting for location "
+ +"updates every %d secs with priority %s.", locationClient.getPackage(),
+ locationClient.getEffectiveInterval(), locationClient.getPriority()));
+ }
+ }
try {
- usageAnalysis.put(LOCATION_USAGE_ANALYSIS, mAnalysisBuffer.toString());
+ locationAnalysis.put(LOCATION_USAGE_ANALYSIS, analysis.toString().trim());
} catch (JSONException e) {
// do nothing
}
- return usageAnalysis;
+ return locationAnalysis;
}
}
diff --git a/src/com/android/loganalysis/rule/ProcessUsageRule.java b/src/com/android/loganalysis/rule/ProcessUsageRule.java
index 4e15aee1d2ef7d5efab824f3536d9e7ebd114199..876bdd101354348bc3041617917da0915e8f0d9b 100644
--- a/src/com/android/loganalysis/rule/ProcessUsageRule.java
+++ b/src/com/android/loganalysis/rule/ProcessUsageRule.java
@@ -17,9 +17,14 @@
package com.android.loganalysis.rule;
import com.android.loganalysis.item.BugreportItem;
-import com.android.loganalysis.item.DumpsysProcStatsItem;
import com.android.loganalysis.item.ProcessUsageItem;
import com.android.loganalysis.item.ProcessUsageItem.ProcessUsageInfoItem;
+import com.android.loganalysis.item.ProcessUsageItem.SensorInfoItem;
+
+import com.android.loganalysis.util.NumberFormattingUtil;
+
+import java.util.ArrayList;
+import java.util.List;
import org.json.JSONException;
import org.json.JSONObject;
@@ -30,10 +35,13 @@ import org.json.JSONObject;
*/
public class ProcessUsageRule extends AbstractPowerRule {
- private static final String PROCESS_USAGE_ANALYSIS = "PROCESS_USAGE_ANALYSIS";
+ private static final String ALARM_USAGE_ANALYSIS = "ALARM_USAGE_ANALYSIS";
+ private static final String SENSOR_USAGE_ANALYSIS = "SENSOR_USAGE_ANALYSIS";
private static final long ALARM_THRESHOLD = 60000;
+ private static final float SENSOR_ACTIVE_TIME_THRESHOLD_PERCENTAGE = 0.1f; // 10%
- private StringBuffer mAnalysisBuffer;
+ private List<ProcessUsageInfoItem> mOffendingAlarmList;
+ private List<ProcessUsageInfoItem> mOffendingSensorList;
public ProcessUsageRule (BugreportItem bugreportItem) {
super(bugreportItem);
@@ -42,34 +50,70 @@ public class ProcessUsageRule extends AbstractPowerRule {
@Override
public void applyRule() {
- mAnalysisBuffer = new StringBuffer();
+ mOffendingAlarmList = new ArrayList<ProcessUsageInfoItem>();
+ mOffendingSensorList = new ArrayList<ProcessUsageInfoItem>();
+
ProcessUsageItem processUsageItem = getDetailedAnalysisItem().getProcessUsageItem();
- DumpsysProcStatsItem procStatsItem = getProcStatsItem();
- if (processUsageItem != null && procStatsItem!= null) {
+ if (processUsageItem != null && getTimeOnBattery() > 0) {
for (ProcessUsageInfoItem usage : processUsageItem.getProcessUsage()) {
if (usage.getAlarmWakeups() > 0) {
- final long alarmsPerMs = getTimeOnBattery()/usage.getAlarmWakeups();
- if (alarmsPerMs < ALARM_THRESHOLD) {
- final String processName = procStatsItem.get(usage.getProcessUID());
- if (processName != null) {
- mAnalysisBuffer.append(processName);
- } else {
- mAnalysisBuffer.append(usage.getProcessUID());
- }
- mAnalysisBuffer.append(" has requested frequent repeating alarms");
- }
+ addAlarmAnalysis(usage);
+ }
+ if (usage.getSensorUsage() != null && usage.getSensorUsage().size() > 0) {
+ addSensorAnalysis(usage);
}
}
}
}
+ private void addAlarmAnalysis(ProcessUsageInfoItem usage) {
+ final long alarmsPerMs = getTimeOnBattery()/usage.getAlarmWakeups();
+ if (alarmsPerMs < ALARM_THRESHOLD) {
+ mOffendingAlarmList.add(usage);
+ }
+ }
+
+ private void addSensorAnalysis(ProcessUsageInfoItem usage) {
+ final long sensorUsageThresholdMs = (long) (getTimeOnBattery()
+ * SENSOR_ACTIVE_TIME_THRESHOLD_PERCENTAGE);
+ for (SensorInfoItem sensorInfo : usage.getSensorUsage()) {
+ if (sensorInfo.getUsageDurationMs() > sensorUsageThresholdMs) {
+ mOffendingSensorList.add(usage);
+ }
+ }
+ }
+
@Override
public JSONObject getAnalysis() {
JSONObject usageAnalysis = new JSONObject();
+ StringBuilder alarmAnalysis = new StringBuilder();
+ if (mOffendingAlarmList == null || mOffendingAlarmList.size() <= 0) {
+ alarmAnalysis.append("No apps requested for alarms more frequent than 60 secs.");
+ } else {
+ for (ProcessUsageInfoItem alarmInfo : mOffendingAlarmList) {
+ alarmAnalysis.append(String.format(
+ "UID %s has requested frequent repeating alarms. ",
+ alarmInfo.getProcessUID()));
+ }
+ }
+ StringBuilder sensorAnalysis = new StringBuilder();
+ if (mOffendingSensorList == null || mOffendingSensorList.size() <= 0) {
+ sensorAnalysis.append("No apps used sensors more than 10% time on battery.");
+ } else {
+ for (ProcessUsageInfoItem sensorInfo : mOffendingSensorList) {
+ for (SensorInfoItem sensors : sensorInfo.getSensorUsage()) {
+ sensorAnalysis.append(String.format("sensor %s was used for %s by UID %s. ",
+ sensors.getSensorName(),
+ NumberFormattingUtil.getDuration(sensors.getUsageDurationMs()),
+ sensorInfo.getProcessUID()));
+ }
+ }
+ }
try {
- usageAnalysis.put(PROCESS_USAGE_ANALYSIS, mAnalysisBuffer.toString());
+ usageAnalysis.put(ALARM_USAGE_ANALYSIS, alarmAnalysis.toString().trim());
+ usageAnalysis.put(SENSOR_USAGE_ANALYSIS, sensorAnalysis.toString().trim());
} catch (JSONException e) {
- // do nothing
+ // do nothing
}
return usageAnalysis;
}
diff --git a/src/com/android/loganalysis/rule/RuleEngine.java b/src/com/android/loganalysis/rule/RuleEngine.java
index 61c2081c7325c4c1cfe2bdca1765f7b9def2b00b..728eeb8f81a006c648938362be62a6dfffb8c41d 100644
--- a/src/com/android/loganalysis/rule/RuleEngine.java
+++ b/src/com/android/loganalysis/rule/RuleEngine.java
@@ -68,5 +68,6 @@ public class RuleEngine {
mRulesList.add(new ProcessUsageRule(mBugreportItem));
mRulesList.add(new LocationUsageRule(mBugreportItem));
mRulesList.add(new WifiStatsRule(mBugreportItem));
+ mRulesList.add(new InterruptRule(mBugreportItem));
}
}
diff --git a/src/com/android/loganalysis/rule/WakelockRule.java b/src/com/android/loganalysis/rule/WakelockRule.java
index b2db2cd6c8177a6c13f7da9bc7462fb0ea5c2319..3be02ee524ae2073e6d94a10fe556447a8bc46d0 100644
--- a/src/com/android/loganalysis/rule/WakelockRule.java
+++ b/src/com/android/loganalysis/rule/WakelockRule.java
@@ -21,6 +21,9 @@ import com.android.loganalysis.item.WakelockItem;
import com.android.loganalysis.item.WakelockItem.WakelockInfoItem;
import com.android.loganalysis.util.NumberFormattingUtil;
+import java.util.ArrayList;
+import java.util.List;
+
import org.json.JSONException;
import org.json.JSONObject;
@@ -32,25 +35,23 @@ public class WakelockRule extends AbstractPowerRule {
private static final String WAKELOCK_ANALYSIS = "WAKELOCK_ANALYSIS";
private static final float WAKELOCK_HELD_TIME_THRESHOLD_PERCENTAGE = 0.1f; // 10%
- private String mAnalysis = null;
+ private List<WakelockInfoItem> mOffendingWakelockList;
public WakelockRule (BugreportItem bugreportItem) {
super(bugreportItem);
}
- @SuppressWarnings("cast")
@Override
public void applyRule() {
+ mOffendingWakelockList = new ArrayList<WakelockInfoItem>();
WakelockItem wakelockItem = getDetailedAnalysisItem().getWakelockItem();
- if (wakelockItem != null) {
+ if (wakelockItem != null && getTimeOnBattery() > 0) {
long wakelockThreshold = (long)(getTimeOnBattery()
* WAKELOCK_HELD_TIME_THRESHOLD_PERCENTAGE);
for (WakelockInfoItem wakelocks : wakelockItem.getWakeLocks()) {
if (wakelocks.getHeldTime() > wakelockThreshold) {
- mAnalysis = String.format("%s %s is held for %s", wakelocks.getName(),
- wakelocks.getCategory(),
- NumberFormattingUtil.getDuration(wakelocks.getHeldTime()));
+ mOffendingWakelockList.add(wakelocks);
}
}
}
@@ -59,10 +60,19 @@ public class WakelockRule extends AbstractPowerRule {
@Override
public JSONObject getAnalysis() {
JSONObject wakelockAnalysis = new JSONObject();
- try {
- if (mAnalysis != null) {
- wakelockAnalysis.put(WAKELOCK_ANALYSIS, mAnalysis);
+
+ StringBuilder analysis = new StringBuilder();
+ if (mOffendingWakelockList == null || mOffendingWakelockList.size() <= 0) {
+ analysis.append("No wakelocks were held for more than 10% of time on battery.");
+ } else {
+ for (WakelockInfoItem wakelocks : mOffendingWakelockList) {
+ analysis.append(String.format("%s %s is held for %s. ", wakelocks.getName(),
+ wakelocks.getCategory(),
+ NumberFormattingUtil.getDuration(wakelocks.getHeldTime())));
}
+ }
+ try {
+ wakelockAnalysis.put(WAKELOCK_ANALYSIS, analysis.toString().trim());
} catch (JSONException e) {
// do nothing
}
diff --git a/src/com/android/loganalysis/rule/WifiStatsRule.java b/src/com/android/loganalysis/rule/WifiStatsRule.java
index 4a205202236f6bfb846fa7aa466bdfc31a866219..f9bca3914edbe2b87da8ffa8d8d515ad1f09e95e 100644
--- a/src/com/android/loganalysis/rule/WifiStatsRule.java
+++ b/src/com/android/loganalysis/rule/WifiStatsRule.java
@@ -25,7 +25,7 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
- * Rules definition for Process usage
+ * Rules definition for Wifi stats
*/
public class WifiStatsRule extends AbstractPowerRule {
@@ -34,7 +34,9 @@ public class WifiStatsRule extends AbstractPowerRule {
// Wifi scans are scheduled by GSA every 285 seconds, anything more frequent is an issue
private static final long WIFI_SCAN_INTERVAL_THRESHOLD_MS = 285000;
- private StringBuffer mAnalysisBuffer;
+ private long mFrequentWifiScansIntervalSecs = 0;
+ private int mNumFrequentWifiDisconnects = 0;
+
private BugreportItem mBugreportItem = null;
public WifiStatsRule (BugreportItem bugreportItem) {
@@ -44,7 +46,6 @@ public class WifiStatsRule extends AbstractPowerRule {
@Override
public void applyRule() {
- mAnalysisBuffer = new StringBuffer();
if (mBugreportItem.getDumpsys() == null || getTimeOnBattery() <= 0) {
return;
}
@@ -57,21 +58,33 @@ public class WifiStatsRule extends AbstractPowerRule {
dumpsysWifiStatsItem.getNumWifiScans();
if (observedWifiScanIntervalMs < WIFI_SCAN_INTERVAL_THRESHOLD_MS) {
- mAnalysisBuffer.append(String.format("Wifi scans happened every %d seconds.",
- TimeUnit.MILLISECONDS.toSeconds(observedWifiScanIntervalMs)));
- }
- if (dumpsysWifiStatsItem.getNumWifiDisconnects() >= WIFI_DISCONNECT_THRESHOLD) {
- mAnalysisBuffer.append(String.format("Wifi got disconnected %d times",
- dumpsysWifiStatsItem.getNumWifiDisconnects()));
+ mFrequentWifiScansIntervalSecs = TimeUnit.MILLISECONDS.toSeconds(
+ observedWifiScanIntervalMs);
}
}
+ if (dumpsysWifiStatsItem.getNumWifiDisconnects() >= WIFI_DISCONNECT_THRESHOLD) {
+ mNumFrequentWifiDisconnects = dumpsysWifiStatsItem.getNumWifiDisconnects();
+ }
}
@Override
public JSONObject getAnalysis() {
JSONObject wifiStatsAnalysis = new JSONObject();
+ StringBuilder analysis = new StringBuilder();
+ if (mFrequentWifiScansIntervalSecs == 0) {
+ analysis.append("No apps requested for frequent wifi scans. ");
+ } else {
+ analysis.append(String.format("Wifi scans happened every %d seconds. ",
+ mFrequentWifiScansIntervalSecs));
+ }
+ if (mNumFrequentWifiDisconnects == 0) {
+ analysis.append("No frequent wifi disconnects were observed. ");
+ } else {
+ analysis.append(String.format("Wifi got disconnected %d times. ",
+ mNumFrequentWifiDisconnects));
+ }
try {
- wifiStatsAnalysis.put(WIFI_STATS, mAnalysisBuffer.toString());
+ wifiStatsAnalysis.put(WIFI_STATS, analysis.toString().trim());
} catch (JSONException e) {
// do nothing
}
diff --git a/tests/src/com/android/loganalysis/rule/InterruptRuleTest.java b/tests/src/com/android/loganalysis/rule/InterruptRuleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a08db09bf246d8aa33097d6a51048f81cf48902
--- /dev/null
+++ b/tests/src/com/android/loganalysis/rule/InterruptRuleTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.loganalysis.rule;
+
+import com.android.loganalysis.item.BatteryStatsDetailedInfoItem;
+import com.android.loganalysis.item.BugreportItem;
+import com.android.loganalysis.item.DumpsysBatteryStatsItem;
+import com.android.loganalysis.item.DumpsysItem;
+import com.android.loganalysis.item.InterruptItem;
+import com.android.loganalysis.item.InterruptItem.InterruptCategory;
+
+import junit.framework.TestCase;
+
+import org.json.JSONObject;
+
+/**
+ * Unit tests for {@link InterruptRule}
+ */
+public class InterruptRuleTest extends TestCase {
+
+ BugreportItem mBugreport;
+ DumpsysItem mDumpsys;
+ DumpsysBatteryStatsItem mDumpsysBatteryStats;
+ BatteryStatsDetailedInfoItem mBatteryStatsDetailedInfo;
+
+ @Override
+ public void setUp() {
+ mBugreport = new BugreportItem();
+ mDumpsys = new DumpsysItem();
+ mDumpsysBatteryStats = new DumpsysBatteryStatsItem();
+ mBatteryStatsDetailedInfo = new BatteryStatsDetailedInfoItem();
+
+ mBatteryStatsDetailedInfo.setTimeOnBattery(3902004);
+ mDumpsysBatteryStats.setDetailedBatteryStatsItem(mBatteryStatsDetailedInfo);
+ mDumpsys.setBatteryInfo(mDumpsysBatteryStats);
+ mBugreport.setDumpsys(mDumpsys);
+ }
+
+ /**
+ * Test interrupt analysis
+ */
+ public void testInterruptAnalysis() throws Exception {
+ InterruptItem interrupt = new InterruptItem();
+ interrupt.addInterrupt("2:bcmsdh_sdmmc:2:qcom,smd:2:msmgio", 40,
+ InterruptCategory.WIFI_INTERRUPT);
+ interrupt.addInterrupt("2:qcom,smd-rpm:2:fc4c.qcom,spmi", 7,
+ InterruptCategory.UNKNOWN_INTERRUPT);
+
+ mBatteryStatsDetailedInfo.setInterruptItem(interrupt);
+
+ InterruptRule interruptRule = new InterruptRule(mBugreport);
+ interruptRule.applyRule();
+ JSONObject analysis = interruptRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("INTERRUPT_ANALYSIS"));
+ assertEquals(analysis.getString("INTERRUPT_ANALYSIS"),
+ "Frequent interrupts from WIFI_INTERRUPT (2:bcmsdh_sdmmc:2:qcom,smd:2:msmgio).");
+ }
+
+
+ public void testNoSignificantInterruptAnalysis() throws Exception {
+ InterruptItem interrupt = new InterruptItem();
+ interrupt.addInterrupt("2:bcmsdh_sdmmc:2:qcom,smd:2:msmgio", 5,
+ InterruptCategory.WIFI_INTERRUPT);
+ interrupt.addInterrupt("2:qcom,smd-rpm:2:fc4c.qcom,spmi", 7,
+ InterruptCategory.UNKNOWN_INTERRUPT);
+
+ mBatteryStatsDetailedInfo.setInterruptItem(interrupt);
+
+ InterruptRule interruptRule = new InterruptRule(mBugreport);
+ interruptRule.applyRule();
+ JSONObject analysis = interruptRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("INTERRUPT_ANALYSIS"));
+ assertEquals(analysis.getString("INTERRUPT_ANALYSIS"),
+ "No interrupts woke up device more frequent than 120 secs.");
+ }
+
+ public void testMissingInterruptAnalysis() throws Exception {
+ InterruptRule interruptRule = new InterruptRule(mBugreport);
+ interruptRule.applyRule();
+ JSONObject analysis = interruptRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("INTERRUPT_ANALYSIS"));
+ assertEquals(analysis.getString("INTERRUPT_ANALYSIS"),
+ "No interrupts woke up device more frequent than 120 secs.");
+ }
+}
diff --git a/tests/src/com/android/loganalysis/rule/LocationUsageRuleTest.java b/tests/src/com/android/loganalysis/rule/LocationUsageRuleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5dd7e9e58a17aab436dbd4456e0d4260078ff0a7
--- /dev/null
+++ b/tests/src/com/android/loganalysis/rule/LocationUsageRuleTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.loganalysis.rule;
+
+import com.android.loganalysis.item.ActivityServiceItem;
+import com.android.loganalysis.item.BatteryStatsDetailedInfoItem;
+import com.android.loganalysis.item.BugreportItem;
+import com.android.loganalysis.item.DumpsysBatteryStatsItem;
+import com.android.loganalysis.item.DumpsysItem;
+import com.android.loganalysis.item.LocationDumpsItem;
+
+import junit.framework.TestCase;
+
+import org.json.JSONObject;
+
+/**
+ * Unit tests for {@link LocationUsageRule}
+ */
+public class LocationUsageRuleTest extends TestCase {
+
+ BugreportItem mBugreport;
+ DumpsysItem mDumpsys;
+ DumpsysBatteryStatsItem mDumpsysBatteryStats;
+ BatteryStatsDetailedInfoItem mBatteryStatsDetailedInfo;
+ ActivityServiceItem mActivityService;
+
+ @Override
+ public void setUp() {
+ mBugreport = new BugreportItem();
+ mDumpsys = new DumpsysItem();
+ mDumpsysBatteryStats = new DumpsysBatteryStatsItem();
+ mBatteryStatsDetailedInfo = new BatteryStatsDetailedInfoItem();
+ mActivityService = new ActivityServiceItem();
+
+ mBatteryStatsDetailedInfo.setTimeOnBattery(3902004);
+ mDumpsysBatteryStats.setDetailedBatteryStatsItem(mBatteryStatsDetailedInfo);
+ mDumpsys.setBatteryInfo(mDumpsysBatteryStats);
+ mBugreport.setDumpsys(mDumpsys);
+ mBugreport.setActivityService(mActivityService);
+ }
+
+ /**
+ * Test location usage analysis
+ */
+ public void testLocationUsageAnalysis() throws Exception {
+ LocationDumpsItem location = new LocationDumpsItem();
+ location.addLocationClient("com.google.android.gms", 1, 0, 0, "PRIORITY_NO_POWER", 140);
+ location.addLocationClient("com.google.android.gms", 5, 5, 5,
+ "PRIORITY_BALANCED_POWER_ACCURACY", 140);
+ mActivityService.setLocationDumps(location);
+
+ LocationUsageRule locationUsageRule = new LocationUsageRule(mBugreport);
+ locationUsageRule.applyRule();
+ JSONObject analysis = locationUsageRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("LOCATION_USAGE_ANALYSIS"));
+ assertEquals(analysis.getString("LOCATION_USAGE_ANALYSIS"),
+ "Package com.google.android.gms is requesting for location updates every 5 secs "
+ + "with priority PRIORITY_BALANCED_POWER_ACCURACY.");
+ }
+
+ public void testNoSignificantLocationUsageAnalysis() throws Exception {
+ LocationDumpsItem location = new LocationDumpsItem();
+ location.addLocationClient("com.google.android.gms", 1, 0, 0, "PRIORITY_NO_POWER", 140);
+ location.addLocationClient("com.google.android.gms", 285, 285, 285,
+ "PRIORITY_BALANCED_POWER_ACCURACY", 140);
+ mActivityService.setLocationDumps(location);
+
+ LocationUsageRule locationUsageRule = new LocationUsageRule(mBugreport);
+ locationUsageRule.applyRule();
+ JSONObject analysis = locationUsageRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("LOCATION_USAGE_ANALYSIS"));
+ assertEquals(analysis.getString("LOCATION_USAGE_ANALYSIS"),
+ "No apps requested for frequent location updates.");
+ }
+
+ public void testNoLocationUsageAnalysis() throws Exception {
+ LocationUsageRule locationUsageRule = new LocationUsageRule(mBugreport);
+ locationUsageRule.applyRule();
+ JSONObject analysis = locationUsageRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("LOCATION_USAGE_ANALYSIS"));
+ assertEquals(analysis.getString("LOCATION_USAGE_ANALYSIS"),
+ "No apps requested for frequent location updates.");
+ }
+}
diff --git a/tests/src/com/android/loganalysis/rule/ProcessUsageRuleTest.java b/tests/src/com/android/loganalysis/rule/ProcessUsageRuleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc322dc81737c97768d075340fddf71739304eb6
--- /dev/null
+++ b/tests/src/com/android/loganalysis/rule/ProcessUsageRuleTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.loganalysis.rule;
+
+import com.android.loganalysis.item.BatteryStatsDetailedInfoItem;
+import com.android.loganalysis.item.BugreportItem;
+import com.android.loganalysis.item.DumpsysBatteryStatsItem;
+import com.android.loganalysis.item.DumpsysItem;
+import com.android.loganalysis.item.ProcessUsageItem;
+import com.android.loganalysis.item.ProcessUsageItem.SensorInfoItem;
+
+import java.util.LinkedList;
+import junit.framework.TestCase;
+
+import org.json.JSONObject;
+
+/**
+ * Unit tests for {@link ProcessUsageRule}
+ */
+public class ProcessUsageRuleTest extends TestCase {
+
+ BugreportItem mBugreport;
+ DumpsysItem mDumpsys;
+ DumpsysBatteryStatsItem mDumpsysBatteryStats;
+ BatteryStatsDetailedInfoItem mBatteryStatsDetailedInfo;
+
+ @Override
+ public void setUp() {
+ mBugreport = new BugreportItem();
+ mDumpsys = new DumpsysItem();
+ mDumpsysBatteryStats = new DumpsysBatteryStatsItem();
+ mBatteryStatsDetailedInfo = new BatteryStatsDetailedInfoItem();
+
+ mBatteryStatsDetailedInfo.setTimeOnBattery(3902004);
+ mDumpsysBatteryStats.setDetailedBatteryStatsItem(mBatteryStatsDetailedInfo);
+ mDumpsys.setBatteryInfo(mDumpsysBatteryStats);
+ mBugreport.setDumpsys(mDumpsys);
+ }
+
+ /**
+ * Test alarm usage analysis
+ */
+ public void testAlarmAnalysis() throws Exception {
+ ProcessUsageItem processUsage = new ProcessUsageItem();
+ LinkedList<SensorInfoItem> uid0Sensor = new LinkedList<SensorInfoItem>();
+ uid0Sensor.add(new SensorInfoItem("0", 9908));
+ uid0Sensor.add(new SensorInfoItem("1", 9997));
+
+ LinkedList<SensorInfoItem> uidU0a9Sensor = new LinkedList<SensorInfoItem>();
+ uidU0a9Sensor.add(new SensorInfoItem("2", 1315));
+
+ processUsage.addProcessUsage("0", 0, uid0Sensor);
+ processUsage.addProcessUsage("u0a9", 180, uidU0a9Sensor);
+ processUsage.addProcessUsage("u0a8", 0, null);
+
+ mBatteryStatsDetailedInfo.setProcessUsageItem(processUsage);
+ ProcessUsageRule usage = new ProcessUsageRule(mBugreport);
+ usage.applyRule();
+ JSONObject analysis = usage.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("ALARM_USAGE_ANALYSIS"));
+ assertEquals(analysis.getString("ALARM_USAGE_ANALYSIS"),
+ "UID u0a9 has requested frequent repeating alarms.");
+ assertTrue(analysis.has("SENSOR_USAGE_ANALYSIS"));
+ assertEquals(analysis.getString("SENSOR_USAGE_ANALYSIS"),
+ "No apps used sensors more than 10% time on battery.");
+ }
+
+ /**
+ * Test sensor usage analysis
+ */
+ public void testSensorAnalysis() throws Exception {
+ ProcessUsageItem processUsage = new ProcessUsageItem();
+ LinkedList<SensorInfoItem> uid0Sensor = new LinkedList<SensorInfoItem>();
+ uid0Sensor.add(new SensorInfoItem("0", 9908));
+ uid0Sensor.add(new SensorInfoItem("1", 9997));
+
+ LinkedList<SensorInfoItem> uidU0a9Sensor = new LinkedList<SensorInfoItem>();
+ uidU0a9Sensor.add(new SensorInfoItem("2", 913015));
+
+ processUsage.addProcessUsage("0", 0, uid0Sensor);
+ processUsage.addProcessUsage("u0a9", 15, uidU0a9Sensor);
+ processUsage.addProcessUsage("u0a8", 0, null);
+
+ mBatteryStatsDetailedInfo.setProcessUsageItem(processUsage);
+ ProcessUsageRule usage = new ProcessUsageRule(mBugreport);
+ usage.applyRule();
+ JSONObject analysis = usage.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("SENSOR_USAGE_ANALYSIS"));
+ assertEquals(analysis.getString("SENSOR_USAGE_ANALYSIS"),
+ "sensor 2 was used for 0d 0h 15m 13s by UID u0a9.");
+
+ assertTrue(analysis.has("ALARM_USAGE_ANALYSIS"));
+ assertEquals(analysis.getString("ALARM_USAGE_ANALYSIS"),
+ "No apps requested for alarms more frequent than 60 secs.");
+ }
+}
diff --git a/tests/src/com/android/loganalysis/rule/WakelockRuleTest.java b/tests/src/com/android/loganalysis/rule/WakelockRuleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6900c07eb177252ce68835333efd31f067b91832
--- /dev/null
+++ b/tests/src/com/android/loganalysis/rule/WakelockRuleTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.loganalysis.rule;
+
+import com.android.loganalysis.item.BatteryStatsDetailedInfoItem;
+import com.android.loganalysis.item.BugreportItem;
+import com.android.loganalysis.item.DumpsysBatteryStatsItem;
+import com.android.loganalysis.item.DumpsysItem;
+import com.android.loganalysis.item.WakelockItem;
+import com.android.loganalysis.item.WakelockItem.WakeLockCategory;
+
+import junit.framework.TestCase;
+
+import org.json.JSONObject;
+
+/**
+ * Unit tests for {@link WakelockRule}
+ */
+public class WakelockRuleTest extends TestCase {
+
+ BugreportItem mBugreport;
+ DumpsysItem mDumpsys;
+ DumpsysBatteryStatsItem mDumpsysBatteryStats;
+ BatteryStatsDetailedInfoItem mBatteryStatsDetailedInfo;
+
+ @Override
+ public void setUp() {
+ mBugreport = new BugreportItem();
+ mDumpsys = new DumpsysItem();
+ mDumpsysBatteryStats = new DumpsysBatteryStatsItem();
+ mBatteryStatsDetailedInfo = new BatteryStatsDetailedInfoItem();
+
+ mBatteryStatsDetailedInfo.setTimeOnBattery(3902004);
+ mDumpsysBatteryStats.setDetailedBatteryStatsItem(mBatteryStatsDetailedInfo);
+ mDumpsys.setBatteryInfo(mDumpsysBatteryStats);
+ mBugreport.setDumpsys(mDumpsys);
+ }
+
+ /**
+ * Test wakelock analysis
+ */
+ public void testWakelockAnalysis() throws Exception {
+ WakelockItem wakelock = new WakelockItem();
+ wakelock.addWakeLock("PowerManagerService.WakeLocks", 310006, 2,
+ WakeLockCategory.KERNEL_WAKELOCK);
+ wakelock.addWakeLock("msm_serial_hs_rx", 133612, 258,
+ WakeLockCategory.KERNEL_WAKELOCK);
+
+ wakelock.addWakeLock("ProxyController", "1001", 3887565, 4,
+ WakeLockCategory.PARTIAL_WAKELOCK);
+ wakelock.addWakeLock("AudioMix", "1013", 1979, 3,
+ WakeLockCategory.PARTIAL_WAKELOCK);
+
+ mBatteryStatsDetailedInfo.setWakelockItem(wakelock);
+ WakelockRule wakelockRule = new WakelockRule(mBugreport);
+ wakelockRule.applyRule();
+ JSONObject analysis = wakelockRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("WAKELOCK_ANALYSIS"));
+ assertEquals(analysis.getString("WAKELOCK_ANALYSIS"),
+ "ProxyController PARTIAL_WAKELOCK is held for 0d 1h 4m 47s.");
+ }
+
+ public void testNoSignificantWakelockAnalysis() throws Exception {
+ WakelockItem wakelock = new WakelockItem();
+ wakelock.addWakeLock("PowerManagerService.WakeLocks", 310006, 2,
+ WakeLockCategory.KERNEL_WAKELOCK);
+ wakelock.addWakeLock("msm_serial_hs_rx", 133612, 258,
+ WakeLockCategory.KERNEL_WAKELOCK);
+
+ wakelock.addWakeLock("ProxyController", "1001", 287565, 4,
+ WakeLockCategory.PARTIAL_WAKELOCK);
+ wakelock.addWakeLock("AudioMix", "1013", 1979, 3,
+ WakeLockCategory.PARTIAL_WAKELOCK);
+
+ mBatteryStatsDetailedInfo.setWakelockItem(wakelock);
+ WakelockRule wakelockRule = new WakelockRule(mBugreport);
+ wakelockRule.applyRule();
+ JSONObject analysis = wakelockRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("WAKELOCK_ANALYSIS"));
+ assertEquals(analysis.getString("WAKELOCK_ANALYSIS"),
+ "No wakelocks were held for more than 10% of time on battery.");
+ }
+
+ public void testNoWakelockAnalysis() throws Exception {
+ WakelockRule wakelockRule = new WakelockRule(mBugreport);
+ wakelockRule.applyRule();
+ JSONObject analysis = wakelockRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("WAKELOCK_ANALYSIS"));
+ assertEquals(analysis.getString("WAKELOCK_ANALYSIS"),
+ "No wakelocks were held for more than 10% of time on battery.");
+ }
+}
diff --git a/tests/src/com/android/loganalysis/rule/WifiStatsRuleTest.java b/tests/src/com/android/loganalysis/rule/WifiStatsRuleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..628039e1226900c61d802579b78197b8119cfd56
--- /dev/null
+++ b/tests/src/com/android/loganalysis/rule/WifiStatsRuleTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.loganalysis.rule;
+
+import com.android.loganalysis.item.BatteryStatsDetailedInfoItem;
+import com.android.loganalysis.item.BugreportItem;
+import com.android.loganalysis.item.DumpsysBatteryStatsItem;
+import com.android.loganalysis.item.DumpsysItem;
+import com.android.loganalysis.item.DumpsysWifiStatsItem;
+import com.android.loganalysis.parser.BugreportParser;
+
+import java.util.Arrays;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+import org.json.JSONObject;
+
+/**
+ */
+public class WifiStatsRuleTest extends TestCase {
+
+ BugreportItem mBugreport;
+ DumpsysItem mDumpsys;
+ DumpsysBatteryStatsItem mDumpsysBatteryStats;
+ BatteryStatsDetailedInfoItem mBatteryStatsDetailedInfo;
+
+ @Override
+ public void setUp() {
+ mBugreport = new BugreportItem();
+ mDumpsys = new DumpsysItem();
+ mDumpsysBatteryStats = new DumpsysBatteryStatsItem();
+ mBatteryStatsDetailedInfo = new BatteryStatsDetailedInfoItem();
+
+ mBatteryStatsDetailedInfo.setTimeOnBattery(302004);
+ mDumpsysBatteryStats.setDetailedBatteryStatsItem(mBatteryStatsDetailedInfo);
+ mDumpsys.setBatteryInfo(mDumpsysBatteryStats);
+ mBugreport.setDumpsys(mDumpsys);
+ }
+
+ /**
+ * Test wifistats analysis
+ */
+ public void testWifiDisconnectAnalysis() throws Exception {
+ DumpsysWifiStatsItem wifiStats = new DumpsysWifiStatsItem();
+ wifiStats.setNumWifiDisconnect(1);
+ wifiStats.setNumWifiScan(0);
+
+ mDumpsys.setWifiStats(wifiStats);
+ WifiStatsRule wifiStatsRule = new WifiStatsRule(mBugreport);
+ wifiStatsRule.applyRule();
+ JSONObject analysis = wifiStatsRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("WIFI_STATS"));
+ assertEquals(analysis.getString("WIFI_STATS"),
+ "No apps requested for frequent wifi scans. Wifi got disconnected 1 times.");
+ }
+
+ public void testWifiScanAnalysis() throws Exception {
+ DumpsysWifiStatsItem wifiStats = new DumpsysWifiStatsItem();
+ wifiStats.setNumWifiDisconnect(0);
+ wifiStats.setNumWifiScan(3);
+
+ mDumpsys.setWifiStats(wifiStats);
+ WifiStatsRule wifiStatsRule = new WifiStatsRule(mBugreport);
+ wifiStatsRule.applyRule();
+ JSONObject analysis = wifiStatsRule.getAnalysis();
+ assertNotNull(analysis);
+ assertTrue(analysis.has("WIFI_STATS"));
+ assertEquals(analysis.getString("WIFI_STATS"),
+ "Wifi scans happened every 100 seconds. No frequent wifi disconnects were observed."
+ );
+ }
+}