1 /* 2 * Copyright (C) 2014 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 com.android.internal.util; 18 19 import android.annotation.ColorInt; 20 import android.annotation.FloatRange; 21 import android.annotation.IntRange; 22 import android.annotation.NonNull; 23 import android.app.Notification; 24 import android.content.Context; 25 import android.content.res.ColorStateList; 26 import android.content.res.Resources; 27 import android.graphics.Bitmap; 28 import android.graphics.Color; 29 import android.graphics.drawable.AnimationDrawable; 30 import android.graphics.drawable.BitmapDrawable; 31 import android.graphics.drawable.Drawable; 32 import android.graphics.drawable.Icon; 33 import android.graphics.drawable.VectorDrawable; 34 import android.text.SpannableStringBuilder; 35 import android.text.Spanned; 36 import android.text.style.BackgroundColorSpan; 37 import android.text.style.CharacterStyle; 38 import android.text.style.ForegroundColorSpan; 39 import android.text.style.TextAppearanceSpan; 40 import android.util.Log; 41 import android.util.Pair; 42 43 import java.util.Arrays; 44 import java.util.WeakHashMap; 45 46 /** 47 * Helper class to process legacy (Holo) notifications to make them look like material notifications. 48 * 49 * @hide 50 */ 51 public class ContrastColorUtil { 52 53 private static final String TAG = "ContrastColorUtil"; 54 private static final boolean DEBUG = false; 55 56 private static final Object sLock = new Object(); 57 private static ContrastColorUtil sInstance; 58 59 private final ImageUtils mImageUtils = new ImageUtils(); 60 private final WeakHashMap<Bitmap, Pair<Boolean, Integer>> mGrayscaleBitmapCache = 61 new WeakHashMap<Bitmap, Pair<Boolean, Integer>>(); 62 63 private final int mGrayscaleIconMaxSize; // @dimen/notification_large_icon_width (64dp) 64 getInstance(Context context)65 public static ContrastColorUtil getInstance(Context context) { 66 synchronized (sLock) { 67 if (sInstance == null) { 68 sInstance = new ContrastColorUtil(context); 69 } 70 return sInstance; 71 } 72 } 73 ContrastColorUtil(Context context)74 private ContrastColorUtil(Context context) { 75 mGrayscaleIconMaxSize = context.getResources().getDimensionPixelSize( 76 com.android.internal.R.dimen.notification_grayscale_icon_max_size); 77 } 78 79 /** 80 * Checks whether a Bitmap is a small grayscale icon. 81 * Grayscale here means "very close to a perfect gray"; icon means "no larger than 64dp". 82 * 83 * @param bitmap The bitmap to test. 84 * @return True if the bitmap is grayscale; false if it is color or too large to examine. 85 */ isGrayscaleIcon(Bitmap bitmap)86 public boolean isGrayscaleIcon(Bitmap bitmap) { 87 // quick test: reject large bitmaps 88 if (bitmap.getWidth() > mGrayscaleIconMaxSize 89 || bitmap.getHeight() > mGrayscaleIconMaxSize) { 90 return false; 91 } 92 93 synchronized (sLock) { 94 Pair<Boolean, Integer> cached = mGrayscaleBitmapCache.get(bitmap); 95 if (cached != null) { 96 if (cached.second == bitmap.getGenerationId()) { 97 return cached.first; 98 } 99 } 100 } 101 boolean result; 102 int generationId; 103 synchronized (mImageUtils) { 104 result = mImageUtils.isGrayscale(bitmap); 105 106 // generationId and the check whether the Bitmap is grayscale can't be read atomically 107 // here. However, since the thread is in the process of posting the notification, we can 108 // assume that it doesn't modify the bitmap while we are checking the pixels. 109 generationId = bitmap.getGenerationId(); 110 } 111 synchronized (sLock) { 112 mGrayscaleBitmapCache.put(bitmap, Pair.create(result, generationId)); 113 } 114 return result; 115 } 116 117 /** 118 * Checks whether a Drawable is a small grayscale icon. 119 * Grayscale here means "very close to a perfect gray"; icon means "no larger than 64dp". 120 * 121 * @param d The drawable to test. 122 * @return True if the bitmap is grayscale; false if it is color or too large to examine. 123 */ isGrayscaleIcon(Drawable d)124 public boolean isGrayscaleIcon(Drawable d) { 125 if (d == null) { 126 return false; 127 } else if (d instanceof BitmapDrawable) { 128 BitmapDrawable bd = (BitmapDrawable) d; 129 return bd.getBitmap() != null && isGrayscaleIcon(bd.getBitmap()); 130 } else if (d instanceof AnimationDrawable) { 131 AnimationDrawable ad = (AnimationDrawable) d; 132 int count = ad.getNumberOfFrames(); 133 return count > 0 && isGrayscaleIcon(ad.getFrame(0)); 134 } else if (d instanceof VectorDrawable) { 135 // We just assume you're doing the right thing if using vectors 136 return true; 137 } else { 138 return false; 139 } 140 } 141 isGrayscaleIcon(Context context, Icon icon)142 public boolean isGrayscaleIcon(Context context, Icon icon) { 143 if (icon == null) { 144 return false; 145 } 146 switch (icon.getType()) { 147 case Icon.TYPE_BITMAP: 148 return isGrayscaleIcon(icon.getBitmap()); 149 case Icon.TYPE_RESOURCE: 150 return isGrayscaleIcon(context, icon.getResId()); 151 default: 152 return false; 153 } 154 } 155 156 /** 157 * Checks whether a drawable with a resoure id is a small grayscale icon. 158 * Grayscale here means "very close to a perfect gray"; icon means "no larger than 64dp". 159 * 160 * @param context The context to load the drawable from. 161 * @return True if the bitmap is grayscale; false if it is color or too large to examine. 162 */ isGrayscaleIcon(Context context, int drawableResId)163 public boolean isGrayscaleIcon(Context context, int drawableResId) { 164 if (drawableResId != 0) { 165 try { 166 return isGrayscaleIcon(context.getDrawable(drawableResId)); 167 } catch (Resources.NotFoundException ex) { 168 Log.e(TAG, "Drawable not found: " + drawableResId); 169 return false; 170 } 171 } else { 172 return false; 173 } 174 } 175 176 /** 177 * Inverts all the grayscale colors set by {@link android.text.style.TextAppearanceSpan}s on 178 * the text. 179 * 180 * @param charSequence The text to process. 181 * @return The color inverted text. 182 */ invertCharSequenceColors(CharSequence charSequence)183 public CharSequence invertCharSequenceColors(CharSequence charSequence) { 184 if (charSequence instanceof Spanned) { 185 Spanned ss = (Spanned) charSequence; 186 Object[] spans = ss.getSpans(0, ss.length(), Object.class); 187 SpannableStringBuilder builder = new SpannableStringBuilder(ss.toString()); 188 for (Object span : spans) { 189 Object resultSpan = span; 190 if (resultSpan instanceof CharacterStyle) { 191 resultSpan = ((CharacterStyle) span).getUnderlying(); 192 } 193 if (resultSpan instanceof TextAppearanceSpan) { 194 TextAppearanceSpan processedSpan = processTextAppearanceSpan( 195 (TextAppearanceSpan) span); 196 if (processedSpan != resultSpan) { 197 resultSpan = processedSpan; 198 } else { 199 // we need to still take the orgininal for wrapped spans 200 resultSpan = span; 201 } 202 } else if (resultSpan instanceof ForegroundColorSpan) { 203 ForegroundColorSpan originalSpan = (ForegroundColorSpan) resultSpan; 204 int foregroundColor = originalSpan.getForegroundColor(); 205 resultSpan = new ForegroundColorSpan(processColor(foregroundColor)); 206 } else { 207 resultSpan = span; 208 } 209 builder.setSpan(resultSpan, ss.getSpanStart(span), ss.getSpanEnd(span), 210 ss.getSpanFlags(span)); 211 } 212 return builder; 213 } 214 return charSequence; 215 } 216 processTextAppearanceSpan(TextAppearanceSpan span)217 private TextAppearanceSpan processTextAppearanceSpan(TextAppearanceSpan span) { 218 ColorStateList colorStateList = span.getTextColor(); 219 if (colorStateList != null) { 220 int[] colors = colorStateList.getColors(); 221 boolean changed = false; 222 for (int i = 0; i < colors.length; i++) { 223 if (ImageUtils.isGrayscale(colors[i])) { 224 225 // Allocate a new array so we don't change the colors in the old color state 226 // list. 227 if (!changed) { 228 colors = Arrays.copyOf(colors, colors.length); 229 } 230 colors[i] = processColor(colors[i]); 231 changed = true; 232 } 233 } 234 if (changed) { 235 return new TextAppearanceSpan( 236 span.getFamily(), span.getTextStyle(), span.getTextSize(), 237 new ColorStateList(colorStateList.getStates(), colors), 238 span.getLinkTextColor()); 239 } 240 } 241 return span; 242 } 243 244 /** 245 * Clears all color spans of a text 246 * @param charSequence the input text 247 * @return the same text but without color spans 248 */ clearColorSpans(CharSequence charSequence)249 public static CharSequence clearColorSpans(CharSequence charSequence) { 250 if (charSequence instanceof Spanned) { 251 Spanned ss = (Spanned) charSequence; 252 Object[] spans = ss.getSpans(0, ss.length(), Object.class); 253 SpannableStringBuilder builder = new SpannableStringBuilder(ss.toString()); 254 for (Object span : spans) { 255 Object resultSpan = span; 256 if (resultSpan instanceof CharacterStyle) { 257 resultSpan = ((CharacterStyle) span).getUnderlying(); 258 } 259 if (resultSpan instanceof TextAppearanceSpan) { 260 TextAppearanceSpan originalSpan = (TextAppearanceSpan) resultSpan; 261 if (originalSpan.getTextColor() != null) { 262 resultSpan = new TextAppearanceSpan( 263 originalSpan.getFamily(), 264 originalSpan.getTextStyle(), 265 originalSpan.getTextSize(), 266 null, 267 originalSpan.getLinkTextColor()); 268 } 269 } else if (resultSpan instanceof ForegroundColorSpan 270 || (resultSpan instanceof BackgroundColorSpan)) { 271 continue; 272 } else { 273 resultSpan = span; 274 } 275 builder.setSpan(resultSpan, ss.getSpanStart(span), ss.getSpanEnd(span), 276 ss.getSpanFlags(span)); 277 } 278 return builder; 279 } 280 return charSequence; 281 } 282 processColor(int color)283 private int processColor(int color) { 284 return Color.argb(Color.alpha(color), 285 255 - Color.red(color), 286 255 - Color.green(color), 287 255 - Color.blue(color)); 288 } 289 290 /** 291 * Finds a suitable color such that there's enough contrast. 292 * 293 * @param color the color to start searching from. 294 * @param other the color to ensure contrast against. Assumed to be lighter than {@param color} 295 * @param findFg if true, we assume {@param color} is a foreground, otherwise a background. 296 * @param minRatio the minimum contrast ratio required. 297 * @return a color with the same hue as {@param color}, potentially darkened to meet the 298 * contrast ratio. 299 */ findContrastColor(int color, int other, boolean findFg, double minRatio)300 public static int findContrastColor(int color, int other, boolean findFg, double minRatio) { 301 int fg = findFg ? color : other; 302 int bg = findFg ? other : color; 303 if (ColorUtilsFromCompat.calculateContrast(fg, bg) >= minRatio) { 304 return color; 305 } 306 307 double[] lab = new double[3]; 308 ColorUtilsFromCompat.colorToLAB(findFg ? fg : bg, lab); 309 310 double low = 0, high = lab[0]; 311 final double a = lab[1], b = lab[2]; 312 for (int i = 0; i < 15 && high - low > 0.00001; i++) { 313 final double l = (low + high) / 2; 314 if (findFg) { 315 fg = ColorUtilsFromCompat.LABToColor(l, a, b); 316 } else { 317 bg = ColorUtilsFromCompat.LABToColor(l, a, b); 318 } 319 if (ColorUtilsFromCompat.calculateContrast(fg, bg) > minRatio) { 320 low = l; 321 } else { 322 high = l; 323 } 324 } 325 return ColorUtilsFromCompat.LABToColor(low, a, b); 326 } 327 328 /** 329 * Finds a suitable alpha such that there's enough contrast. 330 * 331 * @param color the color to start searching from. 332 * @param backgroundColor the color to ensure contrast against. 333 * @param minRatio the minimum contrast ratio required. 334 * @return the same color as {@param color} with potentially modified alpha to meet contrast 335 */ findAlphaToMeetContrast(int color, int backgroundColor, double minRatio)336 public static int findAlphaToMeetContrast(int color, int backgroundColor, double minRatio) { 337 int fg = color; 338 int bg = backgroundColor; 339 if (ColorUtilsFromCompat.calculateContrast(fg, bg) >= minRatio) { 340 return color; 341 } 342 int startAlpha = Color.alpha(color); 343 int r = Color.red(color); 344 int g = Color.green(color); 345 int b = Color.blue(color); 346 347 int low = startAlpha, high = 255; 348 for (int i = 0; i < 15 && high - low > 0; i++) { 349 final int alpha = (low + high) / 2; 350 fg = Color.argb(alpha, r, g, b); 351 if (ColorUtilsFromCompat.calculateContrast(fg, bg) > minRatio) { 352 high = alpha; 353 } else { 354 low = alpha; 355 } 356 } 357 return Color.argb(high, r, g, b); 358 } 359 360 /** 361 * Finds a suitable color such that there's enough contrast. 362 * 363 * @param color the color to start searching from. 364 * @param other the color to ensure contrast against. Assumed to be darker than {@param color} 365 * @param findFg if true, we assume {@param color} is a foreground, otherwise a background. 366 * @param minRatio the minimum contrast ratio required. 367 * @return a color with the same hue as {@param color}, potentially darkened to meet the 368 * contrast ratio. 369 */ findContrastColorAgainstDark(int color, int other, boolean findFg, double minRatio)370 public static int findContrastColorAgainstDark(int color, int other, boolean findFg, 371 double minRatio) { 372 int fg = findFg ? color : other; 373 int bg = findFg ? other : color; 374 if (ColorUtilsFromCompat.calculateContrast(fg, bg) >= minRatio) { 375 return color; 376 } 377 378 float[] hsl = new float[3]; 379 ColorUtilsFromCompat.colorToHSL(findFg ? fg : bg, hsl); 380 381 float low = hsl[2], high = 1; 382 for (int i = 0; i < 15 && high - low > 0.00001; i++) { 383 final float l = (low + high) / 2; 384 hsl[2] = l; 385 if (findFg) { 386 fg = ColorUtilsFromCompat.HSLToColor(hsl); 387 } else { 388 bg = ColorUtilsFromCompat.HSLToColor(hsl); 389 } 390 if (ColorUtilsFromCompat.calculateContrast(fg, bg) > minRatio) { 391 high = l; 392 } else { 393 low = l; 394 } 395 } 396 return findFg ? fg : bg; 397 } 398 ensureTextContrastOnBlack(int color)399 public static int ensureTextContrastOnBlack(int color) { 400 return findContrastColorAgainstDark(color, Color.BLACK, true /* fg */, 12); 401 } 402 403 /** 404 * Finds a large text color with sufficient contrast over bg that has the same or darker hue as 405 * the original color, depending on the value of {@code isBgDarker}. 406 * 407 * @param isBgDarker {@code true} if {@code bg} is darker than {@code color}. 408 */ ensureLargeTextContrast(int color, int bg, boolean isBgDarker)409 public static int ensureLargeTextContrast(int color, int bg, boolean isBgDarker) { 410 return isBgDarker 411 ? findContrastColorAgainstDark(color, bg, true, 3) 412 : findContrastColor(color, bg, true, 3); 413 } 414 415 /** 416 * Finds a text color with sufficient contrast over bg that has the same or darker hue as the 417 * original color, depending on the value of {@code isBgDarker}. 418 * 419 * @param isBgDarker {@code true} if {@code bg} is darker than {@code color}. 420 */ ensureTextContrast(int color, int bg, boolean isBgDarker)421 public static int ensureTextContrast(int color, int bg, boolean isBgDarker) { 422 return ensureContrast(color, bg, isBgDarker, 4.5); 423 } 424 425 /** 426 * Finds a color with sufficient contrast over bg that has the same or darker hue as the 427 * original color, depending on the value of {@code isBgDarker}. 428 * 429 * @param color the color to start searching from 430 * @param bg the color to ensure contrast against 431 * @param isBgDarker {@code true} if {@code bg} is darker than {@code color} 432 * @param minRatio the minimum contrast ratio required 433 */ ensureContrast(int color, int bg, boolean isBgDarker, double minRatio)434 public static int ensureContrast(int color, int bg, boolean isBgDarker, double minRatio) { 435 return isBgDarker 436 ? findContrastColorAgainstDark(color, bg, true, minRatio) 437 : findContrastColor(color, bg, true, minRatio); 438 } 439 440 /** Finds a background color for a text view with given text color and hint text color, that 441 * has the same hue as the original color. 442 */ ensureTextBackgroundColor(int color, int textColor, int hintColor)443 public static int ensureTextBackgroundColor(int color, int textColor, int hintColor) { 444 color = findContrastColor(color, hintColor, false, 3.0); 445 return findContrastColor(color, textColor, false, 4.5); 446 } 447 contrastChange(int colorOld, int colorNew, int bg)448 private static String contrastChange(int colorOld, int colorNew, int bg) { 449 return String.format("from %.2f:1 to %.2f:1", 450 ColorUtilsFromCompat.calculateContrast(colorOld, bg), 451 ColorUtilsFromCompat.calculateContrast(colorNew, bg)); 452 } 453 454 /** 455 * Resolves {@param color} to an actual color if it is {@link Notification#COLOR_DEFAULT} 456 */ resolveColor(Context context, int color, boolean defaultBackgroundIsDark)457 public static int resolveColor(Context context, int color, boolean defaultBackgroundIsDark) { 458 if (color == Notification.COLOR_DEFAULT) { 459 int res = defaultBackgroundIsDark 460 ? com.android.internal.R.color.notification_default_color_dark 461 : com.android.internal.R.color.notification_default_color_light; 462 return context.getColor(res); 463 } 464 return color; 465 } 466 467 /** 468 * Resolves a Notification's color such that it has enough contrast to be used as the 469 * color for the Notification's action and header text on a background that is lighter than 470 * {@code notificationColor}. 471 * 472 * @see {@link #resolveContrastColor(Context, int, boolean)} 473 */ resolveContrastColor(Context context, int notificationColor, int backgroundColor)474 public static int resolveContrastColor(Context context, int notificationColor, 475 int backgroundColor) { 476 return ContrastColorUtil.resolveContrastColor(context, notificationColor, 477 backgroundColor, false /* isDark */); 478 } 479 480 /** 481 * Resolves a Notification's color such that it has enough contrast to be used as the 482 * color for the Notification's action and header text. 483 * 484 * @param notificationColor the color of the notification or {@link Notification#COLOR_DEFAULT} 485 * @param backgroundColor the background color to ensure the contrast against. 486 * @param isDark whether or not the {@code notificationColor} will be placed on a background 487 * that is darker than the color itself 488 * @return a color of the same hue with enough contrast against the backgrounds. 489 */ resolveContrastColor(Context context, int notificationColor, int backgroundColor, boolean isDark)490 public static int resolveContrastColor(Context context, int notificationColor, 491 int backgroundColor, boolean isDark) { 492 final int resolvedColor = resolveColor(context, notificationColor, isDark); 493 494 int color = resolvedColor; 495 color = ContrastColorUtil.ensureTextContrast(color, backgroundColor, isDark); 496 497 if (color != resolvedColor) { 498 if (DEBUG){ 499 Log.w(TAG, String.format( 500 "Enhanced contrast of notification for %s" 501 + " and %s (over background) by changing #%s to %s", 502 context.getPackageName(), 503 ContrastColorUtil.contrastChange(resolvedColor, color, backgroundColor), 504 Integer.toHexString(resolvedColor), Integer.toHexString(color))); 505 } 506 } 507 return color; 508 } 509 510 /** 511 * Change a color by a specified value 512 * @param baseColor the base color to lighten 513 * @param amount the amount to lighten the color from 0 to 100. This corresponds to the L 514 * increase in the LAB color space. A negative value will darken the color and 515 * a positive will lighten it. 516 * @return the changed color 517 */ changeColorLightness(int baseColor, int amount)518 public static int changeColorLightness(int baseColor, int amount) { 519 final double[] result = ColorUtilsFromCompat.getTempDouble3Array(); 520 ColorUtilsFromCompat.colorToLAB(baseColor, result); 521 result[0] = Math.max(Math.min(100, result[0] + amount), 0); 522 return ColorUtilsFromCompat.LABToColor(result[0], result[1], result[2]); 523 } 524 resolvePrimaryColor(Context context, int backgroundColor, boolean defaultBackgroundIsDark)525 public static int resolvePrimaryColor(Context context, int backgroundColor, 526 boolean defaultBackgroundIsDark) { 527 boolean useDark = shouldUseDark(backgroundColor, defaultBackgroundIsDark); 528 if (useDark) { 529 return context.getColor( 530 com.android.internal.R.color.notification_primary_text_color_light); 531 } else { 532 return context.getColor( 533 com.android.internal.R.color.notification_primary_text_color_dark); 534 } 535 } 536 resolveSecondaryColor(Context context, int backgroundColor, boolean defaultBackgroundIsDark)537 public static int resolveSecondaryColor(Context context, int backgroundColor, 538 boolean defaultBackgroundIsDark) { 539 boolean useDark = shouldUseDark(backgroundColor, defaultBackgroundIsDark); 540 if (useDark) { 541 return context.getColor( 542 com.android.internal.R.color.notification_secondary_text_color_light); 543 } else { 544 return context.getColor( 545 com.android.internal.R.color.notification_secondary_text_color_dark); 546 } 547 } 548 resolveDefaultColor(Context context, int backgroundColor, boolean defaultBackgroundIsDark)549 public static int resolveDefaultColor(Context context, int backgroundColor, 550 boolean defaultBackgroundIsDark) { 551 boolean useDark = shouldUseDark(backgroundColor, defaultBackgroundIsDark); 552 if (useDark) { 553 return context.getColor( 554 com.android.internal.R.color.notification_default_color_light); 555 } else { 556 return context.getColor( 557 com.android.internal.R.color.notification_default_color_dark); 558 } 559 } 560 561 /** 562 * Get a color that stays in the same tint, but darkens or lightens it by a certain 563 * amount. 564 * This also looks at the lightness of the provided color and shifts it appropriately. 565 * 566 * @param color the base color to use 567 * @param amount the amount from 1 to 100 how much to modify the color 568 * @return the new color that was modified 569 */ getShiftedColor(int color, int amount)570 public static int getShiftedColor(int color, int amount) { 571 final double[] result = ColorUtilsFromCompat.getTempDouble3Array(); 572 ColorUtilsFromCompat.colorToLAB(color, result); 573 if (result[0] >= 4) { 574 result[0] = Math.max(0, result[0] - amount); 575 } else { 576 result[0] = Math.min(100, result[0] + amount); 577 } 578 return ColorUtilsFromCompat.LABToColor(result[0], result[1], result[2]); 579 } 580 581 /** 582 * Blends the provided color with white to create a muted version. 583 * 584 * @param color the color to mute 585 * @param alpha the amount from 0 to 1 to set the alpha component of the white scrim 586 * @return the new color that was modified 587 */ getMutedColor(int color, float alpha)588 public static int getMutedColor(int color, float alpha) { 589 int whiteScrim = ColorUtilsFromCompat.setAlphaComponent( 590 Color.WHITE, (int) (255 * alpha)); 591 return compositeColors(whiteScrim, color); 592 } 593 shouldUseDark(int backgroundColor, boolean defaultBackgroundIsDark)594 private static boolean shouldUseDark(int backgroundColor, boolean defaultBackgroundIsDark) { 595 if (backgroundColor == Notification.COLOR_DEFAULT) { 596 return !defaultBackgroundIsDark; 597 } 598 // Color contrast ratio luminance midpoint, X: 1.05 / (X + 0.05) = (X + 0.05) / 0.05 599 // Solved as X = sqrt(.05 * 1.05) - 0.05 = 0.17912878474 600 return ColorUtilsFromCompat.calculateLuminance(backgroundColor) > 0.17912878474; 601 } 602 calculateLuminance(int backgroundColor)603 public static double calculateLuminance(int backgroundColor) { 604 return ColorUtilsFromCompat.calculateLuminance(backgroundColor); 605 } 606 607 calculateContrast(int foregroundColor, int backgroundColor)608 public static double calculateContrast(int foregroundColor, int backgroundColor) { 609 return ColorUtilsFromCompat.calculateContrast(foregroundColor, backgroundColor); 610 } 611 satisfiesTextContrast(int backgroundColor, int foregroundColor)612 public static boolean satisfiesTextContrast(int backgroundColor, int foregroundColor) { 613 return ContrastColorUtil.calculateContrast(foregroundColor, backgroundColor) >= 4.5; 614 } 615 616 /** 617 * Composite two potentially translucent colors over each other and returns the result. 618 */ compositeColors(int foreground, int background)619 public static int compositeColors(int foreground, int background) { 620 return ColorUtilsFromCompat.compositeColors(foreground, background); 621 } 622 isColorLight(int backgroundColor)623 public static boolean isColorLight(int backgroundColor) { 624 // TODO(b/188947832): Use 0.17912878474 instead of 0.5 to ensure better contrast 625 return calculateLuminance(backgroundColor) > 0.5f; 626 } 627 628 /** 629 * Framework copy of functions needed from android.support.v4.graphics.ColorUtils. 630 */ 631 private static class ColorUtilsFromCompat { 632 private static final double XYZ_WHITE_REFERENCE_X = 95.047; 633 private static final double XYZ_WHITE_REFERENCE_Y = 100; 634 private static final double XYZ_WHITE_REFERENCE_Z = 108.883; 635 private static final double XYZ_EPSILON = 0.008856; 636 private static final double XYZ_KAPPA = 903.3; 637 638 private static final int MIN_ALPHA_SEARCH_MAX_ITERATIONS = 10; 639 private static final int MIN_ALPHA_SEARCH_PRECISION = 1; 640 641 private static final ThreadLocal<double[]> TEMP_ARRAY = new ThreadLocal<>(); 642 ColorUtilsFromCompat()643 private ColorUtilsFromCompat() {} 644 645 /** 646 * Composite two potentially translucent colors over each other and returns the result. 647 */ compositeColors(@olorInt int foreground, @ColorInt int background)648 public static int compositeColors(@ColorInt int foreground, @ColorInt int background) { 649 int bgAlpha = Color.alpha(background); 650 int fgAlpha = Color.alpha(foreground); 651 int a = compositeAlpha(fgAlpha, bgAlpha); 652 653 int r = compositeComponent(Color.red(foreground), fgAlpha, 654 Color.red(background), bgAlpha, a); 655 int g = compositeComponent(Color.green(foreground), fgAlpha, 656 Color.green(background), bgAlpha, a); 657 int b = compositeComponent(Color.blue(foreground), fgAlpha, 658 Color.blue(background), bgAlpha, a); 659 660 return Color.argb(a, r, g, b); 661 } 662 compositeAlpha(int foregroundAlpha, int backgroundAlpha)663 private static int compositeAlpha(int foregroundAlpha, int backgroundAlpha) { 664 return 0xFF - (((0xFF - backgroundAlpha) * (0xFF - foregroundAlpha)) / 0xFF); 665 } 666 compositeComponent(int fgC, int fgA, int bgC, int bgA, int a)667 private static int compositeComponent(int fgC, int fgA, int bgC, int bgA, int a) { 668 if (a == 0) return 0; 669 return ((0xFF * fgC * fgA) + (bgC * bgA * (0xFF - fgA))) / (a * 0xFF); 670 } 671 672 /** 673 * Set the alpha component of {@code color} to be {@code alpha}. 674 */ 675 @ColorInt setAlphaComponent(@olorInt int color, @IntRange(from = 0x0, to = 0xFF) int alpha)676 public static int setAlphaComponent(@ColorInt int color, 677 @IntRange(from = 0x0, to = 0xFF) int alpha) { 678 if (alpha < 0 || alpha > 255) { 679 throw new IllegalArgumentException("alpha must be between 0 and 255."); 680 } 681 return (color & 0x00ffffff) | (alpha << 24); 682 } 683 684 /** 685 * Returns the luminance of a color as a float between {@code 0.0} and {@code 1.0}. 686 * <p>Defined as the Y component in the XYZ representation of {@code color}.</p> 687 */ 688 @FloatRange(from = 0.0, to = 1.0) calculateLuminance(@olorInt int color)689 public static double calculateLuminance(@ColorInt int color) { 690 final double[] result = getTempDouble3Array(); 691 colorToXYZ(color, result); 692 // Luminance is the Y component 693 return result[1] / 100; 694 } 695 696 /** 697 * Returns the contrast ratio between {@code foreground} and {@code background}. 698 * {@code background} must be opaque. 699 * <p> 700 * Formula defined 701 * <a href="http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef">here</a>. 702 */ calculateContrast(@olorInt int foreground, @ColorInt int background)703 public static double calculateContrast(@ColorInt int foreground, @ColorInt int background) { 704 if (Color.alpha(background) != 255) { 705 Log.wtf(TAG, "background can not be translucent: #" 706 + Integer.toHexString(background)); 707 } 708 if (Color.alpha(foreground) < 255) { 709 // If the foreground is translucent, composite the foreground over the background 710 foreground = compositeColors(foreground, background); 711 } 712 713 final double luminance1 = calculateLuminance(foreground) + 0.05; 714 final double luminance2 = calculateLuminance(background) + 0.05; 715 716 // Now return the lighter luminance divided by the darker luminance 717 return Math.max(luminance1, luminance2) / Math.min(luminance1, luminance2); 718 } 719 720 /** 721 * Convert the ARGB color to its CIE Lab representative components. 722 * 723 * @param color the ARGB color to convert. The alpha component is ignored 724 * @param outLab 3-element array which holds the resulting LAB components 725 */ colorToLAB(@olorInt int color, @NonNull double[] outLab)726 public static void colorToLAB(@ColorInt int color, @NonNull double[] outLab) { 727 RGBToLAB(Color.red(color), Color.green(color), Color.blue(color), outLab); 728 } 729 730 /** 731 * Convert RGB components to its CIE Lab representative components. 732 * 733 * <ul> 734 * <li>outLab[0] is L [0 ...100)</li> 735 * <li>outLab[1] is a [-128...127)</li> 736 * <li>outLab[2] is b [-128...127)</li> 737 * </ul> 738 * 739 * @param r red component value [0..255] 740 * @param g green component value [0..255] 741 * @param b blue component value [0..255] 742 * @param outLab 3-element array which holds the resulting LAB components 743 */ RGBToLAB(@ntRangefrom = 0x0, to = 0xFF) int r, @IntRange(from = 0x0, to = 0xFF) int g, @IntRange(from = 0x0, to = 0xFF) int b, @NonNull double[] outLab)744 public static void RGBToLAB(@IntRange(from = 0x0, to = 0xFF) int r, 745 @IntRange(from = 0x0, to = 0xFF) int g, @IntRange(from = 0x0, to = 0xFF) int b, 746 @NonNull double[] outLab) { 747 // First we convert RGB to XYZ 748 RGBToXYZ(r, g, b, outLab); 749 // outLab now contains XYZ 750 XYZToLAB(outLab[0], outLab[1], outLab[2], outLab); 751 // outLab now contains LAB representation 752 } 753 754 /** 755 * Convert the ARGB color to it's CIE XYZ representative components. 756 * 757 * <p>The resulting XYZ representation will use the D65 illuminant and the CIE 758 * 2° Standard Observer (1931).</p> 759 * 760 * <ul> 761 * <li>outXyz[0] is X [0 ...95.047)</li> 762 * <li>outXyz[1] is Y [0...100)</li> 763 * <li>outXyz[2] is Z [0...108.883)</li> 764 * </ul> 765 * 766 * @param color the ARGB color to convert. The alpha component is ignored 767 * @param outXyz 3-element array which holds the resulting LAB components 768 */ colorToXYZ(@olorInt int color, @NonNull double[] outXyz)769 public static void colorToXYZ(@ColorInt int color, @NonNull double[] outXyz) { 770 RGBToXYZ(Color.red(color), Color.green(color), Color.blue(color), outXyz); 771 } 772 773 /** 774 * Convert RGB components to it's CIE XYZ representative components. 775 * 776 * <p>The resulting XYZ representation will use the D65 illuminant and the CIE 777 * 2° Standard Observer (1931).</p> 778 * 779 * <ul> 780 * <li>outXyz[0] is X [0 ...95.047)</li> 781 * <li>outXyz[1] is Y [0...100)</li> 782 * <li>outXyz[2] is Z [0...108.883)</li> 783 * </ul> 784 * 785 * @param r red component value [0..255] 786 * @param g green component value [0..255] 787 * @param b blue component value [0..255] 788 * @param outXyz 3-element array which holds the resulting XYZ components 789 */ RGBToXYZ(@ntRangefrom = 0x0, to = 0xFF) int r, @IntRange(from = 0x0, to = 0xFF) int g, @IntRange(from = 0x0, to = 0xFF) int b, @NonNull double[] outXyz)790 public static void RGBToXYZ(@IntRange(from = 0x0, to = 0xFF) int r, 791 @IntRange(from = 0x0, to = 0xFF) int g, @IntRange(from = 0x0, to = 0xFF) int b, 792 @NonNull double[] outXyz) { 793 if (outXyz.length != 3) { 794 throw new IllegalArgumentException("outXyz must have a length of 3."); 795 } 796 797 double sr = r / 255.0; 798 sr = sr < 0.04045 ? sr / 12.92 : Math.pow((sr + 0.055) / 1.055, 2.4); 799 double sg = g / 255.0; 800 sg = sg < 0.04045 ? sg / 12.92 : Math.pow((sg + 0.055) / 1.055, 2.4); 801 double sb = b / 255.0; 802 sb = sb < 0.04045 ? sb / 12.92 : Math.pow((sb + 0.055) / 1.055, 2.4); 803 804 outXyz[0] = 100 * (sr * 0.4124 + sg * 0.3576 + sb * 0.1805); 805 outXyz[1] = 100 * (sr * 0.2126 + sg * 0.7152 + sb * 0.0722); 806 outXyz[2] = 100 * (sr * 0.0193 + sg * 0.1192 + sb * 0.9505); 807 } 808 809 /** 810 * Converts a color from CIE XYZ to CIE Lab representation. 811 * 812 * <p>This method expects the XYZ representation to use the D65 illuminant and the CIE 813 * 2° Standard Observer (1931).</p> 814 * 815 * <ul> 816 * <li>outLab[0] is L [0 ...100)</li> 817 * <li>outLab[1] is a [-128...127)</li> 818 * <li>outLab[2] is b [-128...127)</li> 819 * </ul> 820 * 821 * @param x X component value [0...95.047) 822 * @param y Y component value [0...100) 823 * @param z Z component value [0...108.883) 824 * @param outLab 3-element array which holds the resulting Lab components 825 */ 826 public static void XYZToLAB(@FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_X) double x, 827 @FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_Y) double y, 828 @FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_Z) double z, 829 @NonNull double[] outLab) { 830 if (outLab.length != 3) { 831 throw new IllegalArgumentException("outLab must have a length of 3."); 832 } 833 x = pivotXyzComponent(x / XYZ_WHITE_REFERENCE_X); 834 y = pivotXyzComponent(y / XYZ_WHITE_REFERENCE_Y); 835 z = pivotXyzComponent(z / XYZ_WHITE_REFERENCE_Z); 836 outLab[0] = Math.max(0, 116 * y - 16); 837 outLab[1] = 500 * (x - y); 838 outLab[2] = 200 * (y - z); 839 } 840 841 /** 842 * Converts a color from CIE Lab to CIE XYZ representation. 843 * 844 * <p>The resulting XYZ representation will use the D65 illuminant and the CIE 845 * 2° Standard Observer (1931).</p> 846 * 847 * <ul> 848 * <li>outXyz[0] is X [0 ...95.047)</li> 849 * <li>outXyz[1] is Y [0...100)</li> 850 * <li>outXyz[2] is Z [0...108.883)</li> 851 * </ul> 852 * 853 * @param l L component value [0...100) 854 * @param a A component value [-128...127) 855 * @param b B component value [-128...127) 856 * @param outXyz 3-element array which holds the resulting XYZ components 857 */ 858 public static void LABToXYZ(@FloatRange(from = 0f, to = 100) final double l, 859 @FloatRange(from = -128, to = 127) final double a, 860 @FloatRange(from = -128, to = 127) final double b, 861 @NonNull double[] outXyz) { 862 final double fy = (l + 16) / 116; 863 final double fx = a / 500 + fy; 864 final double fz = fy - b / 200; 865 866 double tmp = Math.pow(fx, 3); 867 final double xr = tmp > XYZ_EPSILON ? tmp : (116 * fx - 16) / XYZ_KAPPA; 868 final double yr = l > XYZ_KAPPA * XYZ_EPSILON ? Math.pow(fy, 3) : l / XYZ_KAPPA; 869 870 tmp = Math.pow(fz, 3); 871 final double zr = tmp > XYZ_EPSILON ? tmp : (116 * fz - 16) / XYZ_KAPPA; 872 873 outXyz[0] = xr * XYZ_WHITE_REFERENCE_X; 874 outXyz[1] = yr * XYZ_WHITE_REFERENCE_Y; 875 outXyz[2] = zr * XYZ_WHITE_REFERENCE_Z; 876 } 877 878 /** 879 * Converts a color from CIE XYZ to its RGB representation. 880 * 881 * <p>This method expects the XYZ representation to use the D65 illuminant and the CIE 882 * 2° Standard Observer (1931).</p> 883 * 884 * @param x X component value [0...95.047) 885 * @param y Y component value [0...100) 886 * @param z Z component value [0...108.883) 887 * @return int containing the RGB representation 888 */ 889 @ColorInt XYZToColor(@loatRangefrom = 0f, to = XYZ_WHITE_REFERENCE_X) double x, @FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_Y) double y, @FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_Z) double z)890 public static int XYZToColor(@FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_X) double x, 891 @FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_Y) double y, 892 @FloatRange(from = 0f, to = XYZ_WHITE_REFERENCE_Z) double z) { 893 double r = (x * 3.2406 + y * -1.5372 + z * -0.4986) / 100; 894 double g = (x * -0.9689 + y * 1.8758 + z * 0.0415) / 100; 895 double b = (x * 0.0557 + y * -0.2040 + z * 1.0570) / 100; 896 897 r = r > 0.0031308 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : 12.92 * r; 898 g = g > 0.0031308 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : 12.92 * g; 899 b = b > 0.0031308 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : 12.92 * b; 900 901 return Color.rgb( 902 constrain((int) Math.round(r * 255), 0, 255), 903 constrain((int) Math.round(g * 255), 0, 255), 904 constrain((int) Math.round(b * 255), 0, 255)); 905 } 906 907 /** 908 * Converts a color from CIE Lab to its RGB representation. 909 * 910 * @param l L component value [0...100] 911 * @param a A component value [-128...127] 912 * @param b B component value [-128...127] 913 * @return int containing the RGB representation 914 */ 915 @ColorInt LABToColor(@loatRangefrom = 0f, to = 100) final double l, @FloatRange(from = -128, to = 127) final double a, @FloatRange(from = -128, to = 127) final double b)916 public static int LABToColor(@FloatRange(from = 0f, to = 100) final double l, 917 @FloatRange(from = -128, to = 127) final double a, 918 @FloatRange(from = -128, to = 127) final double b) { 919 final double[] result = getTempDouble3Array(); 920 LABToXYZ(l, a, b, result); 921 return XYZToColor(result[0], result[1], result[2]); 922 } 923 constrain(int amount, int low, int high)924 private static int constrain(int amount, int low, int high) { 925 return amount < low ? low : (amount > high ? high : amount); 926 } 927 constrain(float amount, float low, float high)928 private static float constrain(float amount, float low, float high) { 929 return amount < low ? low : (amount > high ? high : amount); 930 } 931 pivotXyzComponent(double component)932 private static double pivotXyzComponent(double component) { 933 return component > XYZ_EPSILON 934 ? Math.pow(component, 1 / 3.0) 935 : (XYZ_KAPPA * component + 16) / 116; 936 } 937 getTempDouble3Array()938 public static double[] getTempDouble3Array() { 939 double[] result = TEMP_ARRAY.get(); 940 if (result == null) { 941 result = new double[3]; 942 TEMP_ARRAY.set(result); 943 } 944 return result; 945 } 946 947 /** 948 * Convert HSL (hue-saturation-lightness) components to a RGB color. 949 * <ul> 950 * <li>hsl[0] is Hue [0 .. 360)</li> 951 * <li>hsl[1] is Saturation [0...1]</li> 952 * <li>hsl[2] is Lightness [0...1]</li> 953 * </ul> 954 * If hsv values are out of range, they are pinned. 955 * 956 * @param hsl 3-element array which holds the input HSL components 957 * @return the resulting RGB color 958 */ 959 @ColorInt HSLToColor(@onNull float[] hsl)960 public static int HSLToColor(@NonNull float[] hsl) { 961 final float h = hsl[0]; 962 final float s = hsl[1]; 963 final float l = hsl[2]; 964 965 final float c = (1f - Math.abs(2 * l - 1f)) * s; 966 final float m = l - 0.5f * c; 967 final float x = c * (1f - Math.abs((h / 60f % 2f) - 1f)); 968 969 final int hueSegment = (int) h / 60; 970 971 int r = 0, g = 0, b = 0; 972 973 switch (hueSegment) { 974 case 0: 975 r = Math.round(255 * (c + m)); 976 g = Math.round(255 * (x + m)); 977 b = Math.round(255 * m); 978 break; 979 case 1: 980 r = Math.round(255 * (x + m)); 981 g = Math.round(255 * (c + m)); 982 b = Math.round(255 * m); 983 break; 984 case 2: 985 r = Math.round(255 * m); 986 g = Math.round(255 * (c + m)); 987 b = Math.round(255 * (x + m)); 988 break; 989 case 3: 990 r = Math.round(255 * m); 991 g = Math.round(255 * (x + m)); 992 b = Math.round(255 * (c + m)); 993 break; 994 case 4: 995 r = Math.round(255 * (x + m)); 996 g = Math.round(255 * m); 997 b = Math.round(255 * (c + m)); 998 break; 999 case 5: 1000 case 6: 1001 r = Math.round(255 * (c + m)); 1002 g = Math.round(255 * m); 1003 b = Math.round(255 * (x + m)); 1004 break; 1005 } 1006 1007 r = constrain(r, 0, 255); 1008 g = constrain(g, 0, 255); 1009 b = constrain(b, 0, 255); 1010 1011 return Color.rgb(r, g, b); 1012 } 1013 1014 /** 1015 * Convert the ARGB color to its HSL (hue-saturation-lightness) components. 1016 * <ul> 1017 * <li>outHsl[0] is Hue [0 .. 360)</li> 1018 * <li>outHsl[1] is Saturation [0...1]</li> 1019 * <li>outHsl[2] is Lightness [0...1]</li> 1020 * </ul> 1021 * 1022 * @param color the ARGB color to convert. The alpha component is ignored 1023 * @param outHsl 3-element array which holds the resulting HSL components 1024 */ colorToHSL(@olorInt int color, @NonNull float[] outHsl)1025 public static void colorToHSL(@ColorInt int color, @NonNull float[] outHsl) { 1026 RGBToHSL(Color.red(color), Color.green(color), Color.blue(color), outHsl); 1027 } 1028 1029 /** 1030 * Convert RGB components to HSL (hue-saturation-lightness). 1031 * <ul> 1032 * <li>outHsl[0] is Hue [0 .. 360)</li> 1033 * <li>outHsl[1] is Saturation [0...1]</li> 1034 * <li>outHsl[2] is Lightness [0...1]</li> 1035 * </ul> 1036 * 1037 * @param r red component value [0..255] 1038 * @param g green component value [0..255] 1039 * @param b blue component value [0..255] 1040 * @param outHsl 3-element array which holds the resulting HSL components 1041 */ RGBToHSL(@ntRangefrom = 0x0, to = 0xFF) int r, @IntRange(from = 0x0, to = 0xFF) int g, @IntRange(from = 0x0, to = 0xFF) int b, @NonNull float[] outHsl)1042 public static void RGBToHSL(@IntRange(from = 0x0, to = 0xFF) int r, 1043 @IntRange(from = 0x0, to = 0xFF) int g, @IntRange(from = 0x0, to = 0xFF) int b, 1044 @NonNull float[] outHsl) { 1045 final float rf = r / 255f; 1046 final float gf = g / 255f; 1047 final float bf = b / 255f; 1048 1049 final float max = Math.max(rf, Math.max(gf, bf)); 1050 final float min = Math.min(rf, Math.min(gf, bf)); 1051 final float deltaMaxMin = max - min; 1052 1053 float h, s; 1054 float l = (max + min) / 2f; 1055 1056 if (max == min) { 1057 // Monochromatic 1058 h = s = 0f; 1059 } else { 1060 if (max == rf) { 1061 h = ((gf - bf) / deltaMaxMin) % 6f; 1062 } else if (max == gf) { 1063 h = ((bf - rf) / deltaMaxMin) + 2f; 1064 } else { 1065 h = ((rf - gf) / deltaMaxMin) + 4f; 1066 } 1067 1068 s = deltaMaxMin / (1f - Math.abs(2f * l - 1f)); 1069 } 1070 1071 h = (h * 60f) % 360f; 1072 if (h < 0) { 1073 h += 360f; 1074 } 1075 1076 outHsl[0] = constrain(h, 0f, 360f); 1077 outHsl[1] = constrain(s, 0f, 1f); 1078 outHsl[2] = constrain(l, 0f, 1f); 1079 } 1080 1081 } 1082 } 1083