Java Examples for android.graphics.ColorMatrixColorFilter

public static ColorFilter getColorFilter(int color) {
    ColorMatrixColorFilter colorFilter;
    int red = (color & 0xFF0000) / 0xFFFF;
    int green = (color & 0xFF00) / 0xFF;
    int blue = color & 0xFF;
    float[] matrix = { 0, 0, 0, 0, red, 0, 0, 0, 0, green, 0, 0, 0, 0, blue, 0, 0, 0, 1, 0 };
    colorFilter = new ColorMatrixColorFilter(matrix);
    return colorFilter;
}

public static ColorFilter getColorFilter(int color) {
    ColorMatrixColorFilter colorFilter;
    int red = (color & 0xFF0000) / 0xFFFF;
    int green = (color & 0xFF00) / 0xFF;
    int blue = color & 0xFF;
    float[] matrix = { 0, 0, 0, 0, red, 0, 0, 0, 0, green, 0, 0, 0, 0, blue, 0, 0, 0, 1, 0 };
    colorFilter = new ColorMatrixColorFilter(matrix);
    return colorFilter;
}

public static ColorFilter getColorFilter(int color) {
    ColorMatrixColorFilter colorFilter;
    int red = (color & 0xFF0000) / 0xFFFF;
    int green = (color & 0xFF00) / 0xFF;
    int blue = color & 0xFF;
    float[] matrix = { 0, 0, 0, 0, red, 0, 0, 0, 0, green, 0, 0, 0, 0, blue, 0, 0, 0, 1, 0 };
    colorFilter = new ColorMatrixColorFilter(matrix);
    return colorFilter;
}

@Override
public void addOverlays() {
    //p.s. there's a ton of examples here
    //http://stackoverflow.com/questions/4354939/understanding-the-use-of-colormatrix-and-colormatrixcolorfilter-to-modify-a-draw
    //http://developer.android.com/reference/android/graphics/ColorMatrix.html
    //this will make things look pinkish
    //this.mMapView.getOverlayManager().getTilesOverlay().setColorFilter(adjustHue(160));
    ColorMatrix cm = new ColorMatrix();
    // reduce color's by 50%. i.e. just make it darker
    float brightness = .5f;
    cm.set(new float[] { //red
    brightness, //red
    0, //red
    0, //red
    0, //red
    0, //green
    0, //green
    brightness, //green
    0, //green
    0, //green
    0, //blue
    0, //blue
    0, //blue
    brightness, //blue
    0, //blue
    0, 0, 0, 0, 1, //alpha
    0 });
    this.mMapView.getOverlayManager().getTilesOverlay().setColorFilter(new ColorMatrixColorFilter(cm));
//pro tip, set the color filter to null to reset to normal viewing
}

public static Bitmap greyScale(Bitmap source) {
    int width = source.getWidth();
    int height = source.getHeight();
    Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    ColorMatrix saturation = new ColorMatrix();
    saturation.setSaturation(0f);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(saturation));
    canvas.drawBitmap(source, 0, 0, paint);
    source.recycle();
    if (source != bitmap) {
        source.recycle();
    }
    return bitmap;
}

@Override
public boolean onTouch(View v, MotionEvent event) {
    if (event.getAction() == MotionEvent.ACTION_DOWN) {
        ((ImageView) v).getDrawable().setColorFilter(new ColorMatrixColorFilter(BUTTON_PRESSED));
        ((ImageView) v).setImageDrawable((((ImageView) v).getDrawable()));
    } else if (event.getAction() == MotionEvent.ACTION_UP) {
        ((ImageView) v).getDrawable().setColorFilter(new ColorMatrixColorFilter(BUTTON_RELEASED));
        ((ImageView) v).setImageDrawable((((ImageView) v).getDrawable()));
    }
    return false;
}

public Bitmap process(Bitmap bitmap) {
    Log.i("Image Processing Command", ID + " : " + brightness);
    float b = valueToMatrix(brightness);
    ColorMatrix cm = new ColorMatrix();
    cm.set(new float[] { 1, 0, 0, 0, b, 0, 1, 0, 0, b, 0, 0, 1, 0, b, 0, 0, 0, 1, 0 });
    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    paint.setColorFilter(new ColorMatrixColorFilter(cm));
    Bitmap result = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), bitmap.getConfig());
    Canvas canvas = new Canvas(result);
    canvas.drawBitmap(bitmap, new Matrix(), paint);
    return result;
}

private void setup(int duration) {
    //region saturation
    animationSaturation = ValueAnimator.ofFloat(0.2f, 1f);
    animationSaturation.setDuration(duration);
    animationSaturation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            saturation = animation.getAnimatedFraction();
        }
    });
    //endregion
    //region contrast
    animationContrast = ValueAnimator.ofFloat(0, 1f);
    animationContrast.setDuration(duration * 3 / 4);
    animationContrast.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            ColorMatrix colorMatrix = setContrast(animation.getAnimatedFraction());
            colorMatrix.setSaturation(saturation);
            ColorMatrixColorFilter colorFilter = new ColorMatrixColorFilter(colorMatrix);
            drawable.setColorFilter(colorFilter);
        }
    });
    //endregion
    //region alpha
    animationAlpha = ObjectAnimator.ofFloat(imageView, "alpha", 0f, 1f);
    animationAlpha.setDuration(duration / 2);
//endregion
}

protected Bitmap process(Bitmap original, ColorMatrix colorMatrix) {
    Bitmap bitmap = Bitmap.createBitmap(original.getWidth(), original.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
    canvas.drawBitmap(original, 0, 0, paint);
    return bitmap;
}

@Override
public boolean onTouch(View v, MotionEvent event) {
    if (event.getAction() == MotionEvent.ACTION_DOWN) {
        ImageView iv = (ImageView) v;
        iv.setColorFilter(new ColorMatrixColorFilter(BT_SELECTED_DARK));
    } else if (event.getAction() == MotionEvent.ACTION_UP) {
        ImageView iv = (ImageView) v;
        iv.clearColorFilter();
        mPerformClick();
    } else if (event.getAction() == MotionEvent.ACTION_CANCEL) {
        ImageView iv = (ImageView) v;
        iv.clearColorFilter();
    }
    // 如为false，执行ACTION_DOWN���往下执行
    return true;
}

@Override
public void onFocusChange(View v, boolean hasFocus) {
    if (hasFocus) {
        v.getBackground().setColorFilter(new ColorMatrixColorFilter(BT_SELECTED));
        v.setBackgroundDrawable(v.getBackground());
    } else {
        v.getBackground().setColorFilter(new ColorMatrixColorFilter(BT_NOT_SELECTED));
        v.setBackgroundDrawable(v.getBackground());
    }
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    switch(event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            if (getDrawable() != null) {
                if (mPressFilter == null) {
                    mPressFilter = new ColorMatrixColorFilter(BT_SELECTED);
                }
                getDrawable().setColorFilter(mPressFilter);
            }
            break;
        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP:
            if (getDrawable() != null) {
                if (mNormalFilter == null) {
                    mNormalFilter = new ColorMatrixColorFilter(BT_NOT_SELECTED);
                }
                getDrawable().setColorFilter(mNormalFilter);
            }
            break;
        default:
            break;
    }
    return super.onTouchEvent(event);
}

@Override
public Bitmap transform(Bitmap source) {
    int size = Math.min(source.getWidth(), source.getHeight());
    int x = (source.getWidth() - size) / 2;
    int y = (source.getHeight() - size) / 2;
    Bitmap squaredBitmap = Bitmap.createBitmap(source, x, y, size, size);
    if (squaredBitmap != source) {
        source.recycle();
    }
    Bitmap bitmap = Bitmap.createBitmap(size, size, source.getConfig());
    ColorMatrix colorMatrix = new ColorMatrix();
    colorMatrix.setSaturation(0);
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(colorMatrix);
    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint();
    paint.setColorFilter(filter);
    BitmapShader shader = new BitmapShader(squaredBitmap, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
    paint.setShader(shader);
    paint.setAntiAlias(true);
    float r = size / 2f;
    canvas.drawCircle(r, r, r, paint);
    squaredBitmap.recycle();
    return bitmap;
}

@Override
public void process(Bitmap dest, Bitmap source) {
    super.process(dest, source);
    Canvas canvas = new Canvas(dest);
    ColorMatrix saturation = new ColorMatrix();
    saturation.setSaturation(0f);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(saturation));
    canvas.drawBitmap(source, 0, 0, paint);
}

private static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

@Override
public View getView(int position, View convertView, ViewGroup parent) {
    PermissonItem item = mData.get(position);
    View view = View.inflate(parent.getContext(), R.layout.permission_info_item, null);
    int blue = Color.blue(mFilterColor);
    int green = Color.green(mFilterColor);
    int red = Color.red(mFilterColor);
    ImageView icon = (ImageView) view.findViewById(R.id.icon);
    float[] cm = new float[] { // 红色值
    1, // 红色值
    0, // 红色值
    0, // 红色值
    0, // 红色值
    red, // 绿色值
    0, // 绿色值
    1, // 绿色值
    0, // 绿色值
    0, // 绿色值
    green, // �色值
    0, // �色值
    0, // �色值
    1, // �色值
    0, // �色值
    blue, // �明度
    0, // �明度
    0, // �明度
    0, // �明度
    1, // �明度
    1 };
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(cm);
    icon.setColorFilter(filter);
    TextView name = (TextView) view.findViewById(R.id.name);
    if (mTextColor != 0)
        name.setTextColor(mTextColor);
    icon.setImageResource(item.PermissionIconRes);
    name.setText(item.PermissionName);
    return view;
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    if (mDisplayOptions.isShowPressEffect()) {
        switch(event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                if (getDrawable() != null) {
                    if (mPressFilter == null) {
                        mPressFilter = new ColorMatrixColorFilter(BT_SELECTED);
                    }
                    getDrawable().setColorFilter(mPressFilter);
                }
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                if (getDrawable() != null) {
                    if (mNormalFilter == null) {
                        mNormalFilter = new ColorMatrixColorFilter(BT_NOT_SELECTED);
                    }
                    getDrawable().setColorFilter(mNormalFilter);
                }
                break;
            default:
                break;
        }
    }
    return super.onTouchEvent(event);
}

/*public static Bitmap bitmapThresholding(Bitmap originalBmp, int threshold) {
		Bitmap bmp = toGrayscale(originalBmp);
		Bitmap out = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(), Bitmap.Config.RGB_565);
		
		for (int x = 0; x < bmp.getWidth(); x++) {
			for (int y = 0; y < bmp.getWidth(); y++) {
				int color = Color.red(bmp.getPixel(x, y));
				
				if (color < threshold) {
					out.setPixel(x, y, Color.rgb(0, 0, 0));
				} else {
					out.setPixel(x, y, Color.rgb(255, 255, 255));
				}
			}
		}
		
		return out;
		
	}
	
	public static int calculateThresholdValue(Bitmap originalBmp) {
		Bitmap bmp = toGrayscale(originalBmp);
		
		int T = 128;
		int Ts = 127;
		
		while (T != Ts) {
			
			T = Ts;
			
			int T1 = 0;
			int T2 = 0;
			
			int G1 = 0;
			int G2 = 0;
			int G1_count = 0;
			int G2_count = 0;
		
			for (int x = 0; x < bmp.getWidth(); x++) {
				for (int y = 0; y < bmp.getWidth(); y++) {
					int color = Color.red(bmp.getPixel(x, y));
					
					if (color < T) {
						G1 += color;
						G1_count++;
					} else {
						G2 += color;
						G2_count++;
					}
				}
			}
			
			T1 = G1 / G1_count;
			T2 = G2 / G2_count;
		
			Ts = (T1 + T2) / 2;
		}
		
		return T;
	}*/
public static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

@Override
public Bitmap transform(Bitmap source) {
    int width = source.getWidth();
    int height = source.getHeight();
    Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    ColorMatrix saturation = new ColorMatrix();
    saturation.setSaturation(0f);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(saturation));
    canvas.drawBitmap(source, 0, 0, paint);
    source.recycle();
    return bitmap;
}

public Bitmap process(Bitmap bmp, int flag) {
    Bitmap bitmap = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    if (mAllMatrix == null) {
        mAllMatrix = new ColorMatrix();
    }
    if (mSaturationMatrix == null) {
        mSaturationMatrix = new ColorMatrix();
    }
    if (mHueMatrix == null) {
        mHueMatrix = new ColorMatrix();
    }
    if (mLumMatrix == null) {
        mLumMatrix = new ColorMatrix();
    }
    if (flag == 0) {
        mSaturationMatrix.reset();
        mSaturationMatrix.setSaturation(mSaturationValue);
    } else if (flag == 1) {
        mHueMatrix.reset();
        mHueMatrix.setRotate(0, mHueValue);
        mHueMatrix.setRotate(1, mHueValue);
        mHueMatrix.setRotate(2, mHueValue);
    } else if (flag == 2) {
        mLumMatrix.reset();
        mLumMatrix.setScale(mLumValue, mLumValue, mLumValue, 1);
    }
    mAllMatrix.reset();
    mAllMatrix.postConcat(mHueMatrix);
    mAllMatrix.postConcat(mSaturationMatrix);
    mAllMatrix.postConcat(mLumMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(mAllMatrix));
    canvas.drawBitmap(bmp, 0, 0, paint);
    return bitmap;
}

private ColorFilter getOverridingColorFilter(int color) {
    if (mColourFilter == null) {
        int red = (color & 0xFF0000) / 0xFFFF;
        int green = (color & 0xFF00) / 0xFF;
        int blue = color & 0xFF;
        float[] matrix = { 0, 0, 0, 0, red, 0, 0, 0, 0, green, 0, 0, 0, 0, blue, 0, 0, 0, 1, 0 };
        mColourFilter = new ColorMatrixColorFilter(matrix);
    }
    return mColourFilter;
}

private void initAvatarBackground() {
    Drawable drawable = getResources().getDrawable(R.drawable.rocko);
    Bitmap srcBitmap = BitmapUtils.drawable2Bitmap(drawable);
    /*先黑白图片*/
    float[] src = new float[] { 0.28F, 0.60F, 0.40F, 0, 0, 0.28F, 0.60F, 0.40F, 0, 0, 0.28F, 0.60F, 0.40F, 0, 0, 0, 0, 0, 1, 0 };
    ColorMatrix cm = new ColorMatrix(src);
    //        cm.setSaturation(0.0f);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    Bitmap resultBitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(resultBitmap);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setAlpha(100);
    paint.setColorFilter(f);
    canvas.drawBitmap(srcBitmap, 0, 0, paint);
    /*�模糊图片*/
    Bitmap bB = BitmapUtils.blurBitmap(getApplicationContext(), resultBitmap, 15.5f);
    bg.setBackgroundDrawable(new BitmapDrawable(getResources(), bB));
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    switch(event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            if (getDrawable() != null) {
                if (mPressFilter == null) {
                    mPressFilter = new ColorMatrixColorFilter(BT_SELECTED);
                }
                getDrawable().setColorFilter(mPressFilter);
            }
            break;
        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP:
            if (getDrawable() != null) {
                if (mNormalFilter == null) {
                    mNormalFilter = new ColorMatrixColorFilter(BT_NOT_SELECTED);
                }
                getDrawable().setColorFilter(mNormalFilter);
            }
            break;
        default:
            break;
    }
    return super.onTouchEvent(event);
}

@Override
protected Bitmap transform(BitmapPool pool, Bitmap toTransform, int outWidth, int outHeight) {
    Bitmap result = createBitmap(toTransform.getWidth(), toTransform.getHeight(), toTransform.getConfig());
    Bitmap noise = BitmapFactory.decodeResource(context.getResources(), R.drawable.noise);
    BitmapShader shader = new BitmapShader(noise, REPEAT, REPEAT);
    ColorMatrix colorMatrix = new ColorMatrix();
    colorMatrix.setSaturation(0);
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(colorMatrix);
    Paint paint = new Paint(ANTI_ALIAS_FLAG);
    paint.setColorFilter(filter);
    Canvas canvas = new Canvas(result);
    canvas.drawBitmap(toTransform, 0, 0, paint);
    paint.setColorFilter(null);
    paint.setShader(shader);
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));
    canvas.drawRect(0, 0, canvas.getWidth(), canvas.getHeight(), paint);
    toTransform.recycle();
    noise.recycle();
    return result;
}

public static Bitmap handleImageEffect(Bitmap bm, float hue, float saturation, float lum) {
    Bitmap bmp = Bitmap.createBitmap(bm.getWidth(), bm.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bmp);
    Paint paint = new Paint();
    ColorMatrix hueMatrix = new ColorMatrix();
    hueMatrix.setRotate(0, hue);
    hueMatrix.setRotate(1, hue);
    hueMatrix.setRotate(2, hue);
    ColorMatrix saturationMatrix = new ColorMatrix();
    saturationMatrix.setSaturation(saturation);
    ColorMatrix lumMatrix = new ColorMatrix();
    lumMatrix.setScale(lum, lum, lum, 1);
    ColorMatrix imageMatrix = new ColorMatrix();
    imageMatrix.postConcat(hueMatrix);
    imageMatrix.postConcat(saturationMatrix);
    imageMatrix.postConcat(lumMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(imageMatrix));
    canvas.drawBitmap(bm, 0, 0, paint);
    return bmp;
}

private Bitmap getGrayscaleBitmap(Bitmap color) {
    ColorMatrix colorMatrix = new ColorMatrix();
    colorMatrix.setSaturation(0);
    ColorMatrixColorFilter colorMatrixFilter = new ColorMatrixColorFilter(colorMatrix);
    Bitmap grayscale = color.copy(Bitmap.Config.ARGB_8888, true);
    Paint paint = new Paint();
    paint.setColorFilter(colorMatrixFilter);
    Canvas canvas = new Canvas(grayscale);
    canvas.drawBitmap(grayscale, 0, 0, paint);
    return grayscale;
}

@Override
public Resource<Bitmap> transform(Resource<Bitmap> resource, int outWidth, int outHeight) {
    Bitmap source = resource.get();
    int width = source.getWidth();
    int height = source.getHeight();
    Bitmap.Config config = source.getConfig() != null ? source.getConfig() : Bitmap.Config.ARGB_8888;
    Bitmap bitmap = mBitmapPool.get(width, height, config);
    if (bitmap == null) {
        bitmap = Bitmap.createBitmap(width, height, config);
    }
    Canvas canvas = new Canvas(bitmap);
    ColorMatrix saturation = new ColorMatrix();
    saturation.setSaturation(0f);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(saturation));
    canvas.drawBitmap(source, 0, 0, paint);
    return BitmapResource.obtain(bitmap, mBitmapPool);
}

public View getView(int position, View convertView, ViewGroup parent) {
    final Typeface robotoMedium = Typeface.createFromAsset(parentContext.getAssets(), "fonts/Roboto-Medium.ttf");
    // First let's verify the convertView is not null
    if (convertView == null) {
        // This a new view we inflate the new layout
        LayoutInflater inflater = (LayoutInflater) parentContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        switch(position % 5) {
            case 0:
                convertView = inflater.inflate(R.layout.navigation_drawer_user_card, parent, false);
                break;
            case 1:
                convertView = inflater.inflate(R.layout.navigation_drawer_section_1, parent, false);
                break;
            case 2:
                convertView = inflater.inflate(R.layout.navigation_drawer_section_2, parent, false);
                break;
            case 3:
                convertView = inflater.inflate(R.layout.navigation_drawer_section_3, parent, false);
                break;
            case 4:
                convertView = inflater.inflate(R.layout.navigation_drawer_section_4, parent, false);
                break;
        }
        if (position == 0) {
            CircleImageView pictureFrame = (CircleImageView) convertView.findViewById(R.id.user_avatar);
            LinearLayout linearLayout = (LinearLayout) convertView.findViewById(R.id.user_card_layout);
            //replace this with user avatar bitmap
            Bitmap profile = BitmapFactory.decodeResource(parentContext.getResources(), R.drawable.kanshu);
            pictureFrame.setImageBitmap(profile);
            Bitmap filteredBitmap = Bitmap.createBitmap(profile.getWidth(), profile.getHeight(), Bitmap.Config.RGB_565);
            Canvas c = new Canvas(filteredBitmap);
            Paint red = new Paint();
            red.setColor(parentContext.getResources().getColor(R.color.primary_dark_red));
            c.drawRect(0, 0, profile.getWidth(), profile.getHeight(), red);
            Paint paint = new Paint();
            float[] mat = new float[] { 0.5f, 0.5f, 0.5f, 0, 0, 0.5f, 0.5f, 0.5f, 0, 0, 0.5f, 0.5f, 0.5f, 0, 0, 0, 0, 0, 0.2f, 0 };
            ColorMatrixColorFilter filter = new ColorMatrixColorFilter(mat);
            paint.setColorFilter(filter);
            c.drawBitmap(profile, 0, 0, paint);
            ImageView backgroundFrame = (ImageView) convertView.findViewById(R.id.background);
            backgroundFrame.setImageBitmap(filteredBitmap);
            //other user info
            User userData = ((NavigationDrawerFragment.NavigationDrawerData) parentContext).getCurrentUser();
            TextView username = (TextView) convertView.findViewById(R.id.user_name);
            username.setText(userData.getUserName());
            TextView userlevel = (TextView) convertView.findViewById(R.id.user_level);
            userlevel.setText(userData.getUserLevel());
            userlevel.setTypeface(robotoMedium);
            username.setTypeface(robotoMedium);
        } else {
            LinearLayout linearLayout = (LinearLayout) convertView;
            for (int i = 0; i < linearLayout.getChildCount(); i++) {
                if (linearLayout.getChildAt(i) instanceof TextView)
                    ((TextView) linearLayout.getChildAt(i)).setTypeface(robotoMedium);
            }
        }
    }
    return convertView;
}

public void setColorMatrix(View view, float[] colorMatrix) {
    if (colorMatrix != null) {
        ColorMatrix matrix = new ColorMatrix(colorMatrix);
        ColorMatrixColorFilter filter = new ColorMatrixColorFilter(matrix);
        bd.setColorFilter(filter);
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            //ugly hack
            colorDrawable = new ColorDrawable(ColorUtil.transformColor(Color.WHITE, matrix));
        }
        colorDrawable.setColorFilter(filter);
        borderPaint.setColorFilter(filter);
    } else {
        bd.setColorFilter(null);
        colorDrawable.setColorFilter(null);
        borderPaint.setColorFilter(null);
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            //ugly hack
            colorDrawable = new ColorDrawable(Color.WHITE);
        }
    }
    renderOffPage(view, renderOffPage);
}

public Bitmap handleImage(int type) {
    Bitmap bmp = Bitmap.createBitmap(mBitmap.getWidth(), mBitmap.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bmp);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    if (mAllMatrix == null) {
        mAllMatrix = new ColorMatrix();
    }
    /* 饱和度矩阵 */
    if (saturationMatrix == null) {
        saturationMatrix = new ColorMatrix();
    }
    /* 对比度矩阵 */
    if (contrastMatrix == null) {
        contrastMatrix = new ColorMatrix();
    }
    /* 亮度矩阵 */
    if (brightnessMatrix == null) {
        brightnessMatrix = new ColorMatrix();
    }
    switch(type) {
        case Enhance_Saturation:
            saturationMatrix.reset();
            saturationMatrix.setSaturation(saturationNum);
            break;
        case Enhance_Brightness:
            brightnessMatrix.reset();
            brightnessMatrix.set(new float[] { 1, 0, 0, 0, brightNum, 0, 1, 0, 0, brightNum, 0, 0, 1, 0, brightNum, 0, 0, 0, 1, 0 });
            break;
        case Enhance_Contrast:
            /* 在亮度ä¸?å?˜çš„情况下，æ??高对比度必定è¦?é™?低亮度 */
            float regulateBright = 0;
            regulateBright = (1 - contrastNum) * 128;
            contrastMatrix.reset();
            contrastMatrix.set(new float[] { contrastNum, 0, 0, 0, regulateBright, 0, contrastNum, 0, 0, regulateBright, 0, 0, contrastNum, 0, regulateBright, 0, 0, 0, 1, 0 });
            break;
        default:
            break;
    }
    mAllMatrix.reset();
    mAllMatrix.postConcat(saturationMatrix);
    mAllMatrix.postConcat(brightnessMatrix);
    mAllMatrix.postConcat(contrastMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(mAllMatrix));
    canvas.drawBitmap(mBitmap, 0, 0, paint);
    return bmp;
}

@Override
public Bitmap transform(Bitmap source) {
    Bitmap result = createBitmap(source.getWidth(), source.getHeight(), source.getConfig());
    Bitmap noise;
    try {
        noise = picasso.load(R.drawable.noise).get();
    } catch (IOException e) {
        throw new RuntimeException("Failed to apply transformation! Missing resource.");
    }
    BitmapShader shader = new BitmapShader(noise, REPEAT, REPEAT);
    ColorMatrix colorMatrix = new ColorMatrix();
    colorMatrix.setSaturation(0);
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(colorMatrix);
    Paint paint = new Paint(ANTI_ALIAS_FLAG);
    paint.setColorFilter(filter);
    Canvas canvas = new Canvas(result);
    canvas.drawBitmap(source, 0, 0, paint);
    paint.setColorFilter(null);
    paint.setShader(shader);
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));
    canvas.drawRect(0, 0, canvas.getWidth(), canvas.getHeight(), paint);
    source.recycle();
    noise.recycle();
    return result;
}

public Bitmap handleImage(int type) {
    Bitmap bmp = Bitmap.createBitmap(mBitmap.getWidth(), mBitmap.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bmp);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    if (mAllMatrix == null) {
        mAllMatrix = new ColorMatrix();
    }
    /* 饱和度矩阵 */
    if (saturationMatrix == null) {
        saturationMatrix = new ColorMatrix();
    }
    /* 对比度矩阵 */
    if (contrastMatrix == null) {
        contrastMatrix = new ColorMatrix();
    }
    /* 亮度矩阵 */
    if (brightnessMatrix == null) {
        brightnessMatrix = new ColorMatrix();
    }
    switch(type) {
        case Enhance_Saturation:
            saturationMatrix.reset();
            saturationMatrix.setSaturation(saturationNum);
            break;
        case Enhance_Brightness:
            brightnessMatrix.reset();
            brightnessMatrix.set(new float[] { 1, 0, 0, 0, brightNum, 0, 1, 0, 0, brightNum, 0, 0, 1, 0, brightNum, 0, 0, 0, 1, 0 });
            break;
        case Enhance_Contrast:
            /* 在亮度ä¸?å?˜çš„情况下，æ??高对比度必定è¦?é™?低亮度 */
            float regulateBright = 0;
            regulateBright = (1 - contrastNum) * 128;
            contrastMatrix.reset();
            contrastMatrix.set(new float[] { contrastNum, 0, 0, 0, regulateBright, 0, contrastNum, 0, 0, regulateBright, 0, 0, contrastNum, 0, regulateBright, 0, 0, 0, 1, 0 });
            break;
        default:
            break;
    }
    mAllMatrix.reset();
    mAllMatrix.postConcat(saturationMatrix);
    mAllMatrix.postConcat(brightnessMatrix);
    mAllMatrix.postConcat(contrastMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(mAllMatrix));
    canvas.drawBitmap(mBitmap, 0, 0, paint);
    return bmp;
}

private Drawable getColouredDrawable(Drawable _drawable, boolean _isSelected) {
    int iColor = _isSelected ? mContext.getResources().getColor(R.color.primary) : mContext.getResources().getColor(R.color.text_secondary);
    int red = (iColor & 0xFF0000) / 0xFFFF;
    int green = (iColor & 0xFF00) / 0xFF;
    int blue = iColor & 0xFF;
    float[] matrix = { 0, 0, 0, 0, red, 0, 0, 0, 0, green, 0, 0, 0, 0, blue, 0, 0, 0, 1, 0 };
    ColorFilter colorFilter = new ColorMatrixColorFilter(matrix);
    _drawable.setColorFilter(new PorterDuffColorFilter(iColor, PorterDuff.Mode.SRC_IN));
    return _drawable;
}

private Drawable getColouredDrawable(Drawable _drawable, boolean _isSelected) {
    int iColor = _isSelected ? mContext.getResources().getColor(R.color.primary) : mContext.getResources().getColor(R.color.text_secondary);
    int red = (iColor & 0xFF0000) / 0xFFFF;
    int green = (iColor & 0xFF00) / 0xFF;
    int blue = iColor & 0xFF;
    float[] matrix = { 0, 0, 0, 0, red, 0, 0, 0, 0, green, 0, 0, 0, 0, blue, 0, 0, 0, 1, 0 };
    ColorFilter colorFilter = new ColorMatrixColorFilter(matrix);
    _drawable.setColorFilter(new PorterDuffColorFilter(iColor, PorterDuff.Mode.SRC_IN));
    return _drawable;
}

@Override
public Resource<Bitmap> transform(Resource<Bitmap> resource, int outWidth, int outHeight) {
    Bitmap source = resource.get();
    int width = source.getWidth();
    int height = source.getHeight();
    Bitmap.Config config = source.getConfig() != null ? source.getConfig() : Bitmap.Config.ARGB_8888;
    Bitmap bitmap = mBitmapPool.get(width, height, config);
    if (bitmap == null) {
        bitmap = Bitmap.createBitmap(width, height, config);
    }
    Canvas canvas = new Canvas(bitmap);
    ColorMatrix saturation = new ColorMatrix();
    saturation.setSaturation(0f);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(saturation));
    canvas.drawBitmap(source, 0, 0, paint);
    return BitmapResource.obtain(bitmap, mBitmapPool);
}

private Bitmap drawBitmap(Bitmap original) {
    Bitmap bitmap = Bitmap.createBitmap(original.getWidth(), original.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(getColorMatrix()));
    paint.setMaskFilter(new BlurMaskFilter(200, BlurMaskFilter.Blur.NORMAL));
    canvas.drawBitmap(original, 0, 0, paint);
    return bitmap;
}

private void updateColorFilter(float percent) {
    float dark = 0.4f;
    float scale = (percent * (1 - dark)) + dark;
    matrixScale.setScale(scale, scale, scale, 1f);
    matrixSaturation.setSaturation(percent);
    matrix.setConcat(matrixScale, matrixSaturation);
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(matrix);
    paint.setColorFilter(filter);
}

@Override
public Bitmap transform(Bitmap source) {
    Bitmap result = createBitmap(source.getWidth(), source.getHeight(), source.getConfig());
    BitmapShader shader = new BitmapShader(result, REPEAT, REPEAT);
    ColorMatrix colorMatrix = new ColorMatrix();
    colorMatrix.setSaturation(0);
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(colorMatrix);
    Paint paint = new Paint(ANTI_ALIAS_FLAG);
    paint.setColorFilter(filter);
    Canvas canvas = new Canvas(result);
    canvas.drawBitmap(source, 0, 0, paint);
    paint.setColorFilter(null);
    paint.setShader(shader);
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));
    canvas.drawRect(0, 0, canvas.getWidth(), canvas.getHeight(), paint);
    source.recycle();
    return result;
}

/**
	 * Gets the Android {@link Paint} for colorizing from the given {@link com.xenoage.utils.color.Color}.
	 */
public static Paint createPaintColorize(com.xenoage.utils.color.Color colorInfo) {
    Paint paint = new Paint();
    float r = colorInfo.r / 255f;
    float g = colorInfo.g / 255f;
    float b = colorInfo.b / 255f;
    float a = colorInfo.a / 255f;
    ColorMatrix cm = new ColorMatrix(new float[] { r, 0, 0, 0, 0, 0, g, 0, 0, 0, 0, 0, b, 0, 0, 0, 0, 0, a, 0 });
    paint.setColorFilter(new ColorMatrixColorFilter(cm));
    paint.setAntiAlias(true);
    return paint;
}

public static Bitmap convertToBlackAndWhite(Bitmap sampleBitmap) {
    ColorMatrix bwMatrix = new ColorMatrix();
    bwMatrix.setSaturation(0);
    final ColorMatrixColorFilter colorFilter = new ColorMatrixColorFilter(bwMatrix);
    Bitmap rBitmap = sampleBitmap.copy(Bitmap.Config.ARGB_8888, true);
    Paint paint = new Paint();
    paint.setColorFilter(colorFilter);
    Canvas myCanvas = new Canvas(rBitmap);
    myCanvas.drawBitmap(rBitmap, 0, 0, paint);
    return rBitmap;
}

protected void fadeGrayscale(final ImageView target, final boolean dark, long delay) {
    startIntensityAnimation(new ValueAnimator.AnimatorUpdateListener() {

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            updateGrayscaleMatrix((float) animation.getAnimatedValue());
            target.setColorFilter(new ColorMatrixColorFilter(mGrayscaleColorMatrix));
        }
    }, dark, delay, new AnimatorListenerAdapter() {

        @Override
        public void onAnimationEnd(Animator animation) {
            if (!dark) {
                target.setColorFilter(null);
            }
        }
    });
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.lockscreen_shortcuts);
    getActionBar().setDisplayHomeAsUpEnabled(true);
    mPicker = new ShortcutPickHelper(this, this);
    mShortcutHelper = new LockscreenShortcutsHelper(this, this);
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    mFilter = new ColorMatrixColorFilter(cm);
    ImageView unlockButton = (ImageView) findViewById(R.id.middle_button);
    mDefaultTintList = unlockButton.getImageTintList();
    createActionList();
    initiateViews();
    updateDrawables();
}

public static void setSaturationOnView(View view, boolean greyScale) {
    if (view == null) {
        return;
    }
    Drawable background = getBrickLayout(view).getBackground();
    if (greyScale) {
        ColorMatrix matrix = new ColorMatrix();
        matrix.setSaturation(0);
        ColorMatrixColorFilter filter = new ColorMatrixColorFilter(matrix);
        background.setColorFilter(filter);
    } else {
        background.clearColorFilter();
    }
}

@SuppressWarnings("deprecation")
@Override
public boolean onTouch(View v, MotionEvent event) {
    if (event.getAction() == MotionEvent.ACTION_DOWN) {
        if (v instanceof ImageView) {
            ImageView iv = (ImageView) v;
            iv.setColorFilter(new ColorMatrixColorFilter(BT_SELECTED));
        } else {
            v.getBackground().setColorFilter(new ColorMatrixColorFilter(BT_SELECTED));
            v.setBackgroundDrawable(v.getBackground());
        }
    } else if (event.getAction() == MotionEvent.ACTION_UP) {
        if (v instanceof ImageView) {
            ImageView iv = (ImageView) v;
            iv.setColorFilter(new ColorMatrixColorFilter(BT_NOT_SELECTED));
        } else {
            v.getBackground().setColorFilter(new ColorMatrixColorFilter(BT_NOT_SELECTED));
            v.setBackgroundDrawable(v.getBackground());
        }
    }
    return false;
}

/**
	 *
	 * @param bmp input bitmap
	 * @param contrast 0..10 1 is default
	 * @param brightness -255..255 0 is default
	 * @return new bitmap
	 */
public static Bitmap changeBitmapContrastBrightness(Bitmap bmp, float contrast, float brightness) {
    ColorMatrix cm = new ColorMatrix(new float[] { contrast, 0, 0, 0, brightness, 0, contrast, 0, 0, brightness, 0, 0, contrast, 0, brightness, 0, 0, 0, 1, 0 });
    Bitmap ret = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(), bmp.getConfig());
    Canvas canvas = new Canvas(ret);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(cm));
    canvas.drawBitmap(bmp, 0, 0, paint);
    return ret;
}

@Override
public void onAnimationUpdate(final ValueAnimator animation) {
    final float value = (float) animation.getAnimatedValue();
    // dt = 2, v = [0.0, 1.0]
    final float alpha = Math.min(value, 2f) / 2f;
    // dt = 3, v = [-1.0, 0.0]
    final float contrast = Math.min(value, 3f) / 3f - 1f;
    // dt = 4, v = [-1.0, 0.0]
    final float saturation = value / 4f - 1f;
    ColorUtils.alpha(alpha, contrastMatrix);
    ColorUtils.contrast(contrast, contrastMatrix);
    ColorUtils.saturation(saturation, saturationMatrix);
    resultMatrix.setConcat(contrastMatrix, saturationMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(resultMatrix));
    ViewCompat.postInvalidateOnAnimation(MaterialImageView.this);
}

/**
     * カラーフィルターをセット.
     *
     * @param imageView 対象�ImageView
     * @param red       Red�値
     * @param green     Green�値
     * @param blue      Blue�値
     */
private void setColorFilter(ImageView imageView, float red, float green, float blue) {
    float[] colorMatrix = { //red
    (1.0f - red), //red
    0, //red
    0, //red
    0, //red
    0, //green
    0, //green
    (1.0f - green), //green
    0, //green
    0, //green
    0, //blue
    0, //blue
    0, //blue
    (1.0f - blue), //blue
    0, //blue
    0, //alpha
    0, //alpha
    0, //alpha
    0, //alpha
    1, //alpha
    0 };
    ColorFilter filter = new ColorMatrixColorFilter(colorMatrix);
    imageView.setColorFilter(filter);
}

// Replace the contents of a view (invoked by the layout manager)
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
    final Browser browser = mBrowsers[position];
    holder.mIcon.setImageDrawable(browser.icon);
    holder.mLabel.setText(browser.label);
    if (browser.isKnown) {
        if (browser.isRecommended && browser.isInstalled) {
            holder.mStatus.setImageDrawable(mCtx.getResources().getDrawable(R.drawable.ic_stars_white_24dp));
            holder.mStatus.setVisibility(View.VISIBLE);
        } else if (browser.isSupported && !browser.isInstalled) {
            holder.mStatus.setImageDrawable(mCtx.getResources().getDrawable(R.drawable.ic_shop_white_24dp));
            holder.mStatus.setOnClickListener(new View.OnClickListener() {

                @Override
                public void onClick(View view) {
                    String uriMarket = "market://search?q=pname:" + browser.packageName;
                    Uri uri = Uri.parse(uriMarket);
                    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
                    mCtx.startActivity(intent);
                }
            });
            holder.mStatus.setVisibility(View.VISIBLE);
        } else if (!browser.isSupported) {
            // Make the icon gray-scale to show it is unsupported
            ColorMatrix matrix = new ColorMatrix();
            matrix.setSaturation(0);
            ColorMatrixColorFilter filter = new ColorMatrixColorFilter(matrix);
            holder.mIcon.setColorFilter(filter);
            holder.mLabel.setTextColor(mCtx.getResources().getColor(R.color.primary_text_disabled_material_dark));
        }
    }
    holder.itemView.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View view) {
            mListener.onBrowserSelected(browser);
        }
    });
}

/**
     * 设置图片的色调\饱和度\亮度
     *
     * @param bm
     * @param hue        色调
     * @param saturation 饱和度
     * @param lum        亮度
     * @return
     */
public static Bitmap handleImageEffect(Bitmap bm, float hue, float saturation, float lum) {
    Bitmap bmp = Bitmap.createBitmap(bm.getWidth(), bm.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bmp);
    Paint paint = new Paint();
    ColorMatrix hueMatrix = new ColorMatrix();
    hueMatrix.setRotate(0, hue);
    hueMatrix.setRotate(1, hue);
    hueMatrix.setRotate(2, hue);
    ColorMatrix saturationMatrix = new ColorMatrix();
    saturationMatrix.setSaturation(saturation);
    ColorMatrix lumMatrix = new ColorMatrix();
    lumMatrix.setScale(lum, lum, lum, 1);
    ColorMatrix imageMatrix = new ColorMatrix();
    imageMatrix.postConcat(hueMatrix);
    imageMatrix.postConcat(saturationMatrix);
    imageMatrix.postConcat(lumMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(imageMatrix));
    canvas.drawBitmap(bm, 0, 0, paint);
    return bmp;
}

/**
     * 设置图片的色调\饱和度\亮度
     *
     * @param bm
     * @param hue        色调
     * @param saturation 饱和度
     * @param lum        亮度
     * @return
     */
public static Bitmap handleImageEffect(Bitmap bm, float hue, float saturation, float lum) {
    Bitmap bmp = Bitmap.createBitmap(bm.getWidth(), bm.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bmp);
    Paint paint = new Paint();
    ColorMatrix hueMatrix = new ColorMatrix();
    hueMatrix.setRotate(0, hue);
    hueMatrix.setRotate(1, hue);
    hueMatrix.setRotate(2, hue);
    ColorMatrix saturationMatrix = new ColorMatrix();
    saturationMatrix.setSaturation(saturation);
    ColorMatrix lumMatrix = new ColorMatrix();
    lumMatrix.setScale(lum, lum, lum, 1);
    ColorMatrix imageMatrix = new ColorMatrix();
    imageMatrix.postConcat(hueMatrix);
    imageMatrix.postConcat(saturationMatrix);
    imageMatrix.postConcat(lumMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(imageMatrix));
    canvas.drawBitmap(bm, 0, 0, paint);
    return bmp;
}

private void setColorMatrix(int foreColor, int backColor) {
    if ((foreColor != mCurrentForeColor) || (backColor != mCurrentBackColor) || (mColorMatrix == null)) {
        mCurrentForeColor = foreColor;
        mCurrentBackColor = backColor;
        if (mColorMatrix == null) {
            mColorMatrix = new float[20];
            // Just copy Alpha
            mColorMatrix[18] = 1.0f;
        }
        for (int component = 0; component < 3; component++) {
            int rightShift = (2 - component) << 3;
            int fore = 0xff & (foreColor >> rightShift);
            int back = 0xff & (backColor >> rightShift);
            int delta = back - fore;
            mColorMatrix[component * 6] = delta * BYTE_SCALE;
            mColorMatrix[component * 5 + 4] = fore;
        }
        mPaint.setColorFilter(new ColorMatrixColorFilter(mColorMatrix));
    }
}

private void updateInvertPaint(float intensity) {
    float components = 1 - 2 * intensity;
    final float[] invert = { components, 0f, 0f, 0f, 255f * intensity, 0f, components, 0f, 0f, 255f * intensity, 0f, 0f, components, 0f, 255f * intensity, 0f, 0f, 0f, 1f, 0f };
    mMatrix.set(invert);
    mGrayscaleMatrix.setSaturation(1 - intensity);
    mMatrix.preConcat(mGrayscaleMatrix);
    mDarkPaint.setColorFilter(new ColorMatrixColorFilter(mMatrix));
}

public static Bitmap doSepia(Bitmap bmpOriginal) {
    ColorMatrix sepiaMatrix = new ColorMatrix();
    float[] sepMat = { 0.3930000066757202f, 0.7689999938011169f, 0.1889999955892563f, 0, 0, 0.3490000069141388f, 0.6859999895095825f, 0.1679999977350235f, 0, 0, 0.2720000147819519f, 0.5339999794960022f, 0.1309999972581863f, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1 };
    sepiaMatrix.set(sepMat);
    final ColorMatrixColorFilter colorFilter = new ColorMatrixColorFilter(sepiaMatrix);
    Bitmap resultantBitmap = bmpOriginal.copy(Bitmap.Config.ARGB_8888, true);
    Paint paint = new Paint();
    paint.setColorFilter(colorFilter);
    Canvas myCanvas = new Canvas(resultantBitmap);
    myCanvas.drawBitmap(resultantBitmap, 0, 0, paint);
    return resultantBitmap;
}

@SuppressLint("NewApi")
private void init(AttributeSet attrs) {
    if (attrs != null) {
        TypedArray styledAttrs = getContext().obtainStyledAttributes(attrs, R.styleable.RoundImage);
        mCornerRadius = styledAttrs.getDimension(R.styleable.RoundImage_roundradius, mCornerRadius);
        mBlackWhite = styledAttrs.getBoolean(R.styleable.RoundImage_blackwhite, mBlackWhite);
        styledAttrs.recycle();
    }
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    filter = new ColorMatrixColorFilter(cm);
    if (Build.VERSION.SDK_INT >= 11) {
        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    }
    mMaskPaint = new Paint();
    mMaskPaint.setAntiAlias(true);
    mMaskPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
}

@Test
public void withColorFilterSet_draw_shouldCopyDescriptionToCanvas() throws Exception {
    BitmapDrawable drawable = (BitmapDrawable) resources.getDrawable(R.drawable.an_image);
    drawable.setColorFilter(new ColorMatrixColorFilter(new ColorMatrix()));
    Canvas canvas = new Canvas();
    drawable.draw(canvas);
    assertThat(shadowOf(canvas).getDescription()).isEqualTo("Bitmap for resource:org.robolectric:drawable/an_image with ColorMatrixColorFilter<1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0>");
}

private void setUnread(boolean unread) {
    int colorId = unread ? R.color.text : R.color.text_secondary;
    int color = getResources().getColor(colorId);
    title.setTextColor(color);
    sourceTitle.setTextColor(color);
    dateTime.setTextColor(color);
    ColorMatrix matrix = new ColorMatrix();
    matrix.setSaturation(.1f);
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(matrix);
    image.setColorFilter(unread ? null : filter);
}

public static int[] BitmaptoGrayscale(Bitmap bmSrc) {
    /*
		int color[] = new int[6]; // RGBDLH
		int picw = bmpOriginal.getWidth();
		int pich = bmpOriginal.getHeight();
		int[] pix = new int[picw * pich];
		int[] ret = new int[picw * pich];
		bmpOriginal.getPixels(pix, 0, picw, 0, 0, picw, pich);
		int r, g, b;
		for (int i = 0; i < pix.length; i++) {
			int _red = ((pix[i]) >> 16) & 0xFF;
			int _green = ((pix[i]) >> 8) & 0xFF;
			int _blue = ((pix[i])) & 0xFF;
			ret[i]=(int) (0.3 * _red + 0.59 * _green + 0.11 * _blue);

		}
		*/
    int width = bmSrc.getWidth();
    int height = bmSrc.getHeight();
    // 创建目标�度图�  
    Bitmap bmpGray = null;
    bmpGray = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    // 创建画布  
    Canvas c = new Canvas(bmpGray);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmSrc, 0, 0, paint);
    int[] pix = new int[width * height];
    int i = 0;
    for (int h = 0; h < height; h++) for (int w = 0; w < width; w++) {
        pix[i] = bmpGray.getPixel(w, h);
        i++;
    }
    return pix;
}

public Paint getPaintByModel() {
    Paint paint = new Paint();
    switch(toWhich) {
        case TO_LIGHT:
            paint.setColor(0x40222222);
            break;
        case TO_DARK:
            ColorMatrix cm = new ColorMatrix();
            float contrast = 0.5f;
            cm.set(new float[] { contrast, 0, 0, 0, 0, 0, // 改�对比度
            contrast, // 改�对比度
            0, // 改�对比度
            0, // 改�对比度
            0, 0, 0, contrast, 0, 0, 0, 0, 0, 1, 0 });
            paint.setColorFilter(new ColorMatrixColorFilter(cm));
            break;
        default:
            break;
    }
    return paint;
}

private void updateInvertPaint(float intensity) {
    float components = 1 - 2 * intensity;
    final float[] invert = { components, 0f, 0f, 0f, 255f * intensity, 0f, components, 0f, 0f, 255f * intensity, 0f, 0f, components, 0f, 255f * intensity, 0f, 0f, 0f, 1f, 0f };
    mMatrix.set(invert);
    mGrayscaleMatrix.setSaturation(1 - intensity);
    mMatrix.preConcat(mGrayscaleMatrix);
    mDarkPaint.setColorFilter(new ColorMatrixColorFilter(mMatrix));
}

private void setColorMatrix(int foreColor, int backColor) {
    if ((foreColor != mCurrentForeColor) || (backColor != mCurrentBackColor) || (mColorMatrix == null)) {
        mCurrentForeColor = foreColor;
        mCurrentBackColor = backColor;
        if (mColorMatrix == null) {
            mColorMatrix = new float[20];
            // Just copy Alpha
            mColorMatrix[18] = 1.0f;
        }
        for (int component = 0; component < 3; component++) {
            int rightShift = (2 - component) << 3;
            int fore = 0xff & (foreColor >> rightShift);
            int back = 0xff & (backColor >> rightShift);
            int delta = back - fore;
            mColorMatrix[component * 6] = delta * BYTE_SCALE;
            mColorMatrix[component * 5 + 4] = fore;
        }
        mPaint.setColorFilter(new ColorMatrixColorFilter(mColorMatrix));
    }
}

private void setColorMatrix(int foreColor, int backColor) {
    if ((foreColor != mCurrentForeColor) || (backColor != mCurrentBackColor) || (mColorMatrix == null)) {
        mCurrentForeColor = foreColor;
        mCurrentBackColor = backColor;
        if (mColorMatrix == null) {
            mColorMatrix = new float[20];
            // Just copy Alpha
            mColorMatrix[18] = 1.0f;
        }
        for (int component = 0; component < 3; component++) {
            int rightShift = (2 - component) << 3;
            int fore = 0xff & (foreColor >> rightShift);
            int back = 0xff & (backColor >> rightShift);
            int delta = back - fore;
            mColorMatrix[component * 6] = delta * BYTE_SCALE;
            mColorMatrix[component * 5 + 4] = fore;
        }
        mPaint.setColorFilter(new ColorMatrixColorFilter(mColorMatrix));
    }
}

/**
	      * ͼƬȥɫ,·µ»Ø»Ò¶ÈͼƬ
	      * @param bmpOriginal ´«ÈëµÄͼƬ
	     * @return ȥɫºóµÄͼƬ
	     */
public static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

@Override
public void onFinalImageSet(String id, ImageInfo imageInfo, Animatable animatable) {
    ((AppCompatActivity) activity).getSupportActionBar().setTitle(R.string.title_captcha);
    if (progressDialog.isShowing()) {
        progressDialog.hide();
    }
    // for our Dark theme, show a "negative image" of the captcha!
    final int maxColorVal = 255;
    if (WikipediaApp.getInstance().isCurrentThemeDark()) {
        float[] colorMatrixNegative = { //red
        -1.0f, //red
        0, //red
        0, //red
        0, //red
        maxColorVal, //green
        0, //green
        -1.0f, //green
        0, //green
        0, //green
        maxColorVal, //blue
        0, //blue
        0, //blue
        -1.0f, //blue
        0, //blue
        maxColorVal, //alpha
        0, //alpha
        0, //alpha
        0, //alpha
        1.0f, //alpha
        0 };
        captchaImage.getDrawable().setColorFilter(new ColorMatrixColorFilter(colorMatrixNegative));
    } else {
        captchaImage.getDrawable().clearColorFilter();
    }
    // In case there was a captcha attempt before
    captchaText.setText("");
}

public static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

static void setColorFilter(Drawable drawable, int color) {
    ColorMatrix s = new ColorMatrix();
    s.setScale(1 - Color.red(color) / 255f, 1 - Color.green(color) / 255f, 1 - Color.blue(color) / 255f, 1);
    s.preConcat(colorMatrixNegative);
    s.postConcat(colorMatrixNegative);
    ColorMatrixColorFilter filter = new ColorMatrixColorFilter(s);
    drawable.setColorFilter(filter);
}

private void updateFilter() {
    if (mGhostModeEnabled) {
        if (sGhostModeMatrix == null) {
            sGhostModeMatrix = new ColorMatrix();
            sGhostModeMatrix.setSaturation(0);
            // For ghost mode, set the color range to [GHOST_MODE_MIN_COLOR_RANGE, 255]
            float range = (255 - GHOST_MODE_MIN_COLOR_RANGE) / 255.0f;
            sTempMatrix.set(new float[] { range, 0, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, range, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, range, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, 0, 1, 0 });
            sGhostModeMatrix.preConcat(sTempMatrix);
        }
        if (mBrightness == 0) {
            mPaint.setColorFilter(new ColorMatrixColorFilter(sGhostModeMatrix));
        } else {
            setBrightnessMatrix(sTempMatrix, mBrightness);
            sTempMatrix.postConcat(sGhostModeMatrix);
            mPaint.setColorFilter(new ColorMatrixColorFilter(sTempMatrix));
        }
    } else if (mBrightness != 0) {
        ColorFilter filter = sCachedBrightnessFilter.get(mBrightness);
        if (filter == null) {
            filter = new PorterDuffColorFilter(Color.argb(mBrightness, 255, 255, 255), PorterDuff.Mode.SRC_ATOP);
            sCachedBrightnessFilter.put(mBrightness, filter);
        }
        mPaint.setColorFilter(filter);
    } else {
        mPaint.setColorFilter(null);
    }
}

private void setColorMatrix(int foreColor, int backColor) {
    if ((foreColor != mCurrentForeColor) || (backColor != mCurrentBackColor) || (mColorMatrix == null)) {
        mCurrentForeColor = foreColor;
        mCurrentBackColor = backColor;
        if (mColorMatrix == null) {
            mColorMatrix = new float[20];
            // Just copy Alpha
            mColorMatrix[18] = 1.0f;
        }
        for (int component = 0; component < 3; component++) {
            int rightShift = (2 - component) << 3;
            int fore = 0xff & (foreColor >> rightShift);
            int back = 0xff & (backColor >> rightShift);
            int delta = back - fore;
            mColorMatrix[component * 6] = delta * BYTE_SCALE;
            mColorMatrix[component * 5 + 4] = fore;
        }
        mPaint.setColorFilter(new ColorMatrixColorFilter(mColorMatrix));
    }
}

public static void startLoadingAnimation(final ImageView loadingImageImageView) {
    // Alpha
    loadingImageImageView.setAlpha(0F);
    loadingImageImageView.animate().setDuration(1000L).alpha(1F);
    // Saturation
    ViewCompat.setHasTransientState(loadingImageImageView, true);
    final ObservableColorMatrix cm = new ObservableColorMatrix();
    ObjectAnimator saturation = ObjectAnimator.ofFloat(cm, ObservableColorMatrix.SATURATION, 0f, 1f);
    saturation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

        @Override
        public void onAnimationUpdate(ValueAnimator valueAnimator) {
            loadingImageImageView.setColorFilter(new ColorMatrixColorFilter(cm));
        }
    });
    saturation.setDuration(2000L);
    saturation.setInterpolator(new FastOutSlowInInterpolator());
    saturation.addListener(new AnimatorListenerAdapter() {

        @Override
        public void onAnimationEnd(Animator animation) {
            loadingImageImageView.clearColorFilter();
            ViewCompat.setHasTransientState(loadingImageImageView, false);
        }
    });
    saturation.start();
}

/**
	      * ͼƬȥɫ,·µ»Ø»Ò¶ÈͼƬ
	      * @param bmpOriginal ´«ÈëµÄͼƬ
	     * @return ȥɫºóµÄͼƬ
	     */
public static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

/**
     * 创建一个�以改�颜色的ColorFilter
     *
     * @param color �明度是没有用的
     * @return ColorMatrixColorFilter
     */
public static ColorMatrixColorFilter makeResetColorFilter(int color) {
    float mRed = Color.red(color);
    float mGreen = Color.green(color);
    float mBlue = Color.blue(color);
    float[] src = new float[] { 0, 0, 0, 0, mRed, 0, 0, 0, 0, mGreen, 0, 0, 0, 0, mBlue, 0, 0, 0, 1, 0 };
    ColorMatrix matrix = new ColorMatrix();
    matrix.set(src);
    return new ColorMatrixColorFilter(src);
}

private void updateFilter() {
    if (mGhostModeEnabled) {
        if (sGhostModeMatrix == null) {
            sGhostModeMatrix = new ColorMatrix();
            sGhostModeMatrix.setSaturation(0);
            // For ghost mode, set the color range to [GHOST_MODE_MIN_COLOR_RANGE, 255]
            float range = (255 - GHOST_MODE_MIN_COLOR_RANGE) / 255.0f;
            sTempMatrix.set(new float[] { range, 0, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, range, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, range, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, 0, 1, 0 });
            sGhostModeMatrix.preConcat(sTempMatrix);
        }
        if (mBrightness == 0) {
            mPaint.setColorFilter(new ColorMatrixColorFilter(sGhostModeMatrix));
        } else {
            setBrightnessMatrix(sTempMatrix, mBrightness);
            sTempMatrix.postConcat(sGhostModeMatrix);
            mPaint.setColorFilter(new ColorMatrixColorFilter(sTempMatrix));
        }
    } else if (mBrightness != 0) {
        ColorFilter filter = sCachedBrightnessFilter.get(mBrightness);
        if (filter == null) {
            filter = new PorterDuffColorFilter(Color.argb(mBrightness, 255, 255, 255), PorterDuff.Mode.SRC_ATOP);
            sCachedBrightnessFilter.put(mBrightness, filter);
        }
        mPaint.setColorFilter(filter);
    } else {
        mPaint.setColorFilter(null);
    }
}

/**
	 * 图片去色,返回�度图片
	 * 
	 * @param bmpOriginal
	 *            传入的图片
	 * @return 去色�的图片
	 */
public static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    paint.setColorFilter(null);
    c.drawBitmap(bmpGrayscale, 0, 0, paint);
    ColorMatrix cm = new ColorMatrix();
    getValueBlackAndWhite();
    cm.set(carray);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

private void setColorMatrix(int foreColor, int backColor) {
    if ((foreColor != mCurrentForeColor) || (backColor != mCurrentBackColor) || (mColorMatrix == null)) {
        mCurrentForeColor = foreColor;
        mCurrentBackColor = backColor;
        if (mColorMatrix == null) {
            mColorMatrix = new float[20];
            // Just copy Alpha
            mColorMatrix[18] = 1.0f;
        }
        for (int component = 0; component < 3; component++) {
            int rightShift = (2 - component) << 3;
            int fore = 0xff & (foreColor >> rightShift);
            int back = 0xff & (backColor >> rightShift);
            int delta = back - fore;
            mColorMatrix[component * 6] = delta * BYTE_SCALE;
            mColorMatrix[component * 5 + 4] = fore;
        }
        mPaint.setColorFilter(new ColorMatrixColorFilter(mColorMatrix));
    }
}

/**
     * Changes the contrast and brightness of the bitmap
     * 
     * @param bitmap
     *            input bitmap
     * @param contrast
     *            0..10 1 is default
     * @param brightness
     *            -255..255 0 is default
     * @return new bitmap
     */
public static Bitmap changeBitmapContrastBrightness(Bitmap bitmap, float contrast, float brightness) {
    ColorMatrix cm = new ColorMatrix(new float[] { contrast, 0, 0, 0, brightness, 0, contrast, 0, 0, brightness, 0, 0, contrast, 0, brightness, 0, 0, 0, 1, 0 });
    Bitmap ret = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), bitmap.getConfig());
    Canvas canvas = new Canvas(ret);
    Paint paint = new Paint();
    paint.setColorFilter(new ColorMatrixColorFilter(cm));
    canvas.drawBitmap(bitmap, 0, 0, paint);
    return ret;
}

private void wave(final Context context, final int imageViewHeight2width) {
    if (resourceId == -1)
        throw new IllegalStateException("resourceId not be null!");
    final Bitmap bt = SampleUtils.load(context, resourceId).override(imageViewHeight2width, imageViewHeight2width).bitmap();
    final ColorMatrix colorMatrix = new ColorMatrix();
    colorMatrix.setSaturation(0);
    final BitmapComposer bitmapComposer = BitmapComposer.newComposition(bt.getWidth(), bt.getHeight(), Bitmap.Config.ARGB_4444);
    //        Matrix first = new Matrix();
    //        first.postTranslate(0, -20);
    mWaveHelper = new WaveHelper(bt.getWidth(), bt.getHeight(), new WaveHelper.RefreshCallback() {

        @Override
        public void refresh(Bitmap wave) {
            Bitmap render = bitmapComposer.clear().newLayer(BitmapComposer.Layer.bitmap(bt).colorFilter(new ColorMatrixColorFilter(colorMatrix))).newLayer(BitmapComposer.Layer.bitmap(bt).mask(wave, PorterDuff.Mode.DST_IN)).render();
            imageView.setImageBitmap(render);
        }
    });
    mWaveHelper.cancel();
    mWaveHelper.setAmplitude(imageViewHeight2width / 16);
    mWaveHelper.setLength(imageViewHeight2width / 1.2F);
    mWaveHelper.setSpeed(imageViewHeight2width * 1.2F);
    mWaveHelper.setLevelProgress(0F);
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    //        sGlowColorPressedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    //        sGlowColorFocusedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorPressedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    sGlowColorFocusedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private void updateFilter() {
    if (mGhostModeEnabled) {
        if (sGhostModeMatrix == null) {
            sGhostModeMatrix = new ColorMatrix();
            sGhostModeMatrix.setSaturation(0);
            // For ghost mode, set the color range to [GHOST_MODE_MIN_COLOR_RANGE, 255]
            float range = (255 - GHOST_MODE_MIN_COLOR_RANGE) / 255.0f;
            sTempMatrix.set(new float[] { range, 0, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, range, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, range, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, 0, 1, 0 });
            sGhostModeMatrix.preConcat(sTempMatrix);
        }
        if (mBrightness == 0) {
            mPaint.setColorFilter(new ColorMatrixColorFilter(sGhostModeMatrix));
        } else {
            setBrightnessMatrix(sTempMatrix, mBrightness);
            sTempMatrix.postConcat(sGhostModeMatrix);
            mPaint.setColorFilter(new ColorMatrixColorFilter(sTempMatrix));
        }
    } else if (mBrightness != 0) {
        ColorFilter filter = sCachedBrightnessFilter.get(mBrightness);
        if (filter == null) {
            filter = new PorterDuffColorFilter(Color.argb(mBrightness, 255, 255, 255), PorterDuff.Mode.SRC_ATOP);
            sCachedBrightnessFilter.put(mBrightness, filter);
        }
        mPaint.setColorFilter(filter);
    } else {
        mPaint.setColorFilter(null);
    }
}

public static Bitmap handleImage(Bitmap bm, int hue) {
    Bitmap bmp = Bitmap.createBitmap(bm.getWidth(), bm.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bmp);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    ColorMatrix mHueMatrix = new ColorMatrix();
    ColorMatrix mAllMatrix = new ColorMatrix();
    float mHueValue = hue * 1.0F / 127;
    mHueMatrix.reset();
    mHueMatrix.setScale(mHueValue, mHueValue, mHueValue, 1);
    mAllMatrix.reset();
    mAllMatrix.postConcat(mHueMatrix);
    paint.setColorFilter(new ColorMatrixColorFilter(mAllMatrix));
    canvas.drawBitmap(bm, 0, 0, paint);
    return bmp;
}

protected void drawBitmap(Canvas canvas, Bitmap bitmap, boolean animating, float fraction) {
    if (animating) {
        colorMatrix.reset();
        MaterialTransition.apply(colorMatrix, fraction);
        colorMatrixColorFilter = new ColorMatrixColorFilter(colorMatrix);
        paint.setColorFilter(colorMatrixColorFilter);
    } else if (paint.getColorFilter() != null) {
        paint.setColorFilter(null);
    }
    canvas.drawBitmap(bitmap, getPaddingLeft(), getPaddingTop(), paint);
}

public static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

// Desaturates and color-scrims the image
public static ColorFilter makeSessionImageScrimColorFilter(int sessionColor) {
    float a = SESSION_PHOTO_SCRIM_ALPHA;
    // saturation (0=gray, 1=color)
    float sat = SESSION_PHOTO_SCRIM_SATURATION;
    return new ColorMatrixColorFilter(new float[] { ((1 - 0.213f) * sat + 0.213f) * a, ((0 - 0.715f) * sat + 0.715f) * a, ((0 - 0.072f) * sat + 0.072f) * a, 0, Color.red(sessionColor) * (1 - a), ((0 - 0.213f) * sat + 0.213f) * a, ((1 - 0.715f) * sat + 0.715f) * a, ((0 - 0.072f) * sat + 0.072f) * a, 0, Color.green(sessionColor) * (1 - a), ((0 - 0.213f) * sat + 0.213f) * a, ((0 - 0.715f) * sat + 0.715f) * a, ((1 - 0.072f) * sat + 0.072f) * a, 0, Color.blue(sessionColor) * (1 - a), 0, 0, 0, 0, 255 });
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    //        sGlowColorPressedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    //        sGlowColorFocusedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private void otherInit() {
    // Other initialization
    mBlackPaint = new Paint();
    mBlackPaint.setColor(0xff000000);
    mMaskedPaint = new Paint();
    mMaskedPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    // Always want a cache allocated.
    mCacheBitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
    if (mDesaturateOnPress) {
        // Create a desaturate color filter for pressed state.
        ColorMatrix cm = new ColorMatrix();
        cm.setSaturation(0);
        mDesaturateColorFilter = new ColorMatrixColorFilter(cm);
    }
}

@Override
public void draw(Canvas canvas) {
    synchronized (mDrawLock) {
        if (mAnimating) {
            if (mStartTime < 0) {
                mStartTime = SystemClock.uptimeMillis();
            }
            final float rawProgress = Math.min(1.0f, ((float) (SystemClock.uptimeMillis() - mStartTime)) / ((float) mDuration));
            // As per the Material Design spec, animation goes into 3 steps. Ranging from 0 to 100,
            // opacity is full at 50, exposure (gamma + black output) at 75, and saturation at 100.
            // For performance, we only do the saturation and opacity transition
            final float inputOpacity = Math.min(1.0f, rawProgress * (1.0f / 0.5f));
            // final float inputExposure = Math.min(1.0f, rawProgress * (1.0f / 0.75f));
            final float progressOpacity = mInterpolator.getInterpolation(inputOpacity);
            // final float progressExposure = 1.0f - mInterpolator.getInterpolation(inputExposure);
            final float progressSaturation = mInterpolator.getInterpolation(rawProgress);
            if (mBaseDrawable != null) {
                drawTranslatedBase(canvas);
            }
            if (mExtColorFilter == null) {
                mColorMatSaturation.setSaturation(progressSaturation);
                ColorMatrixColorFilter colorMatFilter = new ColorMatrixColorFilter(mColorMatSaturation);
                mPaint.setAlpha((int) (progressOpacity * 255.0f));
                mPaint.setColorFilter(colorMatFilter);
            } else {
                mPaint.setColorFilter(mExtColorFilter);
            }
            if (!mTargetDrawable.getBitmap().isRecycled()) {
                try {
                    canvas.drawBitmap(mTargetDrawable.getBitmap(), 0, 0, mPaint);
                } catch (RuntimeException e) {
                    Log.w(TAG, "Couldn't write target bitmap!");
                }
            }
            if (rawProgress >= 1.0f) {
                mAnimating = false;
                if (mBaseDrawable != null && mBaseDrawable instanceof RecyclingBitmapDrawable) {
                    ((RecyclingBitmapDrawable) mBaseDrawable).setIsDisplayed(false);
                }
                mBaseDrawable = mTargetDrawable;
            } else {
                invalidateSelf();
            }
        } else if (mBaseDrawable != null) {
            if (!mBaseDrawable.getBitmap().isRecycled()) {
                try {
                    mBaseDrawable.draw(canvas);
                } catch (Exception e) {
                    Log.w(TAG, "Couldn't draw base drawable: " + e.getMessage());
                }
            }
        }
        if (mShowOfflineOverdraw) {
            int alpha = (int) Math.min(160, (SystemClock.uptimeMillis() - mOfflineStartTime) / 4);
            canvas.drawColor(0x00888888 | ((alpha & 0xFF) << 24));
            mPaint.setAlpha(alpha * 255 / 160);
            canvas.drawBitmap(mOfflineDrawable.getBitmap(), getBounds().centerX() - mOfflineDrawable.getIntrinsicWidth() / 2, getBounds().centerY() - mOfflineDrawable.getIntrinsicHeight() / 2, mPaint);
            if (alpha != 160) {
                invalidateSelf();
            }
        }
    }
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

@Override
public final void onDragEnter(DragObject d) {
    d.dragView.setColor(mHoverColor);
    if (Utilities.ATLEAST_LOLLIPOP) {
        animateTextColor(mHoverColor);
    } else {
        if (mCurrentFilter == null) {
            mCurrentFilter = new ColorMatrix();
        }
        DragView.setColorScale(mHoverColor, mCurrentFilter);
        mDrawable.setColorFilter(new ColorMatrixColorFilter(mCurrentFilter));
        setTextColor(mHoverColor);
    }
    if (d.stateAnnouncer != null) {
        d.stateAnnouncer.cancel();
    }
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
}

// 转��度图
public static Bitmap toGrayscale(Bitmap bmpOriginal) {
    int width, height;
    height = bmpOriginal.getHeight();
    width = bmpOriginal.getWidth();
    Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Config.ARGB_8888);
    Canvas c = new Canvas(bmpGrayscale);
    Paint paint = new Paint();
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0);
    ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
    paint.setColorFilter(f);
    c.drawBitmap(bmpOriginal, 0, 0, paint);
    return bmpGrayscale;
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_mirror);
    mConfigSettings = new ConfigurationSettings(this);
    AlarmReceiver.startMirrorUpdates(this);
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    } else {
        View decorView = getWindow().getDecorView();
        int uiOptions = View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY | View.SYSTEM_UI_FLAG_IMMERSIVE;
        decorView.setSystemUiVisibility(uiOptions);
        ActionBar actionBar = getSupportActionBar();
        actionBar.hide();
    }
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    mBirthdayText = (TextView) findViewById(R.id.birthday_text);
    mDayText = (TextView) findViewById(R.id.day_text);
    mWeatherSummary = (TextView) findViewById(R.id.weather_summary);
    mHelloText = (TextView) findViewById(R.id.hello_text);
    mWaterPlants = findViewById(R.id.water_plants);
    mGroceryList = findViewById(R.id.grocery_list);
    mBikeTodayText = (TextView) findViewById(R.id.can_bike);
    mStockText = (TextView) findViewById(R.id.stock_text);
    mMoodText = (TextView) findViewById(R.id.mood_text);
    mXKCDImage = (ImageView) findViewById(R.id.xkcd_image);
    mNewsHeadline = (TextView) findViewById(R.id.news_headline);
    mCalendarTitleText = (TextView) findViewById(R.id.calendar_title);
    mCalendarDetailsText = (TextView) findViewById(R.id.calendar_details);
    mCountdownText = (TextView) findViewById(R.id.countdown_text);
    if (mConfigSettings.invertXKCD()) {
        //Negative of XKCD image
        float[] colorMatrixNegative = { //red
        -1.0f, //red
        0, //red
        0, //red
        0, //red
        255, //green
        0, //green
        -1.0f, //green
        0, //green
        0, //green
        255, //blue
        0, //blue
        0, //blue
        -1.0f, //blue
        0, //blue
        255, //alpha
        0, //alpha
        0, //alpha
        0, //alpha
        1.0f, //alpha
        0 };
        ColorFilter colorFilterNegative = new ColorMatrixColorFilter(colorMatrixNegative);
        // not inverting for now
        mXKCDImage.setColorFilter(colorFilterNegative);
    }
    setViewState();
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_mirror);
    mConfigSettings = new ConfigurationSettings(this);
    AlarmReceiver.startMirrorUpdates(this);
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    } else {
        View decorView = getWindow().getDecorView();
        int uiOptions = View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY | View.SYSTEM_UI_FLAG_IMMERSIVE;
        decorView.setSystemUiVisibility(uiOptions);
        ActionBar actionBar = getSupportActionBar();
        actionBar.hide();
    }
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    mBirthdayText = (TextView) findViewById(R.id.birthday_text);
    mDayText = (TextView) findViewById(R.id.day_text);
    mWeatherSummary = (TextView) findViewById(R.id.weather_summary);
    mHelloText = (TextView) findViewById(R.id.hello_text);
    mWaterPlants = findViewById(R.id.water_plants);
    mGroceryList = findViewById(R.id.grocery_list);
    mBikeTodayText = (TextView) findViewById(R.id.can_bike);
    mStockText = (TextView) findViewById(R.id.stock_text);
    mMoodText = (TextView) findViewById(R.id.mood_text);
    mXKCDImage = (ImageView) findViewById(R.id.xkcd_image);
    mNewsHeadline = (TextView) findViewById(R.id.news_headline);
    mCalendarTitleText = (TextView) findViewById(R.id.calendar_title);
    mCalendarDetailsText = (TextView) findViewById(R.id.calendar_details);
    mCountdownText = (TextView) findViewById(R.id.countdown_text);
    if (mConfigSettings.invertXKCD()) {
        //Negative of XKCD image
        float[] colorMatrixNegative = { //red
        -1.0f, //red
        0, //red
        0, //red
        0, //red
        255, //green
        0, //green
        -1.0f, //green
        0, //green
        0, //green
        255, //blue
        0, //blue
        0, //blue
        -1.0f, //blue
        0, //blue
        255, //alpha
        0, //alpha
        0, //alpha
        0, //alpha
        1.0f, //alpha
        0 };
        ColorFilter colorFilterNegative = new ColorMatrixColorFilter(colorMatrixNegative);
        // not inverting for now
        mXKCDImage.setColorFilter(colorFilterNegative);
    }
    setViewState();
}

@Override
public final void onDragEnter(DragObject d) {
    d.dragView.setColor(mHoverColor);
    if (Utilities.ATLEAST_LOLLIPOP) {
        animateTextColor(mHoverColor);
    } else {
        if (mCurrentFilter == null) {
            mCurrentFilter = new ColorMatrix();
        }
        DragView.setColorScale(mHoverColor, mCurrentFilter);
        mDrawable.setColorFilter(new ColorMatrixColorFilter(mCurrentFilter));
        setTextColor(mHoverColor);
    }
    if (d.stateAnnouncer != null) {
        d.stateAnnouncer.cancel();
    }
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
}

private void otherInit() {
    // Other initialization
    mBlackPaint = new Paint();
    mBlackPaint.setColor(0xff000000);
    mMaskedPaint = new Paint();
    mMaskedPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    // Always want a cache allocated.
    mCacheBitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
    if (mDesaturateOnPress) {
        // Create a desaturate color filter for pressed state.
        ColorMatrix cm = new ColorMatrix();
        cm.setSaturation(0);
        mDesaturateColorFilter = new ColorMatrixColorFilter(cm);
    }
}

private static void initStatics(Context context) {
    final Resources resources = context.getResources();
    final DisplayMetrics metrics = resources.getDisplayMetrics();
    final float density = metrics.density;
    sIconWidth = sIconHeight = (int) resources.getDimension(R.dimen.app_icon_size);
    sIconTextureWidth = sIconTextureHeight = sIconWidth;
    sBlurPaint.setMaskFilter(new BlurMaskFilter(5 * density, BlurMaskFilter.Blur.NORMAL));
    sGlowColorPressedPaint.setColor(0xffffc300);
    sGlowColorPressedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    sGlowColorFocusedPaint.setColor(0xffff8e00);
    sGlowColorFocusedPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
    ColorMatrix cm = new ColorMatrix();
    cm.setSaturation(0.2f);
    sDisabledPaint.setColorFilter(new ColorMatrixColorFilter(cm));
    sDisabledPaint.setAlpha(0x88);
}

private void updateFilter() {
    if (mGhostModeEnabled) {
        if (sGhostModeMatrix == null) {
            sGhostModeMatrix = new ColorMatrix();
            sGhostModeMatrix.setSaturation(0);
            // For ghost mode, set the color range to [GHOST_MODE_MIN_COLOR_RANGE, 255]
            float range = (255 - GHOST_MODE_MIN_COLOR_RANGE) / 255.0f;
            sTempMatrix.set(new float[] { range, 0, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, range, 0, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, range, 0, GHOST_MODE_MIN_COLOR_RANGE, 0, 0, 0, 1, 0 });
            sGhostModeMatrix.preConcat(sTempMatrix);
        }
        if (mBrightness == 0) {
            mPaint.setColorFilter(new ColorMatrixColorFilter(sGhostModeMatrix));
        } else {
            setBrightnessMatrix(sTempMatrix, mBrightness);
            sTempMatrix.postConcat(sGhostModeMatrix);
            mPaint.setColorFilter(new ColorMatrixColorFilter(sTempMatrix));
        }
    } else if (mBrightness != 0) {
        ColorFilter filter = sCachedBrightnessFilter.get(mBrightness);
        if (filter == null) {
            filter = new PorterDuffColorFilter(Color.argb(mBrightness, 255, 255, 255), PorterDuff.Mode.SRC_ATOP);
            sCachedBrightnessFilter.put(mBrightness, filter);
        }
        mPaint.setColorFilter(filter);
    } else {
        mPaint.setColorFilter(null);
    }
}

@Override
public boolean onResourceReady(GlideDrawable resource, String model, Target<GlideDrawable> target, boolean isFromMemoryCache, boolean isFirstResource) {
    if (!zhihuDailyItem.hasFadedIn) {
        holder.imageView.setHasTransientState(true);
        final ObservableColorMatrix cm = new ObservableColorMatrix();
        final ObjectAnimator animator = ObjectAnimator.ofFloat(cm, ObservableColorMatrix.SATURATION, 0f, 1f);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                holder.imageView.setColorFilter(new ColorMatrixColorFilter(cm));
            }
        });
        animator.setDuration(2000L);
        animator.setInterpolator(new AccelerateInterpolator());
        animator.addListener(new AnimatorListenerAdapter() {

            @Override
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                holder.imageView.clearColorFilter();
                holder.imageView.setHasTransientState(false);
                animator.start();
                zhihuDailyItem.hasFadedIn = true;
            }
        });
    }
    return false;
}

public static Bitmap createDot(Context context, Location location, User user) {
    Bitmap dotBitmap = null;
    try {
        Long interval = (System.currentTimeMillis() - location.getTimestamp().getTime()) / 1000l;
        // max out at 30 minutes
        interval = Math.min(interval, upperBoundTimeInSeconds);
        // upper bound in minutes
        Double u = upperBoundTimeInSeconds.doubleValue() / 60.0;
        // non-linear lookup
        // 0 mins = blue
        // 10 mins = yellow
        // 30 mins = orange
        Double gradientIndexDecimalNormalized = -0.25 + Math.sqrt((u * u) + (u * 24 * (interval.doubleValue() / 60.0))) / (4 * u);
        // between 0 and 1
        gradientIndexDecimalNormalized = Math.min(Math.max(0.0, gradientIndexDecimalNormalized), 1.0);
        // find the index into the gradient
        int gradientIndex = (int) (gradientIndexDecimalNormalized * (double) (colorGradient.length - 1));
        // linearly interpolate between the gradient index
        Integer COLOR1 = colorGradient[gradientIndex];
        Integer COLOR2 = colorGradient[Math.min(gradientIndex + 1, colorGradient.length - 1)];
        // TODO : this use to use a gradient, but no longer do. Could remove some of this code
        int color = (Integer) new ArgbEvaluator().evaluate(gradientIndexDecimalNormalized.floatValue(), COLOR1, COLOR1);
        // use a invert filter to swap black and white colors in the bitmap. This will preserve the original black
        float[] colorMatrix_Negative = { -1.0f, 0, 0, 0, 255, 0, -1.0f, 0, 0, 255, 0, 0, -1.0f, 0, 255, 0, 0, 0, 1.0f, 0 };
        // make a mutable copy of the bitmap
        Bitmap bitmapFile = BitmapFactory.decodeStream(context.getAssets().open("dots/black_dot.png"));
        // scale the image to a good size
        Integer maxDimension = Math.max(bitmapFile.getWidth(), bitmapFile.getHeight());
        //context.getResources().getDisplayMetrics().densityDpi;
        float density = context.getResources().getDisplayMetrics().xdpi;
        double scale = (density / 10.0) / maxDimension;
        int outWidth = Double.valueOf(scale * Integer.valueOf(bitmapFile.getWidth()).doubleValue()).intValue();
        int outHeight = Double.valueOf(scale * Integer.valueOf(bitmapFile.getHeight()).doubleValue()).intValue();
        bitmapFile = Bitmap.createScaledBitmap(bitmapFile, outWidth, outHeight, true);
        dotBitmap = bitmapFile.copy(Bitmap.Config.ARGB_8888, true);
        Canvas myCanvas = new Canvas(dotBitmap);
        // invert the gradient first
        Paint gradientPaint = new Paint();
        gradientPaint.setColorFilter(new LightingColorFilter(Color.WHITE, 0xFFFFFFFF - color));
        myCanvas.drawBitmap(dotBitmap, 0, 0, gradientPaint);
        // invert the entire image second
        Paint negativePaint = new Paint();
        negativePaint.setColorFilter(new ColorMatrixColorFilter(new ColorMatrix(colorMatrix_Negative)));
        myCanvas.drawBitmap(dotBitmap, 0, 0, negativePaint);
    } catch (IOException e1) {
        try {
            dotBitmap = BitmapFactory.decodeStream(context.getAssets().open("dots/maps_dav_bw_dot.png"));
            Integer maxDimension = Math.max(dotBitmap.getWidth(), dotBitmap.getHeight());
            float density = context.getResources().getDisplayMetrics().xdpi;
            double scale = (density / 3.5) / maxDimension;
            int outWidth = Double.valueOf(scale * Integer.valueOf(dotBitmap.getWidth()).doubleValue()).intValue();
            int outHeight = Double.valueOf(scale * Integer.valueOf(dotBitmap.getHeight()).doubleValue()).intValue();
            dotBitmap = Bitmap.createScaledBitmap(dotBitmap, outWidth, outHeight, true);
        } catch (IOException e2) {
            Log.e(LOG_NAME, "Problem setting generating bitmap", e2);
        }
    }
    return dotBitmap;
}