ColorFilter

ColorFilter

颜色过滤器可以与Paint一起使用，以修改使用该Paint的每个像素的颜色。
这是一个不应该直接使用的抽象类。

public class ColorFilter {
   

    private static class NoImagePreloadHolder {
   
        public static final NativeAllocationRegistry sRegistry = new NativeAllocationRegistry(
                ColorFilter.class.getClassLoader(), nativeGetFinalizer(), 50);
    }

    /** @deprecated 使用子类构造函数直接替代。 */
    @Deprecated
    public ColorFilter() {
   }

    /** 当前native SkColorFilter实例。 */
    private long mNativeInstance;
    // 可以立即销毁
    private Runnable mCleaner;

    long createNativeInstance() {
   
        return 0;
    }

    void discardNativeInstance() {
   
        if (mNativeInstance != 0) {
   
            mCleaner.run();
            mCleaner = null;
            mNativeInstance = 0;
        }
    }

    /** @hide */
    public long getNativeInstance() {
   
        if (mNativeInstance == 0) {
   
            mNativeInstance = createNativeInstance();
            if (mNativeInstance != 0) {
   
            	// 注意：这里必须检查null，因为如果native SkColorFilter在绘制时是no-op，
            	// 那么createNativeInstance()可能返回nullptr。
            	// 有关更多信息，请参见子类创建方法的native实现。
                mCleaner = NoImagePreloadHolder.sRegistry.registerNativeAllocation(
                        this, mNativeInstance);
            }
        }
        return mNativeInstance;
    }

    private static native long nativeGetFinalizer();
}

---

LightingColorFilter

可用于模拟简单lighting效果的颜色过滤器。LightingColorFilter由两个参数定义，一个用于乘以源颜色（称为colorMultiply），另一个用于相加源颜色（称为colorAdd）。alpha通道不受此颜色过滤器的影响。

给定源颜色RGB，计算得到的R’G’B’颜色：
R’ = R * colorMultiply.R + colorAdd.R
G’ = G * colorMultiply.G + colorAdd.G
B’ = B * colorMultiply.B + colorAdd.B
结果固定到每个通道的[0…255]范围。

public class LightingColorFilter extends ColorFilter {
   
    @ColorInt
    private int mMul;
    @ColorInt
    private int mAdd;

    /** 创建一个ColorFilter，将RGB乘以一个颜色，然后相加第二个颜色。mul和add的alpha被忽略。 */
    public LightingColorFilter(@ColorInt int mul, @ColorInt int add) {
   
        mMul = mul;
        mAdd = add;
    }

    /** 应用ColorFilter时，返回用于乘以源颜色的RGB颜色。 */
    @ColorInt
    public int getColorMultiply() {
   
        return mMul;
    }

    /** 应用ColorFilter时，指定用于乘以源颜色的RGB颜色。忽略此颜色的alpha。 @hide */
    public void setColorMultiply(@ColorInt int mul) {
   
        if (mMul != mul) {
   
            mMul = mul;
            discardNativeInstance();
        }
    }

    /** 应用ColorFilter时，返回将相加源颜色的RGB颜色。 */
    @ColorInt
    public int getColorAdd() {
   
        return mAdd;
    }

    /** 应用ColorFilter时，指定将相加源颜色的RGB。忽略此颜色的alpha。 @hide */
    public void setColorAdd(@ColorInt int add) {
   
        if (mAdd != add) {
   
            mAdd = add;
            discardNativeInstance();
        }
    }

    @Override
    long createNativeInstance() {
   
        return native_CreateLightingFilter(mMul, mAdd);
    }

    private static native long native_CreateLightingFilter(int mul, int add);
}

---

PoterDuffColorFilter

一种颜色过滤器，可用于使用单一颜色和特定PorterDuff混合模式对源像素进行着色。

public class PorterDuffColorFilter extends ColorFilter {
   
    @ColorInt
    private int mColor;
    private PorterDuff.Mode mMode;

    /** 
     * 创建使用指定颜色和PorterDuff模式的ColorFilter。
     *
     * @param color 与指定PorterDuff模式一起使用的ARGB源颜色
     * @param mode 应用的PorterDuff模式
     */
    public PorterDuffColorFilter(@ColorInt int color, @NonNull PorterDuff.Mode mode) {
   
        mColor = color;
        mMode = mode;
    }

    /** 应用此filter时，返回用于着色源像素的ARGB颜色。 @hide */
    @ColorInt
    public int getColor() {
   
        return mColor;
    }

    /** 在应用此ColorFilter时，指定对源像素进行着色的颜色。 @hide */
    public void setColor(@ColorInt int color) {
   
        if (mColor != color) {
   
            mColor = color;
            discardNativeInstance();
        }
    }

    /** 应用此filter时，返回用于将此ColorFilter的颜色与源像素混合的PorterDuff模式。 @hide */
    public PorterDuff.Mode getMode() {
   
        return mMode;
    }

    /** 绘制时，将此ColorFilter的颜色与源像素混合时使用指定的PorterDuff模式。 @hide */
    public void setMode(@NonNull PorterDuff.Mode mode) {
   
        if (mode == null) {
   
            throw new IllegalArgumentException("mode must be non-null");
        }
        mMode = mode;
        discardNativeInstance();
    }

    @Override
    long createNativeInstance() {
   
        return native_CreatePorterDuffFilter(mColor, mMode.nativeInt);
    }

    @Override
    public boolean equals(Object object) {
   
        if (this == object) {
   
            return true;
        }
        if (object == null || getClass(