blob: dfdbda60c74b10c7f89ad5dd972cce4e23204fc9 [file] [log] [blame]
The Android Open Source Project88b60792009-03-03 19:28:42 -08001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17import com.sun.javadoc.*;
18
19import org.clearsilver.HDF;
20
21import java.util.*;
22import java.io.*;
23import java.lang.reflect.Proxy;
24import java.lang.reflect.Array;
25import java.lang.reflect.InvocationHandler;
26import java.lang.reflect.InvocationTargetException;
27import java.lang.reflect.Method;
28
29public class DroidDoc
30{
31 private static final String SDK_CONSTANT_ANNOTATION = "android.annotation.SdkConstant";
32 private static final String SDK_CONSTANT_TYPE_ACTIVITY_ACTION = "android.annotation.SdkConstant.SdkConstantType.ACTIVITY_INTENT_ACTION";
33 private static final String SDK_CONSTANT_TYPE_BROADCAST_ACTION = "android.annotation.SdkConstant.SdkConstantType.BROADCAST_INTENT_ACTION";
34 private static final String SDK_CONSTANT_TYPE_SERVICE_ACTION = "android.annotation.SdkConstant.SdkConstantType.SERVICE_INTENT_ACTION";
35 private static final String SDK_CONSTANT_TYPE_CATEGORY = "android.annotation.SdkConstant.SdkConstantType.INTENT_CATEGORY";
Xavier Ducrohetf9b6d382009-12-14 17:55:05 -080036 private static final String SDK_CONSTANT_TYPE_FEATURE = "android.annotation.SdkConstant.SdkConstantType.FEATURE";
The Android Open Source Project88b60792009-03-03 19:28:42 -080037 private static final String SDK_WIDGET_ANNOTATION = "android.annotation.Widget";
38 private static final String SDK_LAYOUT_ANNOTATION = "android.annotation.Layout";
39
40 private static final int TYPE_NONE = 0;
41 private static final int TYPE_WIDGET = 1;
42 private static final int TYPE_LAYOUT = 2;
43 private static final int TYPE_LAYOUT_PARAM = 3;
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -070044
The Android Open Source Project88b60792009-03-03 19:28:42 -080045 public static final int SHOW_PUBLIC = 0x00000001;
46 public static final int SHOW_PROTECTED = 0x00000003;
47 public static final int SHOW_PACKAGE = 0x00000007;
48 public static final int SHOW_PRIVATE = 0x0000000f;
49 public static final int SHOW_HIDDEN = 0x0000001f;
50
51 public static int showLevel = SHOW_PROTECTED;
52
53 public static final String javadocDir = "reference/";
54 public static String htmlExtension;
55
56 public static RootDoc root;
57 public static ArrayList<String[]> mHDFData = new ArrayList<String[]>();
58 public static Map<Character,String> escapeChars = new HashMap<Character,String>();
59 public static String title = "";
Scott Main25fda192009-08-04 11:26:30 -070060 public static SinceTagger sinceTagger = new SinceTagger();
Joe Onorato63170ff2010-09-16 11:57:42 -040061 public static HashSet<String> knownTags = new HashSet<String>();
The Android Open Source Project88b60792009-03-03 19:28:42 -080062
Joe Onorato0ee89a72010-08-31 11:27:25 -070063 private static boolean parseComments = false;
64 private static boolean generateDocs = true;
65
66 /**
67 * Returns true if we should parse javadoc comments,
68 * reporting errors in the process.
69 */
70 public static boolean parseComments() {
71 return generateDocs || parseComments;
72 }
73
The Android Open Source Project88b60792009-03-03 19:28:42 -080074 public static boolean checkLevel(int level)
75 {
76 return (showLevel & level) == level;
77 }
78
79 public static boolean checkLevel(boolean pub, boolean prot, boolean pkgp,
80 boolean priv, boolean hidden)
81 {
82 int level = 0;
83 if (hidden && !checkLevel(SHOW_HIDDEN)) {
84 return false;
85 }
86 if (pub && checkLevel(SHOW_PUBLIC)) {
87 return true;
88 }
89 if (prot && checkLevel(SHOW_PROTECTED)) {
90 return true;
91 }
92 if (pkgp && checkLevel(SHOW_PACKAGE)) {
93 return true;
94 }
95 if (priv && checkLevel(SHOW_PRIVATE)) {
96 return true;
97 }
98 return false;
99 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -0700100
The Android Open Source Project88b60792009-03-03 19:28:42 -0800101 public static boolean start(RootDoc r)
102 {
103 String keepListFile = null;
104 String proofreadFile = null;
105 String todoFile = null;
106 String sdkValuePath = null;
107 ArrayList<SampleCode> sampleCodes = new ArrayList<SampleCode>();
108 String stubsDir = null;
109 //Create the dependency graph for the stubs directory
110 boolean apiXML = false;
Scott Main2fa99f12009-11-20 10:41:49 -0800111 boolean offlineMode = false;
The Android Open Source Project88b60792009-03-03 19:28:42 -0800112 String apiFile = null;
113 String debugStubsFile = "";
114 HashSet<String> stubPackages = null;
Joe Onorato63170ff2010-09-16 11:57:42 -0400115 ArrayList<String> knownTagsFiles = new ArrayList<String>();
The Android Open Source Project88b60792009-03-03 19:28:42 -0800116
117 root = r;
118
119 String[][] options = r.options();
120 for (String[] a: options) {
121 if (a[0].equals("-d")) {
122 ClearPage.outputDir = a[1];
123 }
124 else if (a[0].equals("-templatedir")) {
125 ClearPage.addTemplateDir(a[1]);
126 }
127 else if (a[0].equals("-hdf")) {
128 mHDFData.add(new String[] {a[1], a[2]});
129 }
Joe Onorato63170ff2010-09-16 11:57:42 -0400130 else if (a[0].equals("-knowntags")) {
131 knownTagsFiles.add(a[1]);
132 }
The Android Open Source Project88b60792009-03-03 19:28:42 -0800133 else if (a[0].equals("-toroot")) {
134 ClearPage.toroot = a[1];
135 }
136 else if (a[0].equals("-samplecode")) {
137 sampleCodes.add(new SampleCode(a[1], a[2], a[3]));
138 }
139 else if (a[0].equals("-htmldir")) {
Bill Napier0e143c02010-08-24 22:16:01 -0700140 ClearPage.htmlDirs.add(a[1]);
The Android Open Source Project88b60792009-03-03 19:28:42 -0800141 }
142 else if (a[0].equals("-title")) {
143 DroidDoc.title = a[1];
144 }
145 else if (a[0].equals("-werror")) {
146 Errors.setWarningsAreErrors(true);
147 }
148 else if (a[0].equals("-error") || a[0].equals("-warning")
149 || a[0].equals("-hide")) {
150 try {
151 int level = -1;
152 if (a[0].equals("-error")) {
153 level = Errors.ERROR;
154 }
155 else if (a[0].equals("-warning")) {
156 level = Errors.WARNING;
157 }
158 else if (a[0].equals("-hide")) {
159 level = Errors.HIDDEN;
160 }
161 Errors.setErrorLevel(Integer.parseInt(a[1]), level);
162 }
163 catch (NumberFormatException e) {
164 // already printed below
165 return false;
166 }
167 }
168 else if (a[0].equals("-keeplist")) {
169 keepListFile = a[1];
170 }
171 else if (a[0].equals("-proofread")) {
172 proofreadFile = a[1];
173 }
174 else if (a[0].equals("-todo")) {
175 todoFile = a[1];
176 }
177 else if (a[0].equals("-public")) {
178 showLevel = SHOW_PUBLIC;
179 }
180 else if (a[0].equals("-protected")) {
181 showLevel = SHOW_PROTECTED;
182 }
183 else if (a[0].equals("-package")) {
184 showLevel = SHOW_PACKAGE;
185 }
186 else if (a[0].equals("-private")) {
187 showLevel = SHOW_PRIVATE;
188 }
189 else if (a[0].equals("-hidden")) {
190 showLevel = SHOW_HIDDEN;
191 }
192 else if (a[0].equals("-stubs")) {
193 stubsDir = a[1];
194 }
195 else if (a[0].equals("-stubpackages")) {
196 stubPackages = new HashSet();
197 for (String pkg: a[1].split(":")) {
198 stubPackages.add(pkg);
199 }
200 }
201 else if (a[0].equals("-sdkvalues")) {
202 sdkValuePath = a[1];
203 }
204 else if (a[0].equals("-apixml")) {
205 apiXML = true;
206 apiFile = a[1];
207 }
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400208 else if (a[0].equals("-nodocs")) {
Joe Onorato0ee89a72010-08-31 11:27:25 -0700209 generateDocs = false;
210 }
211 else if (a[0].equals("-parsecomments")) {
212 parseComments = true;
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400213 }
Jesse Wilson5e0dd412009-06-01 17:59:44 -0700214 else if (a[0].equals("-since")) {
215 sinceTagger.addVersion(a[1], a[2]);
216 }
Scott Main2fa99f12009-11-20 10:41:49 -0800217 else if (a[0].equals("-offlinemode")) {
218 offlineMode = true;
219 }
The Android Open Source Project88b60792009-03-03 19:28:42 -0800220 }
221
Joe Onorato63170ff2010-09-16 11:57:42 -0400222 if (!readKnownTagsFiles(knownTags, knownTagsFiles)) {
223 return false;
224 }
225
The Android Open Source Project88b60792009-03-03 19:28:42 -0800226 // read some prefs from the template
227 if (!readTemplateSettings()) {
228 return false;
229 }
230
231 // Set up the data structures
232 Converter.makeInfo(r);
233
Joe Onorato0ee89a72010-08-31 11:27:25 -0700234 if (generateDocs) {
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400235 long startTime = System.nanoTime();
236
Jesse Wilson5e0dd412009-06-01 17:59:44 -0700237 // Apply @since tags from the XML file
238 sinceTagger.tagAll(Converter.rootClasses());
239
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400240 // Files for proofreading
241 if (proofreadFile != null) {
242 Proofread.initProofread(proofreadFile);
243 }
244 if (todoFile != null) {
245 TodoFile.writeTodoFile(todoFile);
246 }
247
248 // HTML Pages
Bill Napier0e143c02010-08-24 22:16:01 -0700249 if (!ClearPage.htmlDirs.isEmpty()) {
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400250 writeHTMLPages();
251 }
252
253 // Navigation tree
254 NavTree.writeNavTree(javadocDir);
255
256 // Packages Pages
257 writePackages(javadocDir
Bill Napier0e143c02010-08-24 22:16:01 -0700258 + (!ClearPage.htmlDirs.isEmpty()
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400259 ? "packages" + htmlExtension
260 : "index" + htmlExtension));
261
262 // Classes
263 writeClassLists();
264 writeClasses();
265 writeHierarchy();
266 // writeKeywords();
267
268 // Lists for JavaScript
269 writeLists();
270 if (keepListFile != null) {
271 writeKeepList(keepListFile);
272 }
273
274 // Sample Code
275 for (SampleCode sc: sampleCodes) {
Scott Main2fa99f12009-11-20 10:41:49 -0800276 sc.write(offlineMode);
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400277 }
278
279 // Index page
280 writeIndex();
281
282 Proofread.finishProofread(proofreadFile);
283
284 if (sdkValuePath != null) {
285 writeSdkValues(sdkValuePath);
286 }
287
288 long time = System.nanoTime() - startTime;
289 System.out.println("DroidDoc took " + (time / 1000000000) + " sec. to write docs to "
290 + ClearPage.outputDir);
The Android Open Source Project88b60792009-03-03 19:28:42 -0800291 }
The Android Open Source Project88b60792009-03-03 19:28:42 -0800292
293 // Stubs
294 if (stubsDir != null) {
295 Stubs.writeStubs(stubsDir, apiXML, apiFile, stubPackages);
296 }
Jesse Wilson5e0dd412009-06-01 17:59:44 -0700297
The Android Open Source Project88b60792009-03-03 19:28:42 -0800298 Errors.printErrors();
299 return !Errors.hadError;
300 }
301
302 private static void writeIndex() {
303 HDF data = makeHDF();
304 ClearPage.write(data, "index.cs", javadocDir + "index" + htmlExtension);
305 }
306
307 private static boolean readTemplateSettings()
308 {
309 HDF data = makeHDF();
310 htmlExtension = data.getValue("template.extension", ".html");
311 int i=0;
312 while (true) {
313 String k = data.getValue("template.escape." + i + ".key", "");
314 String v = data.getValue("template.escape." + i + ".value", "");
315 if ("".equals(k)) {
316 break;
317 }
318 if (k.length() != 1) {
319 System.err.println("template.escape." + i + ".key must have a length of 1: " + k);
320 return false;
321 }
322 escapeChars.put(k.charAt(0), v);
323 i++;
324 }
325 return true;
326 }
327
Joe Onorato63170ff2010-09-16 11:57:42 -0400328 private static boolean readKnownTagsFiles(HashSet<String> knownTags,
329 ArrayList<String> knownTagsFiles) {
330 for (String fn: knownTagsFiles) {
331 BufferedReader in = null;
332 try {
333 in = new BufferedReader(new FileReader(fn));
334 int lineno = 0;
335 boolean fail = false;
336 while (true) {
337 lineno++;
338 String line = in.readLine();
339 if (line == null) {
340 break;
341 }
342 line = line.trim();
343 if (line.length() == 0) {
344 continue;
345 } else if (line.charAt(0) == '#') {
346 continue;
347 }
348 String[] words = line.split("\\s+", 2);
349 if (words.length == 2) {
350 if (words[1].charAt(0) != '#') {
351 System.err.println(fn + ":" + lineno
352 + ": Only one tag allowed per line: " + line);
353 fail = true;
354 continue;
355 }
356 }
357 knownTags.add(words[0]);
Joe Onorato63170ff2010-09-16 11:57:42 -0400358 }
359 if (fail) {
360 return false;
361 }
362 } catch (IOException ex) {
363 System.err.println("Error reading file: " + fn + " (" + ex.getMessage() + ")");
364 return false;
365 } finally {
366 if (in != null) {
367 try {
368 in.close();
369 } catch (IOException e) {
370 }
371 }
372 }
373 }
374 return true;
375 }
376
The Android Open Source Project88b60792009-03-03 19:28:42 -0800377 public static String escape(String s) {
378 if (escapeChars.size() == 0) {
379 return s;
380 }
381 StringBuffer b = null;
382 int begin = 0;
383 final int N = s.length();
384 for (int i=0; i<N; i++) {
385 char c = s.charAt(i);
386 String mapped = escapeChars.get(c);
387 if (mapped != null) {
388 if (b == null) {
389 b = new StringBuffer(s.length() + mapped.length());
390 }
391 if (begin != i) {
392 b.append(s.substring(begin, i));
393 }
394 b.append(mapped);
395 begin = i+1;
396 }
397 }
398 if (b != null) {
399 if (begin != N) {
400 b.append(s.substring(begin, N));
401 }
402 return b.toString();
403 }
404 return s;
405 }
406
407 public static void setPageTitle(HDF data, String title)
408 {
409 String s = title;
410 if (DroidDoc.title.length() > 0) {
411 s += " - " + DroidDoc.title;
412 }
413 data.setValue("page.title", s);
414 }
415
416 public static LanguageVersion languageVersion()
417 {
418 return LanguageVersion.JAVA_1_5;
419 }
420
421 public static int optionLength(String option)
422 {
423 if (option.equals("-d")) {
424 return 2;
425 }
426 if (option.equals("-templatedir")) {
427 return 2;
428 }
429 if (option.equals("-hdf")) {
430 return 3;
431 }
Joe Onorato63170ff2010-09-16 11:57:42 -0400432 if (option.equals("-knowntags")) {
433 return 2;
434 }
The Android Open Source Project88b60792009-03-03 19:28:42 -0800435 if (option.equals("-toroot")) {
436 return 2;
437 }
438 if (option.equals("-samplecode")) {
439 return 4;
440 }
441 if (option.equals("-htmldir")) {
442 return 2;
443 }
444 if (option.equals("-title")) {
445 return 2;
446 }
447 if (option.equals("-werror")) {
448 return 1;
449 }
450 if (option.equals("-hide")) {
451 return 2;
452 }
453 if (option.equals("-warning")) {
454 return 2;
455 }
456 if (option.equals("-error")) {
457 return 2;
458 }
459 if (option.equals("-keeplist")) {
460 return 2;
461 }
462 if (option.equals("-proofread")) {
463 return 2;
464 }
465 if (option.equals("-todo")) {
466 return 2;
467 }
468 if (option.equals("-public")) {
469 return 1;
470 }
471 if (option.equals("-protected")) {
472 return 1;
473 }
474 if (option.equals("-package")) {
475 return 1;
476 }
477 if (option.equals("-private")) {
478 return 1;
479 }
480 if (option.equals("-hidden")) {
481 return 1;
482 }
483 if (option.equals("-stubs")) {
484 return 2;
485 }
486 if (option.equals("-stubpackages")) {
487 return 2;
488 }
489 if (option.equals("-sdkvalues")) {
490 return 2;
491 }
492 if (option.equals("-apixml")) {
493 return 2;
494 }
Joe Onoratob7c41aa2009-07-20 11:57:59 -0400495 if (option.equals("-nodocs")) {
496 return 1;
497 }
Joe Onoratocd7c7752010-08-31 12:56:49 -0700498 if (option.equals("-parsecomments")) {
499 return 1;
500 }
Jesse Wilson5e0dd412009-06-01 17:59:44 -0700501 if (option.equals("-since")) {
502 return 3;
503 }
Scott Main2fa99f12009-11-20 10:41:49 -0800504 if (option.equals("-offlinemode")) {
505 return 1;
506 }
The Android Open Source Project88b60792009-03-03 19:28:42 -0800507 return 0;
508 }
Jesse Wilson5e0dd412009-06-01 17:59:44 -0700509
The Android Open Source Project88b60792009-03-03 19:28:42 -0800510 public static boolean validOptions(String[][] options, DocErrorReporter r)
511 {
512 for (String[] a: options) {
513 if (a[0].equals("-error") || a[0].equals("-warning")
514 || a[0].equals("-hide")) {
515 try {
516 Integer.parseInt(a[1]);
517 }
518 catch (NumberFormatException e) {
519 r.printError("bad -" + a[0] + " value must be a number: "
520 + a[1]);
521 return false;
522 }
523 }
524 }
525
526 return true;
527 }
528
529 public static HDF makeHDF()
530 {
531 HDF data = new HDF();
532
533 for (String[] p: mHDFData) {
534 data.setValue(p[0], p[1]);
535 }
536
537 try {
538 for (String p: ClearPage.hdfFiles) {
539 data.readFile(p);
540 }
541 }
542 catch (IOException e) {
543 throw new RuntimeException(e);
544 }
545
546 return data;
547 }
548
549 public static HDF makePackageHDF()
550 {
551 HDF data = makeHDF();
552 ClassInfo[] classes = Converter.rootClasses();
553
554 SortedMap<String, PackageInfo> sorted = new TreeMap<String, PackageInfo>();
555 for (ClassInfo cl: classes) {
556 PackageInfo pkg = cl.containingPackage();
557 String name;
558 if (pkg == null) {
559 name = "";
560 } else {
561 name = pkg.name();
562 }
563 sorted.put(name, pkg);
564 }
565
566 int i = 0;
567 for (String s: sorted.keySet()) {
568 PackageInfo pkg = sorted.get(s);
569
570 if (pkg.isHidden()) {
571 continue;
572 }
573 Boolean allHidden = true;
574 int pass = 0;
575 ClassInfo[] classesToCheck = null;
576 while (pass < 5 ) {
577 switch(pass) {
578 case 0:
579 classesToCheck = pkg.ordinaryClasses();
580 break;
581 case 1:
582 classesToCheck = pkg.enums();
583 break;
584 case 2:
585 classesToCheck = pkg.errors();
586 break;
587 case 3:
588 classesToCheck = pkg.exceptions();
589 break;
590 case 4:
591 classesToCheck = pkg.interfaces();
592 break;
593 default:
594 System.err.println("Error reading package: " + pkg.name());
595 break;
596 }
597 for (ClassInfo cl : classesToCheck) {
598 if (!cl.isHidden()) {
599 allHidden = false;
600 break;
601 }
602 }
603 if (!allHidden) {
604 break;
605 }
606 pass++;
607 }
608 if (allHidden) {
609 continue;
610 }
611
612 data.setValue("reference", "true");
613 data.setValue("docs.packages." + i + ".name", s);
614 data.setValue("docs.packages." + i + ".link", pkg.htmlPage());
Scott Maindf094242009-07-27 09:47:11 -0700615 data.setValue("docs.packages." + i + ".since", pkg.getSince());
The Android Open Source Project88b60792009-03-03 19:28:42 -0800616 TagInfo.makeHDF(data, "docs.packages." + i + ".shortDescr",
617 pkg.firstSentenceTags());
618 i++;
619 }
620
Scott Main25fda192009-08-04 11:26:30 -0700621 sinceTagger.writeVersionNames(data);
The Android Open Source Project88b60792009-03-03 19:28:42 -0800622 return data;
623 }
624
625 public static void writeDirectory(File dir, String relative)
626 {
627 File[] files = dir.listFiles();
628 int i, count = files.length;
629 for (i=0; i<count; i++) {
630 File f = files[i];
631 if (f.isFile()) {
632 String templ = relative + f.getName();
633 int len = templ.length();
634 if (len > 3 && ".cs".equals(templ.substring(len-3))) {
635 HDF data = makeHDF();
636 String filename = templ.substring(0,len-3) + htmlExtension;
637 ClearPage.write(data, templ, filename);
638 }
639 else if (len > 3 && ".jd".equals(templ.substring(len-3))) {
640 String filename = templ.substring(0,len-3) + htmlExtension;
641 DocFile.writePage(f.getAbsolutePath(), relative, filename);
642 }
643 else {
644 ClearPage.copyFile(f, templ);
645 }
646 }
647 else if (f.isDirectory()) {
648 writeDirectory(f, relative + f.getName() + "/");
649 }
650 }
651 }
652
653 public static void writeHTMLPages()
654 {
Bill Napier0e143c02010-08-24 22:16:01 -0700655 for (String htmlDir : ClearPage.htmlDirs) {
656 File f = new File(htmlDir);
657 if (!f.isDirectory()) {
658 System.err.println("htmlDir not a directory: " + htmlDir);
Bill Napier10cd7f92010-08-25 09:59:14 -0700659 continue;
Bill Napier0e143c02010-08-24 22:16:01 -0700660 }
661 writeDirectory(f, "");
The Android Open Source Project88b60792009-03-03 19:28:42 -0800662 }
The Android Open Source Project88b60792009-03-03 19:28:42 -0800663 }
664
665 public static void writeLists()
666 {
667 HDF data = makeHDF();
668
669 ClassInfo[] classes = Converter.rootClasses();
670
671 SortedMap<String, Object> sorted = new TreeMap<String, Object>();
672 for (ClassInfo cl: classes) {
673 if (cl.isHidden()) {
674 continue;
675 }
676 sorted.put(cl.qualifiedName(), cl);
677 PackageInfo pkg = cl.containingPackage();
678 String name;
679 if (pkg == null) {
680 name = "";
681 } else {
682 name = pkg.name();
683 }
684 sorted.put(name, pkg);
685 }
686
687 int i = 0;
688 for (String s: sorted.keySet()) {
689 data.setValue("docs.pages." + i + ".id" , ""+i);
690 data.setValue("docs.pages." + i + ".label" , s);
691
692 Object o = sorted.get(s);
693 if (o instanceof PackageInfo) {
694 PackageInfo pkg = (PackageInfo)o;
695 data.setValue("docs.pages." + i + ".link" , pkg.htmlPage());
696 data.setValue("docs.pages." + i + ".type" , "package");
697 }
698 else if (o instanceof ClassInfo) {
699 ClassInfo cl = (ClassInfo)o;
700 data.setValue("docs.pages." + i + ".link" , cl.htmlPage());
701 data.setValue("docs.pages." + i + ".type" , "class");
702 }
703 i++;
704 }
705
706 ClearPage.write(data, "lists.cs", javadocDir + "lists.js");
707 }
708
709 public static void cantStripThis(ClassInfo cl, HashSet<ClassInfo> notStrippable) {
710 if (!notStrippable.add(cl)) {
711 // slight optimization: if it already contains cl, it already contains
712 // all of cl's parents
713 return;
714 }
715 ClassInfo supr = cl.superclass();
716 if (supr != null) {
717 cantStripThis(supr, notStrippable);
718 }
719 for (ClassInfo iface: cl.interfaces()) {
720 cantStripThis(iface, notStrippable);
721 }
722 }
723
724 private static String getPrintableName(ClassInfo cl) {
725 ClassInfo containingClass = cl.containingClass();
726 if (containingClass != null) {
727 // This is an inner class.
728 String baseName = cl.name();
729 baseName = baseName.substring(baseName.lastIndexOf('.') + 1);
730 return getPrintableName(containingClass) + '$' + baseName;
731 }
732 return cl.qualifiedName();
733 }
734
735 /**
736 * Writes the list of classes that must be present in order to
737 * provide the non-hidden APIs known to javadoc.
738 *
739 * @param filename the path to the file to write the list to
740 */
741 public static void writeKeepList(String filename) {
742 HashSet<ClassInfo> notStrippable = new HashSet<ClassInfo>();
743 ClassInfo[] all = Converter.allClasses();
744 Arrays.sort(all); // just to make the file a little more readable
745
746 // If a class is public and not hidden, then it and everything it derives
747 // from cannot be stripped. Otherwise we can strip it.
748 for (ClassInfo cl: all) {
749 if (cl.isPublic() && !cl.isHidden()) {
750 cantStripThis(cl, notStrippable);
751 }
752 }
753 PrintStream stream = null;
754 try {
755 stream = new PrintStream(filename);
756 for (ClassInfo cl: notStrippable) {
757 stream.println(getPrintableName(cl));
758 }
759 }
760 catch (FileNotFoundException e) {
761 System.err.println("error writing file: " + filename);
762 }
763 finally {
764 if (stream != null) {
765 stream.close();
766 }
767 }
768 }
769
770 private static PackageInfo[] sVisiblePackages = null;
771 public static PackageInfo[] choosePackages() {
772 if (sVisiblePackages != null) {
773 return sVisiblePackages;
774 }
775
776 ClassInfo[] classes = Converter.rootClasses();
777 SortedMap<String, PackageInfo> sorted = new TreeMap<String, PackageInfo>();
778 for (ClassInfo cl: classes) {
779 PackageInfo pkg = cl.containingPackage();
780 String name;
781 if (pkg == null) {
782 name = "";
783 } else {
784 name = pkg.name();
785 }
786 sorted.put(name, pkg);
787 }
788
789 ArrayList<PackageInfo> result = new ArrayList();
790
791 for (String s: sorted.keySet()) {
792 PackageInfo pkg = sorted.get(s);
793
794 if (pkg.isHidden()) {
795 continue;
796 }
797 Boolean allHidden = true;
798 int pass = 0;
799 ClassInfo[] classesToCheck = null;
800 while (pass < 5 ) {
801 switch(pass) {
802 case 0:
803 classesToCheck = pkg.ordinaryClasses();
804 break;
805 case 1:
806 classesToCheck = pkg.enums();
807 break;
808 case 2:
809 classesToCheck = pkg.errors();
810 break;
811 case 3:
812 classesToCheck = pkg.exceptions();
813 break;
814 case 4:
815 classesToCheck = pkg.interfaces();
816 break;
817 default:
818 System.err.println("Error reading package: " + pkg.name());
819 break;
820 }
821 for (ClassInfo cl : classesToCheck) {
822 if (!cl.isHidden()) {
823 allHidden = false;
824 break;
825 }
826 }
827 if (!allHidden) {
828 break;
829 }
830 pass++;
831 }
832 if (allHidden) {
833 continue;
834 }
835
836 result.add(pkg);
837 }
838
839 sVisiblePackages = result.toArray(new PackageInfo[result.size()]);
840 return sVisiblePackages;
841 }
842
843 public static void writePackages(String filename)
844 {
845 HDF data = makePackageHDF();
846
847 int i = 0;
848 for (PackageInfo pkg: choosePackages()) {
849 writePackage(pkg);
850
851 data.setValue("docs.packages." + i + ".name", pkg.name());
852 data.setValue("docs.packages." + i + ".link", pkg.htmlPage());
853 TagInfo.makeHDF(data, "docs.packages." + i + ".shortDescr",
854 pkg.firstSentenceTags());
855
856 i++;
857 }
858
859 setPageTitle(data, "Package Index");
860
861 TagInfo.makeHDF(data, "root.descr",
862 Converter.convertTags(root.inlineTags(), null));
863
864 ClearPage.write(data, "packages.cs", filename);
865 ClearPage.write(data, "package-list.cs", javadocDir + "package-list");
866
867 Proofread.writePackages(filename,
868 Converter.convertTags(root.inlineTags(), null));
869 }
870
871 public static void writePackage(PackageInfo pkg)
872 {
873 // these this and the description are in the same directory,
874 // so it's okay
875 HDF data = makePackageHDF();
876
877 String name = pkg.name();
878
879 data.setValue("package.name", name);
Jesse Wilson5e0dd412009-06-01 17:59:44 -0700880 data.setValue("package.since", pkg.getSince());
The Android Open Source Project88b60792009-03-03 19:28:42 -0800881 data.setValue("package.descr", "...description...");
882
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -0700883 makeClassListHDF(data, "package.interfaces",
The Android Open Source Project88b60792009-03-03 19:28:42 -0800884 ClassInfo.sortByName(pkg.interfaces()));
885 makeClassListHDF(data, "package.classes",
886 ClassInfo.sortByName(pkg.ordinaryClasses()));
887 makeClassListHDF(data, "package.enums",
888 ClassInfo.sortByName(pkg.enums()));
889 makeClassListHDF(data, "package.exceptions",
890 ClassInfo.sortByName(pkg.exceptions()));
891 makeClassListHDF(data, "package.errors",
892 ClassInfo.sortByName(pkg.errors()));
893 TagInfo.makeHDF(data, "package.shortDescr",
894 pkg.firstSentenceTags());
895 TagInfo.makeHDF(data, "package.descr", pkg.inlineTags());
896
897 String filename = pkg.htmlPage();
898 setPageTitle(data, name);
899 ClearPage.write(data, "package.cs", filename);
900
901 filename = pkg.fullDescriptionHtmlPage();
902 setPageTitle(data, name + " Details");
903 ClearPage.write(data, "package-descr.cs", filename);
904
905 Proofread.writePackage(filename, pkg.inlineTags());
906 }
907
908 public static void writeClassLists()
909 {
910 int i;
911 HDF data = makePackageHDF();
912
913 ClassInfo[] classes = PackageInfo.filterHidden(
914 Converter.convertClasses(root.classes()));
915 if (classes.length == 0) {
916 return ;
917 }
918
919 Sorter[] sorted = new Sorter[classes.length];
920 for (i=0; i<sorted.length; i++) {
921 ClassInfo cl = classes[i];
922 String name = cl.name();
923 sorted[i] = new Sorter(name, cl);
924 }
925
926 Arrays.sort(sorted);
927
928 // make a pass and resolve ones that have the same name
929 int firstMatch = 0;
930 String lastName = sorted[0].label;
931 for (i=1; i<sorted.length; i++) {
932 String s = sorted[i].label;
933 if (!lastName.equals(s)) {
934 if (firstMatch != i-1) {
935 // there were duplicates
936 for (int j=firstMatch; j<i; j++) {
937 PackageInfo pkg = ((ClassInfo)sorted[j].data).containingPackage();
938 if (pkg != null) {
939 sorted[j].label = sorted[j].label + " (" + pkg.name() + ")";
940 }
941 }
942 }
943 firstMatch = i;
944 lastName = s;
945 }
946 }
947
948 // and sort again
949 Arrays.sort(sorted);
950
951 for (i=0; i<sorted.length; i++) {
952 String s = sorted[i].label;
953 ClassInfo cl = (ClassInfo)sorted[i].data;
954 char first = Character.toUpperCase(s.charAt(0));
955 cl.makeShortDescrHDF(data, "docs.classes." + first + '.' + i);
956 }
957
958 setPageTitle(data, "Class Index");
959 ClearPage.write(data, "classes.cs", javadocDir + "classes" + htmlExtension);
960 }
961
962 // we use the word keywords because "index" means something else in html land
963 // the user only ever sees the word index
964/* public static void writeKeywords()
965 {
966 ArrayList<KeywordEntry> keywords = new ArrayList<KeywordEntry>();
967
968 ClassInfo[] classes = PackageInfo.filterHidden(Converter.convertClasses(root.classes()));
969
970 for (ClassInfo cl: classes) {
971 cl.makeKeywordEntries(keywords);
972 }
973
974 HDF data = makeHDF();
975
976 Collections.sort(keywords);
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -0700977
The Android Open Source Project88b60792009-03-03 19:28:42 -0800978 int i=0;
979 for (KeywordEntry entry: keywords) {
980 String base = "keywords." + entry.firstChar() + "." + i;
981 entry.makeHDF(data, base);
982 i++;
983 }
984
985 setPageTitle(data, "Index");
986 ClearPage.write(data, "keywords.cs", javadocDir + "keywords" + htmlExtension);
987 } */
988
989 public static void writeHierarchy()
990 {
991 ClassInfo[] classes = Converter.rootClasses();
992 ArrayList<ClassInfo> info = new ArrayList<ClassInfo>();
993 for (ClassInfo cl: classes) {
994 if (!cl.isHidden()) {
995 info.add(cl);
996 }
997 }
998 HDF data = makePackageHDF();
999 Hierarchy.makeHierarchy(data, info.toArray(new ClassInfo[info.size()]));
1000 setPageTitle(data, "Class Hierarchy");
1001 ClearPage.write(data, "hierarchy.cs", javadocDir + "hierarchy" + htmlExtension);
1002 }
1003
1004 public static void writeClasses()
1005 {
1006 ClassInfo[] classes = Converter.rootClasses();
1007
1008 for (ClassInfo cl: classes) {
1009 HDF data = makePackageHDF();
1010 if (!cl.isHidden()) {
1011 writeClass(cl, data);
1012 }
1013 }
1014 }
1015
1016 public static void writeClass(ClassInfo cl, HDF data)
1017 {
1018 cl.makeHDF(data);
1019
1020 setPageTitle(data, cl.name());
1021 ClearPage.write(data, "class.cs", cl.htmlPage());
1022
1023 Proofread.writeClass(cl.htmlPage(), cl);
1024 }
1025
1026 public static void makeClassListHDF(HDF data, String base,
1027 ClassInfo[] classes)
1028 {
1029 for (int i=0; i<classes.length; i++) {
1030 ClassInfo cl = classes[i];
1031 if (!cl.isHidden()) {
1032 cl.makeShortDescrHDF(data, base + "." + i);
1033 }
1034 }
1035 }
1036
1037 public static String linkTarget(String source, String target)
1038 {
1039 String[] src = source.split("/");
1040 String[] tgt = target.split("/");
1041
1042 int srclen = src.length;
1043 int tgtlen = tgt.length;
1044
1045 int same = 0;
1046 while (same < (srclen-1)
1047 && same < (tgtlen-1)
1048 && (src[same].equals(tgt[same]))) {
1049 same++;
1050 }
1051
1052 String s = "";
1053
1054 int up = srclen-same-1;
1055 for (int i=0; i<up; i++) {
1056 s += "../";
1057 }
1058
1059
1060 int N = tgtlen-1;
1061 for (int i=same; i<N; i++) {
1062 s += tgt[i] + '/';
1063 }
1064 s += tgt[tgtlen-1];
1065
1066 return s;
1067 }
1068
1069 /**
Xavier Ducrohet02e14df2009-09-10 14:50:12 -07001070 * Returns true if the given element has an @hide or @pending annotation.
The Android Open Source Project88b60792009-03-03 19:28:42 -08001071 */
1072 private static boolean hasHideAnnotation(Doc doc) {
Xavier Ducrohet02e14df2009-09-10 14:50:12 -07001073 String comment = doc.getRawCommentText();
1074 return comment.indexOf("@hide") != -1 || comment.indexOf("@pending") != -1;
The Android Open Source Project88b60792009-03-03 19:28:42 -08001075 }
1076
1077 /**
1078 * Returns true if the given element is hidden.
1079 */
1080 private static boolean isHidden(Doc doc) {
1081 // Methods, fields, constructors.
1082 if (doc instanceof MemberDoc) {
1083 return hasHideAnnotation(doc);
1084 }
1085
1086 // Classes, interfaces, enums, annotation types.
1087 if (doc instanceof ClassDoc) {
1088 ClassDoc classDoc = (ClassDoc) doc;
1089
1090 // Check the containing package.
1091 if (hasHideAnnotation(classDoc.containingPackage())) {
1092 return true;
1093 }
1094
1095 // Check the class doc and containing class docs if this is a
1096 // nested class.
1097 ClassDoc current = classDoc;
1098 do {
1099 if (hasHideAnnotation(current)) {
1100 return true;
1101 }
1102
1103 current = current.containingClass();
1104 } while (current != null);
1105 }
1106
1107 return false;
1108 }
1109
1110 /**
1111 * Filters out hidden elements.
1112 */
1113 private static Object filterHidden(Object o, Class<?> expected) {
1114 if (o == null) {
1115 return null;
1116 }
1117
1118 Class type = o.getClass();
1119 if (type.getName().startsWith("com.sun.")) {
1120 // TODO: Implement interfaces from superclasses, too.
1121 return Proxy.newProxyInstance(type.getClassLoader(),
1122 type.getInterfaces(), new HideHandler(o));
1123 } else if (o instanceof Object[]) {
1124 Class<?> componentType = expected.getComponentType();
1125 Object[] array = (Object[]) o;
1126 List<Object> list = new ArrayList<Object>(array.length);
1127 for (Object entry : array) {
1128 if ((entry instanceof Doc) && isHidden((Doc) entry)) {
1129 continue;
1130 }
1131 list.add(filterHidden(entry, componentType));
1132 }
1133 return list.toArray(
1134 (Object[]) Array.newInstance(componentType, list.size()));
1135 } else {
1136 return o;
1137 }
1138 }
1139
1140 /**
1141 * Filters hidden elements out of method return values.
1142 */
1143 private static class HideHandler implements InvocationHandler {
1144
1145 private final Object target;
1146
1147 public HideHandler(Object target) {
1148 this.target = target;
1149 }
1150
1151 public Object invoke(Object proxy, Method method, Object[] args)
1152 throws Throwable {
1153 String methodName = method.getName();
1154 if (args != null) {
1155 if (methodName.equals("compareTo") ||
1156 methodName.equals("equals") ||
1157 methodName.equals("overrides") ||
1158 methodName.equals("subclassOf")) {
1159 args[0] = unwrap(args[0]);
1160 }
1161 }
1162
1163 if (methodName.equals("getRawCommentText")) {
1164 return filterComment((String) method.invoke(target, args));
1165 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001166
The Android Open Source Project88b60792009-03-03 19:28:42 -08001167 // escape "&" in disjunctive types.
1168 if (proxy instanceof Type && methodName.equals("toString")) {
1169 return ((String) method.invoke(target, args))
1170 .replace("&", "&amp;");
1171 }
1172
1173 try {
1174 return filterHidden(method.invoke(target, args),
1175 method.getReturnType());
1176 } catch (InvocationTargetException e) {
1177 throw e.getTargetException();
1178 }
1179 }
1180
1181 private String filterComment(String s) {
1182 if (s == null) {
1183 return null;
1184 }
1185
1186 s = s.trim();
1187
1188 // Work around off by one error
1189 while (s.length() >= 5
1190 && s.charAt(s.length() - 5) == '{') {
1191 s += "&nbsp;";
1192 }
1193
1194 return s;
1195 }
1196
1197 private static Object unwrap(Object proxy) {
1198 if (proxy instanceof Proxy)
1199 return ((HideHandler)Proxy.getInvocationHandler(proxy)).target;
1200 return proxy;
1201 }
1202 }
1203
1204 public static String scope(Scoped scoped) {
1205 if (scoped.isPublic()) {
1206 return "public";
1207 }
1208 else if (scoped.isProtected()) {
1209 return "protected";
1210 }
1211 else if (scoped.isPackagePrivate()) {
1212 return "";
1213 }
1214 else if (scoped.isPrivate()) {
1215 return "private";
1216 }
1217 else {
1218 throw new RuntimeException("invalid scope for object " + scoped);
1219 }
1220 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001221
The Android Open Source Project88b60792009-03-03 19:28:42 -08001222 /**
1223 * Collect the values used by the Dev tools and write them in files packaged with the SDK
1224 * @param output the ouput directory for the files.
1225 */
1226 private static void writeSdkValues(String output) {
1227 ArrayList<String> activityActions = new ArrayList<String>();
1228 ArrayList<String> broadcastActions = new ArrayList<String>();
1229 ArrayList<String> serviceActions = new ArrayList<String>();
1230 ArrayList<String> categories = new ArrayList<String>();
Xavier Ducrohetf9b6d382009-12-14 17:55:05 -08001231 ArrayList<String> features = new ArrayList<String>();
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001232
The Android Open Source Project88b60792009-03-03 19:28:42 -08001233 ArrayList<ClassInfo> layouts = new ArrayList<ClassInfo>();
1234 ArrayList<ClassInfo> widgets = new ArrayList<ClassInfo>();
1235 ArrayList<ClassInfo> layoutParams = new ArrayList<ClassInfo>();
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001236
The Android Open Source Project88b60792009-03-03 19:28:42 -08001237 ClassInfo[] classes = Converter.allClasses();
1238
1239 // Go through all the fields of all the classes, looking SDK stuff.
1240 for (ClassInfo clazz : classes) {
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001241
The Android Open Source Project88b60792009-03-03 19:28:42 -08001242 // first check constant fields for the SdkConstant annotation.
1243 FieldInfo[] fields = clazz.allSelfFields();
1244 for (FieldInfo field : fields) {
1245 Object cValue = field.constantValue();
1246 if (cValue != null) {
1247 AnnotationInstanceInfo[] annotations = field.annotations();
1248 if (annotations.length > 0) {
1249 for (AnnotationInstanceInfo annotation : annotations) {
1250 if (SDK_CONSTANT_ANNOTATION.equals(annotation.type().qualifiedName())) {
1251 AnnotationValueInfo[] values = annotation.elementValues();
1252 if (values.length > 0) {
1253 String type = values[0].valueString();
1254 if (SDK_CONSTANT_TYPE_ACTIVITY_ACTION.equals(type)) {
1255 activityActions.add(cValue.toString());
1256 } else if (SDK_CONSTANT_TYPE_BROADCAST_ACTION.equals(type)) {
1257 broadcastActions.add(cValue.toString());
1258 } else if (SDK_CONSTANT_TYPE_SERVICE_ACTION.equals(type)) {
1259 serviceActions.add(cValue.toString());
1260 } else if (SDK_CONSTANT_TYPE_CATEGORY.equals(type)) {
1261 categories.add(cValue.toString());
Xavier Ducrohetf9b6d382009-12-14 17:55:05 -08001262 } else if (SDK_CONSTANT_TYPE_FEATURE.equals(type)) {
1263 features.add(cValue.toString());
The Android Open Source Project88b60792009-03-03 19:28:42 -08001264 }
1265 }
1266 break;
1267 }
1268 }
1269 }
1270 }
1271 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001272
The Android Open Source Project88b60792009-03-03 19:28:42 -08001273 // Now check the class for @Widget or if its in the android.widget package
1274 // (unless the class is hidden or abstract, or non public)
1275 if (clazz.isHidden() == false && clazz.isPublic() && clazz.isAbstract() == false) {
1276 boolean annotated = false;
1277 AnnotationInstanceInfo[] annotations = clazz.annotations();
1278 if (annotations.length > 0) {
1279 for (AnnotationInstanceInfo annotation : annotations) {
1280 if (SDK_WIDGET_ANNOTATION.equals(annotation.type().qualifiedName())) {
1281 widgets.add(clazz);
1282 annotated = true;
1283 break;
1284 } else if (SDK_LAYOUT_ANNOTATION.equals(annotation.type().qualifiedName())) {
1285 layouts.add(clazz);
1286 annotated = true;
1287 break;
1288 }
1289 }
1290 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001291
The Android Open Source Project88b60792009-03-03 19:28:42 -08001292 if (annotated == false) {
1293 // lets check if this is inside android.widget
1294 PackageInfo pckg = clazz.containingPackage();
1295 String packageName = pckg.name();
1296 if ("android.widget".equals(packageName) ||
1297 "android.view".equals(packageName)) {
1298 // now we check what this class inherits either from android.view.ViewGroup
1299 // or android.view.View, or android.view.ViewGroup.LayoutParams
1300 int type = checkInheritance(clazz);
1301 switch (type) {
1302 case TYPE_WIDGET:
1303 widgets.add(clazz);
1304 break;
1305 case TYPE_LAYOUT:
1306 layouts.add(clazz);
1307 break;
1308 case TYPE_LAYOUT_PARAM:
1309 layoutParams.add(clazz);
1310 break;
1311 }
1312 }
1313 }
1314 }
1315 }
1316
1317 // now write the files, whether or not the list are empty.
1318 // the SDK built requires those files to be present.
1319
1320 Collections.sort(activityActions);
1321 writeValues(output + "/activity_actions.txt", activityActions);
1322
1323 Collections.sort(broadcastActions);
1324 writeValues(output + "/broadcast_actions.txt", broadcastActions);
1325
1326 Collections.sort(serviceActions);
1327 writeValues(output + "/service_actions.txt", serviceActions);
1328
1329 Collections.sort(categories);
1330 writeValues(output + "/categories.txt", categories);
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001331
Xavier Ducrohetf9b6d382009-12-14 17:55:05 -08001332 Collections.sort(features);
1333 writeValues(output + "/features.txt", features);
1334
The Android Open Source Project88b60792009-03-03 19:28:42 -08001335 // before writing the list of classes, we do some checks, to make sure the layout params
1336 // are enclosed by a layout class (and not one that has been declared as a widget)
1337 for (int i = 0 ; i < layoutParams.size();) {
1338 ClassInfo layoutParamClass = layoutParams.get(i);
1339 ClassInfo containingClass = layoutParamClass.containingClass();
1340 if (containingClass == null || layouts.indexOf(containingClass) == -1) {
1341 layoutParams.remove(i);
1342 } else {
1343 i++;
1344 }
1345 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001346
The Android Open Source Project88b60792009-03-03 19:28:42 -08001347 writeClasses(output + "/widgets.txt", widgets, layouts, layoutParams);
1348 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001349
The Android Open Source Project88b60792009-03-03 19:28:42 -08001350 /**
1351 * Writes a list of values into a text files.
1352 * @param pathname the absolute os path of the output file.
1353 * @param values the list of values to write.
1354 */
1355 private static void writeValues(String pathname, ArrayList<String> values) {
1356 FileWriter fw = null;
1357 BufferedWriter bw = null;
1358 try {
1359 fw = new FileWriter(pathname, false);
1360 bw = new BufferedWriter(fw);
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001361
The Android Open Source Project88b60792009-03-03 19:28:42 -08001362 for (String value : values) {
1363 bw.append(value).append('\n');
1364 }
1365 } catch (IOException e) {
1366 // pass for now
1367 } finally {
1368 try {
1369 if (bw != null) bw.close();
1370 } catch (IOException e) {
1371 // pass for now
1372 }
1373 try {
1374 if (fw != null) fw.close();
1375 } catch (IOException e) {
1376 // pass for now
1377 }
1378 }
1379 }
1380
1381 /**
1382 * Writes the widget/layout/layout param classes into a text files.
1383 * @param pathname the absolute os path of the output file.
1384 * @param widgets the list of widget classes to write.
1385 * @param layouts the list of layout classes to write.
1386 * @param layoutParams the list of layout param classes to write.
1387 */
1388 private static void writeClasses(String pathname, ArrayList<ClassInfo> widgets,
1389 ArrayList<ClassInfo> layouts, ArrayList<ClassInfo> layoutParams) {
1390 FileWriter fw = null;
1391 BufferedWriter bw = null;
1392 try {
1393 fw = new FileWriter(pathname, false);
1394 bw = new BufferedWriter(fw);
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001395
The Android Open Source Project88b60792009-03-03 19:28:42 -08001396 // write the 3 types of classes.
1397 for (ClassInfo clazz : widgets) {
1398 writeClass(bw, clazz, 'W');
1399 }
1400 for (ClassInfo clazz : layoutParams) {
1401 writeClass(bw, clazz, 'P');
1402 }
1403 for (ClassInfo clazz : layouts) {
1404 writeClass(bw, clazz, 'L');
1405 }
1406 } catch (IOException e) {
1407 // pass for now
1408 } finally {
1409 try {
1410 if (bw != null) bw.close();
1411 } catch (IOException e) {
1412 // pass for now
1413 }
1414 try {
1415 if (fw != null) fw.close();
1416 } catch (IOException e) {
1417 // pass for now
1418 }
1419 }
1420 }
1421
1422 /**
1423 * Writes a class name and its super class names into a {@link BufferedWriter}.
1424 * @param writer the BufferedWriter to write into
1425 * @param clazz the class to write
1426 * @param prefix the prefix to put at the beginning of the line.
1427 * @throws IOException
1428 */
1429 private static void writeClass(BufferedWriter writer, ClassInfo clazz, char prefix)
1430 throws IOException {
1431 writer.append(prefix).append(clazz.qualifiedName());
1432 ClassInfo superClass = clazz;
1433 while ((superClass = superClass.superclass()) != null) {
1434 writer.append(' ').append(superClass.qualifiedName());
1435 }
1436 writer.append('\n');
1437 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001438
The Android Open Source Project88b60792009-03-03 19:28:42 -08001439 /**
1440 * Checks the inheritance of {@link ClassInfo} objects. This method return
1441 * <ul>
1442 * <li>{@link #TYPE_LAYOUT}: if the class extends <code>android.view.ViewGroup</code></li>
1443 * <li>{@link #TYPE_WIDGET}: if the class extends <code>android.view.View</code></li>
1444 * <li>{@link #TYPE_LAYOUT_PARAM}: if the class extends <code>android.view.ViewGroup$LayoutParams</code></li>
1445 * <li>{@link #TYPE_NONE}: in all other cases</li>
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001446 * </ul>
The Android Open Source Project88b60792009-03-03 19:28:42 -08001447 * @param clazz the {@link ClassInfo} to check.
1448 */
1449 private static int checkInheritance(ClassInfo clazz) {
1450 if ("android.view.ViewGroup".equals(clazz.qualifiedName())) {
1451 return TYPE_LAYOUT;
1452 } else if ("android.view.View".equals(clazz.qualifiedName())) {
1453 return TYPE_WIDGET;
1454 } else if ("android.view.ViewGroup.LayoutParams".equals(clazz.qualifiedName())) {
1455 return TYPE_LAYOUT_PARAM;
1456 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001457
The Android Open Source Project88b60792009-03-03 19:28:42 -08001458 ClassInfo parent = clazz.superclass();
1459 if (parent != null) {
1460 return checkInheritance(parent);
1461 }
Xavier Ducrohet5ee390d2009-09-10 13:08:27 -07001462
The Android Open Source Project88b60792009-03-03 19:28:42 -08001463 return TYPE_NONE;
1464 }
1465}