func printResults(outputProto *bspb.BatteryStats, fileName string, dir string) {
	if outputProto == nil {
		fmt.Println("Inputs were identical.")
		return
	}

	fmt.Printf("\n################\n")
	fmt.Printf("Partial Wakelocks\n")
	fmt.Printf("################\n\n")
	var pwl []*checkinparse.WakelockInfo
	for _, app := range outputProto.App {
		for _, pw := range app.Wakelock {
			pwl = append(pwl, &checkinparse.WakelockInfo{
				Name:     fmt.Sprintf("%s : %s", app.GetName(), pw.GetName()),
				UID:      app.GetUid(),
				Duration: time.Duration(pw.GetPartialTimeMsec()) * time.Millisecond,
			})
		}
	}

	checkinparse.SortByAbsTime(pwl)
	for _, pw := range pwl[:min(10, len(pwl))] {
		fmt.Printf("%s (File1 uid=%d) %s\n", pw.Duration, pw.UID, pw.Name)
	}

	fmt.Printf("\n################\n")
	fmt.Printf("Kernel Wakelocks\n")
	fmt.Printf("################\n\n")
	var kwl []*checkinparse.WakelockInfo
	for _, kw := range outputProto.GetSystem().KernelWakelock {
		if kw.GetName() != "PowerManagerService.WakeLocks" {
			kwl = append(kwl, &checkinparse.WakelockInfo{
				Name:     kw.GetName(),
				Duration: time.Duration(kw.GetTimeMsec()) * time.Millisecond,
			})
		}
	}
	checkinparse.SortByAbsTime(kwl)
	for _, kw := range kwl[:min(10, len(kwl))] {
		fmt.Printf("%s %s\n", kw.Duration, kw.Name)
	}

	data, err := proto.Marshal(outputProto)
	if err != nil {
		log.Fatalf("Cannot marshal output proto: %v", err)
	}
	ioutil.WriteFile(fileName+".proto", data, 0600)
	ioutil.WriteFile(dir+"/"+fileName+".proto", data, 0600)
}
func parseAppStats(checkin *bspb.BatteryStats) []*bspb.BatteryStats_App {
	var as []*bspb.BatteryStats_App
	unknown := 1

	for _, a := range checkin.GetApp() {
		if a.GetName() == "" {
			a.Name = proto.String("UNKNOWN_" + strconv.Itoa(unknown))
			unknown++
		}
		as = append(as, a)
	}

	// Sort by name so that we can display the apps in alphabetical order in the dropdown.
	sort.Sort(byName(as))
	return as
}
Example #3
0
func parseAppStats(checkin *bspb.BatteryStats, sensors map[int32]bugreportutils.SensorInfo) []AppStat {
	var as []AppStat
	bCapMah := checkin.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah()

	for _, app := range checkin.GetApp() {
		a := AppStat{
			DevicePowerPrediction: 100 * float32(app.GetPowerUseItem().GetComputedPowerMah()) / bCapMah,
			RawStats:              app,
		}

		if app.GetName() == "" {
			app.Name = proto.String(fmt.Sprintf("UNKNOWN_%d", app.GetUid()))
		}

		// Only add it to AppStat if the CPU field exists and is therefore populated.
		if app.Cpu != nil {
			a.CPUPowerPrediction = 100 * (app.Cpu.GetPowerMaMs() / (1000 * 60 * 60)) / bCapMah
		}

		for _, u := range app.GetUserActivity() {
			a.UserActivity = append(a.UserActivity, userActivity{
				Type:  u.GetName().String(),
				Count: u.GetCount(),
			})
		}

		for _, s := range app.GetSensor() {
			sensor, ok := sensors[s.GetNumber()]
			if !ok {
				sensor = bugreportutils.SensorInfo{
					Name:   fmt.Sprintf("unknown sensor (#%d)", s.GetNumber()),
					Number: s.GetNumber(),
				}
			}
			sensor.TotalTimeMs = int64(s.GetTotalTimeMsec())
			sensor.Count = s.GetCount()
			a.Sensor = append(a.Sensor, sensor)
		}
		as = append(as, a)
	}

	// Sort by name so that we can display the apps in alphabetical order in the dropdown.
	sort.Sort(byName(as))
	return as
}
// ParseCheckinData creates a Checkin struct from the given aggregated battery stats.
func ParseCheckinData(c *bspb.BatteryStats) Checkin {
	if c == nil {
		return Checkin{}
	}

	realtime := time.Duration(c.System.Battery.GetBatteryRealtimeMsec()) * time.Millisecond

	out := Checkin{
		Device:           c.Build.GetDevice(),
		Build:            c.Build.GetBuildId(),
		BuildFingerprint: c.Build.GetFingerprint(),
		ReportVersion:    c.GetReportVersion(),

		Realtime:          realtime,
		ScreenOffRealtime: time.Duration(c.System.Battery.GetScreenOffRealtimeMsec()) * time.Millisecond,

		ScreenOffDischargePoints: c.System.BatteryDischarge.GetScreenOff(),
		ScreenOnDischargePoints:  c.System.BatteryDischarge.GetScreenOn(),

		EstimatedDischarge: c.System.PowerUseSummary.GetComputedPowerMah(),
		ActualDischarge:    (c.System.PowerUseSummary.GetMinDrainedPowerMah() + c.System.PowerUseSummary.GetMaxDrainedPowerMah()) / 2,

		// Uptime is the same as screen-off uptime + screen on time
		Uptime: MDuration{
			V: (time.Duration(c.System.Battery.GetBatteryUptimeMsec()) * time.Millisecond),
		},

		ScreenOffUptime: MDuration{
			V: (time.Duration(c.System.Battery.GetScreenOffUptimeMsec()) * time.Millisecond),
		},

		ScreenOnTime: MDuration{
			V: (time.Duration(c.System.Misc.GetScreenOnTimeMsec()) * time.Millisecond),
		},

		PartialWakelockTime: MDuration{
			V: (time.Duration(c.System.Misc.GetPartialWakelockTimeMsec()) * time.Millisecond),
		},

		KernelOverheadTime: MDuration{
			V: (time.Duration(c.System.Battery.GetScreenOffUptimeMsec()-c.System.Misc.GetPartialWakelockTimeMsec()) * time.Millisecond),
		},

		SignalScanningTime: MDuration{
			V: (time.Duration(c.System.SignalScanningTime.GetTimeMsec()) * time.Millisecond),
		},

		MobileActiveTime: MDuration{
			V: (time.Duration(c.System.Misc.GetMobileActiveTimeMsec()) * time.Millisecond),
		},

		PhoneCallTime: MDuration{
			V: (time.Duration(c.System.Misc.GetPhoneOnTimeMsec()) * time.Millisecond),
		},

		WifiOnTime: MDuration{
			V: (time.Duration(c.System.Misc.GetWifiOnTimeMsec()) * time.Millisecond),
		},

		DeviceIdleModeEnabledTime: MDuration{
			V: (time.Duration(c.System.Misc.GetDeviceIdleModeEnabledTimeMsec()) * time.Millisecond),
		},

		DeviceIdlingTime: MDuration{
			V: (time.Duration(c.System.Misc.GetDeviceIdlingTimeMsec()) * time.Millisecond),
		},

		FullWakelockTime: MDuration{
			V: (time.Duration(c.System.Misc.GetFullWakelockTimeMsec()) * time.Millisecond),
		},

		InteractiveTime: MDuration{
			V: (time.Duration(c.System.Misc.GetInteractiveTimeMsec()) * time.Millisecond),
		},

		BluetoothOnTime: MDuration{
			V: (time.Duration(c.System.Misc.GetBluetoothOnTimeMsec()) * time.Millisecond),
		},

		LowPowerModeEnabledTime: MDuration{
			V: (time.Duration(c.System.Misc.GetLowPowerModeEnabledTimeMsec()) * time.Millisecond),
		},
		ConnectivityChanges: c.System.Misc.GetConnectivityChanges(),
	}
	out.ScreenOffUptimePercentage = (float32(out.ScreenOffUptime.V) / float32(realtime)) * 100
	out.ScreenOnTimePercentage = (float32(out.ScreenOnTime.V) / float32(realtime)) * 100
	out.PartialWakelockTimePercentage = (float32(out.PartialWakelockTime.V) / float32(realtime)) * 100
	out.KernelOverheadTimePercentage = (float32(out.KernelOverheadTime.V) / float32(realtime)) * 100
	out.SignalScanningTimePercentage = (float32(out.SignalScanningTime.V) / float32(realtime)) * 100
	out.MobileActiveTimePercentage = (float32(out.MobileActiveTime.V) / float32(realtime)) * 100
	out.FullWakelockTimePercentage = (float32(out.FullWakelockTime.V) / float32(realtime)) * 100
	out.PhoneCallTimePercentage = (float32(out.PhoneCallTime.V) / float32(realtime)) * 100
	out.DeviceIdleModeEnabledTimePercentage = (float32(out.DeviceIdleModeEnabledTime.V) / float32(realtime)) * 100
	out.DeviceIdlingTimePercentage = (float32(out.DeviceIdlingTime.V) / float32(realtime)) * 100
	out.InteractiveTimePercentage = (float32(out.InteractiveTime.V) / float32(realtime)) * 100

	out.BluetoothOnTimePercentage = (float32(out.BluetoothOnTime.V) / float32(realtime)) * 100
	out.LowPowerModeEnabledTimePercentage = (float32(out.LowPowerModeEnabledTime.V) / float32(realtime)) * 100

	out.MobileKiloBytesPerHr = MFloat32{V: (c.System.GlobalNetwork.GetMobileBytesRx() + c.System.GlobalNetwork.GetMobileBytesTx()) / (1024 * float32(realtime.Hours()))}
	out.WifiKiloBytesPerHr = MFloat32{V: (c.System.GlobalNetwork.GetWifiBytesRx() + c.System.GlobalNetwork.GetWifiBytesTx()) / (1024 * float32(realtime.Hours()))}

	if c.GetReportVersion() >= 14 {
		out.WifiOnTime = MDuration{V: time.Duration(c.System.GlobalWifi.GetWifiOnTimeMsec()) * time.Millisecond}
		out.WifiOnTimePercentage = (float32(out.WifiOnTime.V) / float32(realtime)) * 100
		out.WifiIdleTime = MDuration{V: time.Duration(c.System.GlobalWifi.GetWifiIdleTimeMsec()) * time.Millisecond}
		out.WifiTransmitTime = MDuration{V: time.Duration(c.System.GlobalWifi.GetWifiRxTimeMsec()+c.System.GlobalWifi.GetWifiTxTimeMsec()) * time.Millisecond}
		out.WifiTransmitTimePercentage = (float32(out.WifiTransmitTime.V) / float32(realtime)) * 100
		out.WifiDischargePoints = 100 * c.System.GlobalWifi.GetWifiPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah()
		out.WifiDischargeRatePerHr = MFloat32{
			V: 100 * c.System.GlobalWifi.GetWifiPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah() / float32(realtime.Hours()),
		}

		out.BluetoothIdleTime = MDuration{V: time.Duration(c.System.GlobalBluetooth.GetBluetoothIdleTimeMsec()) * time.Millisecond}
		out.BluetoothTransmitTime = MDuration{V: time.Duration(c.System.GlobalBluetooth.GetBluetoothRxTimeMsec()+c.System.GlobalBluetooth.GetBluetoothTxTimeMsec()) * time.Millisecond}
		out.BluetoothTransmitTimePercentage = (float32(out.BluetoothTransmitTime.V) / float32(realtime)) * 100
		out.BluetoothDischargePoints = 100 * c.System.GlobalBluetooth.GetBluetoothPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah()
		out.BluetoothDischargeRatePerHr = MFloat32{
			V: 100 * c.System.GlobalBluetooth.GetBluetoothPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah() / float32(realtime.Hours()),
		}
	}

	if s := c.System.Battery.GetScreenOffRealtimeMsec(); s > 0 {
		out.ScreenOffDischargeRatePerHr = MFloat32{V: 60 * 60 * 1000 * c.System.BatteryDischarge.GetScreenOff() / s}
	}
	if s := c.System.Misc.GetScreenOnTimeMsec(); s > 0 {
		out.ScreenOnDischargeRatePerHr = MFloat32{V: 60 * 60 * 1000 * c.System.BatteryDischarge.GetScreenOn() / s}
	}
	// Screen Brightness.
	out.ScreenBrightness = make(map[string]float32)
	for _, sb := range c.System.ScreenBrightness {
		out.ScreenBrightness[sb.GetName().String()] += (sb.GetTimeMsec() / msecsInMinute) / float32(realtime.Hours())
	}
	// Signal Strength.
	out.SignalStrength = make(map[string]float32)
	for _, ss := range c.System.SignalStrength {
		out.SignalStrength[ss.GetName().String()] += (ss.GetTimeMsec() / msecsInMinute) / float32(realtime.Hours())
	}
	// Wifi Signal Strength.
	out.WifiSignalStrength = make(map[string]float32)
	for _, ws := range c.System.WifiSignalStrength {
		out.WifiSignalStrength[ws.GetName().String()] += (ws.GetTimeMsec() / msecsInMinute) / float32(realtime.Hours())
	}
	// Bluetooth States.
	out.BluetoothState = make(map[string]float32)
	for _, bs := range c.System.BluetoothState {
		out.BluetoothState[bs.GetName().String()] += (bs.GetTimeMsec() / msecsInMinute) / float32(realtime.Hours())

	}
	// DataConnection
	out.DataConnection = make(map[string]float32)
	for _, dc := range c.System.DataConnection {
		out.DataConnection[dc.GetName().String()] += (dc.GetTimeMsec() / msecsInMinute) / float32(realtime.Hours())
	}
	// Kernel Wakelocks.
	var kwl []*checkinparse.WakelockInfo
	for _, kw := range c.System.KernelWakelock {
		if kw.GetName() != "PowerManagerService.WakeLocks" && kw.GetTimeMsec() >= 0.01 {
			kwl = append(kwl, &checkinparse.WakelockInfo{
				Name:     kw.GetName(),
				Duration: time.Duration(kw.GetTimeMsec()) * time.Millisecond,
				Count:    kw.GetCount(),
			})
		}
	}
	// Sorting Kernel Wakelocks by time.
	checkinparse.SortByTime(kwl)
	for _, kw := range kwl {
		out.KernelWakelocks = append(out.KernelWakelocks, ActivityData{
			Name:         kw.Name,
			Count:        kw.Count,
			CountPerHour: kw.Count / float32(realtime.Hours()),
			Duration:     kw.Duration,
			SecondsPerHr: float32(kw.Duration.Seconds()) / float32(realtime.Hours()),
		})
	}

	// Wakeup Reasons.
	var wrl []*checkinparse.WakelockInfo
	for _, wr := range c.System.WakeupReason {
		if wr.GetTimeMsec() >= 0.01 {
			wrl = append(wrl, &checkinparse.WakelockInfo{
				Name:     wr.GetName(),
				Duration: time.Duration(wr.GetTimeMsec()) * time.Millisecond,
				Count:    wr.GetCount(),
			})
		}
	}

	// Sorting Wakeup Reasons by count.
	checkinparse.SortByCount(wrl)
	for _, wr := range wrl {
		out.WakeupReasons = append(out.WakeupReasons, ActivityData{
			Name:         wr.Name,
			Count:        wr.Count,
			CountPerHour: wr.Count / float32(realtime.Hours()),
			Duration:     wr.Duration,
			SecondsPerHr: float32(wr.Duration.Seconds()) / float32(realtime.Hours()),
		})
	}

	// Power usage per app.
	var e []*PowerUseData
	// Network usage per app.
	var m []*checkinparse.WakelockInfo
	var n []*NetworkTrafficData
	// App wakeup count.
	var wu []*RateData
	// App ANR and crash count.
	var ac []*ANRCrashData
	// CPU use per app.
	var cpu []*CPUData
	// Wifi activity per app.
	var wfScan []*checkinparse.WakelockInfo
	var wfFull []*checkinparse.WakelockInfo
	// SyncManager Tasks.
	var stl []*checkinparse.WakelockInfo
	// Userspace Partial Wakelocks and GPS use.
	var pwl []*checkinparse.WakelockInfo
	var gps []*checkinparse.WakelockInfo
	// Camera use per app.
	var ca []*checkinparse.WakelockInfo
	// Flashlight use per app.
	var fla []*checkinparse.WakelockInfo
	au := make(map[string]int32)
	bCapMah := c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah()
	for _, app := range c.App {
		if app.GetName() == "" {
			app.Name = proto.String(fmt.Sprintf("UNKNOWN_%d", app.GetUid()))
		}
		au[app.GetName()] = app.GetUid()
		this := AppData{
			Name: app.GetName(),
			UID:  app.GetUid(),
		}

		if pct := 100 * app.PowerUseItem.GetComputedPowerMah() / bCapMah; pct >= 0.01 {
			e = append(e, &PowerUseData{
				Name:    app.GetName(),
				UID:     app.GetUid(),
				Percent: pct,
			})
		}
		if mat, mac := app.Network.GetMobileActiveTimeMsec(), app.Network.GetMobileActiveCount(); mat >= 0.01 || mac > 0 {
			m = append(m, &checkinparse.WakelockInfo{
				Name:     app.GetName(),
				UID:      app.GetUid(),
				Duration: time.Duration(mat) * time.Millisecond,
				Count:    mac,
			})
		}
		wr := app.Network.GetWifiBytesRx()
		wt := app.Network.GetWifiBytesTx()
		mt := app.Network.GetMobileBytesTx()
		mr := app.Network.GetMobileBytesRx()
		if wr+wt+mt+mr >= 0.01 {
			ntd := NetworkTrafficData{
				Name:                   app.GetName(),
				UID:                    app.GetUid(),
				WifiMegaBytes:          (wr + wt) / (1024 * 1024),
				MobileMegaBytes:        (mr + mt) / (1024 * 1024),
				WifiMegaBytesPerHour:   (wr + wt) / (1024 * 1024) / float32(realtime.Hours()),
				MobileMegaBytesPerHour: (mr + mt) / (1024 * 1024) / float32(realtime.Hours()),
			}
			n = append(n, &ntd)
			this.Network = ntd
		}
		if w := app.Apk.GetWakeups(); w > 0 {
			rd := RateData{
				Name:       app.GetName(),
				UID:        app.GetUid(),
				Count:      w,
				CountPerHr: w / float32(realtime.Hours()),
			}
			wu = append(wu, &rd)
			this.Alarms = rd
		}
		for _, p := range app.Process {
			if an, cr := p.GetAnrs(), p.GetCrashes(); an > 0 || cr > 0 {
				ac = append(ac, &ANRCrashData{
					Name:       fmt.Sprintf("%s : %s", app.GetName(), p.GetName()),
					UID:        app.GetUid(),
					ANRCount:   int32(an),
					CrashCount: int32(cr),
				})
				out.TotalAppANRCount += int32(an)
				out.TotalAppCrashCount += int32(cr)
			}
		}
		out.TotalAppANRRate = float32(out.TotalAppANRCount) / float32(realtime.Hours())
		out.TotalAppCrashRate = float32(out.TotalAppCrashCount) / float32(realtime.Hours())

		if ut, st := app.Cpu.GetUserTimeMs(), app.Cpu.GetSystemTimeMs(); ut > 0 || st > 0 {
			cpud := CPUData{
				Name:       app.GetName(),
				UID:        app.GetUid(),
				UserTime:   time.Duration(ut) * time.Millisecond,
				SystemTime: time.Duration(st) * time.Millisecond,
				PowerPct:   100 * (app.Cpu.GetPowerMaMs() / (1000 * 60 * 60)) / bCapMah,
			}
			cpu = append(cpu, &cpud)
			this.CPU = cpud
		}
		if wfl := app.Wifi.GetFullWifiLockTimeMsec(); wfl > 0 {
			wfFull = append(wfFull, &checkinparse.WakelockInfo{
				Name:     app.GetName(),
				UID:      app.GetUid(),
				Duration: time.Duration(wfl) * time.Millisecond,
			})
		}
		wst := app.Wifi.GetScanTimeMsec()
		wsc := app.Wifi.GetScanCount()
		if wst > 0 || wsc > 0 {
			wfScan = append(wfScan, &checkinparse.WakelockInfo{
				Name:     app.GetName(),
				UID:      app.GetUid(),
				Duration: time.Duration(wst) * time.Millisecond,
				Count:    wsc,
			})
			this.WifiScan = ActivityData{
				Name:         app.GetName(),
				UID:          app.GetUid(),
				Count:        wsc,
				CountPerHour: wsc / float32(realtime.Hours()),
				Duration:     time.Duration(wst) * time.Millisecond,
				SecondsPerHr: float32(time.Duration(wst).Seconds()) / float32(realtime.Hours()),
			}
		}

		var stlt []*checkinparse.WakelockInfo
		for _, st := range app.Sync {
			stlt = append(stlt, &checkinparse.WakelockInfo{
				Name:     fmt.Sprintf("%s : %s", app.GetName(), st.GetName()),
				UID:      app.GetUid(),
				Duration: time.Duration(st.GetTotalTimeMsec()) * time.Millisecond,
				Count:    st.GetCount(),
			})
		}
		stl = append(stl, stlt...)
		this.Syncs = sumWakelockInfo(stlt, realtime)
		this.Syncs.Name = app.GetName()
		this.Syncs.UID = app.GetUid()

		var pwlt []*checkinparse.WakelockInfo
		for _, pw := range app.Wakelock {
			pwlt = append(pwlt, &checkinparse.WakelockInfo{
				Name:     fmt.Sprintf("%s : %s", app.GetName(), pw.GetName()),
				UID:      app.GetUid(),
				Duration: time.Duration(pw.GetPartialTimeMsec()) * time.Millisecond,
				Count:    pw.GetPartialCount(),
			})
		}
		pwl = append(pwl, pwlt...)
		this.PartialWakelocks = sumWakelockInfo(pwlt, realtime)
		this.PartialWakelocks.Name = app.GetName()
		this.PartialWakelocks.UID = app.GetUid()

		var gpst []*checkinparse.WakelockInfo
		for _, s := range app.Sensor {
			if s.GetNumber() == bugreportutils.GPSSensorNumber {
				gpst = append(gpst, &checkinparse.WakelockInfo{
					Name:     app.GetName(),
					UID:      app.GetUid(),
					Duration: time.Duration(s.GetTotalTimeMsec()) * time.Millisecond,
					Count:    s.GetCount(),
				})
				continue
			}
		}
		gps = append(gps, gpst...)
		this.GPSUse = sumWakelockInfo(gpst, realtime)
		this.GPSUse.Name = app.GetName()
		this.GPSUse.UID = app.GetUid()

		if cat, cac := app.Camera.GetTotalTimeMsec(), app.Camera.GetCount(); cat > 0 || cac > 0 {
			ca = append(ca, &checkinparse.WakelockInfo{
				Name:     app.GetName(),
				UID:      app.GetUid(),
				Duration: time.Duration(cat) * time.Millisecond,
				Count:    cac,
			})
		}
		if flt, flc := app.Flashlight.GetTotalTimeMsec(), app.Flashlight.GetCount(); flt > 0 || flc > 0 {
			fla = append(fla, &checkinparse.WakelockInfo{
				Name:     app.GetName(),
				UID:      app.GetUid(),
				Duration: time.Duration(flt) * time.Millisecond,
				Count:    flc,
			})
		}

		out.AggregatedApps = append(out.AggregatedApps, this)
	}
	for _, pwi := range c.System.PowerUseItem {
		if pwi.GetName() == bspb.BatteryStats_System_PowerUseItem_APP {
			// We have the apps split up in the preceding for loop, and the APP entry is just the sum of all of them, so we skip it here.
			continue
		}
		if pct := 100 * pwi.GetComputedPowerMah() / bCapMah; pct >= 0.01 {
			e = append(e, &PowerUseData{
				Name:    pwi.GetName().String(),
				Percent: pct,
			})
		}
	}

	sort.Sort(byPercent(e))
	for _, ent := range e {
		out.DevicePowerEstimates = append(out.DevicePowerEstimates, *ent)
	}

	checkinparse.SortByTime(m)
	for _, mad := range m {
		out.TopMobileActiveApps = append(out.TopMobileActiveApps, ActivityData{
			Name:         mad.Name,
			UID:          mad.UID,
			Count:        mad.Count,
			CountPerHour: mad.Count / float32(realtime.Hours()),
			Duration:     mad.Duration,
			SecondsPerHr: float32(mad.Duration.Seconds()) / float32(realtime.Hours()),
		})
	}

	sort.Sort(byMobileBytes(n))
	for _, ntd := range n {
		if ntd.MobileMegaBytes >= 0.01 {
			out.TopMobileTrafficApps = append(out.TopMobileTrafficApps, *ntd)
		}
	}

	sort.Sort(byWifiBytes(n))
	for _, ntd := range n {
		if ntd.WifiMegaBytes >= 0.01 {
			out.TopWifiTrafficApps = append(out.TopWifiTrafficApps, *ntd)
		}
	}

	sort.Sort(byCount(wu))
	for _, w := range wu {
		out.AppWakeups = append(out.AppWakeups, *w)
		out.TotalAppWakeupsPerHr += w.CountPerHr
	}

	sort.Sort(byCrashThenANR(ac))
	for _, x := range ac {
		out.ANRAndCrash = append(out.ANRAndCrash, *x)
	}

	sort.Sort(byPower(cpu))
	for _, cp := range cpu {
		out.CPUUsage = append(out.CPUUsage, *cp)
		out.TotalAppCPUPowerPct += cp.PowerPct
	}

	checkinparse.SortByTime(wfScan)
	for _, w := range wfScan {
		out.WifiScanActivity = append(out.WifiScanActivity, ActivityData{
			Name:         w.Name,
			UID:          w.UID,
			Count:        w.Count,
			CountPerHour: w.Count / float32(realtime.Hours()),
			Duration:     w.Duration,
			SecondsPerHr: float32(w.Duration.Seconds()) / float32(realtime.Hours()),
		})
	}

	checkinparse.SortByTime(wfFull)
	for _, w := range wfFull {
		out.WifiFullLockActivity = append(out.WifiFullLockActivity, ActivityData{
			Name:         w.Name,
			UID:          w.UID,
			Duration:     w.Duration,
			SecondsPerHr: float32(w.Duration.Seconds()) / float32(realtime.Hours()),
		})
	}

	// Sorting SyncManager Tasks by time.
	checkinparse.SortByTime(stl)
	for _, st := range stl {
		out.SyncTasks = append(out.SyncTasks, ActivityData{
			Name:         st.Name,
			UID:          st.UID,
			Count:        st.Count,
			CountPerHour: st.Count / float32(realtime.Hours()),
			Duration:     st.Duration,
			SecondsPerHr: float32(st.Duration.Seconds()) / float32(realtime.Hours()),
		})
		out.TotalAppSyncsPerHr += float32(st.Duration.Seconds()) / float32(realtime.Hours())
	}

	// Sorting Partial Wakelocks by time.
	checkinparse.SortByTime(pwl)
	for _, pw := range pwl {
		out.UserspaceWakelocks = append(out.UserspaceWakelocks, ActivityData{
			Name:         pw.Name,
			UID:          pw.UID,
			Count:        pw.Count,
			CountPerHour: pw.Count / float32(realtime.Hours()),
			Duration:     pw.Duration,
			SecondsPerHr: float32(pw.Duration.Seconds()) / float32(realtime.Hours()),
		})
	}

	// Sort GPS use by time.
	checkinparse.SortByTime(gps)
	for _, g := range gps {
		out.GPSUse = append(out.GPSUse, ActivityData{
			Name:         g.Name,
			UID:          g.UID,
			Count:        g.Count,
			CountPerHour: g.Count / float32(realtime.Hours()),
			Duration:     g.Duration,
			SecondsPerHr: float32(g.Duration.Seconds()) / float32(realtime.Hours()),
		})
		out.TotalAppGPSUseTimePerHour += float32(g.Duration.Seconds()) / float32(realtime.Hours())
	}

	// Sort camera use by time.
	checkinparse.SortByTime(ca)
	for _, c := range ca {
		out.CameraUse = append(out.CameraUse, ActivityData{
			Name:         c.Name,
			UID:          c.UID,
			Count:        c.Count,
			CountPerHour: c.Count / float32(realtime.Hours()),
			Duration:     c.Duration,
			SecondsPerHr: float32(c.Duration.Seconds()) / float32(realtime.Hours()),
		})
		out.TotalAppCameraUsePerHr += float32(c.Duration.Seconds()) / float32(realtime.Hours())
	}

	// Sort flashlight use by time.
	checkinparse.SortByTime(fla)
	for _, f := range fla {
		out.FlashlightUse = append(out.FlashlightUse, ActivityData{
			Name:         f.Name,
			UID:          f.UID,
			Count:        f.Count,
			CountPerHour: f.Count / float32(realtime.Hours()),
			Duration:     f.Duration,
			SecondsPerHr: float32(f.Duration.Seconds()) / float32(realtime.Hours()),
		})
		out.TotalAppFlashlightUsePerHr += float32(f.Duration.Seconds()) / float32(realtime.Hours())
	}
	return out
}
// NormalizeStats takes in a proto and normalizes it by converting
// any absolute value to value/TotalTime.
func NormalizeStats(p *bspb.BatteryStats) (*bspb.BatteryStats, error) {
	totalTimeHour := roundToTwoDecimal(float64((p.GetSystem().GetBattery().GetBatteryRealtimeMsec()) / (3600 * 1000)))

	if totalTimeHour == 0 {
		return nil, errors.New("battery real time cannot be 0")
	}
	normApp := &bspb.BatteryStats{
		ReportVersion:   p.ReportVersion,
		AggregationType: p.AggregationType,
	}

	// Normalize the app data
	for _, a1 := range p.GetApp() {
		a := normalizeApp(a1, totalTimeHour)
		normApp.App = append(normApp.App, a)
	}

	// Normalize system data
	s1 := p.GetSystem()
	s := &bspb.BatteryStats_System{}

	if norm := normalizeMessage(s1.GetBattery(), totalTimeHour); norm != nil {
		s.Battery = norm.(*bspb.BatteryStats_System_Battery)
	}
	if norm := normalizeMessage(s1.GetBatteryDischarge(), totalTimeHour); norm != nil {
		s.BatteryDischarge = norm.(*bspb.BatteryStats_System_BatteryDischarge)
	}
	s.BatteryLevel = s1.GetBatteryLevel()
	if norm := normalizeRepeatedMessage(s1.GetBluetoothState(), totalTimeHour); !norm.IsNil() {
		s.BluetoothState = norm.Interface().([]*bspb.BatteryStats_System_BluetoothState)
	}
	if norm := normalizeRepeatedMessage(s1.GetDataConnection(), totalTimeHour); !norm.IsNil() {
		s.DataConnection = norm.Interface().([]*bspb.BatteryStats_System_DataConnection)
	}
	if norm := normalizeMessage(s1.GetGlobalNetwork(), totalTimeHour); norm != nil {
		s.GlobalNetwork = norm.(*bspb.BatteryStats_System_GlobalNetwork)
	}
	if norm := normalizeRepeatedMessage(s1.GetKernelWakelock(), totalTimeHour); !norm.IsNil() {
		s.KernelWakelock = norm.Interface().([]*bspb.BatteryStats_System_KernelWakelock)
	}
	if norm := normalizeMessage(s1.GetMisc(), totalTimeHour); norm != nil {
		s.Misc = norm.(*bspb.BatteryStats_System_Misc)
	}
	if norm := normalizeRepeatedMessage(s1.GetPowerUseItem(), totalTimeHour); !norm.IsNil() {
		s.PowerUseItem = norm.Interface().([]*bspb.BatteryStats_System_PowerUseItem)
	}
	if norm := normalizeMessage(s1.GetPowerUseSummary(), totalTimeHour); norm != nil {
		s.PowerUseSummary = norm.(*bspb.BatteryStats_System_PowerUseSummary)
	}
	if norm := normalizeRepeatedMessage(s1.GetScreenBrightness(), totalTimeHour); !norm.IsNil() {
		s.ScreenBrightness = norm.Interface().([]*bspb.BatteryStats_System_ScreenBrightness)
	}
	if norm := normalizeMessage(s1.GetSignalScanningTime(), totalTimeHour); norm != nil {
		s.SignalScanningTime = norm.(*bspb.BatteryStats_System_SignalScanningTime)
	}
	if norm := normalizeRepeatedMessage(s1.GetSignalStrength(), totalTimeHour); !norm.IsNil() {
		s.SignalStrength = norm.Interface().([]*bspb.BatteryStats_System_SignalStrength)
	}
	if norm := normalizeRepeatedMessage(s1.GetWakeupReason(), totalTimeHour); !norm.IsNil() {
		s.WakeupReason = norm.Interface().([]*bspb.BatteryStats_System_WakeupReason)
	}
	if norm := normalizeRepeatedMessage(s1.GetWifiState(), totalTimeHour); !norm.IsNil() {
		s.WifiState = norm.Interface().([]*bspb.BatteryStats_System_WifiState)
	}
	if norm := normalizeRepeatedMessage(s1.GetWifiSupplicantState(), totalTimeHour); !norm.IsNil() {
		s.WifiSupplicantState = norm.Interface().([]*bspb.BatteryStats_System_WifiSupplicantState)
	}
	p.System = s
	p.App = normApp.App
	return p, nil
}
func parseCheckinData(c *bspb.BatteryStats) checkin {
	if c == nil {
		return checkin{}
	}

	realtime := time.Duration(c.System.Battery.GetBatteryRealtimeMsec()) * time.Millisecond

	out := checkin{
		Device:           c.Build.GetDevice(),
		Build:            c.Build.GetBuildId(),
		BuildFingerprint: c.Build.GetFingerprint(),
		ReportVersion:    c.GetReportVersion(),

		Realtime:          realtime,
		ScreenOffRealtime: time.Duration(c.System.Battery.GetScreenOffRealtimeMsec()) * time.Millisecond,

		ScreenOffDischargePoints: c.System.BatteryDischarge.GetScreenOff(),
		ScreenOnDischargePoints:  c.System.BatteryDischarge.GetScreenOn(),

		BatteryCapacity:    c.System.PowerUseSummary.GetBatteryCapacityMah(),
		EstimatedDischarge: c.System.PowerUseSummary.GetComputedPowerMah(),
		ActualDischarge:    (c.System.PowerUseSummary.GetMinDrainedPowerMah() + c.System.PowerUseSummary.GetMaxDrainedPowerMah()) / 2,

		// Uptime is the same as screen-off uptime + screen on time
		Uptime: mDuration{
			V: (time.Duration(c.System.Battery.GetBatteryUptimeMsec()) * time.Millisecond),
		},

		ScreenOffUptime: mDuration{
			V: (time.Duration(c.System.Battery.GetScreenOffUptimeMsec()) * time.Millisecond),
		},

		ScreenOnTime: mDuration{
			V: (time.Duration(c.System.Misc.GetScreenOnTimeMsec()) * time.Millisecond),
		},

		PartialWakelockTime: mDuration{
			V: (time.Duration(c.System.Misc.GetPartialWakelockTimeMsec()) * time.Millisecond),
		},

		KernelOverheadTime: mDuration{
			V: (time.Duration(c.System.Battery.GetScreenOffUptimeMsec()-c.System.Misc.GetPartialWakelockTimeMsec()) * time.Millisecond),
		},

		SignalScanningTime: mDuration{
			V: (time.Duration(c.System.SignalScanningTime.GetTimeMsec()) * time.Millisecond),
		},

		MobileActiveTime: mDuration{
			V: (time.Duration(c.System.Misc.GetMobileActiveTimeMsec()) * time.Millisecond),
		},
	}

	out.MiscPercentage = 100 * (out.ActualDischarge - out.EstimatedDischarge) / out.BatteryCapacity

	out.MobileKiloBytesPerHr = mFloat32{V: (c.System.GlobalNetwork.GetMobileBytesRx() + c.System.GlobalNetwork.GetMobileBytesTx()) / (1024 * float32(realtime.Hours()))}
	out.WifiKiloBytesPerHr = mFloat32{V: (c.System.GlobalNetwork.GetWifiBytesRx() + c.System.GlobalNetwork.GetWifiBytesTx()) / (1024 * float32(realtime.Hours()))}

	if c.GetReportVersion() >= 14 {
		out.WifiOnTime = mDuration{V: time.Duration(c.System.GlobalWifi.GetWifiOnTimeMsec()) * time.Millisecond}
		out.WifiIdleTime = mDuration{V: time.Duration(c.System.GlobalWifi.GetWifiIdleTimeMsec()) * time.Millisecond}
		out.WifiTransmitTime = mDuration{V: time.Duration(c.System.GlobalWifi.GetWifiRxTimeMsec()+c.System.GlobalWifi.GetWifiTxTimeMsec()) * time.Millisecond}
		out.WifiDischargePoints = 100 * c.System.GlobalWifi.GetWifiPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah()
		out.WifiDischargeRatePerHr = mFloat32{
			V: 100 * c.System.GlobalWifi.GetWifiPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah() / float32(realtime.Hours()),
		}

		out.BluetoothIdleTime = mDuration{V: time.Duration(c.System.GlobalBluetooth.GetBluetoothIdleTimeMsec()) * time.Millisecond}
		out.BluetoothTransmitTime = mDuration{V: time.Duration(c.System.GlobalBluetooth.GetBluetoothRxTimeMsec()+c.System.GlobalBluetooth.GetBluetoothTxTimeMsec()) * time.Millisecond}
		out.BluetoothDischargePoints = 100 * c.System.GlobalBluetooth.GetBluetoothPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah()
		out.BluetoothDischargeRatePerHr = mFloat32{
			V: 100 * c.System.GlobalBluetooth.GetBluetoothPowerMah() / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah() / float32(realtime.Hours()),
		}
	}

	if s := c.System.Battery.GetScreenOffRealtimeMsec(); s > 0 {
		out.ScreenOffDichargeRatePerHr = mFloat32{V: 60 * 60 * 1000 * c.System.BatteryDischarge.GetScreenOff() / s}
	}
	if s := c.System.Misc.GetScreenOnTimeMsec(); s > 0 {
		out.ScreenOnDichargeRatePerHr = mFloat32{V: 60 * 60 * 1000 * c.System.BatteryDischarge.GetScreenOn() / s}
	}

	// Top Partial Wakelocks by time and count
	var pwl []*checkinparse.WakelockInfo
	for _, app := range c.App {
		for _, pw := range app.Wakelock {
			if pw.GetPartialTimeMsec() >= 0.01 {
				pwl = append(pwl, &checkinparse.WakelockInfo{
					Name:     fmt.Sprintf("%s : %s", app.GetName(), pw.GetName()),
					UID:      app.GetUid(),
					Duration: time.Duration(pw.GetPartialTimeMsec()) * time.Millisecond,
					Count:    pw.GetPartialCount(),
				})
			}
		}
	}

	// Top Partial Wakelocks by time
	checkinparse.SortByTime(pwl)
	for _, pw := range pwl {
		out.UserspaceWakelocks = append(out.UserspaceWakelocks, WakelockData{
			Name:     pw.Name,
			UID:      pw.UID,
			Count:    pw.Count,
			Duration: pw.Duration,
		})
	}

	// Top 5 Kernel Wakelocks
	var kwl []*checkinparse.WakelockInfo
	for _, kw := range c.System.KernelWakelock {
		if kw.GetName() != "PowerManagerService.WakeLocks" && kw.GetTimeMsec() >= 0.01 {
			kwl = append(kwl, &checkinparse.WakelockInfo{
				Name:     kw.GetName(),
				Duration: time.Duration(kw.GetTimeMsec()) * time.Millisecond,
				Count:    kw.GetCount(),
			})
		}
	}
	// Top Kernel Wakelocks by time
	checkinparse.SortByTime(kwl)
	for _, kw := range kwl {
		out.KernelWakelocks = append(out.KernelWakelocks, WakelockData{
			Name:     kw.Name,
			Count:    kw.Count,
			Duration: kw.Duration,
		})
	}

	// Top SyncTasks by time and count
	var stl []*checkinparse.WakelockInfo
	for _, app := range c.App {
		for _, st := range app.Sync {
			if st.GetTotalTimeMsec() >= 0.01 {
				stl = append(stl, &checkinparse.WakelockInfo{
					Name:     fmt.Sprintf("%s : %s", app.GetName(), st.GetName()),
					UID:      app.GetUid(),
					Duration: time.Duration(st.GetTotalTimeMsec()) * time.Millisecond,
					Count:    st.GetCount(),
				})
			}
		}
	}

	// Top SyncTasks by time
	checkinparse.SortByTime(stl)
	for _, st := range stl {
		out.SyncTasks = append(out.SyncTasks, WakelockData{
			Name:     st.Name,
			UID:      st.UID,
			Count:    st.Count,
			Duration: st.Duration,
		})
	}

	// Top power consumers and network users
	var e []*PowerUseData
	var m []*MobileActiveData
	var n []*NetworkTrafficData
	for _, app := range c.App {
		if mah := app.PowerUseItem.GetComputedPowerMah(); mah >= 0.01 {
			e = append(e, &PowerUseData{
				Name:    app.GetName(),
				UID:     app.GetUid(),
				Percent: 100 * mah / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah(),
			})
		}
		if mat := app.Network.GetMobileActiveTimeMsec(); mat >= 0.01 {
			m = append(m, &MobileActiveData{
				Name:     app.GetName(),
				UID:      app.GetUid(),
				Duration: time.Duration(mat) * time.Millisecond,
			})
		}
		wr := app.Network.GetWifiBytesRx()
		wt := app.Network.GetWifiBytesTx()
		mt := app.Network.GetMobileBytesTx()
		mr := app.Network.GetMobileBytesRx()
		if wr+wt+mt+mr >= 0.01 {
			n = append(n, &NetworkTrafficData{
				Name:            app.GetName(),
				UID:             app.GetUid(),
				WifiMegaBytes:   (wr + wt) / (1024 * 1024),
				MobileMegaBytes: (mr + mt) / (1024 * 1024),
			})
		}
	}
	for _, pwi := range c.System.PowerUseItem {
		if pwi.GetName() == bspb.BatteryStats_System_PowerUseItem_APP {
			// We have the apps split up in the preceding for loop, and the APP entry is just the sum of all of them, so we skip it here.
			continue
		}
		if mah := pwi.GetComputedPowerMah(); mah >= 0.01 {
			e = append(e, &PowerUseData{
				Name:    pwi.GetName().String(),
				Percent: 100 * mah / c.GetSystem().GetPowerUseSummary().GetBatteryCapacityMah(),
			})
		}
	}

	sort.Sort(byPercent(e))
	for _, ent := range e {
		out.TopBatteryConsumingEntities = append(out.TopBatteryConsumingEntities, *ent)
	}

	sort.Sort(byTime(m))
	for _, mad := range m {
		out.TopMobileActiveApps = append(out.TopMobileActiveApps, *mad)
	}

	sort.Sort(byMobileBytes(n))
	for _, ntd := range n {
		if ntd.MobileMegaBytes >= 0.01 {
			out.TopMobileTrafficApps = append(out.TopMobileTrafficApps, *ntd)
		}
	}

	sort.Sort(byWifiBytes(n))
	for _, ntd := range n {
		if ntd.WifiMegaBytes >= 0.01 {
			out.TopWifiTrafficApps = append(out.TopWifiTrafficApps, *ntd)
		}
	}

	return out
}