├── lint.xml
├── assets
    ├── dump.png
    ├── set.png
    ├── detect.png
    └── i2c-command-line-tools.png
├── ic_launcher-web.png
├── libs
    └── android-support-v4.jar
├── res
    ├── drawable-hdpi
    │   └── ic_launcher.png
    ├── drawable-mdpi
    │   └── ic_launcher.png
    ├── drawable-xhdpi
    │   └── ic_launcher.png
    ├── drawable-xxhdpi
    │   └── ic_launcher.png
    ├── values
    │   ├── integers.xml
    │   ├── dimens.xml
    │   ├── styles.xml
    │   ├── array.xml
    │   └── strings.xml
    └── layout
    │   ├── dialog_i2c_info.xml
    │   ├── dialog_i2c_set.xml
    │   └── activity_main.xml
├── project.properties
├── proguard-project.txt
├── AndroidManifest.xml
├── bin
    └── AndroidManifest.xml
├── src
    └── com
    │   └── mitac
    │       └── android
    │           └── i2ctool
    │               ├── LogFileHelper.java
    │               ├── I2cSetDialog.java
    │               ├── I2cInfo.java
    │               ├── I2cToolHelper.java
    │               ├── I2cInfoDialog.java
    │               ├── I2cParserHelper.java
    │               └── MainActivity.java
└── README.md


/lint.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <lint>
3 | </lint>


--------------------------------------------------------------------------------
/assets/dump.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/assets/dump.png


--------------------------------------------------------------------------------
/assets/set.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/assets/set.png


--------------------------------------------------------------------------------
/assets/detect.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/assets/detect.png


--------------------------------------------------------------------------------
/ic_launcher-web.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/ic_launcher-web.png


--------------------------------------------------------------------------------
/libs/android-support-v4.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/libs/android-support-v4.jar


--------------------------------------------------------------------------------
/assets/i2c-command-line-tools.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/assets/i2c-command-line-tools.png


--------------------------------------------------------------------------------
/res/drawable-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/res/drawable-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/res/drawable-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/res/drawable-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/li2/android-i2c-tool/HEAD/res/drawable-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/values/integers.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     
4 |     <integer name="console_max_lines">512</integer>
5 |     
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 |     <!-- Default screen margins, per the Android Design guidelines. -->
4 |     <dimen name="activity_horizontal_margin">16dp</dimen>
5 |     <dimen name="activity_vertical_margin">16dp</dimen>
6 | 
7 | </resources>
8 | 


--------------------------------------------------------------------------------
/res/values/styles.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 |     <!-- Application theme. -->
4 |     <style name="AppTheme" parent="android:style/Theme.Holo.Light">
5 |         <!-- All customizations that are NOT specific to a particular API-level can go here. -->
6 |     </style>
7 |     
8 | </resources>
9 | 


--------------------------------------------------------------------------------
/res/values/array.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 |     <string-array name="loop_interval_choices" >
 4 |         <item>0.5</item>
 5 |         <item>1</item>
 6 |         <item>1.5</item>
 7 |         <item>2</item>
 8 |         <item>5</item>
 9 |         <item>10</item>
10 |     </string-array>    
11 | </resources>
12 | 


--------------------------------------------------------------------------------
/res/values/strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 | 
 4 |     <string name="app_name">Mitac I2C Tool</string>
 5 |     <string name="hello_world">Hello world</string>
 6 |     <string name="i2c_dump">Dump</string>
 7 |     <string name="i2c_set">Set</string>
 8 |     <string name="i2c_detect">Detect</string>
 9 |     <string name="i2c_clean">Clean</string>
10 |     <string name="i2c_data_address">Data Address: 0x</string>
11 |     <string name="i2c_data_value">Value: 0x</string>
12 |     
13 | </resources>
14 | 


--------------------------------------------------------------------------------
/project.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 edit
 7 | # "ant.properties", and override values to adapt the script to your
 8 | # project structure.
 9 | #
10 | # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
11 | #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
12 | 
13 | # Project target.
14 | target=android-22
15 | android.library.reference.1=../../android-sdk/extras/android/support/v7/appcompat
16 | 


--------------------------------------------------------------------------------
/proguard-project.txt:
--------------------------------------------------------------------------------
 1 | # To enable ProGuard in your project, edit project.properties
 2 | # to define the proguard.config property as described in that file.
 3 | #
 4 | # Add project specific ProGuard rules here.
 5 | # By default, the flags in this file are appended to flags specified
 6 | # in ${sdk.dir}/tools/proguard/proguard-android.txt
 7 | # You can edit the include path and order by changing the ProGuard
 8 | # include property in project.properties.
 9 | #
10 | # For more details, see
11 | #   http://developer.android.com/guide/developing/tools/proguard.html
12 | 
13 | # Add any project specific keep options here:
14 | 
15 | # If your project uses WebView with JS, uncomment the following
16 | # and specify the fully qualified class name to the JavaScript interface
17 | # class:
18 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
19 | #   public *;
20 | #}
21 | 


--------------------------------------------------------------------------------
/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     package="com.mitac.android.i2ctool"
 4 |     android:versionCode="1"
 5 |     android:versionName="1.0" >
 6 | 
 7 |     <uses-sdk
 8 |         android:minSdkVersion="11"
 9 |         android:targetSdkVersion="21" />
10 |     
11 |     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
12 |     
13 |     <application
14 |         android:allowBackup="true"
15 |         android:icon="@drawable/ic_launcher"
16 |         android:label="@string/app_name"
17 |         android:theme="@style/AppTheme" >
18 |         <activity
19 |             android:name="com.mitac.android.i2ctool.MainActivity"
20 |             android:screenOrientation="landscape"
21 |             android:label="@string/app_name" >
22 |             <intent-filter>
23 |                 <action android:name="android.intent.action.MAIN" />
24 | 
25 |                 <category android:name="android.intent.category.LAUNCHER" />
26 |             </intent-filter>
27 |         </activity>
28 |     </application>
29 | 
30 | </manifest>
31 | 


--------------------------------------------------------------------------------
/bin/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     package="com.mitac.android.i2ctool"
 4 |     android:versionCode="1"
 5 |     android:versionName="1.0" >
 6 | 
 7 |     <uses-sdk
 8 |         android:minSdkVersion="11"
 9 |         android:targetSdkVersion="21" />
10 |     
11 |     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
12 |     
13 |     <application
14 |         android:allowBackup="true"
15 |         android:icon="@drawable/ic_launcher"
16 |         android:label="@string/app_name"
17 |         android:theme="@style/AppTheme" >
18 |         <activity
19 |             android:name="com.mitac.android.i2ctool.MainActivity"
20 |             android:screenOrientation="landscape"
21 |             android:label="@string/app_name" >
22 |             <intent-filter>
23 |                 <action android:name="android.intent.action.MAIN" />
24 | 
25 |                 <category android:name="android.intent.category.LAUNCHER" />
26 |             </intent-filter>
27 |         </activity>
28 |     </application>
29 | 
30 | </manifest>
31 | 


--------------------------------------------------------------------------------
/res/layout/dialog_i2c_info.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent" >
 5 |     
 6 |     <NumberPicker android:id="@+id/dialogBusIdPicker"
 7 |         android:layout_width="wrap_content"
 8 |         android:layout_height="match_parent"
 9 |         android:layout_alignParentLeft="true"
10 |         android:descendantFocusability="blocksDescendants" />
11 |     
12 |     <NumberPicker android:id="@+id/dialogAddrHighPicker"
13 |         android:layout_width="wrap_content"
14 |         android:layout_height="match_parent"
15 |         android:layout_centerInParent="true"
16 |         android:descendantFocusability="blocksDescendants" />
17 |     
18 |     <NumberPicker android:id="@+id/dialogAddrLowPicker"
19 |         android:layout_width="wrap_content"
20 |         android:layout_height="match_parent"
21 |         android:layout_toRightOf="@id/dialogAddrHighPicker"
22 |         android:descendantFocusability="blocksDescendants" />
23 |     
24 |     <TextView
25 |         android:layout_width="wrap_content"
26 |         android:layout_height="wrap_content"
27 |         android:layout_toLeftOf="@id/dialogAddrHighPicker"
28 |         android:layout_centerVertical="true"
29 |         android:textSize="18sp"
30 |         android:text="Addr: 0x"/>
31 |     
32 |     <NumberPicker android:id="@+id/dialogModePicker"
33 |         android:layout_width="wrap_content"
34 |         android:layout_height="match_parent"
35 |         android:layout_alignParentRight="true"
36 |         android:descendantFocusability="blocksDescendants" />
37 |         
38 | </RelativeLayout>
39 | 


--------------------------------------------------------------------------------
/res/layout/dialog_i2c_set.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="256dp"
 5 |     android:padding="4dp" >
 6 |     
 7 |     <LinearLayout
 8 |         android:layout_width="0dp"
 9 |         android:layout_height="wrap_content"
10 |         android:layout_gravity="left|center_vertical"
11 |         android:layout_weight="0.35"
12 |         android:orientation="vertical" >
13 | 
14 |         <TextView
15 |             android:layout_width="match_parent"
16 |             android:layout_height="wrap_content"
17 |             android:text="@string/i2c_data_address" />
18 | 
19 |         <EditText
20 |             android:id="@+id/dialogDataAddrEt"
21 |             android:layout_width="match_parent"
22 |             android:layout_height="wrap_content"
23 |             android:cursorVisible="false"
24 |             android:enabled="true"
25 |             android:inputType="numberDecimal"
26 |             android:maxLength="6"
27 |             android:singleLine="true" />
28 |     </LinearLayout>
29 |     
30 |     <LinearLayout
31 |         android:layout_width="0dp"
32 |         android:layout_height="wrap_content"
33 |         android:layout_gravity="left|center_vertical"
34 |         android:layout_weight="0.35"
35 |         android:orientation="vertical" >
36 | 
37 |         <TextView
38 |             android:layout_width="match_parent"
39 |             android:layout_height="wrap_content"
40 |             android:text="@string/i2c_data_value" />
41 | 
42 |         <EditText
43 |             android:id="@+id/dialogDataValueEt"
44 |             android:layout_width="match_parent"
45 |             android:layout_height="wrap_content"
46 |             android:cursorVisible="false"
47 |             android:enabled="true"
48 |             android:inputType="numberDecimal"
49 |             android:maxLength="6"
50 |             android:singleLine="true" />
51 |     </LinearLayout>
52 |     
53 |     <NumberPicker android:id="@+id/dialogModePicker"
54 |         android:layout_width="0dp"
55 |         android:layout_weight="0.3"
56 |         android:layout_height="256dp"
57 |         android:descendantFocusability="blocksDescendants" />
58 |     
59 | </LinearLayout>
60 | 


--------------------------------------------------------------------------------
/src/com/mitac/android/i2ctool/LogFileHelper.java:
--------------------------------------------------------------------------------
 1 | package com.mitac.android.i2ctool;
 2 | 
 3 | import java.io.File;
 4 | import java.io.FileNotFoundException;
 5 | import java.io.FileWriter;
 6 | import java.io.IOException;
 7 | import java.text.SimpleDateFormat;
 8 | import java.util.Date;
 9 | import java.util.Locale;
10 | 
11 | import android.os.Environment;
12 | import android.util.Log;
13 | 
14 | public class LogFileHelper {
15 | 
16 |     private static final String TAG = "i2c_LogFileHelper";
17 | 
18 |     public static final String TIME_FORMATTER_YMDHMS = "yyyy-MM-dd HH:mm:ss";
19 |     public static final String TIME_FORMATTER_HMS = "HH:mm:ss";
20 |     
21 |     private static final String LOG_FILE_SUBDIR = "/i2clog";
22 |     
23 |     private static LogFileHelper sLogFileHelper;
24 |     private File mLogDirectory;
25 | 
26 |     private LogFileHelper() {
27 |         super();
28 |         mLogDirectory = new File(getInnerSDCardPath() + LOG_FILE_SUBDIR);
29 |         mLogDirectory.mkdirs();
30 |     }
31 | 
32 |     public static LogFileHelper get() {
33 |         if (sLogFileHelper == null) {
34 |             sLogFileHelper = new LogFileHelper();
35 |         }
36 |         return sLogFileHelper;
37 |     }
38 | 
39 |     public File createFile(String filename) {
40 |         File file = new File(mLogDirectory, filename);
41 |         writeFile(file, "\r\n" + timestamp(TIME_FORMATTER_YMDHMS) + "\r\n\r\n" );
42 |         return file;
43 |     }
44 | 
45 |     /**
46 |      * Method to write ascii text characters to file on SD card. Note that you
47 |      * must add a WRITE_EXTERNAL_STORAGE permission to the manifest file or this
48 |      * method will throw a FileNotFound Exception because you won't have write
49 |      * permission.
50 |      */
51 |     public void writeFile(File file, String content) {
52 |         if (file == null) {
53 |             Log.e(TAG, "File not created.");
54 |         }
55 |         
56 |         try {
57 |             FileWriter out = new FileWriter(file, true);
58 |             out.write("\r\n" + content);
59 |             out.flush();
60 |             out.close();
61 |         } catch (FileNotFoundException e) {
62 |             e.printStackTrace();
63 |             Log.e(TAG, "File not found. Did you add a WRITE_EXTERNAL_STORAGE permission to the manifest?");
64 |         } catch (IOException e) {
65 |             e.printStackTrace();
66 |         }
67 |     }
68 |     
69 |     //Get inner SDCard path
70 |     public String getInnerSDCardPath() {
71 |         return Environment.getExternalStorageDirectory().getPath();
72 |     }
73 |     
74 |     public String timestamp(String formatter) {
75 |         SimpleDateFormat sdf = new SimpleDateFormat(formatter, Locale.US);
76 |         Date date = new Date();        
77 |         return sdf.format(date);
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Android I2C Tool Manual
 2 | 
 3 | This tool is to
 4 | 
 5 | - detect Android I2C devices,
 6 | - dump and set the values of I2C device registers periodically or just one time.
 7 | - log device registers values.
 8 | 
 9 | The core part is running linux commannd line tool through `Runtime.getRuntime().exec()`, then read and parse the stand out/error and then write to log.
10 | 
11 | ### Setup
12 | 
13 | 1. Build the [i2c linux command line tool](https://github.com/suapapa/i2c-tools) in target Android BSP to generate binary files: `i2cdump`, `i2cset`.
14 | 2. Root Android device.
15 | 3. Upload these two files to target device path `/system/xbin`, and modify the permission as 755;
16 | 
17 |     ```sh
18 |     adb-platform-tools>adb remount
19 |     adb-platform-tools>adb push i2cdump /system/xbin
20 |     adb-platform-tools>adb push i2cset /system/xbin
21 |     adb-platform-tools>adb shell chmod 755 /system/xbin/i2c*
22 |     ```
23 | 4. If encounter the following error:
24 | 
25 |     ```sh
26 |     Error: Could not open file `/dev/i2c-2': Permission denied, Run as root?
27 |     ```
28 | then need to modify the permission of Android I2C device file：`root@android:/ # chmod 666 /dev/i2c*`
29 | 
30 | 
31 | ![i2c-command-line-tools](https://github.com/li2/Android_I2C_Tool/blob/master/assets/i2c-command-line-tools.png)
32 | 
33 | 
34 | ### Detect I2C bus and chips on target Android device
35 | 
36 | ![i2c-detect](https://github.com/li2/Android_I2C_Tool/blob/master/assets/detect.png)
37 | 
38 | 
39 | ### Dump all registers of specific I2C chip
40 | 
41 | 1. click right button to popup a I2C device selector dialog, then set bus number, device addres, read mode;
42 | 2. enable read periodically;
43 | 3. enable Log,
44 | 
45 | log path :/mnt/sdcard/i2clog/i2c_log_parsed.txt and i2c_log_raw.txt
46 | 
47 | ```sh
48 |     14:54:59 - 
49 |     24 02 00 00 64 00 12 0c 3f 10 88 02 8c 0b 8c 0b
50 |     c9 0c c9 0c 08 00 ff ff c9 0c fa ff 27 0b 5b fd
51 |     27 0b c9 0c 21 00 00 00 12 0c 02 00 64 00 60 00 
52 |     68 10 fa 05 ff ff 5e 00 53 00 76 11 f4 0b 00 00
53 |     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
54 |     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
55 |     00 00 0a 42 51 32 37 35 34 58 2d 47 31 ff 00 00
56 |     00 00 00 00 00 00 00 00 XX XX 95 ff 3f 10 12 0c
57 |     24 02 00 00 64 00 12 0c 3f 10 88 02 8c 0b 8c 0b
58 |     c9 0c c9 0c 08 00 ff ff c9 0c fa ff 27 0b 5b fd
59 |     27 0b c9 0c 21 00 00 00 12 0c 02 00 64 00 60 00
60 |     68 10 fa 05 ff ff 5e 00 53 00 76 11 f4 0b 00 00
61 |     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
62 |     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
63 |     00 00 0a 42 51 32 37 35 34 58 2d 47 31 ff 00 00
64 |     00 00 00 00 00 00 00 00 XX XX 95 ff 3f 10 12 0c
65 | 14:55:00 - 
66 | ```
67 | ![i2c-dump](https://github.com/li2/Android_I2C_Tool/blob/master/assets/dump.png)
68 | 
69 | 
70 | ### Set value to specific I2C device register
71 | 
72 | ![i2c-set](https://github.com/li2/Android_I2C_Tool/blob/master/assets/set.png)
73 | 
74 | 
75 | ## About
76 | 
77 | App可以用于探测Android设备I2C总线、读取/设置I2C设备寄存器值，并写入log，硬件工程师可以直接把log导入excel，就可以进一步分析数据。
78 | 方便不熟悉命令行和ADB的硬件工程师测试。
79 | 
80 | 核心是通过`Runtime.getRuntime().exec()`调用命令行工具，然后读取进程的标准输出/标准错误。核心代码在`I2cToolHelper.java`和`I2cParserHelper.java`
81 | 
82 | 之所以开发这个App，是因为我负责的驱动模块出现了问题，需要和硬件工程师排一起查软、硬问题。因为硬件工程师不熟悉命令行、ADB，并且使用ADB打印的log不便于处理。
83 | 
84 | 第一版于2013.08开发完成，这是第一次开发Android，所有细节都得搜索，很琐碎很差劲，至于有多差劲，可以看代码：[branch-v1](https://github.com/li2/Android_I2C_Tool/tree/v1)，
85 | 第二版于2015.10开发完成，重构了之前的代码。
86 | 
87 | 之所以开源这个App，是因为没有上述提到的开源的命令行工具，这个App没有任何作用。
88 | 希望对别人有所帮助。
89 | 
90 | weiyi.just2@gmail.com
91 | li2.me
92 | 


--------------------------------------------------------------------------------
/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     xmlns:tools="http://schemas.android.com/tools"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent"
 5 |     android:orientation="horizontal"
 6 |     tools:context="com.mitac.android.i2ctool.MainActivity" >
 7 |     
 8 |     <ScrollView
 9 |         android:id="@+id/i2cConsoleScroll"
10 |         android:layout_width="0dp"
11 |         android:layout_weight="0.8"
12 |         android:layout_height="match_parent"
13 |         android:scrollbarFadeDuration="0" >
14 |         
15 | 	    <TextView
16 | 	        android:id="@+id/i2cConsoleTv"
17 | 	        android:layout_width="match_parent"
18 | 	        android:layout_height="wrap_content"
19 | 	        android:layout_marginLeft="4dp"
20 | 	        android:gravity="left"
21 | 	        android:maxLines="@integer/console_max_lines"
22 |             android:typeface="monospace" />
23 |         
24 |     </ScrollView>
25 |     
26 |     <RelativeLayout
27 |         android:layout_width="0dp"
28 |         android:layout_weight="0.2"
29 |         android:layout_height="match_parent"
30 |         android:padding="2dp"
31 |         android:orientation="vertical">
32 | 	    
33 |         <LinearLayout
34 |             android:id="@+id/i2cLoop"
35 |             android:layout_width="match_parent"
36 |             android:layout_height="wrap_content"
37 |             android:orientation="horizontal" >
38 |             
39 |             <CheckBox
40 |                 android:id="@+id/i2cLoopCheckbox"
41 |                 android:layout_width="wrap_content"
42 |                 android:layout_height="wrap_content"
43 |                 android:layout_gravity="center" />
44 | 
45 |             <Button
46 |                 android:id="@+id/i2cLoopIntervalBtn"
47 |                 android:layout_width="match_parent"
48 |                 android:layout_height="wrap_content" />
49 |             
50 |         </LinearLayout>
51 | 
52 |         <Button
53 |             android:id="@+id/i2cInfoBtn"
54 |             android:layout_width="match_parent"
55 |             android:layout_height="wrap_content"
56 |             android:layout_below="@id/i2cLoop" />
57 |         
58 |         <Button
59 |             android:id="@+id/i2cClearBtn"
60 |             android:layout_width="match_parent"
61 |             android:layout_height="wrap_content"
62 |             android:layout_below="@id/i2cInfoBtn"
63 |             android:text="@string/i2c_clean" />
64 |         
65 |         <Button
66 |             android:id="@+id/i2cDumpBtn"
67 |             android:layout_width="match_parent"
68 |             android:layout_height="64dp"
69 |             android:layout_alignParentBottom="true"
70 |             android:layout_marginBottom="8dp"
71 |             android:text="@string/i2c_dump" />
72 |         
73 |         <Button
74 |             android:id="@+id/i2cSetBtn"
75 |             android:layout_width="match_parent"
76 |             android:layout_height="64dp"
77 |             android:layout_above="@id/i2cDumpBtn"
78 |             android:layout_marginBottom="8dp"
79 |             android:text="@string/i2c_set" />
80 |         
81 |         <Button
82 |             android:id="@+id/i2cDetectBtn"
83 |             android:layout_width="match_parent"
84 |             android:layout_height="wrap_content"
85 |             android:layout_above="@id/i2cSetBtn"
86 |             android:layout_marginBottom="8dp"
87 |             android:text="@string/i2c_detect" />        
88 |         
89 | </RelativeLayout>
90 |     
91 | </LinearLayout>
92 | 


--------------------------------------------------------------------------------
/src/com/mitac/android/i2ctool/I2cSetDialog.java:
--------------------------------------------------------------------------------
  1 | package com.mitac.android.i2ctool;
  2 | 
  3 | import android.annotation.SuppressLint;
  4 | import android.app.AlertDialog;
  5 | import android.app.Dialog;
  6 | import android.content.DialogInterface;
  7 | import android.content.DialogInterface.OnClickListener;
  8 | import android.os.Bundle;
  9 | import android.support.v4.app.DialogFragment;
 10 | import android.view.LayoutInflater;
 11 | import android.view.View;
 12 | import android.widget.EditText;
 13 | import android.widget.NumberPicker;
 14 | import android.widget.NumberPicker.OnValueChangeListener;
 15 | import android.widget.Toast;
 16 | 
 17 | public class I2cSetDialog extends DialogFragment {
 18 |     
 19 |     private static final String TAG = "i2c_I2cSetDialog";
 20 |     
 21 |     private int mDataAddr = 0;
 22 |     private int mDataValue = 0;
 23 |     private int mI2cSetMode = 0;
 24 |     
 25 |     EditText mDataAddrEt;
 26 |     EditText mDataValueEt;
 27 |     
 28 |     private OnSetClickListener mOnSetClickListener;
 29 |     
 30 |     public interface OnSetClickListener {
 31 |         void onSetClick(int dataAddress, int value, String mode);            
 32 |     }
 33 |     
 34 |     public void setOnSetClickListener(OnSetClickListener l) {
 35 |         mOnSetClickListener = l;
 36 |     }
 37 |     
 38 |     @SuppressLint("InflateParams")
 39 |     @Override
 40 |     public Dialog onCreateDialog(Bundle savedInstanceState) {
 41 |         AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 42 |         LayoutInflater inflater = getActivity().getLayoutInflater();
 43 |         
 44 |         View view = inflater.inflate(R.layout.dialog_i2c_set, null);
 45 |         builder.setView(view)
 46 |             .setPositiveButton(R.string.i2c_set, new OnClickListener() {
 47 |                 @Override
 48 |                 public void onClick(DialogInterface dialog, int which) {
 49 |                     if (mOnSetClickListener != null) {
 50 |                         String mode = I2cInfo.getI2cSetMode(mI2cSetMode);
 51 |                         mDataAddr = Integer.valueOf(mDataAddrEt.getText().toString(), 16);
 52 |                         mDataValue = Integer.valueOf(mDataValueEt.getText().toString(), 16);
 53 |                         mOnSetClickListener.onSetClick(mDataAddr, mDataValue, mode);
 54 |                         I2cInfo.saveI2cSetToPref(getActivity(), mDataAddr, mDataValue, mI2cSetMode);
 55 |                     }
 56 |                 }
 57 |             })
 58 |             .setNegativeButton(android.R.string.cancel, new OnClickListener() {
 59 |                 @Override
 60 |                 public void onClick(DialogInterface dialog, int which) {
 61 |                     I2cSetDialog.this.getDialog().cancel();                    
 62 |                 }
 63 |             });
 64 |         
 65 |         mDataAddrEt = (EditText) view.findViewById(R.id.dialogDataAddrEt);
 66 |         mDataValueEt = (EditText) view.findViewById(R.id.dialogDataValueEt);
 67 |         
 68 |         // Mode picker
 69 |         NumberPicker i2cModePicker = (NumberPicker) view.findViewById(R.id.dialogModePicker);
 70 |         i2cModePicker.setMinValue(0);
 71 |         i2cModePicker.setMaxValue(I2cInfo.SET_MODE_COUNT-1);
 72 |         i2cModePicker.setOnValueChangedListener(new OnValueChangeListener() {
 73 |             @Override
 74 |             public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
 75 |                 mI2cSetMode = newVal;
 76 |                 Toast.makeText(getActivity(), I2cInfo.getI2cSetModeDescription(newVal), Toast.LENGTH_SHORT).show();;
 77 |             }
 78 |         });
 79 |         i2cModePicker.setDisplayedValues(getModeDisplayedValues());
 80 |         
 81 |         // Init data
 82 |         mDataAddr = I2cInfo.getDataAddrFromPref(getActivity());
 83 |         mDataValue = I2cInfo.getDataValueFromPref(getActivity());
 84 |         mI2cSetMode = I2cInfo.getSetModeFromPref(getActivity());
 85 |         
 86 |         mDataAddrEt.setText(Integer.toHexString(mDataAddr));
 87 |         mDataValueEt.setText(Integer.toHexString(mDataValue));
 88 |         i2cModePicker.setValue(mI2cSetMode);
 89 |         
 90 |         return builder.create();
 91 |     }       
 92 |     
 93 |     private String[] getModeDisplayedValues() {
 94 |         String[] displayedValues = new String[I2cInfo.SET_MODE_COUNT];
 95 |         for (int i=0; i<I2cInfo.SET_MODE_COUNT; i++) {
 96 |             displayedValues[i] = I2cInfo.getI2cSetMode(i);
 97 |         }
 98 |         return displayedValues;
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/src/com/mitac/android/i2ctool/I2cInfo.java:
--------------------------------------------------------------------------------
  1 | package com.mitac.android.i2ctool;
  2 | 
  3 | import android.content.Context;
  4 | import android.preference.PreferenceManager;
  5 | 
  6 | public class I2cInfo {
  7 | 
  8 |     public static final int ADDR_COUNT = 256;
  9 |     public static final int DUMP_MODE_COUNT = 5;
 10 |     public static final int SET_MODE_COUNT = 2;
 11 |     
 12 |     public static final String PREF_I2C_BUS = "i2cBusId";
 13 |     public static final String PREF_I2C_ADDR = "i2cAddress";
 14 |     public static final String PREF_I2C_DUMP_MODE = "i2cDumpMode";
 15 |     public static final String PREF_I2C_SET_MODE = "i2cSetMode";
 16 |     public static final String PREF_I2C_DATA_ADDR = "i2cDataAddress";
 17 |     public static final String PREF_I2C_DATA_VALUE = "i2cDataValue";
 18 |     
 19 |     public enum I2cDumpMode {
 20 |         Byte("b - byte, default", 0),
 21 | //        Word("w - word", 1),
 22 |         WordOnEvenAddr("W - word on even register addresses", 2),
 23 |         SMBusBlock("s - SMBus block", 3),
 24 |         I2CBlock("i - I2C block", 4),
 25 |         ConsecutiveByte("c- consecutive byte", 5);
 26 |         
 27 |         private String mStringValue;
 28 |         @SuppressWarnings("unused")
 29 |         private int mIntValue;
 30 |         private I2cDumpMode(String toString, int value) {
 31 |             mStringValue = toString;
 32 |             mIntValue = value;
 33 |         }
 34 |         
 35 |         @Override
 36 |         public String toString() {
 37 |             return mStringValue;
 38 |         }
 39 |         
 40 |         // get Enum value from integer
 41 |         private static I2cDumpMode fromInteger(int i) {
 42 |             I2cDumpMode[] modeValues = I2cDumpMode.values();
 43 |             return modeValues[i];
 44 |         }
 45 |     }
 46 |     
 47 |     public enum I2cSetMode {
 48 |         Byte("b - byte, default", 0),
 49 |         Word("w - word", 1);
 50 |         
 51 |         private String mStringValue;
 52 |         @SuppressWarnings("unused")
 53 |         private int mIntValue;
 54 |         private I2cSetMode(String toString, int value) {
 55 |             mStringValue = toString;
 56 |             mIntValue = value;
 57 |         }
 58 |         
 59 |         @Override
 60 |         public String toString() {
 61 |             return mStringValue;
 62 |         }
 63 |         
 64 |         // get Enum value from integer
 65 |         private static I2cSetMode fromInteger(int i) {
 66 |             I2cSetMode[] modeValues = I2cSetMode.values();
 67 |             return modeValues[i];
 68 |         }
 69 |     }    
 70 |     
 71 |     // get the first letter
 72 |     public static String getI2cDumpMode(int value) {
 73 |         return I2cDumpMode.fromInteger(value).toString().substring(0, 1);
 74 |     }
 75 |     
 76 |     public static String getI2cDumpModeDescription(int value) {
 77 |         return I2cDumpMode.fromInteger(value).toString();
 78 |     }
 79 |     
 80 |     public static String getI2cSetMode(int value) {
 81 |         return I2cSetMode.fromInteger(value).toString().substring(0, 1);
 82 |     }
 83 |     
 84 |     // get total string
 85 |     public static String getI2cSetModeDescription(int value) {
 86 |         return I2cSetMode.fromInteger(value).toString();
 87 |     }
 88 |     
 89 |     // Shared Preference
 90 |     public static int getBusIdFromPref(Context context) {
 91 |         return PreferenceManager.getDefaultSharedPreferences(context)
 92 |                 .getInt(PREF_I2C_BUS, 0);
 93 |     }
 94 |     
 95 |     public static int getAddressFromPref(Context context) {
 96 |         return PreferenceManager.getDefaultSharedPreferences(context)
 97 |                 .getInt(PREF_I2C_ADDR, 0);
 98 |     }
 99 |     
100 |     public static int getDumpModeFromFref(Context context) {
101 |         return PreferenceManager.getDefaultSharedPreferences(context)
102 |                 .getInt(PREF_I2C_DUMP_MODE, 0);
103 |     }
104 |     
105 |     public static int getSetModeFromPref(Context context) {
106 |         return PreferenceManager.getDefaultSharedPreferences(context)
107 |                 .getInt(PREF_I2C_SET_MODE, 0);
108 |     }
109 |     
110 |     public static int getDataAddrFromPref(Context context) {
111 |         return PreferenceManager.getDefaultSharedPreferences(context)
112 |                 .getInt(PREF_I2C_DATA_ADDR, 0);
113 |     }
114 |     
115 |     public static int getDataValueFromPref(Context context) {
116 |         return PreferenceManager.getDefaultSharedPreferences(context)
117 |                 .getInt(PREF_I2C_DATA_VALUE, 0);
118 |     }
119 |     
120 |     public static void saveI2cInfoToPref(Context context, int busId, int address, int mode) {
121 |         PreferenceManager.getDefaultSharedPreferences(context)
122 |             .edit()
123 |             .putInt(PREF_I2C_BUS, busId)
124 |             .putInt(PREF_I2C_ADDR, address)
125 |             .putInt(PREF_I2C_DUMP_MODE, mode)
126 |             .commit();
127 |     }
128 |     
129 |     public static void saveI2cSetToPref(Context context, int dataAddr, int dataValue, int mode) {
130 |         PreferenceManager.getDefaultSharedPreferences(context)
131 |             .edit()
132 |             .putInt(PREF_I2C_DATA_ADDR, dataAddr)
133 |             .putInt(PREF_I2C_DATA_VALUE, dataValue)
134 |             .putInt(PREF_I2C_SET_MODE, mode)
135 |             .commit();
136 |     }
137 | }
138 | 


--------------------------------------------------------------------------------
/src/com/mitac/android/i2ctool/I2cToolHelper.java:
--------------------------------------------------------------------------------
  1 | package com.mitac.android.i2ctool;
  2 | 
  3 | import java.io.BufferedReader;
  4 | import java.io.IOException;
  5 | import java.io.InputStreamReader;
  6 | import java.util.ArrayList;
  7 | 
  8 | import android.os.Handler;
  9 | import android.util.Log;
 10 | 
 11 | public class I2cToolHelper {
 12 |     
 13 |     private static final String TAG = "i2c_I2cToolHelper";
 14 |     
 15 |     private static final String I2C_TOOL_PATH = "/system/xbin";
 16 |     private static final String I2C_TOOL_DETECT = "i2cdetect";
 17 |     private static final String I2C_TOOL_DUMP = "i2cdump";
 18 |     private static final String I2C_TOOL_GET = "i2cget";
 19 |     private static final String I2C_TOOL_SET = "i2cset";
 20 |     
 21 |     public static final int PROCESS_STREAM_STDOUT = 1;
 22 |     public static final int PROCESS_STREAM_STDERR = 2;
 23 |     
 24 |     private static final int DELAY_AFTER_CMD_EXECUTED = 50; // 50ms
 25 |     
 26 |     private Process mNativeProcess;
 27 |     private Handler mHandler = new Handler();
 28 |     private Handler mResponseHandler;
 29 |     private OnStreamParsedListener mOnStreamParsedListener;       
 30 |     
 31 |     public interface OnStreamParsedListener {
 32 |         void onStreamParsed(int streamType, ArrayList<String> stream);
 33 |     }
 34 |     
 35 |     public void setOnStreamParsedListener(OnStreamParsedListener l) {
 36 |         mOnStreamParsedListener = l;
 37 |     }
 38 |     
 39 |     public I2cToolHelper(Handler responseHandler) {
 40 |         super();
 41 |         mResponseHandler = responseHandler;
 42 |     }   
 43 |     
 44 |     // android runtime exec Could not open file `/dev/i2c-2'Permission denied, Run as root?
 45 |     // default is 600
 46 |     // chmod 666 /dev/i2c-2
 47 |     // crw------- root     root      89,   2 2015-10-27 14:51 i2c-2
 48 |     // crw-rw-rw- root     root      89,   2 2015-10-27 14:51 i2c-2        
 49 |     private Process doRuntimeExec(String program) {
 50 |         Process process;
 51 |         try {
 52 |             Log.i(TAG, "Execute " + program);
 53 |             process = Runtime.getRuntime().exec(program);
 54 |             mHandler.postDelayed(mStreamParserRunnable, DELAY_AFTER_CMD_EXECUTED);
 55 |             
 56 |         } catch (IOException ioe) {
 57 |             process = null;
 58 |             Log.e(TAG, "Requested program can not be executed: " + program + ", " + ioe);
 59 |         }
 60 |         
 61 |         return process;
 62 |     }
 63 |     
 64 |     public void doDump(int bus, int address, String mode) {
 65 |         String program = I2C_TOOL_PATH + "/" + I2C_TOOL_DUMP + " -f -y " + bus + " " + address;
 66 |         if (mode != null) {
 67 |             program += " " + mode;
 68 |         }
 69 |         mNativeProcess = doRuntimeExec(program);
 70 |     }
 71 |     
 72 |     public void doSet(int bus, int address, int dataAddress, int value, String mode) {
 73 |         String program = I2C_TOOL_PATH + "/" + I2C_TOOL_SET + " -f -y " +
 74 |                 bus + " " + address + " " + dataAddress + " " + value;
 75 |         if (mode != null) {
 76 |             program += " " + mode;
 77 |         }
 78 |         mNativeProcess = doRuntimeExec(program);
 79 |     }
 80 |     
 81 |     public void doDetect() {
 82 |         String program = I2C_TOOL_PATH + "/" + I2C_TOOL_DETECT + " -l";
 83 |         // use this command instead
 84 |         program = "ls /sys/bus/i2c/devices ; ls /sys/bus/i2c/drivers";
 85 |         // program = "ls /sys/bus/i2c/devices ; cat /sys/bus/i2c/devices/*/name";
 86 |         mNativeProcess = doRuntimeExec(program);
 87 |     }
 88 |     
 89 |     private Runnable mStreamParserRunnable = new Runnable() {
 90 |         @Override
 91 |         public void run() {
 92 |             if (mNativeProcess == null) {
 93 |                 return;
 94 |             }
 95 |             ArrayList<String> result;
 96 |             result = getStandOut();
 97 |             if (result == null || result.size() == 0) {
 98 |                 result = getStandError();
 99 |                 if (result != null) {
100 |                     Log.e(TAG, "Stand Err: " + result);
101 |                     handleParseResult(PROCESS_STREAM_STDERR, result);
102 |                 }
103 |             } else {
104 |                 // Log.d(TAG, "Stand Out: " + result);
105 |                 handleParseResult(PROCESS_STREAM_STDOUT, result);
106 |             }
107 |         }
108 |     };
109 |     
110 |     private void handleParseResult(final int streamType, final ArrayList<String> stream) {
111 |         if (mResponseHandler == null) {
112 |             Log.e(TAG, "Response handler is null");
113 |             return;
114 |         }
115 |         
116 |         mResponseHandler.post(new Runnable() {
117 |             @Override
118 |             public void run() {
119 |                 if (mOnStreamParsedListener != null) {
120 |                     mOnStreamParsedListener.onStreamParsed(streamType, stream);
121 |                 }
122 |             }
123 |         });
124 |     }
125 |     
126 |     private ArrayList<String> getStandOut() {
127 |         if (mNativeProcess == null) {
128 |             return null;
129 |         }
130 |         return getProcessStream(mNativeProcess, PROCESS_STREAM_STDOUT);
131 |     }
132 |     
133 |     private ArrayList<String> getStandError() {
134 |         if (mNativeProcess == null) {
135 |             return null;
136 |         }
137 |         return getProcessStream(mNativeProcess, PROCESS_STREAM_STDERR);
138 |     }
139 |     
140 |     private ArrayList<String> getProcessStream(Process process, int streamType) {
141 |         try {
142 |             ArrayList<String> result = new ArrayList<String>();
143 |             String line = "";
144 |             BufferedReader bufReader;
145 |             if (streamType == PROCESS_STREAM_STDERR) {
146 |                 bufReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
147 |             } else {
148 |                 bufReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
149 |             }
150 |             
151 |             while ((line = bufReader.readLine()) != null) {
152 |                 if (line.trim().equals("")) {
153 |                     continue;
154 |                 }
155 |                 result.add(line);
156 |             }            
157 |             return result;
158 |             
159 |         } catch (IOException ioe) {
160 |             ioe.printStackTrace();
161 |             return null;
162 |         }
163 |     }
164 | }
165 | 


--------------------------------------------------------------------------------
/src/com/mitac/android/i2ctool/I2cInfoDialog.java:
--------------------------------------------------------------------------------
  1 | package com.mitac.android.i2ctool;
  2 | 
  3 | import android.annotation.SuppressLint;
  4 | import android.app.AlertDialog;
  5 | import android.app.Dialog;
  6 | import android.content.DialogInterface;
  7 | import android.content.DialogInterface.OnClickListener;
  8 | import android.os.Bundle;
  9 | import android.support.v4.app.DialogFragment;
 10 | import android.util.Log;
 11 | import android.view.LayoutInflater;
 12 | import android.view.View;
 13 | import android.widget.NumberPicker;
 14 | import android.widget.NumberPicker.OnValueChangeListener;
 15 | import android.widget.Toast;
 16 | 
 17 | public class I2cInfoDialog extends DialogFragment {
 18 |     
 19 |     private static final String TAG = "i2c_I2cInfoDialog";
 20 |     
 21 |     private static final int MIN_VALUE = 0;
 22 |     private static final int MAX_VALUE = 0xf;
 23 |     
 24 |     private int mI2cBusId = 0;
 25 |     private int mI2cAddrHigh = 0;
 26 |     private int mI2cAddrLow = 0;
 27 |     private int mI2cMode = 0;
 28 |     
 29 |     private OnI2cInfoChangedListener mOnI2cInfoChangedListener;
 30 |     
 31 |     public interface OnI2cInfoChangedListener {
 32 |         void onI2cInfoChanged(int busId, int address, String mode);            
 33 |     }
 34 |     
 35 |     public void setOnI2cInfoChangedListener(OnI2cInfoChangedListener l) {
 36 |         mOnI2cInfoChangedListener = l;
 37 |     }
 38 |     
 39 |     @SuppressLint("InflateParams")
 40 |     @Override
 41 |     public Dialog onCreateDialog(Bundle savedInstanceState) {
 42 |         AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 43 |         LayoutInflater inflater = getActivity().getLayoutInflater();
 44 |         
 45 |         View view = inflater.inflate(R.layout.dialog_i2c_info, null);
 46 |         builder.setView(view)
 47 |             .setPositiveButton(android.R.string.ok, new OnClickListener() {
 48 |                 @Override
 49 |                 public void onClick(DialogInterface dialog, int which) {
 50 |                     if (mOnI2cInfoChangedListener != null) {
 51 |                         Log.d(TAG, "Address High " + mI2cAddrHigh + ", Low " + mI2cAddrLow);
 52 |                         int address = mI2cAddrHigh * 16 + mI2cAddrLow;
 53 |                         String mode = I2cInfo.getI2cDumpMode(mI2cMode);
 54 |                         mOnI2cInfoChangedListener.onI2cInfoChanged(mI2cBusId, address, mode);
 55 |                         I2cInfo.saveI2cInfoToPref(getActivity(), mI2cBusId, address, mI2cMode);
 56 |                     }
 57 |                 }
 58 |             })
 59 |             .setNegativeButton(android.R.string.cancel, new OnClickListener() {
 60 |                 @Override
 61 |                 public void onClick(DialogInterface dialog, int which) {
 62 |                     I2cInfoDialog.this.getDialog().cancel();                    
 63 |                 }
 64 |             });
 65 |         
 66 |         AlertDialog dialog = builder.create();
 67 |         
 68 |         // dialog.findViewById in DialogFragment onCreateDialog()
 69 |         // view.findViewById solve it.
 70 |         
 71 |         // Bus picker
 72 |         NumberPicker i2cBusIdPicker = (NumberPicker) view.findViewById(R.id.dialogBusIdPicker);
 73 |         i2cBusIdPicker.setMinValue(MIN_VALUE);
 74 |         i2cBusIdPicker.setMaxValue(MAX_VALUE);
 75 |         i2cBusIdPicker.setOnValueChangedListener(new OnValueChangeListener() {
 76 |             @Override
 77 |             public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
 78 |                 mI2cBusId = newVal;
 79 |             }
 80 |         });
 81 |         
 82 |         // Adress picker
 83 |         NumberPicker i2cAddrHightPicker = (NumberPicker) view.findViewById(R.id.dialogAddrHighPicker);
 84 |         i2cAddrHightPicker.setMinValue(MIN_VALUE);
 85 |         i2cAddrHightPicker.setMaxValue(MAX_VALUE);
 86 |         i2cAddrHightPicker.setOnValueChangedListener(new OnValueChangeListener() {
 87 |             @Override
 88 |             public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
 89 |                 mI2cAddrHigh = newVal;
 90 |             }
 91 |         });        
 92 |         // setFormatter return "0x" + Integer.toHexString(value)
 93 |         // 停止滚动后，0xfe变成0，0xf2变成2，所有字母都没有显示！
 94 |         // workaround
 95 |         i2cAddrHightPicker.setDisplayedValues(getAddrDisplayedValues());
 96 |         
 97 |         NumberPicker i2cAddrLowPicker = (NumberPicker) view.findViewById(R.id.dialogAddrLowPicker);
 98 |         i2cAddrLowPicker.setMinValue(MIN_VALUE);
 99 |         i2cAddrLowPicker.setMaxValue(MAX_VALUE);
100 |         i2cAddrLowPicker.setOnValueChangedListener(new OnValueChangeListener() {
101 |             @Override
102 |             public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
103 |                 mI2cAddrLow = newVal;
104 |             }
105 |         });        
106 |         i2cAddrLowPicker.setDisplayedValues(getAddrDisplayedValues());
107 |         
108 |         // Mode picker
109 |         NumberPicker i2cModePicker = (NumberPicker) view.findViewById(R.id.dialogModePicker);
110 |         i2cModePicker.setMinValue(0);
111 |         i2cModePicker.setMaxValue(I2cInfo.DUMP_MODE_COUNT-1);
112 |         i2cModePicker.setOnValueChangedListener(new OnValueChangeListener() {
113 |             @Override
114 |             public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
115 |                 mI2cMode = newVal;
116 |                 Toast.makeText(getActivity(), I2cInfo.getI2cDumpModeDescription(newVal), Toast.LENGTH_SHORT).show();;
117 |             }
118 |         });
119 |         i2cModePicker.setDisplayedValues(getModeDisplayedValues());
120 |         
121 |         // Init data
122 |         mI2cBusId = I2cInfo.getBusIdFromPref(getActivity());
123 |         int address = I2cInfo.getAddressFromPref(getActivity());
124 |         mI2cAddrHigh = address/16;
125 |         mI2cAddrLow = address%16;
126 |         mI2cMode = I2cInfo.getDumpModeFromFref(getActivity());
127 |         
128 |         i2cBusIdPicker.setValue(mI2cBusId);
129 |         i2cAddrHightPicker.setValue(mI2cAddrHigh);
130 |         i2cAddrLowPicker.setValue(mI2cAddrLow);
131 |         i2cModePicker.setValue(mI2cMode);
132 |         return dialog;
133 |     }       
134 |     
135 |     private String[] getModeDisplayedValues() {
136 |         String[] displayedValues = new String[I2cInfo.DUMP_MODE_COUNT];
137 |         for (int i=0; i<I2cInfo.DUMP_MODE_COUNT; i++) {
138 |             displayedValues[i] = I2cInfo.getI2cDumpMode(i);
139 |         }
140 |         return displayedValues;
141 |     }
142 |     
143 |     private String[] getAddrDisplayedValues() {
144 |         String[] displayedValues = new String[I2cInfo.ADDR_COUNT];
145 |         for (int i=0; i<displayedValues.length; i++) {
146 |             displayedValues[i] = Integer.toHexString(i);
147 |         }
148 |         return displayedValues;
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/src/com/mitac/android/i2ctool/I2cParserHelper.java:
--------------------------------------------------------------------------------
  1 | package com.mitac.android.i2ctool;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.List;
  5 | 
  6 | public class I2cParserHelper {
  7 | 
  8 |     private static final int I2C_DUMP_MODE_W_LINES = 16; // data lines in W mode(word on even register addresses)
  9 | 
 10 |     private static final String I2C_DUMP_MODE_W_PATTERN = "(.*)([\\s\\S]*)0123456789abcdef([\\s\\S]*)";
 11 |     
 12 |     // if @s contains the special @pattern, then return true.
 13 |     private static boolean matchPattern(String s, String pattern){
 14 |         return s.matches(pattern);
 15 |     }
 16 |     
 17 |     /*标准错误输出匹配*/
 18 |     public static boolean StderrMatch(String s){
 19 |         //std err 本来包含 询问是否继续操作"I will probe file /dev/i2c-1, address 0x10, mode i2c block Continue? [Y/n]"
 20 |         //然后需要向标准输入中写入y，
 21 |         //但由于命令有选项 -y, 可以忽略上述交互操作，所以stderr目前可以不分析而直接显示。
 22 |         return true;
 23 |     }
 24 |     
 25 | 
 26 |     //先检查i2cdetect/i2cdump/i2cset是否存在
 27 |     // i2cdump: No such file or directory
 28 |     // 废弃，不使用这种方法，2013-09-04
 29 |     private static boolean StderrMatch_ToolNotExit(String s){
 30 |         String pattern_stderr_i2cdetectnotexit = "(.*)([\\s\\S]*)i2cdetect:(.*)No(.*)such(.*)file(.*)([\\s\\S]*)";
 31 |         String pattern_stderr_i2cdumpnotexit = "(.*)([\\s\\S]*)i2cdump:(.*)No(.*)such(.*)file(.*)([\\s\\S]*)";
 32 |         String pattern_stderr_i2csetnotexit = "(.*)([\\s\\S]*)i2cset:(.*)No(.*)such(.*)file(.*)([\\s\\S]*)";
 33 | 
 34 |         if (true == matchPattern(s, pattern_stderr_i2cdetectnotexit)){
 35 |             System.out.println("pattern_stderr_i2cdetectnotexit mach success.");
 36 |             System.out.print(s);            
 37 |             return true;
 38 |         } else if (true == matchPattern(s, pattern_stderr_i2cdumpnotexit)){
 39 |             System.out.println("pattern_stderr_i2cdumpnotexit mach success.");
 40 |             System.out.print(s);            
 41 |             return true;
 42 |         } else if (true == matchPattern(s, pattern_stderr_i2csetnotexit)){
 43 |             System.out.println("pattern_stderr_i2csetnotexit mach success.");
 44 |             System.out.print(s);            
 45 |             return true;
 46 |         } else {
 47 |             //i2cdetect, i2cdump, i2cset 3个文件全部存在
 48 |             return false;           
 49 |         }
 50 |     }    
 51 |     
 52 |     
 53 |     
 54 |     /*
 55 |      * i2c-detect -l
 56 |      * output example is:
 57 |         i2c-0   i2c             sun5i-i2c.0                             I2C adapter
 58 |         i2c-1   i2c             sun5i-i2c.1                             I2C adapter
 59 |         i2c-2   i2c             sun5i-i2c.2                             I2C adapter 
 60 |      *
 61 |      * split by "i2c-", then you will get
 62 |      * 0i2c...
 63 |      * 1i2c...
 64 |      * 2i2c...
 65 |      * 
 66 |      * i2c bus num is the first char.
 67 |      */
 68 |     public static boolean StdoutMatch_I2CBusDetect(String s, List<String> buslist){
 69 |         String pattern_stdout_i2cbus = "(.*)([\\s\\S]*)i2c-(.*)i2c(.*)I2C(.*)adapter(.*)([\\s\\S]*)";
 70 | 
 71 |         // i2cdetect to identify id-0, id-1, id-2, ...;
 72 |         if (true == matchPattern(s, pattern_stdout_i2cbus)){
 73 |             String s_split[] = s.split("i2c-");
 74 |             for (int i=0; i<s_split.length; i++){
 75 |                 //System.out.println(s_split[i]);
 76 |                 //s_split[] length is 4, but only 3 is useful, so jude > 0
 77 |                 if (s_split[i].length() > 0){
 78 |                     buslist.add(String.valueOf(s_split[i].charAt(0)));
 79 |                 }
 80 |             } 
 81 |             return true;
 82 |         }
 83 |         return false;
 84 |     }
 85 |     
 86 | 
 87 |     /*
 88 |      * i2cdetect -y 2
 89 |      * output example is:
 90 |              0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
 91 |         00:          -- -- -- -- -- -- -- -- -- -- -- -- --
 92 |         10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 93 |         20: -- -- -- -- -- -- -- -- -- 29 -- -- -- -- -- --
 94 |         30: -- -- -- -- -- -- -- -- UU -- -- -- -- -- -- --
 95 |         40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 96 |         50: -- -- UU -- -- -- -- -- -- -- -- -- -- -- -- --
 97 |         60: -- -- -- -- -- -- -- -- -- 69 -- -- -- -- -- --
 98 |         70: -- -- -- -- -- -- -- --
 99 |      * "--". The address was probed but no chip answered.
100 |      * "UU". Probing was skipped, because this address is currently in use by a driver. 
101 |      *      This strongly suggests that there is a chip at this address.
102 |      * An address number in hexadecimal, e.g. "2d" or "4e". 
103 |      *      A chip was found at this address.
104 |      */
105 |     public static boolean StdoutMatch_I2CDevDetect(String s, List<String> devlist, String busnum){
106 |         String pattern_stdout_i2cdev = 
107 |                 "(.*)([\\s\\S]*)(.*)00:(.*)--([\\s\\S]*)";
108 | 
109 |         // i2cdetect to identify device attach to bus
110 |         if (true == matchPattern(s, pattern_stdout_i2cdev)){
111 |             //
112 |             List<String> i2c_dev_list = new ArrayList<String>();
113 |             //
114 |             char[] tempchar = new char[2];
115 | 
116 |             //split by "\r\n", then parse every line. 
117 |             //Because line length is difference, is difficult to parse.
118 |             String s_split[] = s.split("\r\n");
119 |             //for (int i=0; i<s_split.length; i++){
120 |             //  System.out.println(s_split[i]);
121 |             //} 
122 |             //
123 |             int char_index = 0, dev_index = 0;
124 |             for (int y=1; y<9; y++){
125 |                 for (int x=0; x<0x10 && dev_index<0x78; x++ ){
126 |                     char_index = 4 + x*3;
127 |                     dev_index = x + (y-1)*16;
128 |                     s_split[y].getChars(char_index, char_index+2, tempchar, 0);
129 |                     i2c_dev_list.add(String.valueOf(tempchar));
130 |                 }
131 |             }
132 |             //
133 |             for (int i=3; i<i2c_dev_list.size() && i<0x78; i++){
134 |                 if (i2c_dev_list.get(i).compareTo("--") != 0){
135 |                     //把"总线号" " 0x" "地址"组合成字符串, 注意总线号和0x之间有空格. 
136 |                     //TODO 增加"设备名称"
137 |                     devlist.add(busnum + " 0x" + Integer.toHexString(i));
138 |                 }
139 |             }
140 |             return true;
141 |         }   
142 |         
143 |         return false;
144 |     }
145 | 
146 |     
147 |     /*
148 |      * i2cdump -y -f 1 0x10 i or W
149 |      * output example is:
150 |              0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f    0123456789abcdef
151 |         00: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
152 |         10: 00 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00    ...?......?..?..
153 |         20: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
154 |         30: 20 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00     ..?......?..?..
155 |         40: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
156 |         50: 40 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00    @..?......?..?..
157 |         60: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
158 |         70: 60 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00    `..?......?..?..
159 |         80: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
160 |         90: 80 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00    ?..?......?..?..
161 |         a0: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
162 |         b0: a0 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00    ?..?......?..?..
163 |         c0: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
164 |         d0: c0 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00    ?..?......?..?..
165 |         e0: 40 00 00 1b 00 ff 00 00 00 00 00 00 12 42 12 93    @..?........?B??
166 |         f0: e0 00 00 1b 00 00 00 00 00 00 01 00 00 03 00 00    ?..?......?..?..
167 | 
168 |         TODO -r first-last
169 |         i2cdump -f -y -r 0-17 0 0x34
170 |              0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f    0123456789abcdef
171 |         00: fa 30 00 41 c8 e4 00 00 2c 00 00 00 00 00 00 0e    ?0.A??..,......?
172 |         10: 01 00                       
173 |      */
174 |     public static ArrayList<String> parseI2cDumpMode_W(ArrayList<String>list){
175 |         if (list == null || list.size() == 0) {
176 |             return null;
177 |         }        
178 |         if (!matchPattern(list.get(0), I2C_DUMP_MODE_W_PATTERN)){
179 |             return null;
180 |         }
181 |         
182 |         ArrayList<String> result = new ArrayList<String>();        
183 |         //parse every line. 
184 |         //Because line length is difference, is difficult to parse.            
185 |         char[] tempchar = new char[2];  //从特定位置连续取2个字符
186 |         int char_index;                 //字符在文本行中的下标；
187 |         int x;                          //i2cdump stdout列序号, 0~15总计16列；
188 |         int y;                          //i2cdump stdout行序号, 0~16 总计17行，数据是1~16行
189 |         int dumpindex;                  //字节在数组中的下标
190 |         
191 |         int y_first = Integer.valueOf(String.valueOf(list.get(1).charAt(0)), 16);
192 |         String tempstr = new String("");
193 |         
194 |         dumpindex = y_first*16;
195 |         //遍历行
196 |         for (y=1; y<list.size() && y <= I2C_DUMP_MODE_W_LINES; y++){
197 |             //遍历列
198 |             for (x=0; x<16 && dumpindex<256; x++, dumpindex++){
199 |                 char_index = 4 + x*3;
200 |                 list.get(y).getChars(char_index, char_index+2, tempchar, 0); //如果+1的话，显示乱码
201 |                 tempstr = String.valueOf(tempchar);
202 |                 if (tempstr.compareTo("  ") == 0){
203 |                     result.add(dumpindex, "00");
204 |                 } else {
205 |                     result.add(dumpindex, tempstr);
206 |                 }
207 |             }
208 |         }
209 |         return result;
210 |     }       
211 | }
212 | 


--------------------------------------------------------------------------------
/src/com/mitac/android/i2ctool/MainActivity.java:
--------------------------------------------------------------------------------
  1 | package com.mitac.android.i2ctool;
  2 | 
  3 | import java.io.File;
  4 | import java.util.ArrayList;
  5 | import java.util.concurrent.Executors;
  6 | import java.util.concurrent.ScheduledExecutorService;
  7 | import java.util.concurrent.ScheduledFuture;
  8 | import java.util.concurrent.TimeUnit;
  9 | 
 10 | import android.app.AlertDialog;
 11 | import android.content.DialogInterface;
 12 | import android.os.Bundle;
 13 | import android.os.Handler;
 14 | import android.support.v4.app.FragmentActivity;
 15 | import android.text.TextUtils;
 16 | import android.util.Log;
 17 | import android.view.View;
 18 | import android.view.View.OnClickListener;
 19 | import android.widget.Button;
 20 | import android.widget.CheckBox;
 21 | import android.widget.ListView;
 22 | import android.widget.ScrollView;
 23 | import android.widget.TextView;
 24 | 
 25 | import com.mitac.android.i2ctool.I2cInfoDialog.OnI2cInfoChangedListener;
 26 | import com.mitac.android.i2ctool.I2cSetDialog.OnSetClickListener;
 27 | import com.mitac.android.i2ctool.I2cToolHelper.OnStreamParsedListener;
 28 | 
 29 | public class MainActivity extends FragmentActivity {
 30 |     private static final String TAG = "i2c_MainActivity";
 31 |     
 32 |     private static final String LOG_RAW_FILE_NAME = "i2c_log_raw.txt";
 33 |     private static final String LOG_PARSED_FILE_NAME = "i2c_log_parsed.txt";
 34 |     
 35 |     private int mI2cBus = 0;
 36 |     private int mI2cAddress = 0x0;
 37 |     private String mI2cMode = null;
 38 |     private int mLoopInterval = 500; // 500ms
 39 |     private int mConsoleMaxLines = 512;
 40 |     
 41 |     private Handler mHandler = new Handler();
 42 |     private I2cToolHelper mI2cToolHelper;
 43 |     private File mLogRawFile;
 44 |     private File mLogParsedFile;
 45 |     
 46 |     private ScrollView mConsoleScroll;
 47 |     private TextView mConsoleTv;
 48 |     private Button mInfoBtn;
 49 |     private Button mCleanBtn;
 50 |     private Button mDetectBtn;
 51 |     private Button mDumpBtn;
 52 |     private Button mSetBtn;
 53 |     private Button mLoopIntervalBtn;
 54 |     private CheckBox mLoopCheckBox;
 55 |     private AlertDialog mLoopChoicesDialog;
 56 |     private I2cInfoDialog mInfoDialog;
 57 |     private I2cSetDialog mSetDialog;
 58 |     
 59 |     @Override
 60 |     protected void onCreate(Bundle savedInstanceState) {
 61 |         super.onCreate(savedInstanceState);
 62 |         setContentView(R.layout.activity_main);
 63 |         initView();
 64 |         
 65 |         mI2cToolHelper = new I2cToolHelper(mHandler);
 66 |         mI2cToolHelper.setOnStreamParsedListener(mOnStreamParsedListener);
 67 |         mLogRawFile = LogFileHelper.get().createFile(LOG_RAW_FILE_NAME);
 68 |         mLogParsedFile = LogFileHelper.get().createFile(LOG_PARSED_FILE_NAME);
 69 |         mConsoleMaxLines = getResources().getInteger(R.integer.console_max_lines);
 70 |         
 71 |         mI2cBus = I2cInfo.getBusIdFromPref(this);
 72 |         mI2cAddress = I2cInfo.getAddressFromPref(this);
 73 |         mI2cMode = I2cInfo.getI2cDumpMode(I2cInfo.getDumpModeFromFref(this));
 74 |         
 75 |         updateI2cInfoView();
 76 |     }
 77 |     
 78 |     @Override
 79 |     protected void onDestroy() {
 80 |         super.onDestroy();
 81 |         
 82 |         // clean dump schedule
 83 |         stopScheduleDump();
 84 |         mExecutorService.shutdown();
 85 |     }
 86 |     
 87 |     private void initView() {
 88 |         mConsoleScroll = (ScrollView) findViewById(R.id.i2cConsoleScroll);
 89 |         mConsoleTv = (TextView) findViewById(R.id.i2cConsoleTv);
 90 |         
 91 |         mCleanBtn = (Button) findViewById(R.id.i2cClearBtn);
 92 |         mCleanBtn.setOnClickListener(new OnClickListener() {
 93 |             @Override
 94 |             public void onClick(View v) {
 95 |                 mConsoleTv.setText("");
 96 |             }
 97 |         });
 98 |         
 99 |         mDetectBtn = (Button) findViewById(R.id.i2cDetectBtn);
100 |         mDetectBtn.setOnClickListener(new OnClickListener() {
101 |             @Override
102 |             public void onClick(View v) {
103 |                 detect();
104 |             }
105 |         });
106 |         
107 |         mDumpBtn = (Button) findViewById(R.id.i2cDumpBtn);
108 |         mDumpBtn.setOnClickListener(new OnClickListener() {
109 |             @Override
110 |             public void onClick(View v) {
111 |                 if (mLoopCheckBox.isChecked()) {
112 |                     scheduleDump();
113 |                 } else {
114 |                     dump();
115 |                 }
116 |             }
117 |         });
118 |         
119 |         // android AlertDialog integer-array NullPointerException, so use string-array instead
120 |         // android.widget.ArrayAdapter.createViewFromResource(ArrayAdapter.java:394)
121 |         AlertDialog.Builder builder = new AlertDialog.Builder(this);
122 |         builder.setSingleChoiceItems(R.array.loop_interval_choices, 0, new AlertDialog.OnClickListener() {
123 |             @Override
124 |             public void onClick(DialogInterface dialog, int which) {
125 |                 ListView lv = ((AlertDialog)dialog).getListView();
126 |                 String checkedItem = (String)lv.getAdapter().getItem(which);
127 |                 mLoopChoicesDialog.dismiss();
128 |                 mLoopInterval = (int)(Float.parseFloat(checkedItem) * 1000);
129 |                 mLoopIntervalBtn.setText(checkedItem + " s");
130 |             }
131 |         });
132 |         mLoopChoicesDialog = builder.create();
133 |         
134 |         mLoopIntervalBtn = (Button) findViewById(R.id.i2cLoopIntervalBtn);
135 |         mLoopIntervalBtn.setOnClickListener(new OnClickListener() {
136 |             @Override
137 |             public void onClick(View v) {
138 |                 mLoopChoicesDialog.show();
139 |             }
140 |         });
141 |         String[] dumpChoiceItems = getResources().getStringArray(R.array.loop_interval_choices);
142 |         mLoopIntervalBtn.setText(dumpChoiceItems[0] + " s");
143 |         
144 |         mLoopCheckBox = (CheckBox) findViewById(R.id.i2cLoopCheckbox);
145 |         mLoopCheckBox.setOnClickListener(new OnClickListener() {
146 |             @Override
147 |             public void onClick(View v) {
148 |                 CheckBox checkbox = (CheckBox) v;
149 |                 mLoopIntervalBtn.setEnabled(!checkbox.isChecked());
150 |                 if (!checkbox.isChecked()) {
151 |                     stopScheduleDump();
152 |                 }
153 |             }
154 |         });
155 |         
156 |         mInfoDialog = new I2cInfoDialog();
157 |         mInfoDialog.setOnI2cInfoChangedListener(new OnI2cInfoChangedListener() {
158 |             @Override
159 |             public void onI2cInfoChanged(int busId, int address, String mode) {
160 |                 Log.d(TAG, "Address " + address);
161 |                 mI2cBus = busId;
162 |                 mI2cAddress = address;
163 |                 mI2cMode = mode;
164 |                 updateI2cInfoView();
165 |             }
166 |         });
167 |         
168 |         mInfoBtn = (Button) findViewById(R.id.i2cInfoBtn);
169 |         mInfoBtn.setOnClickListener(new OnClickListener() {
170 |             @Override
171 |             public void onClick(View v) {
172 |                 mInfoDialog.show(getSupportFragmentManager(), TAG);
173 |             }
174 |         });
175 |         
176 |         mSetDialog = new I2cSetDialog();
177 |         mSetDialog.setOnSetClickListener(new OnSetClickListener() {
178 |             @Override
179 |             public void onSetClick(int dataAddress, int value, String mode) {
180 |                 set(dataAddress, value, mode);
181 |             }
182 |         });
183 |         
184 |         mSetBtn = (Button) findViewById(R.id.i2cSetBtn);
185 |         mSetBtn.setOnClickListener(new OnClickListener() {
186 |             @Override
187 |             public void onClick(View v) {
188 |                 mSetDialog.show(getSupportFragmentManager(), TAG);
189 |             }
190 |         });
191 |     }
192 |     
193 |     private void updateI2cInfoView() {
194 |         mInfoBtn.setText("" + mI2cBus + ", 0x" + Integer.toHexString(mI2cAddress) + ", " + mI2cMode);
195 |     }
196 |     
197 |     private void updateConsoleView(ArrayList<String> stream) {
198 |         // write log raw file
199 |         String newResult = "";
200 |         for (String str : stream) {
201 |             newResult += str + "\r\n";
202 |         }
203 |         LogFileHelper.get().writeFile(mLogRawFile, newResult);
204 |         
205 |         // write log parsed file
206 |         ArrayList<String> parsedStream = I2cParserHelper.parseI2cDumpMode_W(stream);
207 |         if (parsedStream != null) {
208 |             LogFileHelper.get().writeFile(mLogParsedFile,
209 |                     LogFileHelper.get().timestamp(LogFileHelper.TIME_FORMATTER_HMS)
210 |                     + " - "
211 |                     + TextUtils.join(" ", parsedStream));
212 |         }
213 |         
214 |         // update console view
215 |         if (mConsoleTv.getLineCount() + stream.size() > mConsoleMaxLines) {
216 |             mConsoleTv.setText("");
217 |         }
218 |         String result = mConsoleTv.getText().toString() + "\r\n" + newResult;
219 |         mConsoleTv.setText(result);
220 |         mConsoleScroll.postDelayed(new Runnable() { // delay to scrolling down completely
221 |             @Override
222 |             public void run() {
223 |                 mConsoleScroll.fullScroll(ScrollView.FOCUS_DOWN);
224 |             }
225 |         }, 100);
226 |     }
227 |     
228 |     private void detect() {
229 |         mI2cToolHelper.doDetect();
230 |     }
231 |     
232 |     private void set(int dataAddress, int value, String mode) {
233 |         mI2cToolHelper.doSet(mI2cBus, mI2cAddress, dataAddress, value, mode);
234 |     }
235 |     
236 |     private void dump() {
237 |         mI2cToolHelper.doDump(mI2cBus, mI2cAddress, mI2cMode);
238 |     }
239 |     
240 |     private ScheduledExecutorService mExecutorService = Executors.newSingleThreadScheduledExecutor();
241 |     private ScheduledFuture<?> mScheduledFuture; 
242 |     
243 |     private void scheduleDump() {
244 |         stopScheduleDump();
245 |         if (!mExecutorService.isShutdown()) {
246 |             mScheduledFuture = mExecutorService.scheduleAtFixedRate(new Runnable() {
247 |                 @Override
248 |                 public void run() {
249 |                     mHandler.post(mDumpTask);
250 |                 }
251 |             }, 0, mLoopInterval, TimeUnit.MILLISECONDS);
252 |         }
253 |     }
254 |     
255 |     private void stopScheduleDump() {
256 |         if (mScheduledFuture != null) {
257 |             mScheduledFuture.cancel(false);
258 |         }
259 |     }
260 |     
261 |     private final Runnable mDumpTask = new Runnable() {
262 |         @Override
263 |         public void run() {
264 |             dump();
265 |         }
266 |     };
267 |     
268 |     private OnStreamParsedListener mOnStreamParsedListener = new OnStreamParsedListener() {
269 |         @Override
270 |         public void onStreamParsed(int streamType, ArrayList<String> stream) {
271 |             // stream is not null
272 |             updateConsoleView(stream);
273 |         }
274 |     };
275 | }
276 | 


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