1 /* 2 * Copyright (C) 2006 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 17 package android.content.res; 18 19 import android.graphics.Color; 20 import android.text.*; 21 import android.text.style.*; 22 import android.util.Log; 23 import android.util.SparseArray; 24 import android.graphics.Paint; 25 import android.graphics.Rect; 26 import android.graphics.Typeface; 27 28 import java.util.Arrays; 29 30 /** 31 * Conveniences for retrieving data out of a compiled string resource. 32 * 33 * {@hide} 34 */ 35 final class StringBlock { 36 private static final String TAG = "AssetManager"; 37 private static final boolean localLOGV = false; 38 39 private final long mNative; 40 private final boolean mUseSparse; 41 private final boolean mOwnsNative; 42 private CharSequence[] mStrings; 43 private SparseArray<CharSequence> mSparseStrings; 44 StyleIDs mStyleIDs = null; 45 46 public StringBlock(byte[] data, boolean useSparse) { 47 mNative = nativeCreate(data, 0, data.length); 48 mUseSparse = useSparse; 49 mOwnsNative = true; 50 if (localLOGV) Log.v(TAG, "Created string block " + this 51 + ": " + nativeGetSize(mNative)); 52 } 53 54 public StringBlock(byte[] data, int offset, int size, boolean useSparse) { 55 mNative = nativeCreate(data, offset, size); 56 mUseSparse = useSparse; 57 mOwnsNative = true; 58 if (localLOGV) Log.v(TAG, "Created string block " + this 59 + ": " + nativeGetSize(mNative)); 60 } 61 62 public CharSequence get(int idx) { 63 synchronized (this) { 64 if (mStrings != null) { 65 CharSequence res = mStrings[idx]; 66 if (res != null) { 67 return res; 68 } 69 } else if (mSparseStrings != null) { 70 CharSequence res = mSparseStrings.get(idx); 71 if (res != null) { 72 return res; 73 } 74 } else { 75 final int num = nativeGetSize(mNative); 76 if (mUseSparse && num > 250) { 77 mSparseStrings = new SparseArray<CharSequence>(); 78 } else { 79 mStrings = new CharSequence[num]; 80 } 81 } 82 String str = nativeGetString(mNative, idx); 83 CharSequence res = str; 84 int[] style = nativeGetStyle(mNative, idx); 85 if (localLOGV) Log.v(TAG, "Got string: " + str); 86 if (localLOGV) Log.v(TAG, "Got styles: " + Arrays.toString(style)); 87 if (style != null) { 88 if (mStyleIDs == null) { 89 mStyleIDs = new StyleIDs(); 90 } 91 92 // the style array is a flat array of <type, start, end> hence 93 // the magic constant 3. 94 for (int styleIndex = 0; styleIndex < style.length; styleIndex += 3) { 95 int styleId = style[styleIndex]; 96 97 if (styleId == mStyleIDs.boldId || styleId == mStyleIDs.italicId 98 || styleId == mStyleIDs.underlineId || styleId == mStyleIDs.ttId 99 || styleId == mStyleIDs.bigId || styleId == mStyleIDs.smallId 100 || styleId == mStyleIDs.subId || styleId == mStyleIDs.supId 101 || styleId == mStyleIDs.strikeId || styleId == mStyleIDs.listItemId 102 || styleId == mStyleIDs.marqueeId) { 103 // id already found skip to next style 104 continue; 105 } 106 107 String styleTag = nativeGetString(mNative, styleId); 108 109 if (styleTag.equals("b")) { 110 mStyleIDs.boldId = styleId; 111 } else if (styleTag.equals("i")) { 112 mStyleIDs.italicId = styleId; 113 } else if (styleTag.equals("u")) { 114 mStyleIDs.underlineId = styleId; 115 } else if (styleTag.equals("tt")) { 116 mStyleIDs.ttId = styleId; 117 } else if (styleTag.equals("big")) { 118 mStyleIDs.bigId = styleId; 119 } else if (styleTag.equals("small")) { 120 mStyleIDs.smallId = styleId; 121 } else if (styleTag.equals("sup")) { 122 mStyleIDs.supId = styleId; 123 } else if (styleTag.equals("sub")) { 124 mStyleIDs.subId = styleId; 125 } else if (styleTag.equals("strike")) { 126 mStyleIDs.strikeId = styleId; 127 } else if (styleTag.equals("li")) { 128 mStyleIDs.listItemId = styleId; 129 } else if (styleTag.equals("marquee")) { 130 mStyleIDs.marqueeId = styleId; 131 } 132 } 133 134 res = applyStyles(str, style, mStyleIDs); 135 } 136 if (mStrings != null) mStrings[idx] = res; 137 else mSparseStrings.put(idx, res); 138 return res; 139 } 140 } 141 142 protected void finalize() throws Throwable { 143 try { 144 super.finalize(); 145 } finally { 146 if (mOwnsNative) { 147 nativeDestroy(mNative); 148 } 149 } 150 } 151 152 static final class StyleIDs { 153 private int boldId = -1; 154 private int italicId = -1; 155 private int underlineId = -1; 156 private int ttId = -1; 157 private int bigId = -1; 158 private int smallId = -1; 159 private int subId = -1; 160 private int supId = -1; 161 private int strikeId = -1; 162 private int listItemId = -1; 163 private int marqueeId = -1; 164 } 165 166 private CharSequence applyStyles(String str, int[] style, StyleIDs ids) { 167 if (style.length == 0) 168 return str; 169 170 SpannableString buffer = new SpannableString(str); 171 int i=0; 172 while (i < style.length) { 173 int type = style[i]; 174 if (localLOGV) Log.v(TAG, "Applying style span id=" + type 175 + ", start=" + style[i+1] + ", end=" + style[i+2]); 176 177 178 if (type == ids.boldId) { 179 buffer.setSpan(new StyleSpan(Typeface.BOLD), 180 style[i+1], style[i+2]+1, 181 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 182 } else if (type == ids.italicId) { 183 buffer.setSpan(new StyleSpan(Typeface.ITALIC), 184 style[i+1], style[i+2]+1, 185 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 186 } else if (type == ids.underlineId) { 187 buffer.setSpan(new UnderlineSpan(), 188 style[i+1], style[i+2]+1, 189 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 190 } else if (type == ids.ttId) { 191 buffer.setSpan(new TypefaceSpan("monospace"), 192 style[i+1], style[i+2]+1, 193 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 194 } else if (type == ids.bigId) { 195 buffer.setSpan(new RelativeSizeSpan(1.25f), 196 style[i+1], style[i+2]+1, 197 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 198 } else if (type == ids.smallId) { 199 buffer.setSpan(new RelativeSizeSpan(0.8f), 200 style[i+1], style[i+2]+1, 201 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 202 } else if (type == ids.subId) { 203 buffer.setSpan(new SubscriptSpan(), 204 style[i+1], style[i+2]+1, 205 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 206 } else if (type == ids.supId) { 207 buffer.setSpan(new SuperscriptSpan(), 208 style[i+1], style[i+2]+1, 209 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 210 } else if (type == ids.strikeId) { 211 buffer.setSpan(new StrikethroughSpan(), 212 style[i+1], style[i+2]+1, 213 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 214 } else if (type == ids.listItemId) { 215 addParagraphSpan(buffer, new BulletSpan(10), 216 style[i+1], style[i+2]+1); 217 } else if (type == ids.marqueeId) { 218 buffer.setSpan(TextUtils.TruncateAt.MARQUEE, 219 style[i+1], style[i+2]+1, 220 Spannable.SPAN_INCLUSIVE_INCLUSIVE); 221 } else { 222 String tag = nativeGetString(mNative, type); 223 224 if (tag.startsWith("font;")) { 225 String sub; 226 227 sub = subtag(tag, ";height="); 228 if (sub != null) { 229 int size = Integer.parseInt(sub); 230 addParagraphSpan(buffer, new Height(size), 231 style[i+1], style[i+2]+1); 232 } 233 234 sub = subtag(tag, ";size="); 235 if (sub != null) { 236 int size = Integer.parseInt(sub); 237 buffer.setSpan(new AbsoluteSizeSpan(size, true), 238 style[i+1], style[i+2]+1, 239 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 240 } 241 242 sub = subtag(tag, ";fgcolor="); 243 if (sub != null) { 244 buffer.setSpan(getColor(sub, true), 245 style[i+1], style[i+2]+1, 246 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 247 } 248 249 sub = subtag(tag, ";color="); 250 if (sub != null) { 251 buffer.setSpan(getColor(sub, true), 252 style[i+1], style[i+2]+1, 253 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 254 } 255 256 sub = subtag(tag, ";bgcolor="); 257 if (sub != null) { 258 buffer.setSpan(getColor(sub, false), 259 style[i+1], style[i+2]+1, 260 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 261 } 262 263 sub = subtag(tag, ";face="); 264 if (sub != null) { 265 buffer.setSpan(new TypefaceSpan(sub), 266 style[i+1], style[i+2]+1, 267 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 268 } 269 } else if (tag.startsWith("a;")) { 270 String sub; 271 272 sub = subtag(tag, ";href="); 273 if (sub != null) { 274 buffer.setSpan(new URLSpan(sub), 275 style[i+1], style[i+2]+1, 276 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 277 } 278 } else if (tag.startsWith("annotation;")) { 279 int len = tag.length(); 280 int next; 281 282 for (int t = tag.indexOf(';'); t < len; t = next) { 283 int eq = tag.indexOf('=', t); 284 if (eq < 0) { 285 break; 286 } 287 288 next = tag.indexOf(';', eq); 289 if (next < 0) { 290 next = len; 291 } 292 293 String key = tag.substring(t + 1, eq); 294 String value = tag.substring(eq + 1, next); 295 296 buffer.setSpan(new Annotation(key, value), 297 style[i+1], style[i+2]+1, 298 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 299 } 300 } 301 } 302 303 i += 3; 304 } 305 return new SpannedString(buffer); 306 } 307 308 /** 309 * Returns a span for the specified color string representation. 310 * If the specified string does not represent a color (null, empty, etc.) 311 * the color black is returned instead. 312 * 313 * @param color The color as a string. Can be a resource reference, 314 * hexadecimal, octal or a name 315 * @param foreground True if the color will be used as the foreground color, 316 * false otherwise 317 * 318 * @return A CharacterStyle 319 * 320 * @see Color#parseColor(String) 321 */ 322 private static CharacterStyle getColor(String color, boolean foreground) { 323 int c = 0xff000000; 324 325 if (!TextUtils.isEmpty(color)) { 326 if (color.startsWith("@")) { 327 Resources res = Resources.getSystem(); 328 String name = color.substring(1); 329 int colorRes = res.getIdentifier(name, "color", "android"); 330 if (colorRes != 0) { 331 ColorStateList colors = res.getColorStateList(colorRes, null); 332 if (foreground) { 333 return new TextAppearanceSpan(null, 0, 0, colors, null); 334 } else { 335 c = colors.getDefaultColor(); 336 } 337 } 338 } else { 339 try { 340 c = Color.parseColor(color); 341 } catch (IllegalArgumentException e) { 342 c = Color.BLACK; 343 } 344 } 345 } 346 347 if (foreground) { 348 return new ForegroundColorSpan(c); 349 } else { 350 return new BackgroundColorSpan(c); 351 } 352 } 353 354 /** 355 * If a translator has messed up the edges of paragraph-level markup, 356 * fix it to actually cover the entire paragraph that it is attached to 357 * instead of just whatever range they put it on. 358 */ 359 private static void addParagraphSpan(Spannable buffer, Object what, 360 int start, int end) { 361 int len = buffer.length(); 362 363 if (start != 0 && start != len && buffer.charAt(start - 1) != '\n') { 364 for (start--; start > 0; start--) { 365 if (buffer.charAt(start - 1) == '\n') { 366 break; 367 } 368 } 369 } 370 371 if (end != 0 && end != len && buffer.charAt(end - 1) != '\n') { 372 for (end++; end < len; end++) { 373 if (buffer.charAt(end - 1) == '\n') { 374 break; 375 } 376 } 377 } 378 379 buffer.setSpan(what, start, end, Spannable.SPAN_PARAGRAPH); 380 } 381 382 private static String subtag(String full, String attribute) { 383 int start = full.indexOf(attribute); 384 if (start < 0) { 385 return null; 386 } 387 388 start += attribute.length(); 389 int end = full.indexOf(';', start); 390 391 if (end < 0) { 392 return full.substring(start); 393 } else { 394 return full.substring(start, end); 395 } 396 } 397 398 /** 399 * Forces the text line to be the specified height, shrinking/stretching 400 * the ascent if possible, or the descent if shrinking the ascent further 401 * will make the text unreadable. 402 */ 403 private static class Height implements LineHeightSpan.WithDensity { 404 private int mSize; 405 private static float sProportion = 0; 406 407 public Height(int size) { 408 mSize = size; 409 } 410 411 public void chooseHeight(CharSequence text, int start, int end, 412 int spanstartv, int v, 413 Paint.FontMetricsInt fm) { 414 // Should not get called, at least not by StaticLayout. 415 chooseHeight(text, start, end, spanstartv, v, fm, null); 416 } 417 418 public void chooseHeight(CharSequence text, int start, int end, 419 int spanstartv, int v, 420 Paint.FontMetricsInt fm, TextPaint paint) { 421 int size = mSize; 422 if (paint != null) { 423 size *= paint.density; 424 } 425 426 if (fm.bottom - fm.top < size) { 427 fm.top = fm.bottom - size; 428 fm.ascent = fm.ascent - size; 429 } else { 430 if (sProportion == 0) { 431 /* 432 * Calculate what fraction of the nominal ascent 433 * the height of a capital letter actually is, 434 * so that we won't reduce the ascent to less than 435 * that unless we absolutely have to. 436 */ 437 438 Paint p = new Paint(); 439 p.setTextSize(100); 440 Rect r = new Rect(); 441 p.getTextBounds("ABCDEFG", 0, 7, r); 442 443 sProportion = (r.top) / p.ascent(); 444 } 445 446 int need = (int) Math.ceil(-fm.top * sProportion); 447 448 if (size - fm.descent >= need) { 449 /* 450 * It is safe to shrink the ascent this much. 451 */ 452 453 fm.top = fm.bottom - size; 454 fm.ascent = fm.descent - size; 455 } else if (size >= need) { 456 /* 457 * We can't show all the descent, but we can at least 458 * show all the ascent. 459 */ 460 461 fm.top = fm.ascent = -need; 462 fm.bottom = fm.descent = fm.top + size; 463 } else { 464 /* 465 * Show as much of the ascent as we can, and no descent. 466 */ 467 468 fm.top = fm.ascent = -size; 469 fm.bottom = fm.descent = 0; 470 } 471 } 472 } 473 } 474 475 /** 476 * Create from an existing string block native object. This is 477 * -extremely- dangerous -- only use it if you absolutely know what you 478 * are doing! The given native object must exist for the entire lifetime 479 * of this newly creating StringBlock. 480 */ 481 StringBlock(long obj, boolean useSparse) { 482 mNative = obj; 483 mUseSparse = useSparse; 484 mOwnsNative = false; 485 if (localLOGV) Log.v(TAG, "Created string block " + this 486 + ": " + nativeGetSize(mNative)); 487 } 488 489 private static native long nativeCreate(byte[] data, 490 int offset, 491 int size); 492 private static native int nativeGetSize(long obj); 493 private static native String nativeGetString(long obj, int idx); 494 private static native int[] nativeGetStyle(long obj, int idx); 495 private static native void nativeDestroy(long obj); 496 } 497
