├── AndroidManifest.xml
├── LICENCE
├── Makefile
├── README
├── android-9.jar
├── debug.keystore
├── default.properties
├── jni
    ├── Android.mk
    └── bindings.cpp
├── libs
    └── achartengine-1.0.0.jar
├── res
    ├── drawable
    │   ├── background.png
    │   ├── help.png
    │   ├── icon.png
    │   ├── level.xml
    │   ├── level_1.png
    │   ├── level_2.png
    │   ├── level_3.png
    │   ├── level_4.png
    │   ├── level_5.png
    │   ├── level_6.png
    │   ├── level_7.png
    │   ├── level_8.png
    │   ├── level_9.png
    │   ├── line.png
    │   ├── power_off.png
    │   ├── power_on.png
    │   ├── time.xml
    │   ├── time_0.png
    │   ├── time_1.png
    │   ├── time_10.png
    │   ├── time_11.png
    │   ├── time_12.png
    │   ├── time_2.png
    │   ├── time_3.png
    │   ├── time_4.png
    │   ├── time_5.png
    │   ├── time_6.png
    │   ├── time_7.png
    │   ├── time_8.png
    │   ├── time_9.png
    │   └── widget_bg.png
    ├── layout
    │   ├── help.xml
    │   ├── main.xml
    │   ├── misc_item_layout.xml
    │   ├── misc_layout.xml
    │   ├── power_tabs.xml
    │   ├── widget_configure.xml
    │   ├── widget_item_layout.xml
    │   └── widget_layout.xml
    ├── values
    │   ├── arrays.xml
    │   └── strings.xml
    └── xml
    │   ├── preferences.xml
    │   ├── viewer_preferences.xml
    │   └── widget_info.xml
└── src
    └── edu
        └── umich
            └── PowerTutor
                ├── PowerNotifications.aidl
                ├── components
                    ├── Audio.java
                    ├── CPU.java
                    ├── GPS.java
                    ├── LCD.java
                    ├── OLED.java
                    ├── PowerComponent.java
                    ├── Sensors.java
                    ├── Threeg.java
                    └── Wifi.java
                ├── phone
                    ├── DreamConstants.java
                    ├── DreamPowerCalculator.java
                    ├── PassionConstants.java
                    ├── PassionPowerCalculator.java
                    ├── PhoneConstants.java
                    ├── PhonePowerCalculator.java
                    ├── PhoneSelector.java
                    ├── PowerFunction.java
                    ├── SapphireConstants.java
                    └── SapphirePowerCalculator.java
                ├── service
                    ├── ICounterService.aidl
                    ├── IterationData.java
                    ├── LogUploader.java
                    ├── PowerData.java
                    ├── PowerEstimator.java
                    ├── UMLoggerService.java
                    └── UidInfo.java
                ├── ui
                    ├── EditPreferences.java
                    ├── Help.java
                    ├── MiscView.java
                    ├── PowerPie.java
                    ├── PowerTabs.java
                    ├── PowerTop.java
                    ├── PowerViewer.java
                    ├── StartupReceiver.java
                    ├── UMLogger.java
                    └── ViewerPreferences.java
                ├── util
                    ├── BatteryStats.java
                    ├── Counter.java
                    ├── ForegroundDetector.java
                    ├── HexEncode.java
                    ├── HistoryBuffer.java
                    ├── NativeLoader.java
                    ├── NotificationService.java
                    ├── Recycler.java
                    └── SystemInfo.java
                └── widget
                    ├── Configure.java
                    ├── DataSource.java
                    ├── DataSourceConfigure.java
                    └── PowerWidget.java


/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.1" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |       package="edu.umich.PowerTutor"
 4 |       android:versionCode="15" android:versionName="1.5">
 5 |   <application android:icon="@drawable/icon" android:label="@string/app_name">
 6 |     <activity android:name=".ui.UMLogger"
 7 |               android:label="@string/app_name"
 8 |               android:screenOrientation="portrait" >
 9 |       <intent-filter>
10 |         <action android:name="android.intent.action.MAIN" />
11 |         <category android:name="android.intent.category.LAUNCHER" />
12 |       </intent-filter>
13 |     </activity>
14 |     <activity android:name=".ui.Help" >
15 |       <intent-filter>
16 |         <action android:name="android.intent.action.MAIN" />
17 |       </intent-filter>
18 |     </activity>
19 |     <activity android:name=".ui.PowerViewer" >
20 |       <intent-filter>
21 |         <action android:name="android.intent.action.MAIN" />
22 |       </intent-filter>
23 |     </activity>
24 |     <activity android:name=".ui.PowerTop"
25 |               android:label="Power Top" >
26 |       <intent-filter>
27 |         <action android:name="android.intent.action.MAIN" />
28 |       </intent-filter>
29 |     </activity>
30 |     <activity android:name=".ui.PowerPie" >
31 |       <intent-filter>
32 |         <action android:name="android.intent.action.MAIN" />
33 |       </intent-filter>
34 |     </activity>
35 |     <activity android:name=".ui.MiscView" >
36 |       <intent-filter>
37 |         <action android:name="android.intent.action.MAIN" />
38 |       </intent-filter>
39 |     </activity>
40 |     <activity android:name=".ui.PowerTabs"
41 |               android:theme="@android:style/Theme.NoTitleBar">
42 |       <intent-filter>
43 |         <action android:name="android.intent.action.MAIN" />
44 |       </intent-filter>
45 |     </activity>
46 |     <activity android:name=".ui.EditPreferences"
47 |               android:label="PowerTutor Options">
48 |       <intent-filter>
49 |         <action android:name="android.intent.action.MAIN" />
50 |       </intent-filter>
51 |     </activity>
52 |     <activity android:name=".ui.ViewerPreferences"
53 |               android:label="PowerTutor History Options">
54 |       <intent-filter>
55 |         <action android:name="android.intent.action.MAIN" />
56 |       </intent-filter>
57 |     </activity>
58 |     <activity android:name=".widget.Configure"
59 |               android:label="Configure PowerTutor Widget" >
60 |       <intent-filter>
61 |         <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
62 |       </intent-filter>
63 |     </activity>
64 |     <activity android:name=".widget.DataSourceConfigure"
65 |               android:label="Configure Data Source">
66 |       <intent-filter>
67 |         <action android:name="android.intent.action.MAIN" />
68 |       </intent-filter>
69 |     </activity>
70 |     <receiver android:name=".ui.StartupReceiver">
71 |       <intent-filter>
72 |         <action android:name="android.intent.action.BOOT_COMPLETED" />
73 |         <category android:name="android.intent.category.HOME" />
74 |       </intent-filter>
75 |     </receiver>
76 |     <service android:name=".service.UMLoggerService"></service>
77 |     <receiver android:name=".widget.PowerWidget" >
78 |       <intent-filter>
79 |           <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
80 |       </intent-filter>
81 |       <meta-data android:name="android.appwidget.provider"
82 |                  android:resource="@xml/widget_info" />
83 |       </receiver>
84 |   </application>
85 | 
86 |   <uses-sdk android:minSdkVersion="3" />
87 |   <uses-permission android:name="android.permission.INTERNET" />
88 |   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
89 |   <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
90 |   <uses-permission android:name="android.permission.READ_PHONE_STATE" />
91 |   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
92 |   <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
93 | </manifest> 
94 | 


--------------------------------------------------------------------------------
/LICENCE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2011 The University of Michigan
 2 | 
 3 | This program is free software: you can redistribute it and/or modify
 4 | it under the terms of the GNU General Public License as published by
 5 | the Free Software Foundation, either version 3 of the License, or
 6 | (at your option) any later version.
 7 | 
 8 | This program is distributed in the hope that it will be useful,
 9 | but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 | GNU General Public License for more details.
12 | 
13 | You should have received a copy of the GNU General Public License
14 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
15 | 
16 | Please send inquiries to powertutor@umich.edu
17 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | all: package
 2 | 
 3 | ANDROID_LIB=android-9.jar
 4 | CLASSPATH=$(ANDROID_LIB):libs/achartengine-1.0.0.jar
 5 | 
 6 | genres:
 7 | 	mkdir -p gen bin
 8 | 	aapt package -m -J gen -M AndroidManifest.xml -S res -I $(ANDROID_LIB)
 9 | 
10 | aidl:
11 | 	find src/ -type f                                                        | \
12 |       grep '\.aidl$$'                                                      | \
13 |       xargs -n 1 aidl -Isrc -I$(ANDROID_LIB) -ogen
14 | 
15 | gen: genres aidl
16 | 
17 | compile: gen
18 | 	mkdir -p bin
19 | 	find src/ gen/ -type f                                                   | \
20 |       grep '\.java$$'                                                      | \
21 |       xargs javac -cp $(CLASSPATH) -d bin
22 | 	ndk-build
23 | 
24 | dex: compile
25 | 	dx --dex --output=bin/classes.dex bin/ libs/
26 | 
27 | package: dex
28 | 	aapt package -M AndroidManifest.xml -S res \
29 |        -F bin/PowerTutor.apk -I $(ANDROID_LIB)
30 | 	cd bin; zip PowerTutor.apk classes.dex
31 | 	zip bin/PowerTutor.apk -r libs -i \*.so
32 | 	jarsigner -storepass android -keystore debug.keystore \
33 |       bin/PowerTutor.apk androiddebugkey
34 | 
35 | install: package
36 | 	adb install bin/PowerTutor.apk
37 | 
38 | clean:
39 | 	rm -rf bin/ gen/
40 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | PowerTutor Project
 2 | 
 3 | Model based power mobile power estimator by application
 4 | 
 5 | Contact: powertutor@umich.edu
 6 | 
 7 | Website: http://powertutor.org
 8 | 
 9 | This package includes the PowerTutor source code.  The code responsible for
10 | uploading logs to our remote server has been removed and replaced by a stub that
11 | does nothing.
12 | 


--------------------------------------------------------------------------------
/android-9.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/android-9.jar


--------------------------------------------------------------------------------
/debug.keystore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/debug.keystore


--------------------------------------------------------------------------------
/default.properties:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by Android Tools.
 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 | #
 4 | # This file must be checked in Version Control Systems.
 5 | #
 6 | # To customize properties used by the Ant build system use,
 7 | # "build.properties", and override values to adapt the script to your
 8 | # project structure.
 9 | 
10 | # Project target.
11 | target=android-3
12 | 


--------------------------------------------------------------------------------
/jni/Android.mk:
--------------------------------------------------------------------------------
 1 | LOCAL_PATH := $(call my-dir)
 2 | 
 3 | include $(CLEAN_VARS)
 4 | 
 5 | LOCAL_MODULE_FILENAME := bindings
 6 | LOCAL_MODULE := bindings
 7 | LOCAL_SRC_FILES := bindings.cpp
 8 | 
 9 | include $(BUILD_SHARED_LIBRARY)
10 | 


--------------------------------------------------------------------------------
/jni/bindings.cpp:
--------------------------------------------------------------------------------
 1 | #include <jni.h>
 2 | #include <stdio.h>
 3 | #include <linux/fb.h>
 4 | #include <sys/ioctl.h>
 5 | #include <sys/types.h>
 6 | #include <sys/stat.h>
 7 | #include <fcntl.h>
 8 | #include <sys/mman.h>
 9 | #include <stdlib.h>
10 | 
11 | extern "C" {
12 | JNIEXPORT jdouble JNICALL
13 | Java_edu_umich_PowerTutor_components_OLED_getScreenPixPower(
14 |     JNIEnv * env, jobject thiz, jdouble rcoef, jdouble gcoef,
15 |     jdouble bcoef, jdouble modul_coef);
16 | }
17 | 
18 | #define NUMBER_OF_SAMPLES 500
19 | 
20 | static int fd = -2;
21 | static struct fb_fix_screeninfo screeninfo;
22 | static unsigned char* buf;
23 | 
24 | static unsigned int samples[NUMBER_OF_SAMPLES];
25 | 
26 | JNIEXPORT jdouble JNICALL
27 | Java_edu_umich_PowerTutor_components_OLED_getScreenPixPower(
28 |     JNIEnv * env, jobject thiz, jdouble rcoef, jdouble gcoef,
29 |     jdouble bcoef, jdouble modul_coef) {
30 |   if(fd == -1) {
31 |     return (jdouble)-1.0;
32 |   } else if(fd == -2) {
33 |     fd = open("/dev/graphics/fb0", O_RDWR);
34 |     if(fd == -1) {
35 |       fd = open("/dev/fb0", O_RDWR);
36 |     }
37 |     if(fd == -1) {
38 |       return (jdouble)-1.0;
39 |     }
40 |     if(ioctl(fd, FBIOGET_FSCREENINFO, &screeninfo)) {
41 |       close(fd);
42 |       fd = -1;
43 |       return (jdouble)-1.0;
44 |     }
45 |     buf = (unsigned char*)mmap(NULL, screeninfo.smem_len, PROT_READ,
46 |                                MAP_SHARED, fd, 0);
47 |     if(buf == (unsigned char*)-1) {
48 |       close(fd);
49 |       fd = -1;
50 |       return (jdouble)-1.0;
51 |     }
52 |     int range = screeninfo.smem_len / 12;
53 |     srand(555);
54 |     for(int i = 0; i < NUMBER_OF_SAMPLES; i++) {
55 |       int a = range * i / NUMBER_OF_SAMPLES;
56 |       int b = range * (i + 1) / NUMBER_OF_SAMPLES;
57 |       if(b <= a + 1) {
58 |         samples[i] = a;
59 |       } else  {
60 |         samples[i] = a + rand() % (b - a);
61 |       }
62 |     }
63 |   }
64 |   jdouble pixPower = 0.0;
65 |   for(int i = 0; i < NUMBER_OF_SAMPLES; i++) {
66 |     int x = 4 * samples[i];
67 |     int r = buf[x];
68 |     int g = buf[x + 1];
69 |     int b = buf[x + 2];
70 | 
71 |     /* Calculate the power usage of this one pixel if it were at full
72 |      * brightness.  Linearly scale by brightness to get true power
73 |      * consumption.  To calculate whole screen compute average of sampled
74 |      * region and multiply by number of pixels.
75 |      */
76 |     int modul_val = r + g + b;
77 |     pixPower += rcoef * (r * r) + gcoef * (g * g) + bcoef * (b * b) -
78 |                 modul_coef * (modul_val * modul_val);
79 |   }
80 |   return pixPower;
81 | }
82 | 


--------------------------------------------------------------------------------
/libs/achartengine-1.0.0.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/libs/achartengine-1.0.0.jar


--------------------------------------------------------------------------------
/res/drawable/background.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/background.png


--------------------------------------------------------------------------------
/res/drawable/help.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/help.png


--------------------------------------------------------------------------------
/res/drawable/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/icon.png


--------------------------------------------------------------------------------
/res/drawable/level.xml:
--------------------------------------------------------------------------------
 1 | <level-list xmlns:android="http://schemas.android.com/apk/res/android">
 2 |   android:id="@+id/l1"
 3 |   <item android:maxLevel="0" android:drawable="@drawable/level_1" />
 4 |   <item android:maxLevel="1" android:drawable="@drawable/level_2" />
 5 |   <item android:maxLevel="2" android:drawable="@drawable/level_3" />
 6 |   <item android:maxLevel="3" android:drawable="@drawable/level_4" />
 7 |   <item android:maxLevel="4" android:drawable="@drawable/level_5" />
 8 |   <item android:maxLevel="5" android:drawable="@drawable/level_6" />
 9 |   <item android:maxLevel="6" android:drawable="@drawable/level_7" />
10 |   <item android:maxLevel="7" android:drawable="@drawable/level_8" />
11 |   <item android:maxLevel="8" android:drawable="@drawable/level_9" />
12 |    </level-list>
13 | 


--------------------------------------------------------------------------------
/res/drawable/level_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_1.png


--------------------------------------------------------------------------------
/res/drawable/level_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_2.png


--------------------------------------------------------------------------------
/res/drawable/level_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_3.png


--------------------------------------------------------------------------------
/res/drawable/level_4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_4.png


--------------------------------------------------------------------------------
/res/drawable/level_5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_5.png


--------------------------------------------------------------------------------
/res/drawable/level_6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_6.png


--------------------------------------------------------------------------------
/res/drawable/level_7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_7.png


--------------------------------------------------------------------------------
/res/drawable/level_8.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_8.png


--------------------------------------------------------------------------------
/res/drawable/level_9.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/level_9.png


--------------------------------------------------------------------------------
/res/drawable/line.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/line.png


--------------------------------------------------------------------------------
/res/drawable/power_off.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/power_off.png


--------------------------------------------------------------------------------
/res/drawable/power_on.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/power_on.png


--------------------------------------------------------------------------------
/res/drawable/time.xml:
--------------------------------------------------------------------------------
 1 | <level-list xmlns:android="http://schemas.android.com/apk/res/android">
 2 |   <item android:maxLevel="0" android:drawable="@drawable/level_1" />
 3 |   <item android:maxLevel="1" android:drawable="@drawable/time_0" />
 4 |   <item android:maxLevel="2" android:drawable="@drawable/time_1" />
 5 |   <item android:maxLevel="3" android:drawable="@drawable/time_2" />
 6 |   <item android:maxLevel="4" android:drawable="@drawable/time_3" />
 7 |   <item android:maxLevel="5" android:drawable="@drawable/time_4" />
 8 |   <item android:maxLevel="6" android:drawable="@drawable/time_5" />
 9 |   <item android:maxLevel="7" android:drawable="@drawable/time_6" />
10 |   <item android:maxLevel="8" android:drawable="@drawable/time_7" />
11 |   <item android:maxLevel="9" android:drawable="@drawable/time_8" />
12 |   <item android:maxLevel="10" android:drawable="@drawable/time_9" />
13 |   <item android:maxLevel="11" android:drawable="@drawable/time_10" />
14 |   <item android:maxLevel="12" android:drawable="@drawable/time_11" />
15 |   <item android:maxLevel="13" android:drawable="@drawable/time_12" />
16 | </level-list>
17 | 


--------------------------------------------------------------------------------
/res/drawable/time_0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_0.png


--------------------------------------------------------------------------------
/res/drawable/time_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_1.png


--------------------------------------------------------------------------------
/res/drawable/time_10.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_10.png


--------------------------------------------------------------------------------
/res/drawable/time_11.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_11.png


--------------------------------------------------------------------------------
/res/drawable/time_12.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_12.png


--------------------------------------------------------------------------------
/res/drawable/time_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_2.png


--------------------------------------------------------------------------------
/res/drawable/time_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_3.png


--------------------------------------------------------------------------------
/res/drawable/time_4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_4.png


--------------------------------------------------------------------------------
/res/drawable/time_5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_5.png


--------------------------------------------------------------------------------
/res/drawable/time_6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_6.png


--------------------------------------------------------------------------------
/res/drawable/time_7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_7.png


--------------------------------------------------------------------------------
/res/drawable/time_8.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_8.png


--------------------------------------------------------------------------------
/res/drawable/time_9.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/time_9.png


--------------------------------------------------------------------------------
/res/drawable/widget_bg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/msg555/PowerTutor/6ba2d63f97bfdc9abf4b9ff54d6ae3fea7f6ef68/res/drawable/widget_bg.png


--------------------------------------------------------------------------------
/res/layout/help.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:id="@+id/textAreaScroller" 
 4 |     android:layout_width="fill_parent" 
 5 |     android:layout_height="fill_parent" 
 6 |     android:layout_x="0px" 
 7 |     android:layout_y="0px" 
 8 |     android:background = "@drawable/help"
 9 |   > 
10 |   <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
11 |       android:orientation ="vertical"
12 |       android:layout_width="fill_parent"
13 |       android:layout_height="fill_parent"
14 |     >
15 |     <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
16 |         android:layout_width="fill_parent"
17 |         android:layout_height="fill_parent"
18 |       >
19 |       <TextView  
20 |           android:id="@+id/s0"
21 |           android:layout_width="250px" 
22 |           android:layout_height="wrap_content" 
23 |           android:text="@string/help_head"
24 |           android:textColor="#000000"
25 |           android:layout_marginLeft = "5px"
26 |         />
27 |       <TextView  
28 |           android:id="@+id/s0"
29 |           android:layout_width="wrap_content" 
30 |           android:layout_height="wrap_content" 
31 |           android:background ="@drawable/icon"
32 |         />
33 |     </LinearLayout>
34 |     <TextView  
35 |         android:id="@+id/s0"
36 |         android:layout_width="300px" 
37 |         android:layout_height="5px" 
38 |         android:background ="@drawable/line"
39 |         android:layout_marginLeft = "3px"  
40 |       />   
41 |     <TextView  
42 |         android:id="@+id/s0"
43 |         android:layout_width="fill_parent" 
44 |         android:layout_height="wrap_content" 
45 |         android:text="@string/help_text"
46 |         android:textColor="#000000"
47 |         android:textSize="13sp"
48 |         android:layout_marginLeft = "5px" 
49 | 	android:layout_marginRight = "5px" 
50 |       />
51 |     <TextView  
52 |         android:id="@+id/s1"
53 |         android:layout_width="fill_parent" 
54 |         android:layout_height="wrap_content" 
55 |         android:text="@string/url_1"
56 |         android:textColor="#000000"
57 |         android:layout_marginLeft = "5px"  
58 |       />
59 |     <TextView  
60 |         android:id="@+id/S2"
61 |         android:layout_width="fill_parent" 
62 |         android:layout_height="wrap_content" 
63 |         android:text="@string/url_2"
64 |         android:textColor="#000000"
65 |         android:layout_marginLeft = "5px"  
66 |       />
67 |   </LinearLayout>
68 | </ScrollView>
69 | 


--------------------------------------------------------------------------------
/res/layout/main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:orientation="vertical"
 4 |     android:layout_width="fill_parent"
 5 |     android:layout_height="fill_parent"
 6 |     android:background = "@drawable/background"
 7 |   >
 8 |   <TextView android:id="@+id/s0"
 9 |       android:layout_width="fill_parent" 
10 |       android:layout_height="wrap_content" 
11 |       android:text="PowerTutor 1.4"
12 |       android:gravity="center"
13 |       android:layout_weight="0.1"
14 |       android:textSize="16pt"
15 |       android:textColor="#FFFFFF"
16 |     />
17 |   <FrameLayout
18 |       android:layout_width="fill_parent"
19 |       android:layout_height="0px"
20 |       android:layout_weight="1"
21 |     />
22 |   <LinearLayout
23 |     android:orientation="horizontal"
24 |     android:layout_width="fill_parent"
25 |     android:layout_height="wrap_content"
26 |   >
27 |     <FrameLayout
28 |         android:layout_width="0px"
29 |         android:layout_height="fill_parent"
30 |         android:layout_weight="1"
31 |       />
32 |     <LinearLayout
33 |       android:orientation="vertical"
34 |       android:layout_width="0px"
35 |       android:layout_height="fill_parent"
36 |       android:layout_weight="3"
37 |     >
38 |       <Button android:id="@+id/servicestartbutton" 
39 |           android:layout_weight="0.25"
40 |           android:layout_width="fill_parent" 
41 |           android:layout_height="wrap_content" 
42 |           android:textSize="8pt"
43 |         />
44 |       <Button android:id="@+id/appviewerbutton"
45 |           android:layout_weight="0.25"
46 |           android:text="Application Viewer"
47 |           android:layout_width="fill_parent" 
48 |           android:layout_height="wrap_content" 
49 |           android:textSize="8pt"
50 |         />
51 |       <Button android:id="@+id/sysviewerbutton"
52 |           android:layout_weight="0.25"
53 |           android:text="System Viewer"
54 |           android:layout_width="fill_parent"
55 |           android:layout_height="wrap_content" 
56 |           android:textSize="8pt"
57 |         />
58 |       <Button android:id="@+id/helpbutton"
59 |           android:text = "Help"
60 |           android:layout_weight="0.25"
61 |           android:layout_width="fill_parent"
62 |           android:layout_height="wrap_content" 
63 |           android:textSize="8pt"
64 |         />   
65 |     </LinearLayout>
66 |     <FrameLayout
67 |         android:layout_width="0px"
68 |         android:layout_height="fill_parent"
69 |         android:layout_weight="1"
70 |       />
71 |   </LinearLayout>
72 |   <FrameLayout
73 |       android:layout_width="fill_parent"
74 |       android:layout_height="0px"
75 |       android:layout_weight="1"
76 |     />
77 | </LinearLayout>
78 | 
79 | 


--------------------------------------------------------------------------------
/res/layout/misc_item_layout.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 3 |     android:layout_width="fill_parent"
 4 |     android:layout_height="wrap_content"
 5 |     android:minHeight="?android:attr/listPreferredItemHeight"
 6 |     android:gravity="center_vertical"
 7 |     android:paddingRight="?android:attr/scrollbarSize">
 8 | 
 9 |     <RelativeLayout
10 |         android:layout_width="wrap_content"
11 |         android:layout_height="wrap_content"
12 |         android:layout_marginLeft="15dip"
13 |         android:layout_marginRight="6dip"
14 |         android:layout_marginTop="6dip"
15 |         android:layout_marginBottom="6dip"
16 |         android:layout_weight="1">
17 | 
18 |         <TextView android:id="@+id/title"
19 |             android:layout_width="wrap_content"
20 |             android:layout_height="wrap_content"
21 |             android:singleLine="true"
22 |             android:textAppearance="?android:attr/textAppearanceLarge"
23 |             android:ellipsize="marquee"
24 |             android:fadingEdge="horizontal" />
25 | 
26 |         <TextView android:id="@+id/summary"
27 |             android:layout_width="wrap_content"
28 |             android:layout_height="wrap_content"
29 |             android:layout_below="@id/title"
30 |             android:layout_alignLeft="@id/title"
31 |             android:textAppearance="?android:attr/textAppearanceSmall"
32 |             android:maxLines="4" />
33 | 
34 |     </RelativeLayout>
35 | 
36 |     <LinearLayout android:id="@+id/widget_frame"
37 |         android:layout_width="wrap_content"
38 |         android:layout_height="fill_parent"
39 |         android:gravity="center_vertical"
40 |         android:orientation="vertical" />
41 | 
42 | </LinearLayout>
43 | 


--------------------------------------------------------------------------------
/res/layout/misc_layout.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |          android:orientation="vertical"
 4 |          android:layout_width="fill_parent"
 5 |          android:layout_height="fill_parent"
 6 |          android:paddingLeft="8dp"
 7 |          android:paddingRight="8dp">
 8 |      <ListView android:id="@id/android:list"
 9 |                android:layout_width="fill_parent"
10 |                android:layout_height="fill_parent"
11 |                android:background="#00FF00"
12 |                android:layout_weight="1"
13 |                android:drawSelectorOnTop="false"/>
14 |      <TextView android:id="@id/android:empty"
15 |                android:layout_width="fill_parent"
16 |                android:layout_height="fill_parent"
17 |                android:background="#FF0000"
18 |                android:text="No data"/>
19 |  </LinearLayout>
20 | 


--------------------------------------------------------------------------------
/res/layout/power_tabs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <TabHost xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:id="@android:id/tabhost"
 4 |     android:layout_width="fill_parent"
 5 |     android:layout_height="fill_parent">
 6 |   <LinearLayout
 7 |       android:orientation="vertical"
 8 |       android:layout_width="fill_parent"
 9 |       android:layout_height="fill_parent"
10 |       android:padding="5dp">
11 |     <TabWidget
12 |         android:id="@android:id/tabs"
13 |         android:layout_width="fill_parent"
14 |         android:layout_height="wrap_content" />
15 |     <FrameLayout
16 |         android:id="@android:id/tabcontent"
17 |         android:layout_width="fill_parent"
18 |         android:layout_height="fill_parent"
19 |         android:padding="5dp" />
20 |   </LinearLayout>
21 | </TabHost>
22 | 


--------------------------------------------------------------------------------
/res/layout/widget_configure.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:orientation="vertical"
 4 |     android:layout_width="fill_parent"
 5 |     android:layout_height="fill_parent"
 6 |     android:paddingLeft="8dp"
 7 |     android:paddingRight="8dp">
 8 |   <ListView android:id="@+id/list"
 9 |     android:layout_width="fill_parent"
10 |     android:layout_height="fill_parent"
11 |     android:drawSelectorOnTop="false"
12 |     android:layout_weight="0.15"/>
13 |   <LinearLayout
14 |       android:orientation="horizontal"
15 |       android:layout_width="fill_parent"
16 |       android:layout_height="fill_parent"
17 |       android:layout_weight="0.85">
18 |     <Button android:id="@+id/save_button"
19 |         android:text="Save"
20 |         android:layout_width="fill_parent" 
21 |         android:layout_height="fill_parent"
22 |         android:layout_weight="1"
23 |         android:gravity="center"
24 |       />
25 |     <Button android:id="@+id/cancel_button"
26 |         android:text="Cancel"
27 |         android:layout_width="fill_parent" 
28 |         android:layout_height="fill_parent"
29 |         android:layout_weight="1"
30 |         android:gravity="center"
31 |       />
32 |   </LinearLayout>
33 | </LinearLayout>
34 | 


--------------------------------------------------------------------------------
/res/layout/widget_item_layout.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 3 |     android:layout_marginLeft="15dip"
 4 |     android:layout_marginRight="6dip"
 5 |     android:layout_marginTop="6dip"
 6 |     android:layout_marginBottom="6dip"
 7 |     android:layout_width="fill_parent"
 8 |     android:layout_height="wrap_content"
 9 |     android:minHeight="?android:attr/listPreferredItemHeight"
10 |     android:gravity="center_vertical"
11 |     android:paddingRight="?android:attr/scrollbarSize">
12 |   <TextView android:id="@+id/title"
13 |       android:layout_width="wrap_content"
14 |       android:layout_height="wrap_content"
15 |       android:singleLine="true"
16 |       android:textAppearance="?android:attr/textAppearanceLarge"
17 |       android:ellipsize="marquee"
18 |       android:fadingEdge="horizontal" />
19 |   <TextView android:id="@+id/summary"
20 |       android:gravity="center"
21 |       android:layout_width="fill_parent"
22 |       android:layout_height="wrap_content"
23 |       android:layout_below="@id/title"
24 |       android:layout_alignLeft="@id/title"
25 |       android:textAppearance="?android:attr/textAppearanceSmall"
26 |       android:maxLines="4" />
27 | </RelativeLayout>
28 | 


--------------------------------------------------------------------------------
/res/layout/widget_layout.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:orientation="horizontal"
 4 |     android:layout_width="fill_parent"
 5 |     android:layout_height="fill_parent"
 6 |     android:paddingLeft="14dp"
 7 |     android:paddingRight="14dp"
 8 |     android:paddingTop="17dp"
 9 |     android:paddingBottom="17dp"
10 |     android:background="@drawable/widget_bg"
11 |   >
12 |   <ImageView android:id="@+id/power_button"
13 |       android:layout_width="fill_parent" 
14 |       android:layout_height="fill_parent" 
15 |       android:layout_weight="0.25"
16 |       android:paddingRight="3dp"
17 |       android:src="@drawable/power_off"
18 |       android:clickable="true"
19 |       android:scaleType="centerInside"
20 |     />
21 |   <TextView android:id="@+id/text_minute"
22 |       android:layout_width="fill_parent" 
23 |       android:layout_height="fill_parent" 
24 |       android:layout_weight="0.25"
25 |       android:paddingRight="3dp"
26 |       android:gravity="center"
27 |     />
28 |   <TextView android:id="@+id/text_hour"
29 |       android:layout_width="fill_parent" 
30 |       android:layout_height="fill_parent" 
31 |       android:layout_weight="0.25"
32 |       android:paddingRight="3dp"
33 |       android:gravity="center"
34 |     />
35 |   <TextView android:id="@+id/text_day"
36 |       android:layout_width="fill_parent" 
37 |       android:layout_height="fill_parent" 
38 |       android:layout_weight="0.25"
39 |       android:paddingRight="3dp"
40 |       android:gravity="center"
41 |     />
42 | </LinearLayout>
43 | 


--------------------------------------------------------------------------------
/res/values/arrays.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 |   <string-array name="xaxis">
 3 |     <item>Last 10 seconds</item>
 4 |     <item>Last 30 seconds</item>
 5 |     <item>Last 1 minute</item>
 6 |     <item>Last 2 minutes</item>
 7 |     <item>Last 5 minutes</item>
 8 |   </string-array>
 9 |   <integer-array name="xaxis_secs">
10 |     <item>10</item>
11 |     <item>30</item>
12 |     <item>60</item>
13 |     <item>120</item>
14 |     <item>300</item>
15 |   </integer-array>
16 |   <string-array name="xaxis_secs_str">
17 |     <item>10</item>
18 |     <item>30</item>
19 |     <item>60</item>
20 |     <item>120</item>
21 |     <item>300</item>
22 |   </string-array>
23 |   <string-array name="freq">
24 |     <item>Every 1 second</item>
25 |     <item>Every 3 seconds</item>
26 |     <item>Every 6 seconds</item>
27 |     <item>Every 12 seconds</item>
28 |     <item>Every 30 seconds</item>
29 |   </string-array>
30 | </resources>
31 | 


--------------------------------------------------------------------------------
/res/values/strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 |     <string name="app_name">PowerTutor</string>
 4 |     <string name="running_on_startup">The Power Profiler will now run after your phone starts up.</string>
 5 |     <string name="not_running_on_startup">The Power Profiler will no longer run on when your phone starts up.</string>
 6 |     <string name="stop_sending_text">This application sends data on power utilization and running applications to the PowerTutor team. We gather nothing allowing us to associate the data with you or your phone; a cryptographically secure hash function is used to protect your identity.  Pressing \'Stop\' will prevent these data from being sent.</string>
 7 |     <string name="start_sending_text">This application sends data on power utilization and running applications to the PowerTutor team. We gather nothing allowing us to associate the data with you or your phone; a cryptographically secure hash function is used to protect your identity.  Pressing \'Start\' will start sending the data from now on.</string>
 8 |     <string name="unknown_phone">Your phone type is not recognized by PowerTutor. You may continue to use PowerTutor however we may not be able to get all of the data for your phone and the power calculations may not be accurate.</string>
 9 |     <string name="term">
10 |     <p>In this version of PowerTutor the Power Profiler service is run on
11 | startup and power consumption traces are sent back to the PowerTutor team.  This
12 | helps us identify common power consumption problems for real applications.  The
13 | information will be used to improve PowerTutor and recommend power efficiency
14 | improvements to other software, with the end goal of increasing your phone\'s
15 | battery life.\n</p>\n
16 |     <p>We gather\n
17 | 	- CPU use\n
18 | 	- Amount of WiFi/3G traffic (not its content)\n
19 | 	- Screen brightness\n
20 | 	- GPS activity (but not location)\n
21 |   - Audio use (on/off, volume)\n
22 | 	- Total power consumption\n
23 | 	- Application resource utilization\n
24 | 	- Phone mode, e.g., airplane mode or call status\n
25 | </p>
26 |     <p>\nWe do <b>NOT</b> gather any of your personal data used in applications
27 | or phone call logs. None of these data will be associate with you or your phone.
28 | We use a cryptographically secure hash function to protect your identity.\n
29 | </p>\n
30 |     <p>PowerTutor will send back traces only when the phone is plugged in and
31 | will prefer to use Wifi to send back the traces, although your carrier\'s data
32 | service will be used if Wifi is rarely available.  If you would like to disable
33 | sending traces you can do so in the menu or by turning off background data in
34 | the android options.
35 |     </p></string>
36 |     <string name ="help_head"> <big><b>PowerTutor</b></big> - A real-time system and application power monitor.</string>
37 |     <string name ="help_text">\n
38 |     <ul>
39 |     <li><b>Main control panel</b>\n
40 |      - Start/stop profiling services. \n
41 |      - Select <b>Application</b> or <b>System</b> mode to check out power consumption statistics.\n
42 |      - Menu features:\n
43 |         \t* Start/stop sending power traces to the PowerTutor team.\n
44 |         \t* Enable/Disable the profiling service to run on startup.\n
45 |         \t* Save the current power trace to the sdcard.\n
46 |     </li>\n
47 |           <li><b>App View</b>\n
48 |      - Displays power usage information for all of the apps running on the
49 |            phone.\n
50 |      - Press an app row to go to the <i>Graph View</i> for that app\'s power
51 |            usage.\n
52 |      - Press a hardware component name in the top tabs to include/exclude it from power
53 |             calculations.\n
54 |      - Data interpretation:\n
55 |         \t* Percentage value: The percentage of energy/average power consumed by the 
56 |             app in system.\n
57 |         \t* Time value: Time that the app has been actively monitored by PowerTutor.\n
58 |      - Menu features:\n
59 |         \t* Change the sort key to one of current power, average power, or total energy usage.\n
60 |         \t* Change the time span to include the last minute, hour, day, or all time.\n
61 |     </li>\n
62 |     <li><b>Graph View</b>\n
63 |      - Displays app/system power consumption decomposed by hardware component.\n
64 |      - Use the tabs at the top to move between <i>Chart View</i> and <i>Pie
65 |        View</i>.\n
66 |     </li>\n
67 |     <li><b>Chart View</b>\n
68 |      - Displays the power usage of different components on the phone in recent
69 |            history.\n
70 |      - Scroll to view different component power graphs.\n
71 |      - Menu features:\n
72 |         \t* Select \"<i>Set History Size</i>\" to adjust the number of data points
73 |            displayed.\n
74 |         \t* Select \"<i>Magnify Recent Data</i>\" to show more recent data points
75 |            more spread out.\n
76 |         \t* Select \"<i>Pause</i>\" to freeze the display as is, select resume to
77 |            continue.\n
78 |     </li>\n
79 |     <li><b>Pie View</b>\n
80 |      - Displays the power usage percentages of the different components.\n
81 |      - Menu features:\n
82 |         \t* Change the time span to include the last minute, hour, day, or all time.\n
83 |     </li>\n
84 |     </ul>
85 |     </string>
86 | 
87 | 
88 | <string name="url_1">For detailed information, please go to: </string>
89 | <string name="url_2"><a href = "http://powertutor.org">http://powertutor.org</a>.\n</string>
90 | </resources>
91 | 


--------------------------------------------------------------------------------
/res/xml/preferences.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <PreferenceScreen
 3 |   xmlns:android="http://schemas.android.com/apk/res/android">
 4 |   <CheckBoxPreference
 5 |     android:key="runOnStartup"
 6 |     android:title="Run on startup"
 7 |     android:summary="Have the profiling service start when your phone starts" />
 8 |   <CheckBoxPreference
 9 |     android:key="sendPermission"
10 |     android:title="Send logs"
11 |     android:summary="Send back power traces to the PowerTutor team" />
12 | </PreferenceScreen>
13 | 


--------------------------------------------------------------------------------
/res/xml/viewer_preferences.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <PreferenceScreen
 3 |   xmlns:android="http://schemas.android.com/apk/res/android">
 4 |   <CheckBoxPreference
 5 |     android:key="showTotalPower"
 6 |     android:title="Total power"
 7 |     android:summary="Show total power consumption" />
 8 |   <ListPreference android:key="viewNumValues_s"
 9 |     android:title="Set history size"
10 |     android:summary="Change how many data points are displayed"
11 |     android:entries="@array/xaxis"
12 |     android:entryValues="@array/xaxis_secs_str"
13 |     android:dialogTitle="Set number of data points"
14 |     android:defaultValue="60" />
15 | </PreferenceScreen>
16 | 


--------------------------------------------------------------------------------
/res/xml/widget_info.xml:
--------------------------------------------------------------------------------
1 | <appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
2 |     android:configure="edu.umich.PowerTutor.widget.Configure"
3 |     android:minWidth="294dp"
4 |     android:minHeight="72dp"
5 |     android:updatePeriodMillis="0"
6 |     android:initialLayout="@layout/widget_layout"
7 |     >
8 | </appwidget-provider>
9 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/PowerNotifications.aidl:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor;
21 | 
22 | interface PowerNotifications {
23 |     // These are the notifications that are actually supported.  The rest have
24 |     // potential to be supported but aren't needed at the moment so aren't
25 |     // actually hooked.
26 |     void noteStartWakelock(int uid, String name, int type);
27 |     void noteStopWakelock(int uid, String name, int type);
28 |     void noteStartSensor(int uid, int sensor);
29 |     void noteStopSensor(int uid, int sensor);
30 |     void noteStartGps(int uid);
31 |     void noteStopGps(int uid);
32 |     void noteScreenBrightness(int brightness);
33 |     void noteStartMedia(int uid, int id);
34 |     void noteStopMedia(int uid, int id);
35 |     void noteVideoSize(int uid, int id, int width, int height);
36 |     void noteSystemMediaCall(int uid);
37 | 
38 |     void noteScreenOn();
39 |     void noteScreenOff();
40 |     void noteInputEvent();
41 |     void noteUserActivity(int uid, int event);
42 |     void notePhoneOn();
43 |     void notePhoneOff();
44 |     void notePhoneDataConnectionState(int dataType, boolean hasData);
45 |     void noteWifiOn(int uid);
46 |     void noteWifiOff(int uid);
47 |     void noteWifiRunning();
48 |     void noteWifiStopped();
49 |     void noteBluetoothOn();
50 |     void noteBluetoothOff();
51 |     void noteFullWifiLockAcquired(int uid);
52 |     void noteFullWifiLockReleased(int uid);
53 |     void noteScanWifiLockAcquired(int uid);
54 |     void noteScanWifiLockReleased(int uid);
55 |     void noteWifiMulticastEnabled(int uid);
56 |     void noteWifiMulticastDisabled(int uid);
57 |     void setOnBattery(boolean onBattery, int level);
58 |     void recordCurrentLevel(int level);
59 |     /* Also got rid of the non-notification calls.
60 |      * byte[] getStatistics();
61 |      * long getAwakeTimeBattery();
62 |      * long getAwakeTimePlugged();
63 |      */
64 | 
65 |     /* Added functions to the normal IBatteryStats interface. */
66 |     void noteVideoOn(int uid);
67 |     void noteVideoOff(int uid);
68 |     void noteAudioOn(int uid);
69 |     void noteAudioOff(int uid);
70 | }
71 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/components/Audio.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.components;
 21 | 
 22 | import edu.umich.PowerTutor.PowerNotifications;
 23 | import edu.umich.PowerTutor.service.IterationData;
 24 | import edu.umich.PowerTutor.service.PowerData;
 25 | import edu.umich.PowerTutor.util.NotificationService;
 26 | import edu.umich.PowerTutor.util.Recycler;
 27 | 
 28 | import android.content.Context;
 29 | import android.media.AudioManager;
 30 | 
 31 | import java.io.IOException;
 32 | import java.io.OutputStreamWriter;
 33 | import java.util.TreeSet;
 34 | 
 35 | /**This class aims to log the audio device status once per log interval*/
 36 | public class Audio extends PowerComponent {
 37 |   /**This class is the logger data file corresponding to Audio*/
 38 |   public static class AudioData extends PowerData {
 39 |     private static Recycler<AudioData> recycler = new Recycler<AudioData>();
 40 |     
 41 |     public static AudioData obtain() {
 42 |       AudioData result = recycler.obtain();
 43 |       if(result != null) return result;
 44 |       return new AudioData();
 45 |     }
 46 | 
 47 |     @Override
 48 |     public void recycle() {
 49 |       recycler.recycle(this);
 50 |     }
 51 | 
 52 |     public boolean musicOn;
 53 |   
 54 |     private AudioData() {
 55 |     }
 56 | 
 57 |     public void init(boolean musicOn) {
 58 |       this.musicOn = musicOn;
 59 |     }
 60 |   
 61 |     public void writeLogDataInfo(OutputStreamWriter out) throws IOException {
 62 |       out.write("Audio-on " + musicOn + "\n");
 63 |     }
 64 |   }
 65 | 
 66 |   private static class MediaData implements Comparable {
 67 |     private static Recycler<MediaData> recycler = new Recycler<MediaData>();
 68 |     
 69 |     public static MediaData obtain() {
 70 |       MediaData result = recycler.obtain();
 71 |       if(result != null) return result;
 72 |       return new MediaData();
 73 |     }
 74 | 
 75 |     public void recycle() {
 76 |       recycler.recycle(this);
 77 |     }
 78 | 
 79 |     public int uid;
 80 |     public int id;
 81 |     public int assignUid;
 82 | 
 83 |     public int compareTo(Object obj) {
 84 |       MediaData x = (MediaData)obj;
 85 |       if(uid < x.uid) return -1;
 86 |       if(uid > x.uid) return 1;
 87 |       if(id < x.id) return -1;
 88 |       if(id > x.id) return 1;
 89 |       return 0;
 90 |     }
 91 | 
 92 |     public boolean equals(Object obj) {
 93 |       MediaData x = (MediaData)obj;
 94 |       return uid == x.uid && id == x.id;
 95 |     }
 96 |   }
 97 | 
 98 |   private AudioManager audioManager;
 99 |   private PowerNotifications audioNotif;
100 |   private TreeSet<MediaData> uidData;
101 | 
102 |   public Audio(Context context) {
103 |     if(NotificationService.available()) {
104 |       uidData = new TreeSet<MediaData>();
105 |       audioNotif = new NotificationService.DefaultReceiver() {
106 |         private int sysUid = -1;
107 | 
108 |         @Override
109 |         public void noteSystemMediaCall(int uid) {
110 |           sysUid = uid;
111 |         }
112 | 
113 |         @Override
114 |         public void noteStartMedia(int uid, int id) {
115 |           MediaData data = MediaData.obtain();
116 |           data.uid = uid;
117 |           data.id = id;
118 |           if(uid == 1000 && sysUid != -1) {
119 |             data.assignUid = sysUid;
120 |             sysUid = -1;
121 |           } else {
122 |             data.assignUid = uid;
123 |           }
124 |           synchronized(uidData) {
125 |             if(!uidData.add(data)) {
126 |               data.recycle();
127 |             }
128 |           }
129 |         }
130 | 
131 |         @Override
132 |         public void noteStopMedia(int uid, int id) {
133 |           MediaData data = MediaData.obtain();
134 |           data.uid = uid;
135 |           data.id = id;
136 |           synchronized(uidData) {
137 |             uidData.remove(data);
138 |           }
139 |           data.recycle();
140 |         }
141 |       };
142 |       NotificationService.addHook(audioNotif);
143 |     }
144 | 
145 |     audioManager = (AudioManager)context.getSystemService(
146 |                                              Context.AUDIO_SERVICE);
147 |   }
148 | 
149 |   @Override
150 |   protected void onExit() {
151 |     if(audioNotif != null) {
152 |       NotificationService.removeHook(audioNotif);
153 |     }
154 |   }
155 | 
156 |   @Override
157 |   public IterationData calculateIteration(long iteration) {
158 |     IterationData result = IterationData.obtain();
159 |     AudioData data = AudioData.obtain();
160 |     data.init(uidData != null && !uidData.isEmpty() ||
161 |               audioManager.isMusicActive());
162 |     result.setPowerData(data);
163 | 
164 |     if(uidData != null) synchronized(uidData) {
165 |       int last_uid = -1;
166 |       for(MediaData dat : uidData) {
167 |         if(dat.uid != last_uid) {
168 |           AudioData audioPower = AudioData.obtain();
169 |           audioPower.init(true);
170 |           result.addUidPowerData(dat.assignUid, audioPower);
171 |         }
172 |         last_uid = dat.uid;
173 |       }
174 |     }
175 | 
176 |     return result;
177 |   }
178 | 
179 |   @Override
180 |   public boolean hasUidInformation() {
181 |     return audioNotif != null;
182 |   }
183 | 
184 |   @Override
185 |   public String getComponentName() {
186 |     return "Audio";
187 |   }
188 | }
189 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/components/CPU.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.components;
 21 | 
 22 | import edu.umich.PowerTutor.phone.PhoneConstants;
 23 | import edu.umich.PowerTutor.service.IterationData;
 24 | import edu.umich.PowerTutor.service.PowerData;
 25 | import edu.umich.PowerTutor.util.Recycler;
 26 | import edu.umich.PowerTutor.util.SystemInfo;
 27 | 
 28 | import android.util.Log;
 29 | import android.os.Process;
 30 | import android.os.SystemClock;
 31 | import android.util.SparseArray;
 32 | 
 33 | import java.io.BufferedReader;
 34 | import java.io.FileNotFoundException;
 35 | import java.io.FileReader;
 36 | import java.io.IOException;
 37 | import java.io.OutputStreamWriter;
 38 | import java.lang.reflect.Method;
 39 | import java.lang.reflect.InvocationTargetException;
 40 |  
 41 | public class CPU extends PowerComponent {
 42 |   public static class CpuData extends PowerData {
 43 |     private static Recycler<CpuData> recycler = new Recycler<CpuData>();
 44 | 
 45 |     public static CpuData obtain() {
 46 |       CpuData result = recycler.obtain();
 47 |       if(result != null) return result;
 48 |       return new CpuData();
 49 |     }
 50 | 
 51 |     @Override
 52 |     public void recycle() {
 53 |       recycler.recycle(this);
 54 |     }
 55 | 
 56 |     public double sysPerc;
 57 |     public double usrPerc;
 58 |     public double freq;
 59 | 
 60 |     private CpuData() {
 61 |     }
 62 | 
 63 |     public void init(double sysPerc, double usrPerc, double freq) {
 64 |       this.sysPerc = sysPerc;
 65 |       this.usrPerc = usrPerc;
 66 |       this.freq = freq;
 67 |     }
 68 | 
 69 |     public void writeLogDataInfo(OutputStreamWriter out) throws IOException {
 70 |       StringBuilder res = new StringBuilder();
 71 |       res.append("CPU-sys ").append((long)Math.round(sysPerc))
 72 |          .append("\nCPU-usr ").append((long)Math.round(usrPerc))
 73 |          .append("\nCPU-freq ").append(freq)
 74 |          .append("\n");
 75 |       out.write(res.toString());
 76 |     }
 77 |   }
 78 | 
 79 |   private static final String TAG = "CPU";
 80 |   private static final String CPU_FREQ_FILE = "/proc/cpuinfo";
 81 |   private static final String STAT_FILE = "/proc/stat";
 82 | 
 83 |   private CpuStateKeeper cpuState;
 84 |   private SparseArray<CpuStateKeeper> pidStates;
 85 |   private SparseArray<CpuStateKeeper> uidLinks;
 86 | 
 87 |   private int[] pids;
 88 |   private long[] statsBuf;
 89 | 
 90 |   private PhoneConstants constants;
 91 | 
 92 |   public CPU(PhoneConstants constants) {
 93 |     this.constants = constants;
 94 |     cpuState = new CpuStateKeeper(SystemInfo.AID_ALL);
 95 |     pidStates = new SparseArray<CpuStateKeeper>();
 96 |     uidLinks = new SparseArray<CpuStateKeeper>();
 97 |     statsBuf = new long[7];
 98 |   }
 99 | 
100 |   @Override
101 |   public IterationData calculateIteration(long iteration) {
102 |     IterationData result = IterationData.obtain();
103 | 
104 |     SystemInfo sysInfo = SystemInfo.getInstance();
105 |     double freq = readCpuFreq(sysInfo);
106 |     if(freq < 0) {
107 |       Log.w(TAG, "Failed to read cpu frequency");
108 |       return result;
109 |     }
110 | 
111 |     if(!sysInfo.getUsrSysTotalTime(statsBuf)) {
112 |       Log.w(TAG, "Failed to read cpu times");
113 |       return result;
114 |     }
115 | 
116 |     long usrTime = statsBuf[SystemInfo.INDEX_USER_TIME];
117 |     long sysTime = statsBuf[SystemInfo.INDEX_SYS_TIME];
118 |     long totalTime = statsBuf[SystemInfo.INDEX_TOTAL_TIME];
119 | 
120 |     boolean init = cpuState.isInitialized();
121 |     cpuState.updateState(usrTime, sysTime, totalTime, iteration);
122 | 
123 |     if(init) {
124 |       CpuData data = CpuData.obtain();
125 |       data.init(cpuState.getUsrPerc(), cpuState.getSysPerc(), freq);
126 |       result.setPowerData(data);
127 |     }
128 | 
129 |     uidLinks.clear();
130 |     pids = sysInfo.getPids(pids);
131 |     int pidInd = 0;
132 |     if(pids != null) for(int pid : pids) {
133 |       if(pid < 0) {
134 |         break;
135 |       }
136 | 
137 |       CpuStateKeeper pidState;
138 |       if(pidInd < pidStates.size() && pidStates.keyAt(pidInd) == pid) {
139 |         pidState = pidStates.valueAt(pidInd);
140 |       } else {
141 |         int uid = sysInfo.getUidForPid(pid);
142 |         if(uid >= 0) {
143 |           pidState = new CpuStateKeeper(uid);
144 |           pidStates.put(pid, pidState);
145 |         } else {
146 |           /* Assume that this process no longer exists. */
147 |           continue;
148 |         }
149 |       }
150 |       pidInd++;
151 | 
152 |       if(!pidState.isStale(iteration)) {
153 |         /* Nothing much is going on with this pid recently.  We'll just
154 |          * assume that it's not using any of the cpu for this iteration.
155 |          */
156 |         pidState.updateIteration(iteration, totalTime);
157 |       } else if(sysInfo.getPidUsrSysTime(pid, statsBuf)) {
158 |         usrTime = statsBuf[SystemInfo.INDEX_USER_TIME];
159 |         sysTime = statsBuf[SystemInfo.INDEX_SYS_TIME];
160 | 
161 |         init = pidState.isInitialized();
162 |         pidState.updateState(usrTime, sysTime, totalTime, iteration);
163 | 
164 |         if(!init) {
165 |           continue;
166 |         }
167 |       }
168 | 
169 |       CpuStateKeeper linkState = uidLinks.get(pidState.getUid());
170 |       if(linkState == null) {
171 |         uidLinks.put(pidState.getUid(), pidState);
172 |       } else {
173 |         linkState.absorb(pidState);
174 |       }
175 |     }
176 | 
177 |     /* Remove processes that are no longer active. */
178 |     for(int i = 0; i < pidStates.size(); i++) {
179 |       if(!pidStates.valueAt(i).isAlive(iteration)) {
180 |         pidStates.remove(pidStates.keyAt(i--));
181 |       }
182 |     }
183 | 
184 |     /* Collect the summed uid information. */
185 |     for(int i = 0; i < uidLinks.size(); i++) {
186 |       int uid = uidLinks.keyAt(i);
187 |       CpuStateKeeper linkState = uidLinks.valueAt(i);
188 |       
189 |       CpuData uidData = CpuData.obtain();
190 |       predictAppUidState(uidData, linkState.getUsrPerc(),
191 |                          linkState.getSysPerc(), freq);
192 |       result.addUidPowerData(uid, uidData);
193 |     }
194 | 
195 |     return result;
196 |   }
197 | 
198 |   /* This is the function that is responsible for predicting the cpu frequency
199 |    * state of the individual uid as though it were the only thing running.  It
200 |    * simply is finding the lowest frequency that keeps the cpu usage under
201 |    * 70% assuming there is a linear relationship to the cpu utilization at
202 |    * different frequencies.
203 |    */
204 |   private void predictAppUidState(CpuData uidData, double usrPerc,
205 |                                   double sysPerc, double freq) {
206 |     double[] freqs = constants.cpuFreqs();
207 |     if(usrPerc + sysPerc < 1e-6) {
208 |       /* Don't waste time with the binary search if there is no utilization
209 |        * which will be the case a lot.
210 |        */
211 |       uidData.init(sysPerc, usrPerc, freqs[0]);
212 |       return;
213 |     }
214 |     int lo = 0;
215 |     int hi = freqs.length - 1;
216 |     double perc = sysPerc + usrPerc;
217 |     while(lo < hi) {
218 |       int mid = (lo + hi) / 2;
219 |       double nperc = perc * freq / freqs[mid];
220 |       if(nperc < 70) {
221 |         hi = mid;
222 |       } else {
223 |         lo = mid + 1;
224 |       }
225 |     }
226 |     uidData.init(sysPerc * freq / freqs[lo], usrPerc * freq / freqs[lo],
227 |                  freqs[lo]);
228 |   }
229 | 
230 |   private static class CpuStateKeeper {
231 |     private int uid;
232 |     private long iteration;
233 |     private long lastUpdateIteration;
234 |     private long inactiveIterations;
235 | 
236 |     private long lastUsr;
237 |     private long lastSys;
238 |     private long lastTotal;
239 | 
240 |     private long sumUsr;
241 |     private long sumSys;
242 |     private long deltaTotal;
243 | 
244 |     private CpuStateKeeper(int uid) {
245 |       this.uid = uid;
246 |       lastUsr = lastSys = -1;
247 |       lastUpdateIteration = iteration = -1;
248 |       inactiveIterations = 0;
249 |     }
250 | 
251 |     public boolean isInitialized() {
252 |       return lastUsr != -1;
253 |     }
254 | 
255 |     public void updateIteration(long iteration, long totalTime) {
256 |       /* Process is still running but actually reading the cpu utilization has
257 |        * been skipped this iteration to avoid wasting cpu cycles as this process
258 |        * has not been very active recently. */
259 |       sumUsr = 0;
260 |       sumSys = 0;
261 |       deltaTotal = totalTime - lastTotal;
262 |       if(deltaTotal < 1) deltaTotal = 1;
263 |       lastTotal = totalTime;
264 |       this.iteration = iteration;
265 |     }
266 | 
267 |     public void updateState(long usrTime, long sysTime, long totalTime,
268 |                             long iteration) {
269 |       sumUsr = usrTime - lastUsr;
270 |       sumSys = sysTime - lastSys;
271 |       deltaTotal = totalTime - lastTotal;
272 |       if(deltaTotal < 1) deltaTotal = 1;
273 |       lastUsr = usrTime;
274 |       lastSys = sysTime;
275 |       lastTotal = totalTime;
276 |       lastUpdateIteration = this.iteration = iteration;
277 | 
278 |       if(getUsrPerc() + getSysPerc() < 0.1) {
279 |         inactiveIterations++;
280 |       } else {
281 |         inactiveIterations = 0;
282 |       }
283 |     }
284 | 
285 |     public int getUid() {
286 |       return uid;
287 |     }
288 | 
289 |     public void absorb(CpuStateKeeper s) {
290 |       sumUsr += s.sumUsr;
291 |       sumSys += s.sumSys;
292 |     }
293 | 
294 |     public double getUsrPerc() {
295 |       return 100.0 * sumUsr / Math.max(sumUsr + sumSys, deltaTotal);
296 |     }
297 | 
298 |     public double getSysPerc() {
299 |       return 100.0 * sumSys / Math.max(sumUsr + sumSys, deltaTotal);
300 |     }
301 | 
302 |     public boolean isAlive(long iteration) {
303 |       return this.iteration == iteration;
304 |     }
305 | 
306 |     public boolean isStale(long iteration) {
307 |       return 1L << (iteration - lastUpdateIteration) > 
308 |               inactiveIterations * inactiveIterations;
309 |     }
310 |   }
311 | 
312 |   @Override
313 |   public boolean hasUidInformation() {
314 |     return true;
315 |   }
316 | 
317 |   @Override
318 |   public String getComponentName() {
319 |     return "CPU";
320 |   }
321 | 
322 |   /* Returns the frequency of the processor in Mhz.  If the frequency cannot
323 |    * be determined returns a negative value instead.
324 |    */
325 |   private double readCpuFreq(SystemInfo sysInfo) {
326 |     /* Try to read from the /sys/devices file first.  If that doesn't work
327 |      * try manually inspecting the /proc/cpuinfo file.
328 |      */
329 |     long cpuFreqKhz = sysInfo.readLongFromFile(
330 |       "/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq");
331 |     if(cpuFreqKhz != -1) {
332 |       return cpuFreqKhz / 1000.0;
333 |     }
334 | 
335 |     FileReader fstream;
336 |     try {
337 |       fstream = new FileReader(CPU_FREQ_FILE);
338 |     } catch (FileNotFoundException e) {
339 |       Log.w(TAG, "Could not read cpu frequency file");
340 |       return -1;
341 |     }
342 |     BufferedReader in = new BufferedReader(fstream, 500);
343 |     String line;
344 |     try {
345 |       while((line = in.readLine()) != null) {
346 |         if(line.startsWith("BogoMIPS")) {
347 |           return Double.parseDouble(line.trim().split("[ :]+")[1]);
348 |         }
349 |       }
350 |     } catch(IOException e) {
351 |       /* Failed to read from the cpu freq file. */
352 |     } catch(NumberFormatException e) {
353 |       /* Frequency not formatted properly as a double. */
354 |     }
355 |     Log.w(TAG, "Failed to read cpu frequency");
356 |     return -1;
357 |   }
358 | }
359 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/components/LCD.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.components;
 21 | 
 22 | import edu.umich.PowerTutor.PowerNotifications;
 23 | import edu.umich.PowerTutor.service.IterationData;
 24 | import edu.umich.PowerTutor.service.PowerData;
 25 | import edu.umich.PowerTutor.util.ForegroundDetector;
 26 | import edu.umich.PowerTutor.util.NotificationService;
 27 | import edu.umich.PowerTutor.util.Recycler;
 28 | import edu.umich.PowerTutor.util.SystemInfo;
 29 | 
 30 | import android.app.ActivityManager;
 31 | import android.content.BroadcastReceiver;
 32 | import android.content.Context;
 33 | import android.content.Intent;
 34 | import android.content.IntentFilter;
 35 | import android.provider.Settings;
 36 | import android.os.Process;
 37 | import android.util.Log;
 38 | 
 39 | import java.io.File;
 40 | import java.io.IOException;
 41 | import java.io.OutputStreamWriter;
 42 | import java.util.List;
 43 | 
 44 | public class LCD extends PowerComponent {
 45 |   public static class LcdData extends PowerData {
 46 |     private static Recycler<LcdData> recycler = new Recycler<LcdData>();
 47 | 
 48 |     public static LcdData obtain() {
 49 |       LcdData result = recycler.obtain();
 50 |       if(result != null) return result;
 51 |       return new LcdData();
 52 |     }
 53 | 
 54 |     @Override
 55 |     public void recycle() {
 56 |       recycler.recycle(this);
 57 |     }
 58 | 
 59 | 	  public int brightness;
 60 | 	  public boolean screenOn;
 61 | 	
 62 |     private LcdData() {
 63 |     }
 64 | 
 65 |     public void init(int brightness, boolean screenOn) {
 66 |       this.brightness = brightness;
 67 |       this.screenOn = screenOn;
 68 |     }
 69 | 	
 70 | 	  public void writeLogDataInfo(OutputStreamWriter out) throws IOException {
 71 |       StringBuilder res = new StringBuilder();
 72 |       res.append("LCD-brightness ").append(brightness)
 73 |          .append("\nLCD-screen-on ").append(screenOn).append("\n");
 74 |       out.write(res.toString());
 75 |     }
 76 |   }
 77 | 
 78 | 	private final String TAG = "LCD";
 79 |   private static final String[] BACKLIGHT_BRIGHTNESS_FILES = {
 80 |     "/sys/devices/virtual/leds/lcd-backlight/brightness",
 81 |     "/sys/devices/platform/trout-backlight.0/leds/lcd-backlight/brightness",
 82 |   };
 83 | 
 84 |   private Context context;
 85 |   private ForegroundDetector foregroundDetector;
 86 |   private BroadcastReceiver broadcastReceiver;
 87 |   private boolean screenOn;
 88 | 
 89 |   private String brightnessFile;
 90 | 
 91 |   public LCD(Context context) {
 92 |     this.context = context;
 93 |     screenOn = true;
 94 | 
 95 |     if(context == null) {
 96 |       return;
 97 |     }
 98 | 
 99 |     foregroundDetector = new ForegroundDetector((ActivityManager)
100 |         context.getSystemService(context.ACTIVITY_SERVICE));
101 |     broadcastReceiver = new BroadcastReceiver() {
102 |       public void onReceive(Context context, Intent intent) {
103 |         synchronized(this) {
104 |           if(intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
105 |             screenOn = false;
106 |           } else if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
107 |             screenOn = true;
108 |           }
109 |         }
110 |       };
111 |     };
112 |     IntentFilter intentFilter = new IntentFilter();
113 |     intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
114 |     intentFilter.addAction(Intent.ACTION_SCREEN_ON);
115 |     context.registerReceiver(broadcastReceiver, intentFilter);
116 | 
117 |     for(int i = 0; i < BACKLIGHT_BRIGHTNESS_FILES.length; i++) {
118 |       if(new File(BACKLIGHT_BRIGHTNESS_FILES[i]).exists()) {
119 |         brightnessFile = BACKLIGHT_BRIGHTNESS_FILES[i];
120 |       }
121 |     }
122 |   }
123 | 
124 |   @Override
125 |   protected void onExit() {
126 |     context.unregisterReceiver(broadcastReceiver);
127 |     super.onExit();
128 |   } 
129 | 
130 |   @Override
131 |   public IterationData calculateIteration(long iteration) {
132 |     IterationData result = IterationData.obtain();
133 | 
134 |     boolean screen;
135 |     synchronized(this) {
136 |       screen = screenOn;
137 |     }
138 | 
139 |     int brightness;
140 |     if(brightnessFile != null) {
141 |       brightness = (int)SystemInfo.getInstance()
142 |           .readLongFromFile(brightnessFile);
143 |     } else {
144 |       try {
145 |         brightness = Settings.System.getInt(context.getContentResolver(),
146 |                                             Settings.System.SCREEN_BRIGHTNESS);
147 |       } catch(Settings.SettingNotFoundException ex) {
148 |         Log.w(TAG, "Could not retrieve brightness information");
149 |         return result;
150 |       }
151 |     }
152 |     if(brightness < 0 || 255 < brightness) {
153 |       Log.w(TAG, "Could not retrieve brightness information");
154 |       return result;
155 |     }
156 | 
157 |     LcdData data = LcdData.obtain();
158 |     data.init(brightness, screen);
159 |     result.setPowerData(data);
160 | 
161 |     if(screen) {
162 |       LcdData uidData = LcdData.obtain();
163 |       uidData.init(brightness, screen);
164 |       result.addUidPowerData(foregroundDetector.getForegroundUid(), uidData);
165 |     }
166 | 
167 |     return result;
168 |   }
169 | 
170 |   @Override
171 |   public boolean hasUidInformation() {
172 |     return true;
173 |   }
174 | 
175 |   @Override
176 |   public String getComponentName() {
177 |     return "LCD";
178 |   }
179 | }
180 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/components/OLED.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.components;
 21 | 
 22 | import edu.umich.PowerTutor.PowerNotifications;
 23 | import edu.umich.PowerTutor.phone.PhoneConstants;
 24 | import edu.umich.PowerTutor.service.IterationData;
 25 | import edu.umich.PowerTutor.service.PowerData;
 26 | import edu.umich.PowerTutor.util.NativeLoader;
 27 | import edu.umich.PowerTutor.util.NotificationService;
 28 | import edu.umich.PowerTutor.util.Recycler;
 29 | import edu.umich.PowerTutor.util.SystemInfo;
 30 | import edu.umich.PowerTutor.util.ForegroundDetector;
 31 | 
 32 | import android.app.ActivityManager;
 33 | import android.content.BroadcastReceiver;
 34 | import android.content.Context;
 35 | import android.content.Intent;
 36 | import android.content.IntentFilter;
 37 | import android.provider.Settings;
 38 | import android.os.Process;
 39 | import android.util.Log;
 40 | import android.util.DisplayMetrics;
 41 | import android.view.WindowManager;
 42 | 
 43 | import java.io.DataOutputStream;
 44 | import java.io.File;
 45 | import java.io.FileInputStream;
 46 | import java.io.FileNotFoundException;
 47 | import java.io.RandomAccessFile;
 48 | import java.io.IOException;
 49 | import java.io.OutputStreamWriter;
 50 | import java.util.List;
 51 | import java.util.Random;
 52 | 
 53 | import java.io.*;
 54 | import java.nio.*;
 55 | import java.nio.channels.*;
 56 | 
 57 | public class OLED extends PowerComponent {
 58 |   public static class OledData extends PowerData {
 59 |     private static Recycler<OledData> recycler = new Recycler<OledData>();
 60 | 
 61 |     public static OledData obtain() {
 62 |       OledData result = recycler.obtain();
 63 |       if(result != null) return result;
 64 |       return new OledData();
 65 |     }
 66 | 
 67 |     @Override
 68 |     public void recycle() {
 69 |       recycler.recycle(this);
 70 |     }
 71 | 
 72 | 	  public int brightness;
 73 |     public double pixPower;
 74 | 	  public boolean screenOn;
 75 | 	
 76 |     private OledData() {
 77 |     }
 78 | 
 79 |     public void init() {
 80 |       this.screenOn = false;
 81 |     }
 82 | 
 83 |     public void init(int brightness, double pixPower) {
 84 |       screenOn = true;
 85 |       this.brightness = brightness;
 86 |       this.pixPower = pixPower;
 87 |     }
 88 | 	
 89 | 	  public void writeLogDataInfo(OutputStreamWriter out) throws IOException {
 90 |       out.write("OLED-brightness " + brightness + "\n");
 91 |       out.write("OLED-pix-power " + pixPower + "\n");
 92 |       out.write("OLED-screen-on " + screenOn + "\n");
 93 |     }
 94 |   }
 95 | 
 96 | 	private static final String TAG = "OLED";
 97 |   private static final String[] BACKLIGHT_BRIGHTNESS_FILES = {
 98 |     "/sys/class/leds/lcd-backlight/brightness",
 99 |     "/sys/devices/virtual/leds/lcd-backlight/brightness",
100 |     "/sys/devices/platform/trout-backlight.0/leds/lcd-backlight/brightness",
101 |   };
102 | 
103 |   private Context context;
104 |   private ForegroundDetector foregroundDetector;
105 |   private BroadcastReceiver broadcastReceiver;
106 |   private boolean screenOn;
107 | 
108 |   private File frameBufferFile;
109 | 
110 |   private int screenWidth;
111 |   private int screenHeight;
112 | 
113 |   private static final int NUMBER_OF_SAMPLES = 500;
114 |   private int[] samples;
115 | 
116 |   private String brightnessFile;
117 | 
118 |   /* Coefficients pre-computed for pix power calculations.
119 |    */
120 |   private double rcoef;
121 |   private double gcoef;
122 |   private double bcoef;
123 |   private double modul_coef;
124 | 
125 |   public OLED(Context context, PhoneConstants constants) {
126 |     this.context = context;
127 |     screenOn = true;
128 | 
129 |     foregroundDetector = new ForegroundDetector((ActivityManager)
130 |         context.getSystemService(context.ACTIVITY_SERVICE));
131 |     broadcastReceiver = new BroadcastReceiver() {
132 |       public void onReceive(Context context, Intent intent) {
133 |         synchronized(this) {
134 |           if(intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
135 |             screenOn = false;
136 |           } else if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
137 |             screenOn = true;
138 |           }
139 |         }
140 |       };
141 |     };
142 |     IntentFilter intentFilter = new IntentFilter();
143 |     intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
144 |     intentFilter.addAction(Intent.ACTION_SCREEN_ON);
145 |     context.registerReceiver(broadcastReceiver, intentFilter);
146 | 
147 |     frameBufferFile = new File("/dev/fb0");
148 |     if(!frameBufferFile.exists()) {
149 |       frameBufferFile = new File("/dev/graphics/fb0");
150 |     }
151 |     if(frameBufferFile.exists()) try {
152 |       /* Check if we already have permission to read the frame buffer. */
153 |       boolean readOk = false;
154 |       try {
155 |         RandomAccessFile fin = new RandomAccessFile(frameBufferFile, "r");
156 |         int b = fin.read();
157 |         fin.close();
158 |         readOk = true;
159 |       } catch(IOException e) {
160 |       }
161 |       /* Don't have permission, try to change permission as root. */
162 |       if(!readOk) {
163 |         java.lang.Process p = Runtime.getRuntime().exec("su");
164 |         DataOutputStream os = new DataOutputStream(p.getOutputStream());
165 |         os.writeBytes("chown " + android.os.Process.myUid() +
166 |                       " " + frameBufferFile.getAbsolutePath() + "\n");
167 |         os.writeBytes("chown app_" + (android.os.Process.myUid() -
168 |                       SystemInfo.AID_APP) +
169 |                       " " + frameBufferFile.getAbsolutePath() + "\n");
170 |         os.writeBytes("chmod 660 " + frameBufferFile.getAbsolutePath() + "\n");
171 |         os.writeBytes("exit\n");
172 |         os.flush();
173 |         p.waitFor();
174 |         if(p.exitValue() != 0) {
175 |           Log.i(TAG, "failed to change permissions on frame buffer");
176 |         }
177 |       }
178 |     } catch (InterruptedException e) {
179 |       Log.i(TAG, "changing permissions on frame buffer interrupted");
180 |     } catch (IOException e) {
181 |       Log.i(TAG, "unexpected exception while changing permission on " +
182 |             "frame buffer");
183 |       e.printStackTrace();
184 |     }
185 | 
186 |     DisplayMetrics metrics = new DisplayMetrics();
187 |     WindowManager windowManager =
188 |         (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
189 |     windowManager.getDefaultDisplay().getMetrics(metrics);
190 |     screenWidth = metrics.widthPixels;
191 |     screenHeight = metrics.heightPixels;
192 | 
193 |     Random r = new Random();
194 |     samples = new int[NUMBER_OF_SAMPLES];
195 |     for(int i = 0; i < NUMBER_OF_SAMPLES; i++) {
196 |       int a = screenWidth * screenHeight * i / NUMBER_OF_SAMPLES;
197 |       int b = screenWidth * screenHeight * (i + 1) / NUMBER_OF_SAMPLES;
198 |       samples[i] = a + r.nextInt(b - a);
199 |     }
200 | 
201 |     double[] channel = constants.oledChannelPower();
202 |     rcoef = channel[0] / 255 / 255;
203 |     gcoef = channel[1] / 255 / 255;
204 |     bcoef = channel[2] / 255 / 255;
205 |     modul_coef = constants.oledModulation() / 255 / 255 / 3 / 3;
206 | 
207 |     for(int i = 0; i < BACKLIGHT_BRIGHTNESS_FILES.length; i++) {
208 |       if(new File(BACKLIGHT_BRIGHTNESS_FILES[i]).exists()) {
209 |         brightnessFile = BACKLIGHT_BRIGHTNESS_FILES[i];
210 |       }
211 |     }
212 |   }
213 | 
214 |   @Override
215 |   protected void onExit() {
216 |     context.unregisterReceiver(broadcastReceiver);
217 |     super.onExit();
218 |   } 
219 | 
220 |   @Override
221 |   public IterationData calculateIteration(long iteration) {
222 |     IterationData result = IterationData.obtain();
223 | 
224 |     boolean screen;
225 |     synchronized(this) {
226 |       screen = screenOn;
227 |     }
228 | 
229 |     int brightness;
230 |     if(brightnessFile != null) {
231 |       brightness = (int)SystemInfo.getInstance()
232 |           .readLongFromFile(brightnessFile);
233 |     } else {
234 |       try {
235 |         brightness = Settings.System.getInt(context.getContentResolver(),
236 |                                             Settings.System.SCREEN_BRIGHTNESS);
237 |       } catch(Settings.SettingNotFoundException ex) {
238 |         Log.w(TAG, "Could not retrieve brightness information");
239 |         return result;
240 |       }
241 |     }
242 |     if(brightness < 0 || 255 < brightness) {
243 |       Log.w(TAG, "Could not retrieve brightness information");
244 |       return result;
245 |     }
246 | 
247 |     double pixPower = 0;
248 |     if(screen && frameBufferFile.exists()) {
249 |       if(NativeLoader.jniLoaded()) {
250 |         pixPower = getScreenPixPower(rcoef, gcoef, bcoef, modul_coef);
251 |       } else try {
252 |         RandomAccessFile fin = new RandomAccessFile(frameBufferFile, "r");
253 | 
254 |         for(int x : samples) {
255 |           fin.seek(x * 4);
256 |           int px = fin.readInt();
257 |           int b = px >> 8 & 0xFF;
258 |           int g = px >> 16 & 0xFF;
259 |           int r = px >> 24 & 0xFF;
260 | 
261 |           /* Calculate the power usage of this one pixel if it were at full
262 |            * brightness.  Linearly scale by brightness to get true power
263 |            * consumption.  To calculate whole screen compute average of sampled
264 |            * region and multiply by number of pixels.
265 |            */
266 |           int modul_val = r + g + b;
267 |           pixPower += rcoef * (r * r) + gcoef * (g * g) + bcoef * (b * b) -
268 |                       modul_coef * (modul_val * modul_val);
269 |         }
270 |         fin.close();
271 |       } catch(FileNotFoundException e) {
272 |         pixPower = -1;
273 |       } catch(IOException e) {
274 |         pixPower = -1;
275 |         e.printStackTrace();
276 |       }
277 |       if(pixPower >= 0) {
278 |         pixPower *= 1.0 * screenWidth * screenHeight / NUMBER_OF_SAMPLES;
279 |       }
280 |     }
281 | 
282 |     OledData data = OledData.obtain();
283 |     if(!screen) {
284 |       data.init();
285 |     } else {
286 |       data.init(brightness, pixPower);
287 |     }
288 |     result.setPowerData(data);
289 | 
290 |     if(screen) {
291 |       OledData uidData = OledData.obtain();
292 |       uidData.init(brightness, pixPower);
293 |       result.addUidPowerData(foregroundDetector.getForegroundUid(), uidData);
294 |     }
295 | 
296 |     return result;
297 |   }
298 | 
299 |   @Override
300 |   public boolean hasUidInformation() {
301 |     return true;
302 |   }
303 | 
304 |   @Override
305 |   public String getComponentName() {
306 |     return "OLED";
307 |   }
308 | 
309 |   public static native double getScreenPixPower(double rcoef, double gcoef,
310 |                                             double bcoef, double modul_coef);
311 | }
312 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/components/PowerComponent.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.components;
 21 | 
 22 | import edu.umich.PowerTutor.service.IterationData;
 23 | 
 24 | import android.os.SystemClock;
 25 | import android.util.Log;
 26 | 
 27 | public abstract class PowerComponent extends Thread {
 28 | 	private final String TAG = "PowerComponent";
 29 | 
 30 |   /* Extending classes need to override the calculateIteration function.  It
 31 |    * should calculate the data point for the given component in a timely
 32 |    * manner (under 1 second, longer times will cause data to be missed).
 33 |    * The iteration parameter can be ignored in most cases.
 34 |    */
 35 |   protected abstract IterationData calculateIteration(long iteration);
 36 | 
 37 |   /* Extending classes should provide a recognizable name for this component
 38 |    * to be used when writing to logs.
 39 |    */
 40 |   public abstract String getComponentName();
 41 | 
 42 |   /* Returns true if this component collects usage information per uid.
 43 |    */
 44 |   public boolean hasUidInformation() {
 45 |     return false;
 46 |   }
 47 | 
 48 |   /* Called when the thread running this interface is asked to exit.
 49 |    */
 50 |   protected void onExit() {
 51 |   }
 52 | 
 53 |   /* In general we should only need to buffer two data elements.
 54 |    */
 55 |   private IterationData data1;
 56 |   private IterationData data2;
 57 |   private long iteration1;
 58 |   private long iteration2;
 59 | 
 60 |   protected long beginTime;
 61 |   protected long iterationInterval;
 62 | 
 63 |   public PowerComponent() {
 64 |     setDaemon(true);
 65 |   }
 66 | 
 67 |   /* This is called once at the begginning of the daemon loop.
 68 |    */
 69 |   public void init(long beginTime, long iterationInterval) {
 70 |     this.beginTime = beginTime;
 71 |     this.iterationInterval = iterationInterval;
 72 |     data1 = data2 = null;
 73 |     iteration1 = iteration2 = -1;
 74 |   }
 75 | 
 76 |   /* Runs the daemon loop that collects data for this component. */
 77 |   public void run() {
 78 |     android.os.Process.setThreadPriority(
 79 |         android.os.Process.THREAD_PRIORITY_MORE_FAVORABLE);
 80 |     for(long iter = 0; !Thread.interrupted(); ) {
 81 |       /* Hand off to the client class to actually calculate the information
 82 |        * we want for this component.
 83 |        */
 84 |       IterationData data = calculateIteration(iter);
 85 |       if(data != null) {
 86 |         synchronized(this) {
 87 |           if(iteration1 < iteration2) {
 88 |             iteration1 = iter;
 89 |             data1 = data;
 90 |           } else {
 91 |             iteration2 = iter;
 92 |             data2 = data;
 93 |           }
 94 |         }
 95 |       }
 96 |       if(interrupted()) {
 97 |         break;
 98 |       }
 99 | 
100 |       long curTime = SystemClock.elapsedRealtime();
101 |       /* Compute the next iteration that we can make the start of. */
102 |       long oldIter = iter;
103 |       iter = (long)Math.max(iter + 1,
104 |                             1 + (curTime - beginTime) / iterationInterval);
105 |       if(oldIter + 1 != iter) {
106 |         Log.w(TAG, "[" + getComponentName() + "] Had to skip from iteration " +
107 |                    oldIter + " to " + iter);
108 |       }
109 |       /* Sleep until the next iteration completes. */
110 |       try {
111 | 			  sleep(beginTime + iter * iterationInterval - curTime);
112 |       } catch(InterruptedException e) {
113 |         break;
114 |       }
115 |     }
116 |     onExit();
117 |   }
118 | 
119 |   /* Returns the data point for the given iteration.  This method will be called
120 |      with a strictly increasing iteration parameter.
121 |    */
122 |   public IterationData getData(long iteration) {
123 |     synchronized(this) {
124 |       IterationData ret = null;
125 |       if(iteration == iteration1) ret = data1;
126 |       if(iteration == iteration2) ret = data2;
127 |       if(iteration1 <= iteration) {
128 |         data1 = null;
129 |         iteration1 = -1;
130 |       }
131 |       if(iteration2 <= iteration) {
132 |         data2 = null;
133 |         iteration2 = -1;
134 |       }
135 |       if(ret == null) {
136 |         Log.w(TAG, "[" + getComponentName() + "] Could not find data for " +
137 |                    "requested iteration");
138 |       }
139 |       return ret;
140 |     }
141 |   }
142 | }
143 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/components/Sensors.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.components;
 21 | 
 22 | import edu.umich.PowerTutor.PowerNotifications;
 23 | import edu.umich.PowerTutor.service.IterationData;
 24 | import edu.umich.PowerTutor.service.PowerData;
 25 | import edu.umich.PowerTutor.util.NotificationService;
 26 | import edu.umich.PowerTutor.util.Recycler;
 27 | import edu.umich.PowerTutor.util.SystemInfo;
 28 | 
 29 | import android.content.Context;
 30 | import android.hardware.SensorManager;
 31 | import android.os.SystemClock;
 32 | import android.util.Log;
 33 | import android.util.SparseArray;
 34 | 
 35 | import java.io.IOException;
 36 | import java.io.OutputStreamWriter;
 37 | import java.util.Set;
 38 | import java.util.TreeSet;
 39 | import java.util.Map;
 40 | import java.util.TreeMap;
 41 | 
 42 | public class Sensors extends PowerComponent {
 43 | 	private final String TAG = "Sensors";
 44 |   public static final int MAX_SENSORS = 10;
 45 | 
 46 |   public static class SensorData extends PowerData {
 47 |     private static Recycler<SensorData> recycler = new Recycler<SensorData>();
 48 | 
 49 |     public static SensorData obtain() {
 50 |       SensorData result = recycler.obtain();
 51 |       if(result != null) return result;
 52 |       return new SensorData();
 53 |     }
 54 | 
 55 |     @Override
 56 |     public void recycle() {
 57 |       recycler.recycle(this);
 58 |     }
 59 |     
 60 |     public double[] onTime;
 61 | 
 62 |     private SensorData() {
 63 |       onTime = new double[MAX_SENSORS];
 64 |     }
 65 | 
 66 | 	  public void writeLogDataInfo(OutputStreamWriter out) throws IOException {
 67 |       StringBuilder res = new StringBuilder();
 68 |       for(int i = 0; i < MAX_SENSORS; i++) {
 69 |         if(onTime[i] > 1e-7) {
 70 |           res.append("Sensors-time ").append(i).append(" ")
 71 |              .append(onTime[i]).append("\n");
 72 |         }
 73 |       }
 74 |       out.write(res.toString());
 75 |     }
 76 |   }
 77 | 
 78 |   private Context context;
 79 |   private SensorManager sensorManager;
 80 |   private PowerNotifications sensorHook;
 81 | 
 82 |   private SensorStateKeeper sensorState;
 83 |   private SparseArray<SensorStateKeeper> uidStates;
 84 | 
 85 |   public Sensors(Context context) {
 86 |     this.context = context;
 87 |     sensorState = new SensorStateKeeper();
 88 |     uidStates = new SparseArray<SensorStateKeeper>();
 89 | 
 90 |     if(!NotificationService.available()) {
 91 |       Log.w(TAG, "Sensor component created although no notification service " +
 92 |             "available to receive sensor usage information");
 93 |       return;
 94 |     }
 95 |     sensorManager = (SensorManager)context.getSystemService(
 96 |         Context.SENSOR_SERVICE);
 97 |     sensorHook = new NotificationService.DefaultReceiver() {
 98 |       public void noteStartSensor(int uid, int sensor) {
 99 |         if(sensor < 0 || MAX_SENSORS <= sensor) {
100 |           Log.w(TAG, "Received sensor outside of accepted range");
101 |           return;
102 |         }
103 |         synchronized(sensorState) {
104 |           sensorState.startSensor(sensor);
105 |           SensorStateKeeper uidState = uidStates.get(uid);
106 |           if(uidState == null) {
107 |             uidState = new SensorStateKeeper();
108 |             uidStates.put(uid, uidState);
109 |           }
110 |           uidState.startSensor(sensor);
111 |         }
112 |       }
113 | 
114 |       public void noteStopSensor(int uid, int sensor) {
115 |         if(sensor < 0 || MAX_SENSORS <= sensor) {
116 |           Log.w(TAG, "Received sensor outside of accepted range");
117 |           return;
118 |         }
119 |         synchronized(sensorState) {
120 |           sensorState.stopSensor(sensor);
121 |           SensorStateKeeper uidState = uidStates.get(uid);
122 |           if(uidState == null) {
123 |             uidState = new SensorStateKeeper();
124 |             uidStates.put(uid, uidState);
125 |           }
126 |           uidState.stopSensor(sensor);
127 |         }
128 |       }
129 |     };
130 |     NotificationService.addHook(sensorHook);
131 |   }
132 | 
133 |   @Override
134 |   protected void onExit() {
135 |     super.onExit();
136 |     NotificationService.removeHook(sensorHook);
137 |   } 
138 | 
139 |   @Override
140 |   public IterationData calculateIteration(long iteration) {
141 |     IterationData result = IterationData.obtain();
142 |     synchronized(sensorState) {
143 |       SensorData globalData = SensorData.obtain();
144 |       sensorState.setupSensorTimes(globalData.onTime, iterationInterval);
145 |       result.setPowerData(globalData);
146 | 
147 |       for(int i = 0; i < uidStates.size(); i++) {
148 |         int uid = uidStates.keyAt(i);
149 |         SensorStateKeeper uidState = uidStates.valueAt(i);
150 |         SensorData uidData = SensorData.obtain();
151 |         uidState.setupSensorTimes(uidData.onTime, iterationInterval);
152 |         result.addUidPowerData(uid, uidData);
153 | 
154 |         if(uidState.sensorsOn() == 0) {
155 |           uidStates.remove(uid);
156 |           i--;
157 |         }
158 |       }
159 |     }
160 |     return result;
161 |   }
162 | 
163 |   private static class SensorStateKeeper {
164 |     private int[] nesting;
165 |     private long[] times;
166 |     private long lastTime;
167 |     private int count;
168 | 
169 |     public SensorStateKeeper() {
170 |       nesting = new int[MAX_SENSORS];
171 |       times = new long[MAX_SENSORS];
172 |       lastTime = SystemClock.elapsedRealtime();
173 |     }
174 | 
175 |     public void startSensor(int sensor) {
176 |       if(nesting[sensor]++ == 0) {
177 |         times[sensor] -= SystemClock.elapsedRealtime() - lastTime;
178 |         count++;
179 |       }
180 |     }
181 | 
182 |     public void stopSensor(int sensor) {
183 |       if(nesting[sensor] == 0) {
184 |         return;
185 |       } else if(--nesting[sensor] == 0) {
186 |         times[sensor] += SystemClock.elapsedRealtime() - lastTime;
187 |         count--;
188 |       }
189 |     }
190 | 
191 |     public int sensorsOn() {
192 |       return count;
193 |     }
194 | 
195 |     public void setupSensorTimes(double[] sensorTimes, long iterationInterval) {
196 |       long now = SystemClock.elapsedRealtime();
197 |       long div = now - lastTime;
198 |       if(div <= 0) div = 1;
199 |       for(int i = 0; i < MAX_SENSORS; i++) {
200 |         sensorTimes[i] = 1.0 * (times[i] +
201 |                          (nesting[i] > 0 ? now - lastTime : 0)) / div;
202 |         times[i] = 0;
203 |       }
204 |       lastTime = now;
205 |     }
206 |   }
207 | 
208 |   @Override
209 |   public boolean hasUidInformation() {
210 |     return true;
211 |   }
212 | 
213 |   @Override
214 |   public String getComponentName() {
215 |     return "Sensors";
216 |   }
217 | }
218 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/DreamConstants.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.phone;
 21 | 
 22 | import android.content.Context;
 23 | import android.hardware.Sensor;
 24 | import android.hardware.SensorManager;
 25 | 
 26 | import edu.umich.PowerTutor.components.Sensors;
 27 | 
 28 | public class DreamConstants implements PhoneConstants {
 29 |   protected static final String OPER_TMOBILE = "T - Mobile";
 30 |   protected static final String OPER_ATT = "AT&T";
 31 | 
 32 |   /* TODO: Figure out if this is really appropriate or how we should convert
 33 |    * the sensor power ratings (in mA) to mW.  I'm not sure we'll try to model
 34 |    * these thing's power usage but for the developer it's definitely interesting
 35 |    * to get some (perhaps rough?) idea of how much power sensors are using.
 36 |    */
 37 |   protected double BATTERY_VOLTAGE = 3.7;
 38 | 
 39 |   public DreamConstants(Context context) {
 40 |     SensorManager sensorManager = (SensorManager)context.getSystemService(
 41 |                                       Context.SENSOR_SERVICE);
 42 |     sensorPowerArray = new double[Sensors.MAX_SENSORS];
 43 |     for(int i = 0; i < Sensors.MAX_SENSORS; i++) {
 44 |       Sensor sensor = sensorManager.getDefaultSensor(i);
 45 |       if(sensor != null) {
 46 |         sensorPowerArray[i] = sensor.getPower() * BATTERY_VOLTAGE;
 47 |       }
 48 |     }
 49 |   }
 50 | 
 51 |   public String modelName() {
 52 |     return "dream";
 53 |   }
 54 | 
 55 |   public double maxPower() {
 56 |     return 2800;
 57 |   }
 58 | 
 59 |   public double lcdBrightness() {
 60 |     return 2.40276;
 61 |   }
 62 | 
 63 |   public double lcdBacklight() {
 64 |     return 121.4606 + 166.5;
 65 |   }
 66 | 
 67 |   public double oledBasePower() {
 68 |     throw new RuntimeException("oledBasePower() called on device with no " +
 69 |                                "OLED display");
 70 |   }
 71 | 
 72 |   public double[] oledChannelPower() {
 73 |     throw new RuntimeException("oledChannelPower() called on device with no " +
 74 |                                "OLED display");
 75 |   }
 76 | 
 77 |   public double oledModulation() {
 78 |     throw new RuntimeException("oledModulation() called on device with no " +
 79 |                                "OLED display");
 80 |   }
 81 | 
 82 |   private static final double[] arrayCpuPowerRatios = {3.4169, 4.3388};
 83 |   public double[] cpuPowerRatios() {
 84 |     return arrayCpuPowerRatios;
 85 |   }
 86 | 
 87 |   private static final double[] arrayCpuFreqs = {245.36, 383.38};
 88 |   public double[] cpuFreqs() {
 89 |     return arrayCpuFreqs;
 90 |   }
 91 | 
 92 |   public double audioPower() {
 93 |     return 384.62;
 94 |   }
 95 | 
 96 |   private static final double[] arrayGpsStatePower = {0.0, 173.55, 429.55};
 97 |   public double[] gpsStatePower() {
 98 |     return arrayGpsStatePower;
 99 |   }
100 | 
101 |   public double gpsSleepTime() {
102 |     return 6.0;
103 |   }
104 | 
105 |   public double wifiLowPower() {
106 |     return 38.554;
107 |   }
108 | 
109 |   public double wifiHighPower() {
110 |     return 720;
111 |   }
112 | 
113 |   public double wifiLowHighTransition() {
114 |     return 15;
115 |   }
116 | 
117 |   public double wifiHighLowTransition() {
118 |     return 8;
119 |   }
120 | 
121 |   private static final double[] arrayWifiLinkRatios = {
122 |     47.122645, 46.354821, 43.667437, 43.283525, 40.980053, 39.44422, 38.676581,
123 |     34.069637, 29.462693, 20.248805, 11.034917, 6.427122
124 |   };
125 |   public double[] wifiLinkRatios() {
126 |     return arrayWifiLinkRatios;
127 |   }
128 | 
129 |   private static final double[] arrayWifiLinkSpeeds = {
130 |     1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54
131 |   };
132 |   public double[] wifiLinkSpeeds() {
133 |     return arrayWifiLinkSpeeds;
134 |   }
135 | 
136 |   public String threegInterface() {
137 |     return "rmnet0";
138 |   }
139 | 
140 |   public double threegIdlePower(String oper) {
141 |     if(OPER_TMOBILE.equals(oper)) {
142 |       return 10;
143 |     }
144 |     return 10;
145 |   }
146 | 
147 |   public double threegFachPower(String oper) {
148 |     if(OPER_TMOBILE.equals(oper)) {
149 |       return 401;
150 |     }
151 |     return 401;
152 |   }
153 | 
154 |   public double threegDchPower(String oper) {
155 |     if(OPER_TMOBILE.equals(oper)) {
156 |       return 570;
157 |     }
158 |     return 570;
159 |   }
160 | 
161 |   public int threegDchFachDelay(String oper) {
162 |     if(OPER_TMOBILE.equals(oper)) {
163 |       return 6;
164 |     } else if(OPER_ATT.equals(oper)) {
165 |       return 5;
166 |     }
167 |     return 4;
168 |   }
169 | 
170 |   public int threegFachIdleDelay(String oper) {
171 |     if(OPER_TMOBILE.equals(oper)) {
172 |       return 4;
173 |     } else if(OPER_ATT.equals(oper)) {
174 |       return 12;
175 |     }
176 |     return 6;
177 |   }
178 | 
179 |   public int threegUplinkQueue(String oper) {
180 |     return 151;
181 |   }
182 | 
183 |   public int threegDownlinkQueue(String oper) {
184 |     return 119;
185 |   }
186 | 
187 |   private double[] sensorPowerArray;
188 |   public double[] sensorPower() {
189 |     return sensorPowerArray;
190 |   }
191 | 
192 |   public double getMaxPower(String componentName) {
193 |     if("LCD".equals(componentName)) {
194 |       return lcdBacklight() + lcdBrightness() * 255;
195 |     } else if("CPU".equals(componentName)) {
196 |       double[] ratios = cpuPowerRatios();
197 |       return ratios[ratios.length - 1] * 100;
198 |     } else if("Audio".equals(componentName)) {
199 |       return audioPower();
200 |     } else if("GPS".equals(componentName)) {
201 |       double[] gpsPow = gpsStatePower();
202 |       return gpsPow[gpsPow.length - 1];
203 |     } else if("Wifi".equals(componentName)) {
204 |       // TODO: Get a better estimation going here.
205 |       return 800;
206 |     } else if("3G".equals(componentName)) {
207 |       return threegDchPower("");
208 |     } else if("Sensors".equals(componentName)) {
209 |       double res = 0;
210 |       for(double x : sensorPower()) res += x;
211 |       return res;
212 |     } else {
213 |       return 900;
214 |     }
215 |   }
216 | }
217 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/DreamPowerCalculator.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.phone;
 21 | 
 22 | import edu.umich.PowerTutor.components.*;
 23 | import edu.umich.PowerTutor.components.LCD.LcdData;
 24 | import edu.umich.PowerTutor.components.OLED.OledData;
 25 | import edu.umich.PowerTutor.components.CPU.CpuData;
 26 | import edu.umich.PowerTutor.components.Audio.AudioData;
 27 | import edu.umich.PowerTutor.components.GPS.GpsData;
 28 | import edu.umich.PowerTutor.components.Wifi.WifiData;
 29 | import edu.umich.PowerTutor.components.Threeg.ThreegData;
 30 | import edu.umich.PowerTutor.components.Sensors.SensorData;
 31 | 
 32 | import android.content.Context;
 33 | 
 34 | public class DreamPowerCalculator implements PhonePowerCalculator {
 35 |   protected PhoneConstants coeffs;
 36 | 
 37 |   public DreamPowerCalculator(Context context) {
 38 |     this(new DreamConstants(context));
 39 |   }
 40 | 
 41 |   protected DreamPowerCalculator(PhoneConstants coeffs) {
 42 |     this.coeffs = coeffs;
 43 |   }
 44 | 
 45 |   public double getLcdPower(LcdData data) {
 46 |     return data.screenOn ?
 47 |            coeffs.lcdBrightness() * data.brightness + coeffs.lcdBacklight() : 0;
 48 |   } 
 49 | 
 50 |   public double getOledPower(OledData data) {
 51 |     throw new RuntimeException("getOledPower() should not be called for Dream");
 52 |   }
 53 | 
 54 |   public double getCpuPower(CpuData data) {
 55 |     /* Find the two nearest cpu frequency and linearly interpolate
 56 |      * the power ratio for that frequency.
 57 |      */
 58 |     double[] powerRatios = coeffs.cpuPowerRatios();
 59 |     double[] freqs = coeffs.cpuFreqs();
 60 |     double ratio;
 61 |     if(powerRatios.length == 1) {
 62 |       ratio = powerRatios[0];
 63 |     } else {
 64 |       double sfreq = data.freq;
 65 |       if(sfreq < freqs[0]) sfreq = freqs[0];
 66 |       if(sfreq > freqs[freqs.length - 1]) sfreq = freqs[freqs.length - 1];
 67 | 
 68 |       int ind = upperBound(freqs, sfreq);
 69 |       if(ind == 0) ind++;
 70 |       if(ind == freqs.length) ind--;
 71 |       ratio = powerRatios[ind - 1] + (powerRatios[ind] - powerRatios[ind - 1]) /
 72 |                                      (freqs[ind] - freqs[ind - 1]) *
 73 |                                      (sfreq - freqs[ind - 1]);
 74 |     }
 75 |     return Math.max(0, ratio * (data.usrPerc + data.sysPerc));
 76 |   }
 77 | 
 78 |   public double getAudioPower(AudioData data) {
 79 |     return data.musicOn ? coeffs.audioPower() : 0;
 80 |   }
 81 | 
 82 |   public double getGpsPower(GpsData data) {
 83 |     double result = 0;
 84 |     double statePower[] = coeffs.gpsStatePower();
 85 |     for(int i = 0; i < GPS.POWER_STATES; i++) {
 86 |       result += data.stateTimes[i] * statePower[i];
 87 |     }
 88 |     return result;
 89 |   }
 90 | 
 91 |   public double getWifiPower(WifiData data) {
 92 |     if(!data.wifiOn) {
 93 |       return 0;
 94 |     } else if(data.powerState == Wifi.POWER_STATE_LOW) {
 95 |       return coeffs.wifiLowPower();
 96 |     } else if(data.powerState == Wifi.POWER_STATE_HIGH) {
 97 |       double[] linkSpeeds = coeffs.wifiLinkSpeeds();
 98 |       double[] linkRatios = coeffs.wifiLinkRatios();
 99 |       double ratio;
100 |       if(linkSpeeds.length == 1) {
101 |         /* If there is only one set speed we have to use its ratio as we have
102 |          * nothing else to go on.
103 |          */
104 |         ratio = linkRatios[0];
105 |       } else {
106 |         /* Find the two nearest speed/ratio pairs and linearly interpolate
107 |          * the ratio for this link speed.
108 |          */
109 |         int ind = upperBound(linkSpeeds, data.linkSpeed);
110 |         if(ind == 0) ind++;
111 |         if(ind == linkSpeeds.length) ind--;
112 |         ratio = linkRatios[ind - 1] + (linkRatios[ind] - linkRatios[ind - 1]) /
113 |                                       (linkSpeeds[ind] - linkSpeeds[ind - 1]) *
114 |                                       (data.linkSpeed - linkSpeeds[ind - 1]);
115 |       }
116 |       return Math.max(0, coeffs.wifiHighPower() + ratio * data.uplinkRate);
117 |     }
118 |     throw new RuntimeException("Unexpected power state");
119 |   }
120 | 
121 |   public double getThreeGPower(ThreegData data) {
122 |     if(!data.threegOn) {
123 |       return 0;
124 |     } else {
125 |       switch(data.powerState) {
126 |         case Threeg.POWER_STATE_IDLE:
127 |           return coeffs.threegIdlePower(data.oper);
128 |         case Threeg.POWER_STATE_FACH:
129 |           return coeffs.threegFachPower(data.oper);
130 |         case Threeg.POWER_STATE_DCH:
131 |           return coeffs.threegDchPower(data.oper);
132 |       }
133 |     }
134 |     return 0;
135 |   }
136 | 
137 |   public double getSensorPower(SensorData data) {
138 |     double result = 0;
139 |     double[] powerUse = coeffs.sensorPower();
140 |     for(int i = 0; i < Sensors.MAX_SENSORS; i++) {
141 |       result += data.onTime[i] * powerUse[i];
142 |     }
143 |     return result;
144 |   }
145 | 
146 |   /* Returns the largest index y such that if x were inserted into A (which
147 |    * should already be sorted) at y then A would remain sorted.
148 |    */
149 |   protected static int upperBound(double[] A, double x) {
150 |     int lo = 0;
151 |     int hi = A.length;
152 |     while(lo < hi) {
153 |       int mid = lo + (hi - lo) / 2;
154 |       if(A[mid] <= x) {
155 |         lo = mid + 1;
156 |       } else {
157 |         hi = mid;
158 |       }
159 |     }
160 |     return lo;
161 |   }
162 | }
163 | 
164 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/PassionConstants.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.phone;
 21 | 
 22 | import android.content.Context;
 23 | import android.util.DisplayMetrics;
 24 | import android.view.WindowManager;
 25 | 
 26 | public class PassionConstants extends DreamConstants {
 27 |   protected int screenWidth;
 28 |   protected int screenHeight;
 29 | 
 30 |   public PassionConstants(Context context) {
 31 |     super(context);
 32 |     DisplayMetrics metrics = new DisplayMetrics();
 33 |     WindowManager windowManager =
 34 |         (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
 35 |     windowManager.getDefaultDisplay().getMetrics(metrics);
 36 |     screenWidth = metrics.widthPixels;
 37 |     screenHeight = metrics.heightPixels;
 38 |   }
 39 | 
 40 |   public String modelName() {
 41 |     return "passion";
 42 |   }
 43 | 
 44 |   public double maxPower() {
 45 |     return 2800;
 46 |   }
 47 | 
 48 |   public double lcdBrightness() {
 49 | 	return 1.2217;  
 50 | }
 51 | 
 52 |   public double lcdBacklight() {
 53 |     throw new RuntimeException("lcdBacklight() for passion which has no LCD " +
 54 |                                "display");
 55 |   }
 56 | 
 57 |   public double oledBasePower() {
 58 |     return 365; // This incorporates all the constant component in the model.
 59 |   }
 60 | 
 61 |   private static final double[] arrayChannelPower = {
 62 |       3.0647e-006, 4.4799e-006, 6.4045e-006};
 63 |   public double[] oledChannelPower() {
 64 |     return arrayChannelPower;
 65 |   }
 66 | 
 67 |   public double oledModulation() {
 68 |     return 1.7582e-006;
 69 |   }
 70 | 
 71 |   private static final double[] arrayCpuPowerRatios = {1.1273, 1.5907, 1.8736,
 72 |       2.1745, 2.6031, 2.9612, 3.1373,3.4513, 3.9073 ,4.1959, 4.6492, 5.4818};
 73 |   public double[] cpuPowerRatios() {
 74 |     return arrayCpuPowerRatios;
 75 |   }
 76 | 
 77 |   private static final double[] arrayCpuFreqs = {245, 384, 460, 499, 576, 614,
 78 |       653, 691, 768, 806, 845, 998};
 79 |   public double[] cpuFreqs() {
 80 |     return arrayCpuFreqs;
 81 |   }
 82 | 
 83 |   public double audioPower() {
 84 |     return 106.81;
 85 |   }
 86 | 
 87 |   private static final double[] arrayGpsStatePower = {0.0, 17.5, 268.94};
 88 |   public double[] gpsStatePower() {
 89 |     return arrayGpsStatePower;
 90 |   }
 91 | 
 92 |   public double gpsSleepTime() {
 93 |     return 6.0;
 94 |   }
 95 | 
 96 |   public double wifiLowPower() {
 97 |     return 34.37;
 98 |   }
 99 | 
100 |   public double wifiHighPower() {
101 |     return 404.46 ;
102 |   }
103 | 
104 |   public double wifiLowHighTransition() {
105 |     return 15;
106 |   }
107 | 
108 |   public double wifiHighLowTransition() {
109 |     return 8;
110 |   }
111 | 
112 |   private static final double[] arrayWifiLinkRatios = {
113 |     47.122645, 46.354821, 43.667437, 43.283525, 40.980053, 39.44422, 38.676581,
114 |     34.069637, 29.462693, 20.248805, 11.034917, 6.427122
115 |   };
116 |   public double[] wifiLinkRatios() {
117 |     return arrayWifiLinkRatios;
118 |   }
119 | 
120 |   private static final double[] arrayWifiLinkSpeeds = {
121 |     1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54
122 |   };
123 |   public double[] wifiLinkSpeeds() {
124 |     return arrayWifiLinkSpeeds;
125 |   }
126 | 
127 |   public String threegInterface() {
128 |     return "rmnet0";
129 |   }
130 | 
131 |   public double threegIdlePower(String oper) {
132 |     if(OPER_TMOBILE.equals(oper)) {
133 |       return 10;
134 |     }
135 |     return 10; // Return the worst case for unknown operators.
136 |   }
137 | 
138 |   public double threegFachPower(String oper) {
139 |     if(OPER_TMOBILE.equals(oper)) {
140 |       return 405.81;
141 |     }
142 |     return 405.81; // Return the worst case for unknown operators.
143 |   }
144 | 
145 |   public double threegDchPower(String oper) {
146 |     if(OPER_TMOBILE.equals(oper)) {
147 |       return 902.03;
148 |     }
149 |     return 902.03; // Return the worst case for unknown operators.
150 |   }
151 | 
152 |   public double getMaxPower(String componentName) {
153 |     if("OLED".equals(componentName)) {
154 |       double[] channel = oledChannelPower();
155 |       return oledBasePower() + 255 * screenWidth * screenHeight *
156 |              (channel[0] + channel[1] + channel[2] - oledModulation());
157 |     }
158 |     return super.getMaxPower(componentName);
159 |   }
160 | }
161 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/PassionPowerCalculator.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.phone;
21 | 
22 | import edu.umich.PowerTutor.components.LCD.LcdData;
23 | import edu.umich.PowerTutor.components.OLED.OledData;
24 | import edu.umich.PowerTutor.components.CPU.CpuData;
25 | import edu.umich.PowerTutor.components.Audio.AudioData;
26 | import edu.umich.PowerTutor.components.GPS.GpsData;
27 | import edu.umich.PowerTutor.components.Wifi.WifiData;
28 | import edu.umich.PowerTutor.components.Threeg.ThreegData;
29 | 
30 | import android.content.Context;
31 | 
32 | /* Most of this file should be inheritted from DreamPowerCalculator as most of
33 |  * the hardware model details will be the same modulo the coefficients.
34 |  */
35 | public class PassionPowerCalculator extends DreamPowerCalculator {
36 |   public PassionPowerCalculator(Context context) {
37 |     super(new PassionConstants(context));
38 |   }
39 | 
40 |   public PassionPowerCalculator(PhoneConstants coeffs) {
41 |     super(coeffs);
42 |   }
43 | 
44 |   @Override
45 |   public double getOledPower(OledData data) {
46 |     if(!data.screenOn) {
47 |       return 0;
48 |     }
49 |     if(data.pixPower == -1) {
50 |       /* No pixel power available :(. */
51 |       return coeffs.oledBasePower() + coeffs.lcdBrightness() * data.brightness;
52 |     } else {
53 |       return coeffs.oledBasePower() + data.pixPower * data.brightness;
54 |     }
55 |   }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/PhoneConstants.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.phone;
 21 | 
 22 | public interface PhoneConstants {
 23 |   /* Return the name of the model represented by these constants
 24 |    */
 25 |   public String modelName();
 26 | 
 27 |   /* Gives the maximum power that this phone can drain from its battery.
 28 |    */
 29 |   public double maxPower();
 30 | 
 31 |   /* Gives the coefficient to multiply the LCD display's brightness by to
 32 |    * calculate power usage.
 33 |    */
 34 |   public double lcdBrightness();
 35 | 
 36 |   /* Gives the power usage for the lcd display that is incurred by the display
 37 |    * just being turned on.
 38 |    */
 39 |   public double lcdBacklight();
 40 | 
 41 |   /* Gives the base power usage for the OLED display for just being on.
 42 |    */
 43 |   public double oledBasePower();
 44 | 
 45 |   /* Gives the power coefficient for rgb channels (in that order) for a signle
 46 |    * pixel.
 47 |    */
 48 |   public double[] oledChannelPower();
 49 | 
 50 |   /* Gives the modulation coefficient for the per pixel power calculation.
 51 |    */
 52 |   public double oledModulation();
 53 | 
 54 |   /* Gives the coefficients at different cpu frequencies for the amount of
 55 |    * power/cpu utilization the processor is using.
 56 |    */
 57 |   public double[] cpuPowerRatios();
 58 | 
 59 |   /* Gives the frequency for each of the power ratios listed in
 60 |    * cpuPowerRatios().
 61 |    */
 62 |   public double[] cpuFreqs();
 63 | 
 64 |   /* Gives the usage for the audio output being used.  The model doesn't
 65 |    * currently take into account volume.
 66 |    */
 67 |   public double audioPower();
 68 | 
 69 |   /* Gives the power consumption for each of the GPS states.  These states are
 70 |    * {OFF, SLEEP, ON} in that order.  See GPS.java.
 71 |    */
 72 |   public double[] gpsStatePower();
 73 | 
 74 |   /* Gives the time in seconds that the GPS sleeps for after the session
 75 |    * has ended.
 76 |    */
 77 |   public double gpsSleepTime();
 78 | 
 79 |   /* Gives the power consumption of wifi in the low power state.
 80 |    */
 81 |   public double wifiLowPower();
 82 | 
 83 |   /* Gives the base power consumption while the wifi is in high power mode.
 84 |    */
 85 |   public double wifiHighPower();
 86 | 
 87 |   /* Gives the packet rate needed to transition from the low power state
 88 |    * to the high power state.
 89 |    */
 90 |   public double wifiLowHighTransition();
 91 | 
 92 |   /* Gives the packet rate needed to transition from the high power state
 93 |    * to the low power state.
 94 |    */
 95 |   public double wifiHighLowTransition();
 96 | 
 97 |   /* Gives the power/uplinkrate for different link speeds for wifi in high
 98 |    * power mode.
 99 |    */
100 |   public double[] wifiLinkRatios();
101 | 
102 |   /* Gives the link speed associated with each link power ratio.  Elements
103 |    * should be in increasing order.  Should have the same number of elements
104 |    * as wifiLinkRatios().
105 |    */
106 |   public double[] wifiLinkSpeeds();
107 | 
108 |   /* Gives the name of the 3G interface for this phone.
109 |    */
110 |   public String threegInterface();
111 | 
112 |   /* Gives the power consumed while the 3G interface is in the idle state.
113 |    */
114 |   public double threegIdlePower(String oper);
115 | 
116 |   /* Gives the power consumed while the 3G interface is in the FACH state.
117 |    */
118 |   public double threegFachPower(String oper);
119 | 
120 |   /* Gives the power consumed while the 3G interface is in the DCH state.
121 |    */
122 |   public double threegDchPower(String oper);
123 | 
124 |   /* Gives the number of bytes in the uplink queue.
125 |    */
126 |   public int threegUplinkQueue(String oper);
127 | 
128 |   /* Gives the number of bytes in the downlink queue.
129 |    */
130 |   public int threegDownlinkQueue(String oper);
131 | 
132 |   /* Gives the time in seconds that the 3G interface stays idle in the DCH state
133 |    * before transitioning to the FACH state.
134 |    */
135 |   public int threegDchFachDelay(String oper);
136 |   
137 |   /* Gives the time in seconds that the 3G interface stays idle in the FACH
138 |    * state before transitioning to the IDLE state.
139 |    */
140 |   public int threegFachIdleDelay(String oper);
141 | 
142 |   /* Gives the power consumed by each of the sensors.  Should have the same size
143 |    * as Sensors.MAX_SENSORS.
144 |    */
145 |   public double[] sensorPower();
146 | 
147 |   /* Gives the maximum power in mW that the named component can generate.
148 |    */
149 |   public double getMaxPower(String componentName);
150 | }
151 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/PhonePowerCalculator.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.phone;
21 | 
22 | import edu.umich.PowerTutor.components.LCD.LcdData;
23 | import edu.umich.PowerTutor.components.OLED.OledData;
24 | import edu.umich.PowerTutor.components.CPU.CpuData;
25 | import edu.umich.PowerTutor.components.Audio.AudioData;
26 | import edu.umich.PowerTutor.components.GPS.GpsData;
27 | import edu.umich.PowerTutor.components.Wifi.WifiData;
28 | import edu.umich.PowerTutor.components.Threeg.ThreegData;
29 | import edu.umich.PowerTutor.components.Sensors.SensorData;
30 | 
31 | public interface PhonePowerCalculator {
32 |   public double getLcdPower(LcdData data);
33 | 
34 |   public double getOledPower(OledData data);
35 | 
36 |   public double getCpuPower(CpuData data);
37 | 
38 |   public double getAudioPower(AudioData data);
39 | 
40 |   public double getGpsPower(GpsData data);
41 | 
42 |   public double getWifiPower(WifiData data);
43 | 
44 |   public double getThreeGPower(ThreegData data);
45 | 
46 |   public double getSensorPower(SensorData data);
47 | }
48 | 
49 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/PhoneSelector.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.phone;
 21 | 
 22 | import java.util.List;
 23 | 
 24 | import android.content.Context;
 25 | import android.os.Build;
 26 | import android.util.Log;
 27 | import edu.umich.PowerTutor.components.Audio;
 28 | import edu.umich.PowerTutor.components.CPU;
 29 | import edu.umich.PowerTutor.components.GPS;
 30 | import edu.umich.PowerTutor.components.LCD;
 31 | import edu.umich.PowerTutor.components.OLED;
 32 | import edu.umich.PowerTutor.components.PowerComponent;
 33 | import edu.umich.PowerTutor.components.Sensors;
 34 | import edu.umich.PowerTutor.components.Threeg;
 35 | import edu.umich.PowerTutor.components.Wifi;
 36 | import edu.umich.PowerTutor.components.Audio.AudioData;
 37 | import edu.umich.PowerTutor.components.CPU.CpuData;
 38 | import edu.umich.PowerTutor.components.GPS.GpsData;
 39 | import edu.umich.PowerTutor.components.LCD.LcdData;
 40 | import edu.umich.PowerTutor.components.OLED.OledData;
 41 | import edu.umich.PowerTutor.components.Sensors.SensorData;
 42 | import edu.umich.PowerTutor.components.Threeg.ThreegData;
 43 | import edu.umich.PowerTutor.components.Wifi.WifiData;
 44 | import edu.umich.PowerTutor.service.PowerData;
 45 | import edu.umich.PowerTutor.util.NotificationService;
 46 | import edu.umich.PowerTutor.util.SystemInfo;
 47 | 
 48 | public class PhoneSelector {
 49 |   private static final String TAG = "PhoneSelector";
 50 | 
 51 |   public static final int PHONE_UNKNOWN = 0;
 52 |   public static final int PHONE_DREAM = 1; /* G1 */
 53 |   public static final int PHONE_SAPPHIRE = 2; /* G2 */
 54 |   public static final int PHONE_PASSION = 3; /* Nexus One */
 55 | 
 56 |   /* A hard-coded list of phones that have OLED screens. */
 57 |   public static final String[] OLED_PHONES = {
 58 |     "bravo",
 59 |     "passion",
 60 |     "GT-I9000",
 61 |     "inc",
 62 |     "legend",
 63 |     "GT-I7500",
 64 |     "SPH-M900",
 65 |     "SGH-I897",
 66 |     "SGH-T959",
 67 |     "desirec",
 68 |   };
 69 | 
 70 | 
 71 |   /* This class is not supposed to be instantiated.  Just use the static
 72 |    * members.
 73 |    */
 74 |   private PhoneSelector() {}
 75 | 
 76 |   public static boolean phoneSupported() {
 77 |     return getPhoneType() != PHONE_UNKNOWN;
 78 |   }
 79 | 
 80 |   public static boolean hasOled() {
 81 |     for(int i = 0; i < OLED_PHONES.length; i++) {
 82 |       if(Build.DEVICE.equals(OLED_PHONES[i])) {
 83 |         return true;
 84 |       }
 85 |     }
 86 |     return false;
 87 |   }
 88 | 
 89 |   public static int getPhoneType() {
 90 |     if(Build.DEVICE.startsWith("dream")) return PHONE_DREAM;
 91 |     if(Build.DEVICE.startsWith("sapphire")) return PHONE_SAPPHIRE;
 92 |     if(Build.DEVICE.startsWith("passion")) return PHONE_PASSION;
 93 |     return PHONE_UNKNOWN;
 94 |   }
 95 | 
 96 |   public static PhoneConstants getConstants(Context context) {
 97 |     switch(getPhoneType()) {
 98 |       case PHONE_DREAM:
 99 |         return new DreamConstants(context);
100 |       case PHONE_SAPPHIRE:
101 |         return new SapphireConstants(context);
102 |       case PHONE_PASSION:
103 |         return new PassionConstants(context);
104 |       default:
105 |         boolean oled = hasOled();
106 |         Log.w(TAG, "Phone type not recognized (" + Build.DEVICE + "), using " +
107 |               (oled ? "Passion" : "Dream") + " constants");
108 |         return oled ? new PassionConstants(context) :
109 |                       new DreamConstants(context);
110 |     }
111 |   }
112 | 
113 |   public static PhonePowerCalculator getCalculator(Context context) {
114 |     switch(getPhoneType()) {
115 |       case PHONE_DREAM:
116 |         return new DreamPowerCalculator(context);
117 |       case PHONE_SAPPHIRE:
118 |         return new SapphirePowerCalculator(context);
119 |       case PHONE_PASSION:
120 |         return new PassionPowerCalculator(context);
121 |       default:
122 |         boolean oled = hasOled();
123 |         Log.w(TAG, "Phone type not recognized (" + Build.DEVICE + "), using " +
124 |               (oled ? "Passion" : "Dream") + " calculator");
125 |         return oled ? new PassionPowerCalculator(context) :
126 |                       new DreamPowerCalculator(context);
127 |     }
128 |   }
129 | 
130 |   public static void generateComponents(Context context,
131 |                                         List<PowerComponent> components,
132 |                                         List<PowerFunction> functions) {
133 |     final PhoneConstants constants = getConstants(context);
134 |     final PhonePowerCalculator calculator = getCalculator(context);
135 | 
136 |     //TODO: What about bluetooth?
137 |     //TODO: LED light on the Nexus
138 | 
139 |     /* Add display component. */
140 |     if(hasOled()) {
141 |       components.add(new OLED(context, constants));
142 |       functions.add(new PowerFunction() {
143 |         public double calculate(PowerData data) {
144 |           return calculator.getOledPower((OledData)data);
145 |         }});
146 |     } else {
147 |       components.add(new LCD(context));
148 |       functions.add(new PowerFunction() {
149 |         public double calculate(PowerData data) {
150 |           return calculator.getLcdPower((LcdData)data);
151 |         }});
152 |     }
153 | 
154 |     /* Add CPU component. */
155 |     components.add(new CPU(constants));
156 |     functions.add(new PowerFunction() {
157 |       public double calculate(PowerData data) {
158 |         return calculator.getCpuPower((CpuData)data);
159 |       }});
160 | 
161 |     /* Add Wifi component. */
162 |     String wifiInterface = 
163 |         SystemInfo.getInstance().getProperty("wifi.interface");
164 |     if(wifiInterface != null && wifiInterface.length() != 0) {
165 |       components.add(new Wifi(context, constants));
166 |       functions.add(new PowerFunction() {
167 |         public double calculate(PowerData data) {
168 |           return calculator.getWifiPower((WifiData)data);
169 |         }});
170 |     }
171 | 
172 |     /* Add 3G component. */
173 |     if(constants.threegInterface().length() != 0) {
174 |       components.add(new Threeg(context, constants));
175 |       functions.add(new PowerFunction() {
176 |         public double calculate(PowerData data) {
177 |           return calculator.getThreeGPower((ThreegData)data);
178 |         }});
179 |     }
180 | 
181 |     /* Add GPS component. */
182 |     components.add(new GPS(context, constants));
183 |     functions.add(new PowerFunction() {
184 |       public double calculate(PowerData data) {
185 |         return calculator.getGpsPower((GpsData)data);
186 |       }});
187 | 
188 |     /* Add Audio component. */
189 |     components.add(new Audio(context));
190 |     functions.add(new PowerFunction() {
191 |       public double calculate(PowerData data) {
192 |         return calculator.getAudioPower((AudioData)data);
193 |       }});
194 | 
195 |     /* Add Sensors component if avaialble. */
196 |     if(NotificationService.available()) {
197 |       components.add(new Sensors(context));
198 |       functions.add(new PowerFunction() {
199 |         public double calculate(PowerData data) {
200 |           return calculator.getSensorPower((SensorData)data);
201 |         }});
202 |     }
203 |   }
204 | }
205 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/PowerFunction.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.phone;
21 | 
22 | import edu.umich.PowerTutor.service.PowerData;
23 | 
24 | public interface PowerFunction {
25 |   public double calculate(PowerData data);
26 | }
27 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/SapphireConstants.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.phone;
 21 | 
 22 | import android.content.Context;
 23 | 
 24 | public class SapphireConstants extends DreamConstants {
 25 |   public SapphireConstants(Context context) {
 26 |     super(context);
 27 |   }
 28 | 
 29 |   public String modelName() {
 30 |     return "sapphire";
 31 |   }
 32 | 
 33 |   public double maxPower() {
 34 |     return 2800;
 35 |   }
 36 | 
 37 |   public double lcdBrightness() {
 38 |     return 1.72686;
 39 |   }
 40 | 
 41 |   public double lcdBacklight() {
 42 |     return 340.8305;
 43 |   }
 44 | 
 45 |   private static final double[] arrayCpuPowerRatios = {1.4169, 2.3997};
 46 |   public double[] cpuPowerRatios() {
 47 |     return arrayCpuPowerRatios;
 48 |   }
 49 | 
 50 |   private static final double[] arrayCpuFreqs = {245.36, 383.38};
 51 |   public double[] cpuFreqs() {
 52 |     return arrayCpuFreqs;
 53 |   }
 54 | 
 55 |   public double audioPower() {
 56 |     return 184.62;
 57 |   }
 58 | 
 59 |   private static final double[] arrayGpsStatePower = {0.0, 33.577, 284.7624};
 60 |   public double[] gpsStatePower() {
 61 |     return arrayGpsStatePower;
 62 |   }
 63 | 
 64 |   public double gpsSleepTime() {
 65 |     return 6.0;
 66 |   }
 67 | 
 68 |   public double wifiLowPower() {
 69 |     return 38.554;
 70 |   }
 71 | 
 72 |   public double wifiHighPower() {
 73 |     return 733.7631;
 74 |   }
 75 | 
 76 |   public double wifiLowHighTransition() {
 77 |     return 15;
 78 |   }
 79 | 
 80 |   public double wifiHighLowTransition() {
 81 |     return 8;
 82 |   }
 83 | 
 84 |   private static final double[] arrayWifiLinkRatios = {
 85 |     47.122645, 46.354821, 43.667437, 43.283525, 40.980053, 39.44422, 38.676581,
 86 |     34.069637, 29.462693, 20.248805, 11.034917, 6.427122
 87 |   };
 88 |   public double[] wifiLinkRatios() {
 89 |     return arrayWifiLinkRatios;
 90 |   }
 91 | 
 92 |   private static final double[] arrayWifiLinkSpeeds = {
 93 |     1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54
 94 |   };
 95 |   public double[] wifiLinkSpeeds() {
 96 |     return arrayWifiLinkSpeeds;
 97 |   }
 98 | 
 99 |   public String threegInterface() {
100 |     return "rmnet0";
101 |   }
102 | 
103 |   public double threegIdlePower(String oper) {
104 |     if(OPER_TMOBILE.equals(oper)) {
105 |       return 10;
106 |     }
107 |     return 10;
108 |   }
109 | 
110 |   public double threegFachPower(String oper) {
111 |     if(OPER_TMOBILE.equals(oper)) {
112 |       return 413.9689;
113 |     }
114 |     return 413.9689;
115 |   }
116 | 
117 |   public double threegDchPower(String oper) {
118 |     if(OPER_TMOBILE.equals(oper)) {
119 |       return 944.3891;
120 |     }
121 |     return 944.3891;
122 |   }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/phone/SapphirePowerCalculator.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.phone;
21 | 
22 | import edu.umich.PowerTutor.components.LCD.LcdData;
23 | import edu.umich.PowerTutor.components.CPU.CpuData;
24 | import edu.umich.PowerTutor.components.Audio.AudioData;
25 | import edu.umich.PowerTutor.components.GPS.GpsData;
26 | import edu.umich.PowerTutor.components.Wifi.WifiData;
27 | import edu.umich.PowerTutor.components.Threeg.ThreegData;
28 | 
29 | import android.content.Context;
30 | 
31 | /* Most of this file should be inheritted from DreamPowerCalculator as most of
32 |  * the hardware model details will be the same modulo the coefficients.
33 |  */
34 | public class SapphirePowerCalculator extends DreamPowerCalculator {
35 |   public SapphirePowerCalculator(Context context) {
36 |     super(new SapphireConstants(context));
37 |   }
38 | 
39 |   public SapphirePowerCalculator(PhoneConstants coeffs) {
40 |     super(coeffs);
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/service/ICounterService.aidl:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.service;
21 | 
22 | interface ICounterService {
23 |   // Returns the name of the components that are being logged.
24 |   String[] getComponents();
25 | 
26 |   // Returns the maximum power usage for each of the components being logged.
27 |   int[] getComponentsMaxPower();
28 | 
29 |   // Returns a bit mask with a 1 in the ith bit if component i doesn't have
30 |   // uid specific information.
31 |   int getNoUidMask();
32 | 
33 |   // Returns the power consumption in mW for component componentId for the last
34 |   // count iterations.  uid can be specified to make this data only include a
35 |   // specific user id or you can provide SystemInfo.AID_ALL to request
36 |   // global power state information.
37 |   int[] getComponentHistory(int count, int componentId, int uid);
38 | 
39 |   // Returns the total energy consumption for each component in the same order
40 |   // that the components were returned in getComponents() and in the same order
41 |   // that the components are populated by PhoneSelector.generateComponents().
42 |   //
43 |   // uid can be specified to make the information specific to a single user
44 |   // id or SystemInfo.AID_ALL can be specified to request global information.
45 |   //
46 |   // windowType should be one of Counter.WINDOW_MINUTE, Counter.WINDOW_HOUR,
47 |   // Counter.WINDOW_DAY, Counter.WINDOW_TOTAL to request the window that the
48 |   // energy usage will be calculated over.
49 |   //
50 |   // The returned result is given in mJ.
51 |   long[] getTotals(int uid, int windowType);
52 | 
53 |   // Like getTotals() except that each entry is divided by how long the given
54 |   // uid was running.  If SystemInfo.AID_ALL is provided this is effectively
55 |   // like dividing each entry by the window size. (unless PowerTutor hasn't
56 |   // been running that long).
57 |   long[] getMeans(int uid, int windowType);
58 | 
59 |   // Gets the total time that this uid has been running in seconds.
60 |   long getRuntime(int uid, int windowType);
61 | 
62 |   // Returns a byte array representing a serialized array of UidInfo structures.
63 |   // See UidInfo.java for what information is given.  Note that members marked
64 |   // as transient are not filled in.
65 |   // Power contributions from component i will be dropped if the ith bit is set
66 |   // in ignoreMask.  Providing 0 for ignoreMask will give results for all
67 |   // components.
68 |   //
69 |   // Example Usage:
70 |   //   byte[] rawUidInfo = counterService.getUidInfo(windowType);
71 |   //   UidInfo[] uidInfos = (UidInfo[])new ObjectInputStream(
72 |   //       new ByteArrayInputStream(rawUidInfo)).readObject();
73 |   byte[] getUidInfo(int windowType, int ignoreMask);
74 | 
75 |   // Return miscellaneous data point for the passed uid.
76 |   // Current extras included:
77 |   //   OLEDSCORE
78 |   long getUidExtra(String name, int uid);
79 | }
80 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/service/IterationData.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.service;
21 | 
22 | import edu.umich.PowerTutor.util.Recycler;
23 | import edu.umich.PowerTutor.util.SystemInfo;
24 | 
25 | import android.util.SparseArray;
26 | 
27 | /* Class that encloses physical hardware power data as well as estimated power
28 |  * data for each uid that contributes a non-negligable amount of power for this
29 |  * component.
30 |  */
31 | public class IterationData {
32 |   private static Recycler<IterationData> recycler =
33 |       new Recycler<IterationData>();
34 | 
35 |   private SparseArray<PowerData> uidPower;
36 | 
37 |   public static IterationData obtain() {
38 |     IterationData result = recycler.obtain();
39 |     if(result != null) return result;
40 |     return new IterationData();
41 |   }
42 | 
43 |   private IterationData() {
44 |     uidPower = new SparseArray<PowerData>();
45 |   }
46 | 
47 |   /* Initialize the members of this structure.  Remember that this class may not
48 |    * have just been instantiated and may have been used in past iterations.
49 |    */
50 |   public void init() {
51 |     uidPower.clear();
52 |   }
53 | 
54 |   /* Allow this class to be recycled and to recycle all of the PowerData
55 |    * PowerData elements contained within it.
56 |    */
57 |   public void recycle() {
58 |     for(int i = 0; i < uidPower.size(); i++) {
59 |       uidPower.valueAt(i).recycle();
60 |     }
61 |     uidPower.clear();
62 |     recycler.recycle(this);
63 |   }
64 |   
65 |   public void setPowerData(PowerData power) {
66 |     addUidPowerData(SystemInfo.AID_ALL, power);
67 |   }
68 | 
69 |   public void addUidPowerData(int uid, PowerData power) {
70 |     uidPower.put(uid, power);
71 |   }
72 | 
73 |   public SparseArray<PowerData> getUidPowerData() {
74 |     return uidPower;
75 |   }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/service/LogUploader.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.service;
21 | 
22 | import android.content.Context;
23 | 
24 | /* This class is responsible for implementing all policy decisions on when to
25 |  * send log information back to an external server.  Upon a successful call to
26 |  * shouldUpload() PowerEstimator will then call upload(file).  After the call to
27 |  * upload the file with the passed path may be overwritten.
28 |  *
29 |  * This is a stub implementation not supporting log uploading.
30 |  */
31 | public class LogUploader {
32 |   public LogUploader(Context context) {
33 |   }
34 | 
35 |   /* Returns true if this module supports uploading logs. */
36 |   public static boolean uploadSupported() {
37 |     return false;
38 |   }
39 | 
40 |   /* Returns true if the log should be uploaded now.  This may depend on log
41 |    * file size, network conditions, etc. */
42 |   // TODO: This should probably give the file name of the log
43 |   public boolean shouldUpload() {
44 |     return false;
45 |   }
46 | 
47 |   /* Called when the device is plugged in or unplugged.  The intended use of
48 |    * this is to improve upload policy decisions. */
49 |   public void plug(boolean plugged) {
50 |   }
51 | 
52 |   /* Initiate the upload of the file with the passed location. */
53 |   public void upload(String origFile) {
54 |   }
55 | 
56 |   /* Returns true if a file is currently being uploaded. */
57 |   public boolean isUploading() {
58 |     return false;
59 |   }
60 | 
61 |   /* Interrupt any threads doing upload work. */
62 |   public void interrupt() {
63 |   }
64 | 
65 |   /* Join any threads that may be performing log upload work. */
66 |   public void join() throws InterruptedException {
67 |   }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/service/PowerData.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.service;
21 | 
22 | import java.io.OutputStreamWriter;
23 | import java.io.IOException;
24 | import java.util.Vector;
25 | 
26 | public abstract class PowerData {
27 |   private int cachedPower;
28 | 
29 |   public PowerData() {
30 |   }
31 | 
32 |   public void setCachedPower(int power) {
33 |     cachedPower = power;
34 |   }
35 | 
36 |   public int getCachedPower() {
37 |     return cachedPower;
38 |   }
39 | 
40 |   /* To be called when the PowerData object is no longer in use so that it can
41 |    * be used again in the next iteration if it chooses to be.
42 |    */
43 |   public void recycle() {}
44 | 
45 |   /* Simply writes out log information to the passed stream. */
46 |   public abstract void writeLogDataInfo(OutputStreamWriter out)
47 |       throws IOException;
48 | }
49 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/service/UidInfo.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.service;
21 | 
22 | import edu.umich.PowerTutor.util.Recycler;
23 | 
24 | import java.io.Serializable;
25 | 
26 | public class UidInfo implements Serializable, Comparable {
27 |   private static Recycler<UidInfo> recycler = new Recycler<UidInfo>();
28 | 
29 |   public static UidInfo obtain() {
30 |     UidInfo result = recycler.obtain();
31 |     if(result != null) return result;
32 |     return new UidInfo();
33 |   }
34 | 
35 |   public void recycle() {
36 |     recycler.recycle(this);
37 |   }
38 | 
39 |   public int uid;
40 |   public int currentPower;
41 |   public long totalEnergy;
42 |   public long runtime;
43 | 
44 |   public transient double key;
45 |   public transient double percentage;
46 |   public transient String unit;
47 | 
48 |   private UidInfo() {
49 |   }
50 | 
51 |   public void init(int uid, int currentPower, long totalEnergy,
52 |                    long runtime) {
53 |     this.uid = uid;
54 |     this.currentPower = currentPower;
55 |     this.totalEnergy = totalEnergy;
56 |     this.runtime = runtime;
57 |   }
58 | 
59 |   public int compareTo(Object o) {
60 |     UidInfo x = (UidInfo)o;
61 |     if(key > x.key) return -1;
62 |     if(key == x.key) return 0;
63 |     return 1;
64 |   }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/ui/EditPreferences.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.ui;
21 | 
22 | import edu.umich.PowerTutor.R;
23 | 
24 | import android.os.Bundle;
25 | import android.preference.PreferenceActivity;
26 | 
27 | public class EditPreferences extends PreferenceActivity {
28 |   public void onCreate(Bundle savedInstanceState) {
29 |     super.onCreate(savedInstanceState);
30 |     addPreferencesFromResource(R.xml.preferences);
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/ui/Help.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.ui;
21 | 
22 | import edu.umich.PowerTutor.R;
23 | 
24 | import android.app.Activity;
25 | import android.content.Intent;
26 | import android.net.Uri;
27 | import android.os.Bundle;
28 | import android.view.View;
29 | import android.widget.TextView;
30 | 
31 | /**This function implements the UI for help view*/
32 | public class Help extends Activity {
33 |   private static final String powerTutorUrl = "http://powertutor.org";
34 | 
35 |   @Override
36 |   public void onCreate(Bundle savedInstanceState) {
37 |     super.onCreate(savedInstanceState); 
38 |     setContentView(R.layout.help);
39 |     TextView s2 = (TextView)this.findViewById(R.id.S2);
40 | 
41 |     s2.setOnClickListener(new TextView.OnClickListener() {
42 |       public void onClick(View v) {
43 |         Intent myIntent = new Intent(Intent.ACTION_VIEW,
44 |                                      Uri.parse(powerTutorUrl));
45 |         startActivity(myIntent);
46 |       }
47 |     });
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/ui/PowerPie.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.ui;
 21 | 
 22 | import org.achartengine.GraphicalView;
 23 | import org.achartengine.chart.PieChart;
 24 | import org.achartengine.model.CategorySeries;
 25 | import org.achartengine.renderer.DefaultRenderer;
 26 | import org.achartengine.renderer.SimpleSeriesRenderer;
 27 | 
 28 | import android.app.Activity;
 29 | import android.app.AlertDialog;
 30 | import android.app.Dialog;
 31 | import android.content.ComponentName;
 32 | import android.content.DialogInterface;
 33 | import android.content.Intent;
 34 | import android.content.ServiceConnection;
 35 | import android.content.SharedPreferences;
 36 | import android.graphics.Color;
 37 | import android.os.Bundle;
 38 | import android.os.Handler;
 39 | import android.os.IBinder;
 40 | import android.os.RemoteException;
 41 | import android.preference.PreferenceManager;
 42 | import android.util.Log;
 43 | import android.view.Gravity;
 44 | import android.view.Menu;
 45 | import android.view.MenuItem;
 46 | import android.widget.LinearLayout;
 47 | import android.widget.TextView;
 48 | import edu.umich.PowerTutor.service.ICounterService;
 49 | import edu.umich.PowerTutor.service.PowerEstimator;
 50 | import edu.umich.PowerTutor.service.UMLoggerService;
 51 | import edu.umich.PowerTutor.util.Counter;
 52 | import edu.umich.PowerTutor.util.SystemInfo;
 53 | 
 54 | public class PowerPie extends Activity {
 55 |   private static final String TAG = "PowerPie";
 56 | 
 57 |   private SharedPreferences prefs;
 58 |   private int uid;
 59 | 
 60 |   private String[] componentNames;
 61 |   private int noUidMask;
 62 | 
 63 |   private Runnable collector;
 64 | 
 65 |   private Intent serviceIntent;
 66 |   private CounterServiceConnection conn;
 67 |   private ICounterService counterService;
 68 |   private Handler handler;
 69 | 
 70 |   private TextView displayText;
 71 | 
 72 |   public static final int[] COLORS = new int[] {
 73 |       Color.BLUE, Color.GREEN, Color.MAGENTA, Color.YELLOW,
 74 |       Color.RED, Color.LTGRAY, Color.DKGRAY, Color.CYAN
 75 |   };
 76 | 
 77 |   public void refreshView() {
 78 |     if(counterService == null) {
 79 |       TextView loadingText = new TextView(this);
 80 |       loadingText.setText("Waiting for profiler service...");
 81 |       loadingText.setGravity(Gravity.CENTER);
 82 |       setContentView(loadingText);
 83 |       return;
 84 |     }
 85 | 
 86 |     if(uid == SystemInfo.AID_ALL) {
 87 |       /* If we are reporting global power usage then just set noUidMask to 0 so
 88 |        * that all components get displayed.
 89 |        */
 90 |       noUidMask = 0;
 91 |     }
 92 | 
 93 |     displayText = new TextView(this);
 94 |     displayText.setGravity(Gravity.CENTER);
 95 |     updateDisplayText();
 96 | 
 97 |     final CategorySeries series = new CategorySeries("");
 98 |     final DefaultRenderer renderer = new DefaultRenderer();
 99 |     renderer.setLabelsTextSize(15);
100 |     renderer.setLegendTextSize(15);
101 |     renderer.setMargins(new int[] { 5, 50, 5, 50 });
102 | 
103 |     PieChart pieChart = new PieChart(series, renderer);
104 |     final GraphicalView chartView = new GraphicalView(this, pieChart);
105 | 
106 |     /* The collector is responsible for periodically updating the screen with
107 |      * new energy usage information for the current uid.
108 |      */
109 |     collector = new Runnable() {
110 |       public void run() {
111 |         try {
112 |           long[] totals = counterService.getTotals(uid,
113 |               prefs.getInt("pieWindowType", 0));
114 |           long sumTotal = 0;
115 |           for(int i = 0; i < totals.length; i++) {
116 |             totals[i] = totals[i] * PowerEstimator.ITERATION_INTERVAL / 1000;
117 |             sumTotal += totals[i];
118 |           }
119 |           int index = 0;
120 |           if(sumTotal < 1e-7) {
121 |             series.set(0, "No data", 1);
122 |           } else for(int i = 0; i < totals.length; i++) {
123 |             if((noUidMask & 1 << i) != 0) {
124 |               continue;
125 |             }
126 |             String prefix;
127 |             double val = totals[i];
128 |             if(val > 1e12) {
129 |               prefix = "G";
130 |               val /= 1e12;
131 |             } else if(val > 1e9) {
132 |               prefix = "M";
133 |               val /= 1e9;
134 |             } else if(val > 1e6) {
135 |               prefix = "k";
136 |               val /= 1e6;
137 |             } else if(val > 1e3) {
138 |               prefix = "";
139 |               val /= 1e3;
140 |             } else {
141 |               prefix = "m";
142 |             }
143 | 
144 |             String label = String.format("%1$s %2$.1f %3$sJ",
145 |                     componentNames[i], val, prefix);
146 |             if(series.getItemCount() == index) {
147 |               SimpleSeriesRenderer r = new SimpleSeriesRenderer();
148 |               r.setColor(COLORS[i]);
149 |               renderer.addSeriesRenderer(r);
150 |                 
151 |               series.add(label, totals[i]);
152 |             } else {
153 |               series.set(index, label, totals[i]);
154 |             }
155 |             index++;
156 |           }
157 |           chartView.invalidate();
158 |         } catch(RemoteException e) {
159 |           Log.w(TAG, "Failed to contact power tutor profiling service");
160 |         }
161 |         if(handler != null) {
162 |           handler.postDelayed(this, 2 * PowerEstimator.ITERATION_INTERVAL);
163 |         }
164 |       }
165 |     };
166 |     if(handler != null) {
167 |       handler.post(collector);
168 |     }
169 | 
170 |     LinearLayout layout = new LinearLayout(this);
171 |     layout.setOrientation(LinearLayout.VERTICAL);
172 |     layout.addView(displayText);
173 |     layout.addView(chartView);
174 |     setContentView(layout);
175 |   }
176 | 
177 |   public void updateDisplayText() {
178 |     displayText.setText("Displaying energy usage over " +
179 |         Counter.WINDOW_DESCS[prefs.getInt("pieWindowType", 0)] + " for " +
180 |         (uid == SystemInfo.AID_ALL ? " the entire phone." :
181 |         SystemInfo.getInstance().getUidName(uid, getPackageManager()) + "."));
182 |   }
183 | 
184 |   class CounterServiceConnection implements ServiceConnection {
185 |     public void onServiceConnected(ComponentName className, 
186 |                                    IBinder boundService ) {
187 |       counterService = ICounterService.Stub.asInterface((IBinder)boundService);
188 |       try {
189 |         componentNames = counterService.getComponents();
190 |         noUidMask = counterService.getNoUidMask();
191 |         refreshView();
192 |       } catch(RemoteException e) {
193 |         counterService = null;
194 |       }
195 |     }
196 | 
197 |     public void onServiceDisconnected(ComponentName className) {
198 |       counterService = null;
199 |       getApplicationContext().unbindService(conn);
200 |       getApplicationContext().bindService(serviceIntent, conn, 0);
201 |       Log.w(TAG, "Unexpectedly lost connection to service");
202 |     }
203 |   }
204 | 
205 |   @Override
206 |   public void onCreate(Bundle savedInstanceState) {
207 |     super.onCreate(savedInstanceState);
208 |     prefs = PreferenceManager.getDefaultSharedPreferences(this);
209 |     uid = getIntent().getIntExtra("uid", SystemInfo.AID_ALL);
210 | 
211 |     if(savedInstanceState != null) {
212 |       componentNames = savedInstanceState.getStringArray("componentNames");
213 |       noUidMask = savedInstanceState.getInt("noUidMask");
214 |     }
215 | 
216 |     serviceIntent = new Intent(this, UMLoggerService.class);
217 |     conn = new CounterServiceConnection();
218 |   }
219 | 
220 |   @Override
221 |   protected void onResume() {
222 |     super.onResume();
223 |     handler = new Handler();
224 |     getApplicationContext().bindService(serviceIntent, conn, 0);
225 | 
226 |     refreshView();
227 |   }
228 | 
229 |   @Override
230 |   protected void onPause() {
231 |     super.onPause();
232 |     getApplicationContext().unbindService(conn);
233 |     if(collector != null) {
234 |       handler.removeCallbacks(collector);
235 |       handler = null;
236 |     }
237 |   }
238 | 
239 |   @Override
240 |   protected void onSaveInstanceState(Bundle outState) {
241 |     super.onSaveInstanceState(outState);
242 |     outState.putStringArray("componentNames", componentNames);
243 |     outState.putInt("noUidMask", noUidMask);
244 |   }
245 | 
246 |   private static final int MENU_WINDOW = 0;
247 |   private static final int DIALOG_WINDOW = 0;
248 | 
249 |   @Override
250 |   public boolean onCreateOptionsMenu(Menu menu) {
251 |     menu.add(0, MENU_WINDOW, 0, "Time Span");
252 |     return true;
253 |   }
254 | 
255 |   @Override
256 |   public boolean onPrepareOptionsMenu(Menu menu) {
257 |     /* We need to make sure that the user can't cause any of the dialogs to be
258 |      * created before we have contacted the Power Tutor service to get the
259 |      * component names and such.
260 |      */
261 |     for(int i = 0; i < menu.size(); i++) {
262 |       menu.getItem(i).setEnabled(counterService != null);
263 |     }
264 |     return true;
265 |   }
266 | 
267 |   @Override
268 |   public boolean onOptionsItemSelected(MenuItem item) {
269 |     switch(item.getItemId()) {
270 |       case MENU_WINDOW:
271 |         showDialog(DIALOG_WINDOW);
272 |         return true;
273 |     }
274 |     return false;
275 |   }
276 | 
277 |   @Override
278 |   protected Dialog onCreateDialog(int id) {
279 |     AlertDialog.Builder builder = new AlertDialog.Builder(this);
280 |     switch(id) {
281 |       case DIALOG_WINDOW:
282 |         builder.setTitle("Select window type");
283 |         builder.setItems(Counter.WINDOW_NAMES,
284 |           new DialogInterface.OnClickListener() {
285 |             public void onClick(DialogInterface dialog, int item) {
286 |               prefs.edit().putInt("pieWindowType", item).commit();
287 |               updateDisplayText();
288 |             }
289 |         });
290 |         return builder.create();
291 |     }
292 |     return null;
293 |   }
294 | }
295 | 
296 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/ui/PowerTabs.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.ui;
21 | 
22 | import edu.umich.PowerTutor.R;
23 | 
24 | import android.app.TabActivity;
25 | import android.content.Intent;
26 | import android.content.res.Resources;
27 | import android.os.Bundle;
28 | import android.widget.TabHost;
29 | 
30 | public class PowerTabs extends TabActivity {
31 |   public void onCreate(Bundle savedInstanceState) {
32 |     super.onCreate(savedInstanceState);
33 |     setContentView(R.layout.power_tabs);
34 | 
35 |     Resources res = getResources();
36 |     TabHost tabHost = getTabHost();
37 |     TabHost.TabSpec spec;
38 | 
39 |     // TODO: We could put in some icons on each of these two tabs.  Not sure if
40 |     // we care enough or if it would look much better.
41 |     Intent intent = new Intent(this, PowerViewer.class);
42 |     intent.putExtras(getIntent());
43 |     spec = tabHost.newTabSpec("Charts").setIndicator("Chart View")
44 |                   .setContent(intent);
45 |     tabHost.addTab(spec);
46 | 
47 |     // Do the same for the other tabs
48 |     intent = new Intent(this, PowerPie.class);
49 |     intent.putExtras(getIntent());
50 |     spec = tabHost.newTabSpec("Pie").setIndicator("Pie View")
51 |                   .setContent(intent);
52 |     tabHost.addTab(spec);
53 | 
54 |     intent = new Intent(this, MiscView.class);
55 |     intent.putExtras(getIntent());
56 |     spec = tabHost.newTabSpec("Stat").setIndicator("Stat View")
57 |                   .setContent(intent);
58 |     tabHost.addTab(spec);
59 | 
60 |     // Show the PowerViewer activity by default.
61 |     tabHost.setCurrentTab(0);
62 |   }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/ui/StartupReceiver.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.ui;
21 | 
22 | import edu.umich.PowerTutor.service.UMLoggerService;
23 | 
24 | import android.content.BroadcastReceiver;
25 | import android.content.Context;
26 | import android.content.Intent;
27 | import android.content.SharedPreferences;
28 | import android.preference.PreferenceManager;
29 | 
30 | public class StartupReceiver extends BroadcastReceiver {
31 |   @Override
32 |   public void onReceive(Context context, Intent intent) {
33 |     SharedPreferences prefs =
34 |         PreferenceManager.getDefaultSharedPreferences(context);
35 |     if(prefs.getBoolean("runOnStartup", true)) {
36 |       Intent serviceIntent = new Intent(context, UMLoggerService.class);
37 |       context.startService(serviceIntent);
38 |     }
39 |   }
40 | }
41 | 
42 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/ui/ViewerPreferences.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.ui;
21 | 
22 | import edu.umich.PowerTutor.R;
23 | 
24 | import android.os.Bundle;
25 | import android.preference.PreferenceActivity;
26 | 
27 | public class ViewerPreferences extends PreferenceActivity {
28 |   public void onCreate(Bundle savedInstanceState) {
29 |     super.onCreate(savedInstanceState);
30 |     addPreferencesFromResource(R.xml.viewer_preferences);
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/util/BatteryStats.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.util;
 21 | 
 22 | import java.io.File;
 23 | 
 24 | public class BatteryStats {
 25 |   private static final String TAG = "BatteryStats";
 26 |   private static BatteryStats instance = null;
 27 | 
 28 |   public static BatteryStats getInstance() {
 29 |     if(instance == null) {
 30 |       instance = new BatteryStats();
 31 |     }
 32 |     return instance;
 33 |   }
 34 | 
 35 |   private static final String[] VOLTAGE_FILES = {
 36 |     "/sys/class/power_supply/battery/voltage_now",
 37 |     "/sys/class/power_supply/battery/batt_vol",
 38 |   };
 39 |   private static final double[] VOLTAGE_CONV = {
 40 |     1e-6, // Source in microvolts.
 41 |     1e-3, // Source in millivolts.
 42 |   };
 43 | 
 44 |   private static final String[] CURRENT_FILES = {
 45 |     "/sys/class/power_supply/battery/current_now",
 46 |     //"/sys/class/power_supply/battery/batt_current", Doesn't seem good
 47 |   };
 48 |   private static final double[] CURRENT_CONV = {
 49 |     1e-6, // Source in microamps.
 50 |     //1e-3, // Source in milliamps.
 51 |   };
 52 | 
 53 |   private static final String[] TEMP_FILES = {
 54 |     "/sys/class/power_supply/battery/temp",
 55 |     "/sys/class/power_supply/battery/batt_temp",
 56 |   };
 57 |   private static final double[] TEMP_CONV = {
 58 |     1e-1, // Source in tenths of a centigrade.
 59 |     1e-1, // Source in tenths of a centigrade.
 60 |   };
 61 | 
 62 |   private static final String[] CHARGE_FILES = {
 63 |     "/sys/class/power_supply/battery/charge_counter",
 64 |   };
 65 |   private static final double[] CHARGE_CONV = {
 66 |     60*60*1e-6, // Source in micro amp hours.
 67 |   };
 68 | 
 69 |   private static final String[] CAPACITY_FILES = {
 70 |     "/sys/class/power_supply/battery/capacity",
 71 |   };
 72 |   private static final double[] CAPACITY_CONV = {
 73 |     1e-2, // Source in percentage.
 74 |   };
 75 | 
 76 |   private static final String[] FULL_CAPACITY_FILES = {
 77 |     "/sys/class/power_supply/battery/full_bat",
 78 |   };
 79 |   private static final double[] FULL_CAPACITY_CONV = {
 80 |     60*60*1e-6, // Source in micro amp hours.
 81 |   };
 82 | 
 83 |   SystemInfo sysInfo;
 84 | 
 85 |   String voltageFile;
 86 |   String currentFile;
 87 |   String tempFile;
 88 |   String chargeFile;
 89 |   String capacityFile;
 90 |   String fullCapacityFile;
 91 | 
 92 |   double voltageConv;
 93 |   double currentConv;
 94 |   double tempConv;
 95 |   double chargeConv;
 96 |   double capacityConv;
 97 |   double fullCapacityConv;
 98 | 
 99 |   private BatteryStats() {
100 |     sysInfo = SystemInfo.getInstance();
101 | 
102 |     // Get voltage information.
103 |     for(int i = 0; i < VOLTAGE_FILES.length; i++) {
104 |       if(new File(VOLTAGE_FILES[i]).exists()) {
105 |         voltageFile = VOLTAGE_FILES[i];
106 |         voltageConv = VOLTAGE_CONV[i];
107 |       }
108 |     }
109 | 
110 |     // Get current information.
111 |     for(int i = 0; i < CURRENT_FILES.length; i++) {
112 |       if(new File(CURRENT_FILES[i]).exists()) {
113 |         currentFile = CURRENT_FILES[i];
114 |         currentConv = CURRENT_CONV[i];
115 |       }
116 |     }
117 | 
118 |     // Get temperature information.
119 |     for(int i = 0; i < TEMP_FILES.length; i++) {
120 |       if(new File(TEMP_FILES[i]).exists()) {
121 |         tempFile = TEMP_FILES[i];
122 |         tempConv = TEMP_CONV[i];
123 |       }
124 |     }
125 | 
126 |     // Get charge information.
127 |     for(int i = 0; i < CHARGE_FILES.length; i++) {
128 |       if(new File(CHARGE_FILES[i]).exists()) {
129 |         chargeFile = CHARGE_FILES[i];
130 |         chargeConv = CHARGE_CONV[i];
131 |       }
132 |     }
133 | 
134 |     // Get capacity information.
135 |     for(int i = 0; i < CAPACITY_FILES.length; i++) {
136 |       if(new File(CAPACITY_FILES[i]).exists()) {
137 |         capacityFile = CAPACITY_FILES[i];
138 |         capacityConv = CAPACITY_CONV[i];
139 |       }
140 |     }
141 | 
142 |     // Get full capacity information.
143 |     for(int i = 0; i < FULL_CAPACITY_FILES.length; i++) {
144 |       if(new File(FULL_CAPACITY_FILES[i]).exists()) {
145 |         fullCapacityFile = FULL_CAPACITY_FILES[i];
146 |         fullCapacityConv = FULL_CAPACITY_CONV[i];
147 |       }
148 |     }
149 |   }
150 | 
151 |   public boolean hasVoltage() {
152 |     return voltageFile != null;
153 |   }
154 | 
155 |   public double getVoltage() {
156 |     if(voltageFile == null) return -1.0;
157 |     long volt = sysInfo.readLongFromFile(voltageFile);
158 |     return volt == -1 ? -1.0 : voltageConv * volt;
159 |   }
160 | 
161 |   public boolean hasCurrent() {
162 |     return currentFile != null;
163 |   }
164 | 
165 |   public double getCurrent() {
166 |     long curr = sysInfo.readLongFromFile(currentFile);
167 |     return curr == -1 ? -1.0 : currentConv * curr;
168 |   }
169 | 
170 |   public boolean hasTemp() {
171 |     return tempFile != null;
172 |   }
173 | 
174 |   public double getTemp() {
175 |     if(tempFile == null) return -1.0;
176 |     long temp = sysInfo.readLongFromFile(tempFile);
177 |     return temp == -1 ? -1.0 : tempConv * temp;
178 |   }
179 | 
180 |   public boolean hasCharge() {
181 |     return chargeFile != null ||
182 |            hasFullCapacity() && hasCapacity();
183 |   }
184 | 
185 |   public double getCharge() {
186 |     if(chargeFile == null) {
187 |       double r1 = getCapacity();
188 |       double r2 = getFullCapacity();
189 |       return r1 < 0 || r2 < 0 ? -1.0 : r1 * r2;
190 |     }
191 |     long charge = sysInfo.readLongFromFile(chargeFile);
192 |     return charge == -1 ? -1.0 : chargeConv * charge;
193 |   }
194 | 
195 |   public boolean hasCapacity() {
196 |     return capacityFile != null;
197 |   }
198 | 
199 |   public double getCapacity() {
200 |     if(capacityFile == null) return -1.0;
201 |     long cap = sysInfo.readLongFromFile(capacityFile);
202 |     return cap == -1 ? -1.0 : capacityConv * cap;
203 |   }
204 | 
205 |   public boolean hasFullCapacity() {
206 |     return fullCapacityFile != null;
207 |   }
208 | 
209 |   public double getFullCapacity() {
210 |     if(fullCapacityFile == null) return -1.0;
211 |     long cap = sysInfo.readLongFromFile(fullCapacityFile);
212 |     return cap == -1 ? -1.0 : fullCapacityConv * cap;
213 |   }
214 | }
215 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/util/Counter.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.util;
 21 | 
 22 | import android.os.SystemClock;
 23 | 
 24 | public class Counter {
 25 |   public static final int WINDOW_MINUTE = 0;
 26 |   public static final int WINDOW_HOUR = 1;
 27 |   public static final int WINDOW_DAY = 2;
 28 |   public static final int WINDOW_TOTAL = 3;
 29 |   public static final CharSequence[] WINDOW_NAMES = { "Last minute",
 30 |       "Last Hour", "Last Day", "Total"};
 31 |   // To be used for constructions like "Showing X over ..."
 32 |   public static final CharSequence[] WINDOW_DESCS = { "the last minute",
 33 |       "the last hour", "the last day", "all time"};
 34 |   private static final long WINDOW_DURATIONS[] = { 60 * 1000, 60 * 60 * 1000,
 35 |                                                    24 * 60 * 60 * 1000};
 36 | 
 37 |   private long startTime;
 38 |   private long total;
 39 |   private SingleCounter[] counters;
 40 | 
 41 |   public Counter() {
 42 |     total = 0;
 43 |     startTime = SystemClock.elapsedRealtime();
 44 |     counters = new SingleCounter[WINDOW_DURATIONS.length];
 45 |     for(int i = 0; i < counters.length; i++) {
 46 |       counters[i] = new SingleCounter();
 47 |     }
 48 |   }
 49 | 
 50 |   public void add(long x) {
 51 |     total += x;
 52 |     long now = SystemClock.elapsedRealtime() - startTime;
 53 |     for(int i = 0; i < counters.length; i++) {
 54 |       counters[i].add(x, now * SingleCounter.BUCKETS / WINDOW_DURATIONS[i]);
 55 |     }
 56 |   }
 57 | 
 58 |   public long get(int window) {
 59 |     if(window == WINDOW_TOTAL) {
 60 |       return total;
 61 |     }
 62 |     long now = SystemClock.elapsedRealtime() - startTime;
 63 |     return counters[window].get(
 64 |         now * SingleCounter.BUCKETS / WINDOW_DURATIONS[window],
 65 |         (1.0 * now * SingleCounter.BUCKETS % WINDOW_DURATIONS[window]) /
 66 |                                              WINDOW_DURATIONS[window]);
 67 |   }
 68 |   
 69 |   private static class SingleCounter {
 70 |     public static final int BUCKETS = 60;
 71 | 
 72 |     private long base;
 73 |     private int baseIdx;
 74 |     private long droppingBucket;
 75 |     private long[] bucketSum;
 76 |     private long total;
 77 | 
 78 |     public SingleCounter() {
 79 |       bucketSum = new long[BUCKETS];
 80 |     }
 81 | 
 82 |     private void wind(long now) {
 83 |       if(base + 2 * BUCKETS <= now) {
 84 |         /* Completly clear the data structure. */
 85 |         droppingBucket = 0;
 86 |         for(int i = 0; i < BUCKETS; i++) {
 87 |           bucketSum[i] = 0;
 88 |         }
 89 |         total = 0;
 90 |         base = now;
 91 |         baseIdx = 0;
 92 |       } else while(base + BUCKETS <= now) {
 93 |         droppingBucket = bucketSum[baseIdx];
 94 |         total -= droppingBucket;
 95 |         bucketSum[baseIdx] = 0;
 96 |         base++;
 97 |         baseIdx = baseIdx + 1 == BUCKETS ? 0 : baseIdx + 1;
 98 |       }
 99 |     }
100 | 
101 |     public void add(long x, long now) {
102 |       wind(now);
103 |       total += x;
104 |       int idx = (int)(baseIdx + now - base);
105 |       bucketSum[idx < BUCKETS ? idx : idx - BUCKETS] += x;
106 |     }
107 | 
108 |     /* now gives the time slice that we want information for.
109 |      * prog, between 0 and 1, gives the progress through the current time slice
110 |      * with 0 indicating that it just started and 1 indicating that it is about
111 |      * to end.
112 |      */
113 |     public long get(long now, double prog) {
114 |       wind(now);
115 |       return total + (long)((1.0 - prog) * droppingBucket);
116 |     }
117 |   }
118 | }
119 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/util/ForegroundDetector.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.util;
 21 | 
 22 | import edu.umich.PowerTutor.util.SystemInfo;
 23 | 
 24 | import android.app.ActivityManager;
 25 | 
 26 | import java.util.Arrays;
 27 | import java.util.BitSet;
 28 | import java.util.List;
 29 | 
 30 | /* This detector looks for transitions where one app leaves the foreground and
 31 |  * another enters the foreground to detect apps that are legitimately in the
 32 |  * foreground.  If no application is known to be legitimate system is returned.
 33 |  */
 34 | public class ForegroundDetector {
 35 |   int lastSize;
 36 |   int[] lastUids;
 37 |   int nowSize;
 38 |   int[] nowUids;
 39 | 
 40 |   private BitSet validated;
 41 | 
 42 |   private ActivityManager activityManager;
 43 | 
 44 |   public ForegroundDetector(ActivityManager activityManager) {
 45 |     lastSize = nowSize = 0;
 46 |     lastUids = new int[10];
 47 |     nowUids = new int[10];
 48 |     validated = new BitSet(1 << 16);
 49 |     validated.set(android.os.Process.myUid());
 50 |     this.activityManager = activityManager;
 51 |   }
 52 | 
 53 |   // Figure out what uid should be charged for screen usage.
 54 |   public int getForegroundUid() {
 55 |     SystemInfo sysInfo = SystemInfo.getInstance();
 56 |     List<ActivityManager.RunningAppProcessInfo> appProcs =
 57 |         activityManager.getRunningAppProcesses();
 58 | 
 59 |     // Move the last iteration to last and resize the other array if needed.
 60 |     int[] tmp = lastUids;
 61 |     lastUids = nowUids;
 62 |     lastSize = nowSize;
 63 |     if(tmp.length < appProcs.size()) {
 64 |       tmp = new int[appProcs.size()];
 65 |     }
 66 |     nowUids = tmp;
 67 | 
 68 |     // Fill in the uids from appProcs.
 69 |     nowSize = 0;
 70 |     for(ActivityManager.RunningAppProcessInfo app : appProcs) {
 71 |       if(app.importance ==
 72 |              ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
 73 |         int uid = sysInfo.getUidForPid(app.pid);
 74 |         if(SystemInfo.AID_APP <= uid && uid < 1 << 16) {
 75 |           nowUids[nowSize++] = uid;
 76 |         }
 77 |       }
 78 |     }
 79 |     Arrays.sort(nowUids, 0, nowSize);
 80 | 
 81 |     // Find app-exit app-enter transitions.
 82 |     int appExit = -1;
 83 |     int appEnter = -1;
 84 |     int indNow = 0;
 85 |     int indLast = 0;
 86 |     while(indNow < nowSize && indLast < lastSize) {
 87 |       if(nowUids[indNow] == lastUids[indLast]) {
 88 |         indNow++; indLast++;
 89 |       } else if(nowUids[indNow] < lastUids[indLast]) {
 90 |         appEnter = nowUids[indNow++];
 91 |       } else {
 92 |         appExit = lastUids[indLast++];
 93 |       }
 94 |     }
 95 |     if(indNow < nowSize) appEnter = nowUids[indNow];
 96 |     if(indLast < lastSize) appExit = lastUids[indLast];
 97 | 
 98 |     // Found an interesting transition.  Validate both applications.
 99 |     if(appEnter != -1 && appExit != -1) {
100 |       validated.set(appEnter);
101 |       validated.set(appExit);
102 |     }
103 |     
104 |     // Now find a valid application now.  Hopefully there is only one.  If there
105 |     // are none return system.  If there are several return the one with the
106 |     // highest uid.
107 |     for(int i = nowSize - 1; i >= 0; i--) {
108 |       if(validated.get(nowUids[i])) {
109 |         return nowUids[i];
110 |       }
111 |     }
112 |     return SystemInfo.AID_SYSTEM;
113 |   }
114 | }
115 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/util/HexEncode.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.util;
21 | 
22 | public class HexEncode {
23 |   public static String encode(byte[] bytes) {
24 |     StringBuilder bld = new StringBuilder();
25 |     for(int i = 0; i < bytes.length; i++) {
26 |       bld.append((char)('a' + (bytes[i] >> 4 & 0xF)));
27 |       bld.append((char)('a' + (bytes[i] & 0xF)));
28 |     }
29 |     return bld.toString();
30 |   }
31 | 
32 |   public static byte[] decode(String dat) {
33 |     int N = dat.length() / 2;
34 |     byte[] ret = new byte[N];
35 |     for(int i = 0; i < N; i++) {
36 |       ret[i] = (byte)(dat.charAt(2 * i) - 'a' << 4 |
37 |                       dat.charAt(2 * i + 1) - 'a');
38 |     }
39 |     return ret;
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/util/HistoryBuffer.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.util;
 21 | 
 22 | import android.util.SparseArray;
 23 | 
 24 | import java.util.LinkedList;
 25 | import java.util.ListIterator;
 26 | 
 27 | public class HistoryBuffer {
 28 |   private static class UidData {
 29 |     public LinkedList<HistoryDatum> queue;
 30 |     public Counter sum;
 31 |     public Counter count;
 32 | 
 33 |     public UidData() {
 34 |       queue = new LinkedList<HistoryDatum>();
 35 |       sum = new Counter();
 36 |       count = new Counter();
 37 |     }
 38 |   }
 39 | 
 40 |   private static class HistoryDatum {
 41 |     public HistoryDatum() {
 42 |     }
 43 | 
 44 |     public void init(long iteration, int power) {
 45 |       this.iteration = iteration;
 46 |       this.power = power;
 47 |     }
 48 | 
 49 |     public long iteration;
 50 |     public int power;
 51 |   }
 52 | 
 53 |   private int maxSize;
 54 |   private SparseArray<UidData> uidData;
 55 | 
 56 |   public HistoryBuffer(int maxSize) {
 57 |     this.maxSize = maxSize;
 58 |     uidData = new SparseArray<UidData>();
 59 |   }
 60 | 
 61 |   /* The iteration should only increase across successive adds. */
 62 |   public synchronized void add(int uid, long iteration, int power) {
 63 |     UidData data = uidData.get(uid);
 64 |     if(data == null) {
 65 |       data = new UidData();
 66 |       uidData.put(uid, data);
 67 |     }
 68 |     data.count.add(1);
 69 |     if(power == 0) {
 70 |       return;
 71 |     }
 72 |     data.sum.add(power);
 73 |     if(maxSize == 0) {
 74 |       return;
 75 |     }
 76 | 
 77 |     LinkedList<HistoryDatum> queue = data.queue;
 78 |     HistoryDatum datum;
 79 |     if(maxSize <= queue.size()) {
 80 |       datum = queue.getLast();
 81 |       queue.removeLast();
 82 |     } else {
 83 |       datum = new HistoryDatum();
 84 |     }
 85 |     datum.init(iteration, power);
 86 |     queue.addFirst(datum);
 87 |   }
 88 | 
 89 |   /* Fills in the previous number timestamps starting from a timestamp and
 90 |    * working backwards.  Any timestamp with no information is just treated
 91 |    * as using no power.
 92 |    */
 93 |   public synchronized int[] get(int uid, long timestamp, int number) {
 94 |     int ind = 0;
 95 |     if(number < 0) number = 0;
 96 |     if(number > maxSize) number = maxSize;
 97 |     int[] ret = new int[number];
 98 |     UidData data = uidData.get(uid);
 99 |     LinkedList<HistoryDatum> queue = data == null ? null : data.queue;
100 |     if(queue == null || queue.isEmpty()) {
101 |       return ret;
102 |     }
103 |     if(timestamp == -1) {
104 |       timestamp = queue.getFirst().iteration;
105 |     }
106 |     for(ListIterator<HistoryDatum> iter = queue.listIterator();
107 |         iter.hasNext(); ) {
108 |       HistoryDatum datum = iter.next();
109 |       while(datum.iteration < timestamp && ind < number) {
110 |         ind++;
111 |         timestamp--;
112 |       }
113 |       if(ind == number) {
114 |         break;
115 |       }
116 |       if(datum.iteration == timestamp) {
117 |         ret[ind++] = datum.power;
118 |         timestamp--;
119 |       } else {
120 |         /* datum happened after requested interval. */
121 |       }
122 |     }
123 |     return ret;
124 |   }
125 | 
126 |   public synchronized long getTotal(int uid, int windowType) {
127 |     UidData data = uidData.get(uid);
128 |     return data == null ? 0 : data.sum.get(windowType);
129 |   }
130 | 
131 |   public synchronized long getCount(int uid, int windowType) {
132 |     UidData data = uidData.get(uid);
133 |     return data == null ? 0 : data.count.get(windowType);
134 |   }
135 | }
136 | 
137 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/util/NativeLoader.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.util;
21 | 
22 | import android.util.Log;
23 | 
24 | public class NativeLoader {
25 |   private static final String TAG = "NativeLoader";
26 | 
27 |   private static boolean loadOk = false;
28 | 
29 |   static {
30 |     try {
31 |       System.loadLibrary("bindings");
32 |       loadOk = true;
33 |     } catch(SecurityException e) {
34 |       Log.w(TAG, "Failed to load jni dll, will fall back on pure java");
35 |       loadOk = false;
36 |     } catch(UnsatisfiedLinkError e) {
37 |       Log.w(TAG, "Failed to load jni dll, will fall back on pure java");
38 |       loadOk = false;
39 |     }
40 |   }
41 | 
42 |   public static boolean jniLoaded() {
43 |     return loadOk;
44 |   }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/util/Recycler.java:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (C) 2011 The University of Michigan
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | Please send inquiries to powertutor@umich.edu
18 | */
19 | 
20 | package edu.umich.PowerTutor.util;
21 | 
22 | import java.util.Vector;
23 | 
24 | /* The aim of this class is to reduce the amount of objects that need to be
25 |  * created and destroyed every iteration.  If we can avoid having to allocate
26 |  * objects on the heap we can ease the job of the garbage collector and be
27 |  * more efficient.
28 |  */
29 | public class Recycler<T> {
30 |   private Vector<T> list;
31 |   private int avail;
32 | 
33 |   public Recycler() {
34 |     list = new Vector<T>();
35 |     avail = 0;
36 |   }
37 | 
38 |   public synchronized T obtain() {
39 |     if(avail == 0) {
40 |       return null;
41 |     }
42 |     return list.get(--avail);
43 |   }
44 | 
45 |   public synchronized void recycle(T a) {
46 |     if(avail < list.size()) {
47 |       list.set(avail++, a);
48 |     } else {
49 |       list.add(a);
50 |     }
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/widget/Configure.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.widget;
 21 | 
 22 | import edu.umich.PowerTutor.R;
 23 | import edu.umich.PowerTutor.util.HexEncode;
 24 | 
 25 | import android.app.Activity;
 26 | import android.appwidget.AppWidgetManager;
 27 | import android.content.Context;
 28 | import android.content.Intent;
 29 | import android.content.SharedPreferences;
 30 | import android.os.Bundle;
 31 | import android.preference.PreferenceManager;
 32 | import android.util.Log;
 33 | import android.view.View;
 34 | import android.view.ViewGroup;
 35 | import android.widget.AdapterView;
 36 | import android.widget.ArrayAdapter;
 37 | import android.widget.TextView;
 38 | import android.widget.ListView;
 39 | 
 40 | import java.util.ArrayList;
 41 | import java.io.ByteArrayOutputStream;
 42 | import java.io.ObjectOutputStream;
 43 | import java.io.IOException;
 44 | 
 45 | public class Configure extends Activity {
 46 |   private static final String TAG = "Configure";
 47 | 
 48 |   private int widgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
 49 |   
 50 |   private ArrayAdapter adapter;
 51 |   private DataSource[] dataSource;
 52 |   private WidgetItem[] items;
 53 | 
 54 |   @Override
 55 |   public void onCreate(Bundle icicle) {
 56 |     super.onCreate(icicle);
 57 |     setResult(RESULT_CANCELED);
 58 | 
 59 |     Intent intent = getIntent();
 60 |     Bundle extras = intent.getExtras();
 61 |     if(extras != null) {
 62 |       widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID,
 63 |                                AppWidgetManager.INVALID_APPWIDGET_ID);
 64 |     }
 65 |     if(widgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
 66 |       finish();
 67 |     }
 68 | 
 69 |     setContentView(R.layout.widget_configure);
 70 |     findViewById(R.id.save_button).setOnClickListener(
 71 |       new View.OnClickListener() {
 72 |         public void onClick(View v) {
 73 |           String val = "";
 74 |           try {
 75 |             ByteArrayOutputStream ba = new ByteArrayOutputStream();
 76 |             ObjectOutputStream objout = new ObjectOutputStream(ba);
 77 |             for(int i = 0; i < dataSource.length; i++) {
 78 |               objout.writeObject(dataSource[i]);
 79 |             }
 80 |             objout.close();
 81 |             val = HexEncode.encode(ba.toByteArray());
 82 |           } catch(IOException e) {
 83 |             Log.w(TAG, "Failed to write data sources to string");
 84 |             finish();
 85 |           }
 86 |           String key = "widget_" + widgetId;
 87 | 
 88 |           SharedPreferences prefs =
 89 |               PreferenceManager.getDefaultSharedPreferences(Configure.this);
 90 |           prefs.edit().putString(key, val).commit();
 91 | 
 92 |           Intent resultValue = new Intent();
 93 |           resultValue.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, widgetId);
 94 |           setResult(RESULT_OK, resultValue);
 95 |           finish();
 96 |         }
 97 |       });
 98 |     findViewById(R.id.cancel_button).setOnClickListener(
 99 |       new View.OnClickListener() {
100 |         public void onClick(View v) {
101 |           finish();
102 |         }
103 |       });
104 | 
105 |     final ListView listView = (ListView)findViewById(R.id.list);
106 |     adapter = new ArrayAdapter(this, 0) {
107 |       public View getView(int position, View convertView, ViewGroup parent) {
108 |         View itemView = getLayoutInflater()
109 |             .inflate(R.layout.widget_item_layout, listView, false);
110 |         TextView title = (TextView)itemView.findViewById(R.id.title);
111 |         TextView summary = (TextView)itemView.findViewById(R.id.summary);
112 |         WidgetItem item = (WidgetItem)getItem(position);
113 |         item.setupView(title, summary);
114 |         return itemView;
115 |       }
116 |     };
117 | 
118 |     dataSource = DataSource.getDefaults();
119 |     items = new WidgetItem[3];
120 | 
121 |     for(int i = 0; i < 3; i++) {
122 |       items[i] = new WidgetItem(i);
123 |       adapter.add(items[i]);
124 |     }
125 |     listView.setAdapter(adapter);
126 |     listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
127 |       public void onItemClick(AdapterView parent, View view,
128 |                               int position, long id) {
129 |         items[position].onClick();
130 |       }
131 |     });
132 |   }
133 | 
134 |   @Override
135 |   protected void onActivityResult(int reqCode, int resCode, Intent data) {
136 |     if(resCode == RESULT_OK) {
137 |       Bundle extras = data.getExtras();
138 |       DataSource dataSrc = (DataSource)extras.getSerializable("data_source");
139 |       dataSource[reqCode] = dataSrc;
140 |       adapter.notifyDataSetChanged();
141 |     }
142 |   }
143 | 
144 |   private class WidgetItem {
145 |     private int columnId;
146 | 
147 |     public WidgetItem(int columnId) {
148 |       this.columnId = columnId;
149 |     }
150 |   
151 |     public void setupView(TextView title, TextView summary) {
152 |       title.setText("Column " + (columnId + 1) + " - " +
153 |                     dataSource[columnId].getTitle());
154 |       summary.setText(dataSource[columnId].getDescription());
155 |     }
156 | 
157 |     public void onClick() {
158 |       Intent startIntent = new Intent(Configure.this,
159 |                                       DataSourceConfigure.class);
160 |       startActivityForResult(startIntent, columnId);
161 |     }
162 |   }
163 | }
164 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/widget/DataSource.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.widget;
 21 | 
 22 | import java.io.Serializable;
 23 | 
 24 | import edu.umich.PowerTutor.service.PowerEstimator;
 25 | import edu.umich.PowerTutor.util.BatteryStats;
 26 | import edu.umich.PowerTutor.util.Counter;
 27 | import edu.umich.PowerTutor.util.SystemInfo;
 28 | 
 29 | public class DataSource implements Serializable {
 30 |   private static final long serialVersionUID = 14594389587290845L;
 31 | 
 32 |   public int id;
 33 |   public int[] params;
 34 | 
 35 |   private static final int ID_POWER = 0;
 36 |   private static final int ID_BATTERY_TIME = 1;
 37 |   private static final int ID_CHARGE = 2;
 38 |   private static final int ID_VOLTAGE = 3;
 39 |   private static final int ID_CURRENT = 4;
 40 |   private static final int ID_TEMP = 5;
 41 |   private static final int ID_PERC = 6;
 42 |   private static final String[] idShorts = {
 43 |     "Power",
 44 |     "Battery Time",
 45 |     "Charge",
 46 |     "Voltage",
 47 |     "Current",
 48 |     "Temperature",
 49 |     "Percent Battery",
 50 |   };
 51 |   private static final String[] idLongs = {
 52 |     "Displays power in mW",
 53 |     "Displays remaining battery lifetime.  Also can show time until battery " +
 54 |       "is fully charged",
 55 |     "Displays remaining battery charge in mAh",
 56 |     "Displays battery voltage in V",
 57 |     "Displays battery current in mA",
 58 |     "Displays battery temperature",
 59 |     "Displays the percent battery remaning",
 60 |   };
 61 | 
 62 |   private static final int POWER_INSTANT = 0;
 63 |   private static final int POWER_MINUTE = 1;
 64 |   private static final int POWER_HOUR = 2;
 65 |   private static final int POWER_DAY = 3;
 66 |   private static final int POWER_TOTAL = 4;
 67 |   private static final int POWER_SENSOR = 5;
 68 |   private static final String[] powerShorts = {
 69 |     "Instant",
 70 |     "Minute Average",
 71 |     "Hour Average",
 72 |     "Day Average",
 73 |     "Total Average",
 74 |     "Battery Sensors",
 75 |   };
 76 |   private static final String[] powerLongs = {
 77 |     "Estimated instantaneous power consumption",
 78 |     "Average power consumption over the last minute",
 79 |     "Average power consumption over the last hour",
 80 |     "Average power consumption over the last day",
 81 |     "Average power consumption while the profiler has been running",
 82 |     "Calculate power from battery current and voltage sensors",
 83 |   };
 84 | 
 85 |   private static final int CHARGE_SENSOR = 0;
 86 |   private static final int CHARGE_FULL = 1;
 87 |   private static final int CHARGE_1400 = 2;
 88 |   private static final String[] chargeShorts = {
 89 |     "Battery Sensor",
 90 |     "Fully Charged",
 91 |     "1400 mAh",
 92 |   };
 93 |   private static final String[] chargeLongs = {
 94 |     "Use your battery's charge readings",
 95 |     "Assume that your battery is fully charged",
 96 |     "Assume that you have 1400 mAh worth of charge " +
 97 |         "(A typical battery capacity)",
 98 |   };
 99 | 
100 |   private static final int TEMP_CELCIUS = 0;
101 |   private static final int TEMP_FARENHEIT = 1;
102 |   private static final String[] tempShorts = {
103 |     "Celcius",
104 |     "Farenheit",
105 |   };
106 |   private static final String[] tempLongs = {
107 |     "Display battery temperature in celcius",
108 |     "Display battery temperature in farenheit",
109 |   };
110 | 
111 |   private static final int BATT_LIFETIME = 0;
112 |   private static final int BATT_CHARGETIME = 1;
113 |   private static final String[] battShorts = {
114 |     "Life Time",
115 |     "Charge Time",
116 |   };
117 |   private static final String[] battLongs = {
118 |     "Display remaining life time when battery plugged in",
119 |     "Display time until battery fully charged when battery plugged in",
120 |   };
121 | 
122 |   public String getTitle(int level) {
123 |     if(level == 0) return "Select display type";
124 |     switch(id) {
125 |       case ID_POWER: return "Select power source";
126 |       case ID_BATTERY_TIME:
127 |         if(level == 1) return "Select power source";
128 |         if(level == 2) return "Select charge source";
129 |         return "Select charging behavior";
130 |       case ID_TEMP: return "Select temperature scale";
131 |     }
132 |     return "";
133 |   }
134 | 
135 |   public String[] getShortOptions(int level) {
136 |     if(level == 0) return idShorts;
137 |     switch(id) {
138 |       case ID_POWER: return powerShorts;
139 |       case ID_BATTERY_TIME: return level == 1 ? powerShorts :
140 |                                    (level == 2 ? chargeShorts : battShorts);
141 |       case ID_TEMP: return tempShorts;
142 |     }
143 |     return null;
144 |   }
145 | 
146 |   public String[] getLongOptions(int level) {
147 |     if(level == 0) return idLongs;
148 |     switch(id) {
149 |       case ID_POWER: return powerLongs;
150 |       case ID_BATTERY_TIME: return level == 1 ? powerLongs :
151 |                                    (level == 2 ? chargeLongs : battLongs);
152 |       case ID_TEMP: return tempLongs;
153 |     }
154 |     return null;
155 |   }
156 | 
157 |   public boolean hasOption(int level, int value) {
158 |     BatteryStats bst = BatteryStats.getInstance();
159 |     if(level == 0) {
160 |       if(value == ID_PERC) return bst.hasCapacity();
161 |       if(value == ID_CHARGE) return bst.hasCharge();
162 |       if(value == ID_CURRENT) return bst.hasCurrent();
163 |       return true;
164 |     }
165 |     switch(id) {
166 |       case ID_POWER:
167 |         return value != POWER_SENSOR || bst.hasCurrent() && bst.hasVoltage();
168 |       case ID_BATTERY_TIME:
169 |         if(level == 1) {
170 |           return value != POWER_SENSOR || bst.hasCurrent() && bst.hasVoltage();
171 |         } else if(level == 2) {
172 |           return value == CHARGE_1400 ||
173 |                  value == CHARGE_SENSOR && bst.hasCharge() ||
174 |                  value == CHARGE_FULL && bst.hasFullCapacity();
175 |         }
176 |         return true;
177 |       case ID_TEMP:
178 |         return true;
179 |     }
180 |     return false;
181 |   }
182 | 
183 |   public boolean setParam(int level, int value) {
184 |     if(level == 0) {
185 |       id = value;
186 |       int numParams = 0;
187 |       switch(id) {
188 |         case ID_POWER: numParams = 1; break;
189 |         case ID_BATTERY_TIME: numParams = 3; break;
190 |         case ID_TEMP: numParams = 1; break;
191 |       }
192 |       if(numParams > 0) {
193 |         params = new int[numParams];
194 |       }
195 |       return level == numParams;
196 |     } else {
197 |       params[level - 1] = value;
198 |       if(id == ID_BATTERY_TIME) {
199 |         BatteryStats bst = BatteryStats.getInstance();
200 |         if(!(bst.hasCurrent() && bst.hasCharge() && bst.hasCapacity())) {
201 |           return level + 1 == params.length;
202 |         }
203 |       }
204 |       return level == params.length;
205 |     }
206 |   }
207 | 
208 |   public String getTitle() {
209 |     return idShorts[id];
210 |   }
211 |   
212 |   public String getDescription() {
213 |     switch(id) {
214 |       case ID_POWER: return powerLongs[params[0]];
215 |       case ID_BATTERY_TIME:
216 |         return "Power Source: " + powerLongs[params[0]] + "\n" +
217 |                "Charge Source: " + chargeLongs[params[1]];
218 |       case ID_TEMP: return tempLongs[params[0]];
219 |     }
220 |     return idLongs[id];
221 |   }
222 | 
223 |   public static DataSource[] getDefaults() {
224 |     DataSource[] res = new DataSource[3];
225 |     for(int i = 0; i < res.length; i++) res[i] = new DataSource();
226 |     res[0].setParam(0, ID_POWER);
227 |     res[0].setParam(1, POWER_TOTAL);
228 |     res[1].setParam(0, ID_PERC);
229 |     res[2].setParam(0, ID_TEMP);
230 |     res[2].setParam(1, TEMP_CELCIUS);
231 |     return res;
232 |   }
233 | 
234 |   public String getValue(PowerEstimator p) {
235 |     BatteryStats bst = BatteryStats.getInstance();
236 |     switch(id) {
237 |       case ID_POWER: {
238 |         double pow = calcPower(p, params[0]);
239 |         if(pow <= 0) {
240 |           return "Power\n-";
241 |         }
242 |         return String.format("Power\n%1$.0f mW", 1000 * pow);
243 |       } case ID_BATTERY_TIME: {
244 |         if(bst.hasCurrent() && params[2] == BATT_CHARGETIME) {
245 |           double curr = bst.getCurrent();
246 |           double cp = bst.getCapacity();
247 |           if(curr > 0 && cp >= 0.01) {
248 |             // We have been asked to compute the charge time instead.
249 |             long time = (long)(bst.getCharge() / cp * (1.0 - cp) / curr);
250 |             return String.format("Charge time\n%1$d:%2$02d:%3$02d",
251 |                                  time / 60 / 60, time / 60 % 60, time % 60);
252 |           }
253 |         }
254 |           
255 |         double pow = calcPower(p, params[0]);
256 |         double charge = calcCharge(params[1]);
257 |         double volt = bst.getVoltage();
258 |         if(pow <= 0 || charge <= 0 || volt <= 0) {
259 |           return "Batt. time\n-";
260 |         }
261 |         long time = (long)(charge * volt / pow);
262 |         return String.format("Batt. time\n%1$d:%2$02d:%3$02d",
263 |                              time / 60 / 60, time / 60 % 60, time % 60);
264 |       } case ID_CHARGE: {
265 |         return String.format("Charge\n%1$.1f mAh",
266 |                              calcCharge(CHARGE_SENSOR) / 3.6);
267 |       } case ID_VOLTAGE: {
268 |         return String.format("Voltage\n%1$.2f V", bst.getVoltage());
269 |       } case ID_CURRENT: {
270 |         double curr = bst.getCurrent() * 1000;
271 |         if(curr < 0) {
272 |           return String.format("Current\n%1$.1f mA", -curr);
273 |         } else {
274 |           return String.format("Current\n%1$.1f mA\n(charging)", curr);
275 |         }
276 |       } case ID_TEMP: {
277 |         if(params[0] == TEMP_FARENHEIT) {
278 |           return String.format("Temp.\n%1$.1f \u00b0F",
279 |                                bst.getTemp() * 9 / 5 + 32);
280 |         } else {
281 |           return String.format("Temp.\n%1$.1f \u00b0C", bst.getTemp());
282 |         }
283 |       } case ID_PERC: {
284 |         return String.format("Batt. left\n%1$.0f%%", 100 * bst.getCapacity());
285 |       }
286 |     }
287 |     return "";
288 |   }
289 | 
290 |   private static final double POLY_WEIGHT = 0.02;
291 | 
292 |   private double calcPower(PowerEstimator p, int powId) {
293 |     switch(powId) {
294 |       case POWER_INSTANT: {
295 |         int count = 0;
296 |         int[] history = p.getComponentHistory(5 * 60, -1,
297 |                                               SystemInfo.AID_ALL, -1);
298 |         double weightedAvgPower = 0;
299 |         for(int i = history.length - 1; i >= 0; i--) {
300 |           if(history[i] != 0) {
301 |             count++;
302 |             weightedAvgPower *= 1.0 - POLY_WEIGHT;
303 |             weightedAvgPower += POLY_WEIGHT * history[i] / 1000.0;
304 |           }
305 |         }
306 |         if(count == 0) return -1.0;
307 |         return weightedAvgPower / (1.0 - Math.pow(1.0 - POLY_WEIGHT, count));
308 |       } case POWER_MINUTE:
309 |       case POWER_HOUR:
310 |       case POWER_DAY:
311 |       case POWER_TOTAL: {
312 |         int wind = 0;
313 |         if(powId == POWER_MINUTE) wind = Counter.WINDOW_MINUTE;
314 |         if(powId == POWER_HOUR) wind = Counter.WINDOW_HOUR;
315 |         if(powId == POWER_DAY) wind = Counter.WINDOW_DAY;
316 |         if(powId == POWER_TOTAL) wind = Counter.WINDOW_TOTAL;
317 |         double total = 0;
318 |         for(long x : p.getMeans(SystemInfo.AID_ALL, wind)) {
319 |           total += x / 1000.0;
320 |         }
321 |         return total;
322 |       } case POWER_SENSOR: {
323 |         BatteryStats bst = BatteryStats.getInstance();
324 |         double curr = bst.getCurrent();
325 |         if(curr >= 0) return -1.0;
326 |         return curr * bst.getVoltage();
327 |       }
328 |     }
329 |     return -1.0;
330 |   }
331 | 
332 |   private double calcCharge(int chargeId) {
333 |     BatteryStats bst = BatteryStats.getInstance();
334 |     switch(chargeId) {
335 |       case CHARGE_SENSOR: return bst.getCharge();
336 |       case CHARGE_FULL: return bst.getFullCapacity();
337 |       case CHARGE_1400: return 1400 * 3.6; // mAh -> As
338 |     }
339 |     return -1.0;
340 |   }
341 | }
342 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/widget/DataSourceConfigure.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.widget;
 21 | 
 22 | import edu.umich.PowerTutor.R;
 23 | 
 24 | import android.app.Activity;
 25 | import android.appwidget.AppWidgetManager;
 26 | import android.content.Context;
 27 | import android.content.Intent;
 28 | import android.content.SharedPreferences;
 29 | import android.os.Bundle;
 30 | import android.util.Log;
 31 | import android.view.View;
 32 | import android.view.ViewGroup;
 33 | import android.widget.AdapterView;
 34 | import android.widget.ArrayAdapter;
 35 | import android.widget.TextView;
 36 | import android.widget.ListView;
 37 | 
 38 | import java.util.ArrayList;
 39 | 
 40 | public class DataSourceConfigure extends Activity {
 41 |   private DataSource dataSource;
 42 |   private int level;
 43 | 
 44 |   private String[] shortOptions;
 45 |   private String[] longOptions;
 46 | 
 47 |   @Override
 48 |   public void onCreate(Bundle icicle) {
 49 |     super.onCreate(icicle);
 50 |     setResult(RESULT_CANCELED);
 51 | 
 52 |     Intent intent = getIntent();
 53 |     Bundle extras = intent.getExtras();
 54 |     if(extras != null) {
 55 |       dataSource = (DataSource)extras.getSerializable("data_source");
 56 |       level = extras.getInt("level");
 57 |     }
 58 |     if(dataSource == null) {
 59 |       dataSource = new DataSource();
 60 |       level = 0;
 61 |     }
 62 |     setTitle(dataSource.getTitle(level));
 63 |     shortOptions = dataSource.getShortOptions(level);
 64 |     longOptions = dataSource.getLongOptions(level);
 65 | 
 66 |     final ListView listView = new ListView(this);
 67 |     ArrayAdapter adapter = new ArrayAdapter(this, 0) {
 68 |       public View getView(int position, View convertView, ViewGroup parent) {
 69 |         View itemView = getLayoutInflater()
 70 |             .inflate(R.layout.widget_item_layout, listView, false);
 71 |         TextView title = (TextView)itemView.findViewById(R.id.title);
 72 |         TextView summary = (TextView)itemView.findViewById(R.id.summary);
 73 |         Item item = (Item)getItem(position);
 74 |         item.setupView(title, summary);
 75 |         return itemView;
 76 |       }
 77 |     };
 78 | 
 79 |     int pos = 0;
 80 |     final Item[] items = new Item[shortOptions.length];
 81 |     for(int i = 0; i < shortOptions.length; i++) {
 82 |       if(dataSource.hasOption(level, i)) {
 83 |         items[pos] = new Item(i);
 84 |         adapter.add(items[pos++]);
 85 |       }
 86 |     }
 87 |     listView.setAdapter(adapter);
 88 |     listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
 89 |       public void onItemClick(AdapterView parent, View view,
 90 |                               int position, long id) {
 91 |         items[position].onClick();
 92 |       }
 93 |     });
 94 |     setContentView(listView);
 95 |   }
 96 | 
 97 |   @Override
 98 |   protected void onActivityResult(int reqCode, int resCode, Intent data) {
 99 |     if(resCode == RESULT_OK) {
100 |       Intent resultValue = new Intent();
101 |       resultValue.putExtras(data);
102 |       setResult(RESULT_OK, resultValue);
103 |       finish();
104 |     }
105 |   }
106 | 
107 |   private class Item {
108 |     private int id;
109 | 
110 |     public Item(int id) {
111 |       this.id = id;
112 |     }
113 |   
114 |     public void setupView(TextView title, TextView summary) {
115 |       title.setText(shortOptions[id]);
116 |       summary.setText(longOptions[id]);
117 |     }
118 | 
119 |     public void onClick() {
120 |       if(dataSource.setParam(level, id)) {
121 |         Intent resultValue = new Intent();
122 |         resultValue.putExtra("data_source", dataSource);
123 |         setResult(RESULT_OK, resultValue);
124 |         finish();
125 |       } else {
126 |         Intent startIntent = new Intent(DataSourceConfigure.this,
127 |                                         DataSourceConfigure.class);
128 |         startIntent.putExtra("data_source", dataSource);
129 |         startIntent.putExtra("level", level + 1);
130 |         startActivityForResult(startIntent, 0);
131 |       }
132 |     }
133 |   }
134 | }
135 | 


--------------------------------------------------------------------------------
/src/edu/umich/PowerTutor/widget/PowerWidget.java:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (C) 2011 The University of Michigan
  3 | 
  4 | This program is free software: you can redistribute it and/or modify
  5 | it under the terms of the GNU General Public License as published by
  6 | the Free Software Foundation, either version 3 of the License, or
  7 | (at your option) any later version.
  8 | 
  9 | This program is distributed in the hope that it will be useful,
 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | GNU General Public License for more details.
 13 | 
 14 | You should have received a copy of the GNU General Public License
 15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | Please send inquiries to powertutor@umich.edu
 18 | */
 19 | 
 20 | package edu.umich.PowerTutor.widget;
 21 | 
 22 | import android.app.PendingIntent;
 23 | import android.appwidget.AppWidgetProvider;
 24 | import android.appwidget.AppWidgetManager;
 25 | import android.content.Context;
 26 | import android.content.ComponentName;
 27 | import android.content.Intent;
 28 | import android.content.SharedPreferences;
 29 | import android.preference.PreferenceManager;
 30 | import android.util.Log;
 31 | import android.widget.RemoteViews;
 32 | 
 33 | import edu.umich.PowerTutor.R;
 34 | import edu.umich.PowerTutor.service.PowerEstimator;
 35 | import edu.umich.PowerTutor.service.UMLoggerService;
 36 | import edu.umich.PowerTutor.ui.UMLogger;
 37 | import edu.umich.PowerTutor.util.Counter;
 38 | import edu.umich.PowerTutor.util.HexEncode;
 39 | import edu.umich.PowerTutor.util.SystemInfo;
 40 | 
 41 | import java.io.ByteArrayInputStream;
 42 | import java.io.ObjectInputStream;
 43 | import java.io.IOException;
 44 | 
 45 | public class PowerWidget extends AppWidgetProvider {
 46 |   private static final String TAG = "PowerWidget";
 47 | 
 48 |   private static final int[] text_ids = {
 49 |     R.id.text_minute,
 50 |     R.id.text_hour,
 51 |     R.id.text_day,
 52 |   };
 53 | 
 54 |   private static long sumArray(long[] A) {
 55 |     long ret = 0;
 56 |     for(long x : A) {
 57 |       ret += x;
 58 |     }
 59 |     return ret;
 60 |   }
 61 | 
 62 |   // Called once initially.
 63 |   public void onUpdate(Context context, AppWidgetManager appWidgetManager,
 64 |                        int[] appWidgetIds) {
 65 |     updateWidgetDone(context);
 66 |   }
 67 | 
 68 |   public void onDeleted(Context context, int[] appWidgetIds) {
 69 |     SharedPreferences.Editor edit =
 70 |             PreferenceManager.getDefaultSharedPreferences(context).edit();
 71 |     for(int id : appWidgetIds) {
 72 |       edit.remove("widget_" + id);
 73 |     }
 74 |     edit.commit();
 75 |   }
 76 | 
 77 |   public static void updateWidgetDone(Context context) {
 78 |     AppWidgetManager manager = AppWidgetManager.getInstance(context);
 79 |     ComponentName comp = new ComponentName(context, PowerWidget.class);
 80 |     RemoteViews views = new RemoteViews(context.getPackageName(),
 81 |                                         R.layout.widget_layout);
 82 | 
 83 |     Intent notificationIntent = new Intent(context, UMLogger.class);
 84 |     PendingIntent pendingIntent = PendingIntent.getActivity(context, 0,
 85 |                                                 notificationIntent,
 86 |                             PendingIntent.FLAG_UPDATE_CURRENT);
 87 | 
 88 |     views.setOnClickPendingIntent(R.id.power_button, pendingIntent);
 89 |     views.setInt(R.id.power_button, "setImageResource",
 90 |                  R.drawable.power_off);
 91 |     for(int i = 0; i < text_ids.length; i++) {
 92 |       views.setTextViewText(text_ids[i], "N/A");
 93 |     }
 94 |     manager.updateAppWidget(comp, views);
 95 |   }
 96 | 
 97 |   // Called by the UMLogger Service every so often.
 98 |   public static void updateWidget(Context context, PowerEstimator p) {
 99 |     AppWidgetManager manager = AppWidgetManager.getInstance(context);
100 |     ComponentName comp = new ComponentName(context, PowerWidget.class);
101 | 
102 |     for(int id : manager.getAppWidgetIds(comp)) {
103 |       RemoteViews views = new RemoteViews(context.getPackageName(),
104 |                                           R.layout.widget_layout);
105 | 
106 |       Intent notificationIntent = new Intent(context, UMLogger.class);
107 |       notificationIntent.putExtra("isFromIcon", true);
108 |       PendingIntent pendingIntent = PendingIntent.getActivity(context, 0,
109 |                                                   notificationIntent,
110 |                               PendingIntent.FLAG_UPDATE_CURRENT);
111 | 
112 |       views.setOnClickPendingIntent(R.id.power_button, pendingIntent);
113 |       views.setInt(R.id.power_button, "setImageResource",
114 |                    R.drawable.power_on);
115 | 
116 |       boolean ok = false;
117 |       try {
118 |         SharedPreferences prefs =
119 |             PreferenceManager.getDefaultSharedPreferences(context);
120 |         String key = "widget_" + id;
121 |         String val = prefs.getString(key, null);
122 |         if(val != null) {
123 |           ObjectInputStream objin = new ObjectInputStream(
124 |               new ByteArrayInputStream(HexEncode.decode(val)));
125 |           for(int i = 0; i < text_ids.length; i++) {
126 |             DataSource dataSource = (DataSource)objin.readObject();
127 |             views.setTextViewText(text_ids[i], dataSource.getValue(p));
128 |           }
129 |           ok = true;
130 |         } else {
131 |           Log.w(TAG, "Could not find widget data source preference");
132 |         }
133 |       } catch(IOException e) {
134 |         Log.w(TAG, "Failed to extract widget data sources");
135 |       } catch(ClassCastException e) {
136 |         Log.w(TAG, "Failed to extract widget data sources");
137 |       } catch(ClassNotFoundException e) {
138 |         Log.w(TAG, "Failed to extract widget data sources");
139 |       }
140 |       if(!ok) {
141 |         for(int i =0; i < text_ids.length; i++) {
142 |           views.setTextViewText(text_ids[i], "N/A");
143 |         }
144 |       }
145 |       for(int i =0; i < text_ids.length; i++) {
146 |         views.setTextColor(text_ids[i], 0xFFFFFFFF);
147 |       }
148 | 
149 |       manager.updateAppWidget(id, views);
150 |     }
151 |   }
152 | }
153 | 


--------------------------------------------------------------------------------