EMMA Coverage Report (generated Wed Jun 27 17:43:42 CEST 2012)
[all classes][aarddict.android]

COVERAGE SUMMARY FOR SOURCE FILE [N2EpdController.java]

nameclass, %method, %block, %line, %
N2EpdController.java0%   (0/1)0%   (0/6)0%   (0/704)0%   (0/100)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class N2EpdController0%   (0/1)0%   (0/6)0%   (0/704)0%   (0/100)
<static initializer> 0%   (0/1)0%   (0/5)0%   (0/2)
N2EpdController (): void 0%   (0/1)0%   (0/3)0%   (0/1)
enterA2Mode (): void 0%   (0/1)0%   (0/202)0%   (0/24)
exitA2Mode (): void 0%   (0/1)0%   (0/141)0%   (0/20)
setDUMode (): void 0%   (0/1)0%   (0/144)0%   (0/21)
setGL16Mode (int): void 0%   (0/1)0%   (0/209)0%   (0/32)

1package aarddict.android;
2 
3import java.lang.reflect.Constructor;
4import java.lang.reflect.Method;
5 
6/**
7 * Nook Touch EPD controller interface wrapper.
8 * This class is created by DairyKnight for Nook Touch screen support in FBReaderJ.
9 * @author DairyKnight <dairyknight@gmail.com>
10 * http://forum.xda-developers.com/showthread.php?t=1183173
11 */
12public class N2EpdController {
13 
14        public static int vCurrentNode = -2;
15        public static int GL16_MODE = 4;
16        // 0 - blink
17        // 1 - ACTIVE
18        // 2 - ONESHOT
19        // 3 - CLEAR good image (blink) - slow, good
20        // 4 - ACTIVE_All - good, slow                         
21        // 5 - ONESHOT_ALL
22        // 6 - CLEAR_All - good, blink 
23 
24/*        W/System.err( 6883): GC
25        W/System.err( 6883): GU
26        W/System.err( 6883): DU
27        W/System.err( 6883): A2
28        W/System.err( 6883): GL16
29        W/System.err( 6883): AUTO
30 
31        W/System.err( 6982): APP_1
32        W/System.err( 6982): APP_2
33        W/System.err( 6982): APP_3
34        W/System.err( 6982): APP_4*/
35        
36        public static void exitA2Mode() {
37                System.err.println("aarddict::exitA2Mode");
38                vCurrentNode = 0;
39                try {
40                        Class epdControllerClass = Class
41                                        .forName("android.hardware.EpdController");
42                        Class epdControllerRegionClass = Class
43                                        .forName("android.hardware.EpdController$Region");
44                        Class epdControllerRegionParamsClass = Class
45                                        .forName("android.hardware.EpdController$RegionParams");
46                        Class epdControllerWaveClass = Class
47                                        .forName("android.hardware.EpdController$Wave");
48 
49                        Object[] waveEnums = null;
50                        if (epdControllerWaveClass.isEnum()) {
51//                                System.err.println("EpdController Wave Enum successfully retrived.");
52                                waveEnums = epdControllerWaveClass.getEnumConstants();
53                        }
54 
55                        Object[] regionEnums = null;
56                        if (epdControllerRegionClass.isEnum()) {
57//                                System.err.println("EpdController Region Enum successfully retrived.");
58                                regionEnums = epdControllerRegionClass.getEnumConstants();
59                        }
60 
61                        Constructor RegionParamsConstructor = epdControllerRegionParamsClass.getConstructor(new Class[] { Integer.TYPE, Integer.TYPE,
62                                                        Integer.TYPE, Integer.TYPE, epdControllerWaveClass, Integer.TYPE });
63 
64                        Object localRegionParams = RegionParamsConstructor.newInstance(new Object[] { 0, 0, 600, 800, waveEnums[3], 16}); // Wave = A2
65 
66                        Method epdControllerSetRegionMethod = epdControllerClass.getMethod("setRegion", new Class[] { String.class,
67                                                        epdControllerRegionClass,
68                                                        epdControllerRegionParamsClass });
69                        epdControllerSetRegionMethod.invoke(null, new Object[] { "aarddicteadingView", regionEnums[2], localRegionParams });
70                                
71                } catch (Exception e) {
72                        e.printStackTrace();
73                }                
74        }
75        
76        public static void enterA2Mode() {
77                System.err.println("aarddict::enterA2Mode");
78                System.err.println(vCurrentNode);
79                try {
80                        Class epdControllerClass = Class
81                                        .forName("android.hardware.EpdController");
82                        Class epdControllerRegionClass = Class
83                                        .forName("android.hardware.EpdController$Region");
84                        Class epdControllerRegionParamsClass = Class
85                                        .forName("android.hardware.EpdController$RegionParams");
86                        Class epdControllerWaveClass = Class
87                                        .forName("android.hardware.EpdController$Wave");
88 
89                        Object[] waveEnums = null;
90                        if (epdControllerWaveClass.isEnum()) {
91//                                System.err.println("EpdController Wave Enum successfully retrived.");
92                                waveEnums = epdControllerWaveClass.getEnumConstants();
93                        }
94 
95                        Object[] regionEnums = null;
96                        if (epdControllerRegionClass.isEnum()) {
97//                                System.err.println("EpdController Region Enum successfully retrived.");
98                                regionEnums = epdControllerRegionClass.getEnumConstants();
99                        }
100 
101                        Constructor RegionParamsConstructor = epdControllerRegionParamsClass.getConstructor(new Class[] { Integer.TYPE, Integer.TYPE,
102                                                        Integer.TYPE, Integer.TYPE, epdControllerWaveClass, Integer.TYPE });
103 
104                        Object localRegionParams = RegionParamsConstructor.newInstance(new Object[] { 0, 0, 600, 800, waveEnums[2], 16}); // Wave = DU
105 
106                        Method epdControllerSetRegionMethod = epdControllerClass.getMethod("setRegion", new Class[] { String.class,
107                                                        epdControllerRegionClass,
108                                                        epdControllerRegionParamsClass });
109                        epdControllerSetRegionMethod.invoke(null, new Object[] { "aarddict-ReadingView", regionEnums[2], localRegionParams });
110                        
111                        
112 
113                        Thread.sleep(100L);
114                        localRegionParams = RegionParamsConstructor.newInstance(new Object[] { 0, 0, 600, 800, waveEnums[3], 14}); // Wave = A2
115                        epdControllerSetRegionMethod.invoke(null, new Object[] { "aarddict-ReadingView", regionEnums[2], localRegionParams});
116                        vCurrentNode = 3;
117                        
118                } catch (Exception e) {
119                        e.printStackTrace();
120                }
121                
122        }
123        
124        public static void setGL16Mode(int reset) {
125//                System.err.println("aarddict::setGL16Mode");
126                try {
127                        /*
128                         * Loading the Epson EPD Controller Classes
129                         * 
130                         * */
131                        Class epdControllerClass = Class
132                                        .forName("android.hardware.EpdController");
133                        Class epdControllerRegionClass = Class
134                                        .forName("android.hardware.EpdController$Region");
135                        Class epdControllerRegionParamsClass = Class
136                                        .forName("android.hardware.EpdController$RegionParams");
137                        Class epdControllerWaveClass = Class
138                                        .forName("android.hardware.EpdController$Wave");
139                        Class epdControllerModeClass = Class
140                                        .forName("android.hardware.EpdController$Mode");
141 
142                        /*
143                         * Creating EPD enums
144                         * 
145                         * */
146                        Object[] waveEnums = null;
147                        if (epdControllerWaveClass.isEnum()) {
148//                                System.err.println("EpdController Wave Enum successfully retrived.");
149                                waveEnums = epdControllerWaveClass.getEnumConstants();
150                        }
151 
152                        Object[] regionEnums = null;
153                        if (epdControllerRegionClass.isEnum()) {
154//                                System.err.println("EpdController Region Enum successfully retrived.");
155                                regionEnums = epdControllerRegionClass.getEnumConstants();
156                        }
157                        
158                        Object[] modeEnums = null;
159                        if (epdControllerModeClass.isEnum()) {
160//                                System.err.println("EpdController Region Enum successfully retrived.");
161                                modeEnums = epdControllerModeClass.getEnumConstants();
162                                System.err.println(modeEnums);
163                        }
164 
165                        Constructor RegionParamsConstructor = epdControllerRegionParamsClass
166                                        .getConstructor(new Class[] { Integer.TYPE, Integer.TYPE,
167                                                        Integer.TYPE, Integer.TYPE, epdControllerWaveClass});
168 
169                        Object localRegionParams = RegionParamsConstructor
170                                        .newInstance(new Object[] { 0, 0, 600, 800, waveEnums[1]}); // Wave = GU (1)
171 
172                        Method epdControllerSetRegionMethod = epdControllerClass.getMethod(
173                                        "setRegion", new Class[] { String.class,
174                                                        epdControllerRegionClass,
175                                                        epdControllerRegionParamsClass, epdControllerModeClass });
176 
177//                        System.err.println("get " + String.valueOf(reset) + " " + String.valueOf(vCurrentNode));
178                        
179                        if (reset > 0 || vCurrentNode < 0) {
180//                                System.err.println("EpdController resetting.");
181                                epdControllerSetRegionMethod
182                                        .invoke(null, new Object[] { "aarddict-ReadingView",
183                                                        regionEnums[2], localRegionParams, modeEnums[6] });
184                                if (reset > 0) {
185                                        vCurrentNode = 1 - reset;
186                                } else {
187                                        vCurrentNode++;
188                                }
189                        } else {
190                                if (vCurrentNode == 0 || GL16_MODE == 1 || GL16_MODE == 2) {
191//                                        System.err.println("EpdController setting.");
192                                        if (vCurrentNode == 0) {
193                                                epdControllerSetRegionMethod
194                                                        .invoke(null, new Object[] { "aarddict-ReadingView",
195                                                                        regionEnums[2], localRegionParams, modeEnums[GL16_MODE] });
196                                        } 
197                                        if (vCurrentNode == 0) 
198                                                vCurrentNode++;
199                                }
200                        }
201//                        System.err.println("set " + String.valueOf(vCurrentNode));
202                } catch (Exception e) {
203                        e.printStackTrace();
204                }                
205        }
206        
207        public static void setDUMode() {
208                System.err.println("aarddict::setDUMode");
209                System.err.println(vCurrentNode);
210                try {
211                        Class epdControllerClass = Class
212                                        .forName("android.hardware.EpdController");
213                        Class epdControllerRegionClass = Class
214                                        .forName("android.hardware.EpdController$Region");
215                        Class epdControllerRegionParamsClass = Class
216                                        .forName("android.hardware.EpdController$RegionParams");
217                        Class epdControllerWaveClass = Class
218                                        .forName("android.hardware.EpdController$Wave");
219 
220                        Object[] waveEnums = null;
221                        if (epdControllerWaveClass.isEnum()) {
222//                                System.err.println("EpdController Wave Enum successfully retrived.");
223                                waveEnums = epdControllerWaveClass.getEnumConstants();
224                        }
225 
226                        Object[] regionEnums = null;
227                        if (epdControllerRegionClass.isEnum()) {
228//                                System.err.println("EpdController Region Enum successfully retrived.");
229                                regionEnums = epdControllerRegionClass.getEnumConstants();
230                        }
231 
232                        Constructor RegionParamsConstructor = epdControllerRegionParamsClass
233                                        .getConstructor(new Class[] { Integer.TYPE, Integer.TYPE,
234                                                        Integer.TYPE, Integer.TYPE, epdControllerWaveClass,
235                                                        Integer.TYPE });
236 
237                        Object localRegionParams = RegionParamsConstructor
238                                        .newInstance(new Object[] { 0, 0, 600, 800, waveEnums[2],
239                                                        14 });
240 
241                        Method epdControllerSetRegionMethod = epdControllerClass.getMethod(
242                                        "setRegion", new Class[] { String.class,
243                                                        epdControllerRegionClass,
244                                                        epdControllerRegionParamsClass });
245                        epdControllerSetRegionMethod
246                                        .invoke(null, new Object[] { "aarddict-ReadingView",
247                                                        regionEnums[2], localRegionParams });
248                        vCurrentNode = 2;
249                } catch (Exception e) {
250                        e.printStackTrace();
251                }
252        }
253}

[all classes][aarddict.android]
EMMA 0.0.0 (unsupported private build) (C) Vladimir Roubtsov