Cómo crear un selector de color en Android Studio Desarrollador de registros, desarrollo de aplicaciones

Su clase debe implementar ColorPickerDialog.OnColorChangedListener

La clase pública MainActivity implementa ColorPickerDialog.OnColorChangedListener
{
Pintura privada mPaint;

mPaint = nueva pintura ();
// al hacer clic en el botón
nuevo ColorPickerDialog (this, this, mPaint.getColor ()). show ();

}

Diálogo ColorPicker

ColorPickerDialog de clase pública extiende el diálogo {

interfaz pública OnColorChangedListener {
color vacío Cambiado (color int);
}

Private OnColorChangedListener mListener;
private int mInitialColor;

La clase estática privada ColorPickerView extiende la vista {
Pintura privada mPaint;
Paint privado mCenterPaint;
privado final int [] mColors;
Private OnColorChangedListener mListener;

ColorPickerView (Contexto c, OnColorChangedListener l, int color) {
super (c);
mListener = l;
mColors = new int [] {
0xFFFF0000, 0xFFFF00FF, 0xFF0000FF, 0xFF00FFFF, 0xFF00FF00,
0xFFFFFF00, 0xFFFF0000
};
Shader s = new SweepGradient (0, 0, mColors, null);

mPaint = nueva pintura (Paint.ANTI_ALIAS_FLAG);
mPaint.setShader (s);
mPaint.setStyle (Paint.Style.STROKE);
mPaint.setStrokeWidth (32);

mCenterPaint = nueva pintura (Paint.ANTI_ALIAS_FLAG);
mCenterPaint.setColor (color);
mCenterPaint.setStrokeWidth (5);
}

mTrackingCenter booleano privado;
mHighlightCenter booleano privado;

@Anular
vacío protegido en Draw (Canvas Canvas) {
flotante r = CENTER_X – mPaint.getStrokeWidth () * 0.5f;

lienzo.translate (CENTER_X, CENTER_X);

canvas.drawOval (nuevo RectF (-r, -r, r, r), mPaint);
canvas.drawCircle (0, 0, CENTER_RADIUS, mCenterPaint);

if (mTrackingCenter) {
int c = mCenterPaint.getColor ();
mCenterPaint.setStyle (Paint.Style.STROKE);

if (mHighlightCenter) {
mCenterPaint.setAlpha (0xFF);
} más {
mCenterPaint.setAlpha (0x80);
}
canvas.drawCircle (0, 0,
CENTER_RADIUS + mCenterPaint.getStrokeWidth (),
mCenterPaint);

mCenterPaint.setStyle (Paint.Style.FILL);
mCenterPaint.setColor (c);
}
}

@Anular
Void onMeasure protegido (int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension (CENTER_X * 2, CENTER_Y * 2);
}

privado estático final int CENTER_X = 100;
privado estático final int CENTER_Y = 100;
privado estático final int CENTER_RADIUS = 32;

private int floatToByte (float x) {
int n = java.lang.Math.round (x);
volver n;
}
private int pinToByte (int n) {
si (n <0) {
n = 0;
} más si (n> 255) {
n = 255;
}
volver n;
}

privado int ave (int s, int d, float p) {
return s + java.lang.Math.round (p * (d – s));
}

private int interpColor (int colores [], unidad flotante) {
if (unidad <= 0) {
devolver colores [0];
}
if (unidad> = 1) {
devolver colores [colors.length – 1];
}

flotante p = unidad * (colores.longitud – 1);
int i = (int) p;
p – = i;

// ahora p es solo la parte fraccionaria [0 … 1) e i es el índice
int c0 = colores [i];
int c1 = colores [i + 1];
int a = ave (Color.alpha (c0), Color.alpha (c1), p);
int r = ave (Color.red (c0), Color.red (c1), p);
int g = ave (Color.green (c0), Color.green (c1), p);
int b = ave (Color.blue (c0), Color.blue (c1), p);

devuelve Color.argb (a, r, g, b);
}

private int rotateColor (int color, float rad) {
flotación deg = rad * 180 / 3.1415927f;
int r = Color.red (color);
int g = Color.green (color);
int b = Color.blue (color);

ColorMatrix cm = new ColorMatrix ();
ColorMatrix tmp = new ColorMatrix ();

cm.setRGB2YUV ();
tmp.setRotate (0, deg);
cm.postConcat (tmp);
tmp.setYUV2RGB ();
cm.postConcat (tmp);

flotante final [] a = cm.getArray ();

int ir = floatToByte (a [0] * r + a [1] * g + a [2] * b);
int ig = floatToByte (a [5] * r + a [6] * g + a [7] * b);
int ib = floatToByte (a [10] * r + a [11] * g + a [12] * b);

devuelve Color.argb (Color.alpha (color), pinToByte (ir),
pinToByte (ig), pinToByte (ib));
}

flotador final estático privado PI = 3.1415926f;

@Anular
public boolean onTouchEvent (evento MotionEvent) {
float x = event.getX () – CENTER_X;
float y = event.getY () – CENTER_Y;
boolean inCenter = java.lang.Math.sqrt (x * x + y * y) <= CENTER_RADIUS;

switch (event.getAction ()) {
caso MotionEvent.ACTION_DOWN:
mTrackingCenter = inCenter;
if (inCenter) {
mHighlightCenter = true;
invalidar();
descanso;
}
caso MotionEvent.ACTION_MOVE:
if (mTrackingCenter) {
if (mHighlightCenter! = inCenter) {
mHighlightCenter = inCenter;
invalidar();
}
} más {
ángulo de flotación = (flotación) java.lang.Math.atan2 (y, x);
// necesita convertir el ángulo [-PI … PI] en la unidad [0 … .1]
unidad flotante = ángulo / (2 * PI);
si (unidad <0) {
unidad + = 1;
}
mCenterPaint.setColor (interpColor (mColors, unit));
invalidar();
}
descanso;
caso MotionEvent.ACTION_UP:
if (mTrackingCenter) {
if (inCenter) {
mListener.colorChanged (mCenterPaint.getColor ());
}
mTrackingCenter = false; // entonces dibujamos sin halo
invalidar();
}
descanso;
}
volver verdadero;
}
}

ColorPickerDialog público (contexto de contexto,
Oyente OnColorChangedListener,
int initialColor) {
super (contexto);

mListener = oyente;
mInitialColor = initialColor;
}

@Anular
vacío protegido onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
OnColorChangedListener l = new OnColorChangedListener () {
public void colorChanged (int color) {
mListener.colorChanged (color);
despedir();
}
};

setContentView (nuevo ColorPickerView (getContext (), l, mInitialColor));
setTitle (“Elige un color”);
}

Tienes que elegir el color y hacer clic en el círculo central para elegir el color. Establezca el color para su objeto de pintura y use lo mismo para dibujar.

Snap shot

Otro ejemplo:

El código fuente se puede encontrar en https://code.google.com/p/androi…

AndroidAndroid StudioAplicacionesDesarrollo de aplicaciones