1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Part1Fragment extends Fragment {
 @Override
 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 View view = inflater.inflate(R.layout.fragment_layout, container, false);
 ImageView image = (ImageView) view.findViewById(R.id.image);
 Bitmap dog = BitmapFactory.decodeResource(container.getResources(), R.drawable.betty);
 Bitmap mask = BitmapFactory.decodeResource(container.getResources(), R.drawable.mask);
 image.setImageBitmap(combineImages(mask, dog));
 dog.recycle();
 mask.recycle();
 return view;
 }
 public Bitmap combineImages(Bitmap mask, Bitmap dog) {
 Bitmap bmp;
 int width = mask.getWidth() > dog.getWidth() ? mask.getWidth() : dog.getWidth();
 int height = mask.getHeight() > dog.getHeight() ? mask.getHeight() : dog.getHeight();
 bmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
 Paint paint = new Paint();
 paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_ATOP));
 Canvas canvas = new Canvas(bmp);
 canvas.drawBitmap(mask, 0, 0, null);
 canvas.drawBitmap(dog, 0, 0, paint);
 return bmp;
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Part2Fragment extends Fragment {
 private static final float RADIUS_FACTOR = 8.0f;
 @Override
 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 View view = inflater.inflate(R.layout.fragment_layout, container, false);
 ImageView image = (ImageView)view.findViewById(R.id.image);
 Bitmap bitmap = BitmapFactory.decodeResource(container.getResources(), R.drawable.betty);
 image.setImageBitmap(processImage(bitmap));
 bitmap.recycle();
 return view;
 }
 public Bitmap processImage(Bitmap bitmap) {
 Bitmap bmp;
 bmp = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
 BitmapShader shader = new BitmapShader(bitmap, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
 float radius = Math.min(bitmap.getWidth(), bitmap.getHeight()) / RADIUS_FACTOR;
 Canvas canvas = new Canvas(bmp);
 Paint paint = new Paint();
 paint.setAntiAlias(true);
 paint.setShader(shader);
 RectF rect = new RectF(0, 0, bitmap.getWidth(), bitmap.getHeight());
 canvas.drawRoundRect(rect, radius, radius, paint);
 return bmp;
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public class Part3Fragment extends Fragment {
 private static final float RADIUS_FACTOR = 8.0f;
 private static final int TRIANGLE_WIDTH = 120;
 private static final int TRIANGLE_HEIGHT = 100;
 private static final int TRIANGLE_OFFSET = 300;
 @Override
 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 View view = inflater.inflate(R.layout.fragment_layout, container, false);
 ImageView image = (ImageView)view.findViewById(R.id.image);
 Bitmap bitmap = BitmapFactory.decodeResource(container.getResources(), R.drawable.betty);
 image.setImageBitmap(processImage(bitmap));
 bitmap.recycle();
 return view;
 }
 public Bitmap processImage(Bitmap bitmap) {
 Bitmap bmp;
 bmp = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
 BitmapShader shader = new BitmapShader(bitmap, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
 float radius = Math.min(bitmap.getWidth(), bitmap.getHeight()) / RADIUS_FACTOR;
 Canvas canvas = new Canvas(bmp);
 Paint paint = new Paint();
 paint.setAntiAlias(true);
 paint.setShader(shader);
 RectF rect = new RectF(TRIANGLE_WIDTH, 0, bitmap.getWidth(), bitmap.getHeight());
 canvas.drawRoundRect(rect, radius, radius, paint);
 Path triangle = new Path();
 triangle.moveTo(0, TRIANGLE_OFFSET);
 triangle.lineTo(TRIANGLE_WIDTH, TRIANGLE_OFFSET - (TRIANGLE_HEIGHT / 2));
 triangle.lineTo(TRIANGLE_WIDTH, TRIANGLE_OFFSET + (TRIANGLE_HEIGHT / 2));
 triangle.close();
 canvas.drawPath(triangle, paint);
 return bmp;
 }
}

1
2
3
4
5
6
7
8
9
10
11
12

Bitmap bmp;
bmp = Bitmap.createBitmap(bitmap.getWidth(), 
 bitmap.getHeight(), Bitmap.Config.ARGB_8888);
BitmapShader shader = new BitmapShader(bitmap, 
 BitmapShader.TileMode.CLAMP, 
 BitmapShader.TileMode.CLAMP);
Canvas canvas = new Canvas(bmp);
Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setShader(shader);

1
2
3
4
5
6

float width = bitmap.getWidth();
float height = bitmap.getHeight();
Path oval = new Path();
Matrix matrix = new Matrix();
Region region = new Region();

1
2
3
4

RectF ovalRect = new RectF(width / 8, 0, 
 width - (width / 8), height);
oval.addOval(ovalRect, Path.Direction.CW);

1
2

matrix.postRotate(30, width / 2, height / 2);
oval.transform(matrix, oval);

1
2
3

region.setPath(oval, new Region((int)width / 2, 0, 
 (int)width, (int)height));
canvas.drawPath(region.getBoundaryPath(), paint);

1
2

matrix.reset();
oval.reset();

1
2
3
4
5
6

oval.addOval(ovalRect, Path.Direction.CW);
matrix.postRotate(-30, width / 2, height / 2);
oval.transform(matrix, oval);
region.setPath(oval, 
 new Region(0, 0, (int)width / 2, (int)height));
canvas.drawPath(region.getBoundaryPath(), paint);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

public class Part4Fragment extends Fragment {
 @Override
 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 View view = inflater.inflate(R.layout.fragment_layout, container, false);
 ImageView image = (ImageView)view.findViewById(R.id.image);
 Bitmap bitmap = BitmapFactory.decodeResource(container.getResources(), R.drawable.betty);
 image.setImageBitmap(processImage(bitmap));
 bitmap.recycle();
 return view;
 }
 public Bitmap processImage(Bitmap bitmap) {
 Bitmap bmp;
 bmp = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
 BitmapShader shader = new BitmapShader(bitmap, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
 Canvas canvas = new Canvas(bmp);
 Paint paint = new Paint();
 paint.setAntiAlias(true);
 paint.setShader(shader);
 float width = bitmap.getWidth();
 float height = bitmap.getHeight();
 Path oval = new Path();
 Matrix matrix = new Matrix();
 Region region = new Region();
 RectF ovalRect = new RectF(width / 8, 0, width - (width / 8), height);
 oval.addOval(ovalRect, Path.Direction.CW);
 matrix.postRotate(30, width / 2, height / 2);
 oval.transform(matrix, oval);
 region.setPath(oval, new Region((int)width / 2, 0, (int)width, (int)height));
 canvas.drawPath(region.getBoundaryPath(), paint);
 matrix.reset();
 oval.reset();
 oval.addOval(ovalRect, Path.Direction.CW);
 matrix.postRotate(-30, width / 2, height / 2);
 oval.transform(matrix, oval);
 region.setPath(oval, new Region(0, 0, (int)width / 2, (int)height));
 canvas.drawPath(region.getBoundaryPath(), paint);
 return bmp;
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class FlowLayout extends ViewGroup 
{
	private static final String tag="FlowLayout";
	private int hspace=10;
	private int vspace=10;
	public FlowLayout(Context context) {
		super(context);
		initialize(context);
	}
	public FlowLayout(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
		TypedArray t = context.obtainStyledAttributes(attrs,
				R.styleable.FlowLayout, 0, 0);
		hspace = t.getDimensionPixelSize(R.styleable.FlowLayout_hspace,
				hspace);
		vspace = t.getDimensionPixelSize(R.styleable.FlowLayout_vspace,
				vspace);
		Log.d(tag,"hspace:" + hspace);
		Log.d(tag,"vspace:" + vspace);
		t.recycle();
		initialize(context);
	}
	public FlowLayout(Context context, AttributeSet attrs) {
		this(context, attrs, 0);
	}
	private void initialize(Context context) {
	}
	...
}

1
2
3
4
5
6
7
8
9

<resources>
<declare-styleable name="FlowLayout">
 <attr name="hspace" format="dimension"/>
 <attr name="vspace" format="dimension" />
</declare-styleable>
<declare-styleable name="FlowLayout_Layout">
 <attr name="layout_space" format="dimension"/>
</declare-styleable>
</resources>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//This is very basic
//doesn't take into account padding
//You can easily modify it to account for padding
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) 
{
	//********************
	//Initialize
	//********************
	int rw = MeasureSpec.getSize(widthMeasureSpec);
	int rh = MeasureSpec.getSize(heightMeasureSpec);
	int h = 0; //current height
	int w = 0; //current width
	int h1 = 0, w1=0; //Current point to hook the child to
	//********************
	//Loop through children
	//********************
	int numOfChildren = this.getChildCount();
	for (int i=0; i < numOfChildren; i++ )
	{
		//********************
		//Front of the loop
		//********************
		View child = this.getChildAt(i);
		this.measureChild(child,widthMeasureSpec, heightMeasureSpec);
		int vw = child.getMeasuredWidth();
		int vh = child.getMeasuredHeight();
		if (w1 + vw > rw)
		{
			//new line: max of current width and current width position
			//when multiple lines are in play w could be maxed out
			//or in uneven sizes is the max of the right side lines
			//all lines don't have to have the same width
			//some may be larger than others
			w = Math.max(w,w1);
			//reposition the point on the next line
			w1 = 0; //start of the line
			h1 = h1 + vh; //add view height to the current heigh
		}
		//********************
		//Middle of the loop
		//********************
		int w2 = 0, h2 = 0; //new point for the next view
		w2 = w1 + vw;
		h2 = h1;
		//latest height: current point + height of the view
		//however if the previous height is larger use that one
		h = Math.max(h,h1 + vh);
		//********************
		//Save the current coords for the view 
		//in its layout
		//********************
		LayoutParams lp = (LayoutParams)child.getLayoutParams();
		lp.x = w1;
		lp.y = h1;
		//********************
		//Restart the loop 
		//********************
		w1=w2;
		h1=h2;
	}
//********************
//End of for 
//********************
	w = Math.max(w1,w);
	//h = h;
	setMeasuredDimension(
			resolveSize(w, widthMeasureSpec), 
			resolveSize(h,heightMeasureSpec));
};

1
2
3

LayoutParams lp = (LayoutParams)child.getLayoutParams();
int spacing = lp.spacing;
//Adjust your widths based on this spacing.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@Override
protected void onLayout(boolean arg0, int arg1, int arg2, int arg3, int arg4) 
{
	//Call layout() on children
	int numOfChildren = this.getChildCount();
	for (int i=0; i < numOfChildren; i++ )
	{
		View child = this.getChildAt(i);
		LayoutParams lp = (LayoutParams)child.getLayoutParams();
		child.layout(lp.x,
				lp.y,
				lp.x + child.getMeasuredWidth(), 
				lp.y + child.getMeasuredHeight());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

//*********************************************************
//Custom Layout Definition 
//*********************************************************
public static class LayoutParams extends ViewGroup.MarginLayoutParams {
 public int spacing = -1;
 public int x =0;
 public int y =0;
 public LayoutParams(Context c, AttributeSet attrs) {
 super(c, attrs);
 TypedArray a =
 c.obtainStyledAttributes(attrs, R.styleable.FlowLayout_Layout);
 spacing = a.getDimensionPixelSize(R.styleable.FlowLayout_Layout_layout_space, 0);
 Log.d(tag,"child spacing:" + spacing);
 a.recycle();
 }
 public LayoutParams(int width, int height) {
 super(width, height);
 spacing = 0;
 }
 public LayoutParams(ViewGroup.LayoutParams p) {
 super(p);
 }
 public LayoutParams(MarginLayoutParams source) {
 super(source);
 }
}//eof-layout-params

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//*********************************************************
//Layout Param Support 
//*********************************************************
@Override
public LayoutParams generateLayoutParams(AttributeSet attrs) {
 return new FlowLayout.LayoutParams(getContext(), attrs);
}
@Override
protected LayoutParams generateDefaultLayoutParams() {
 return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
}
@Override
protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
 return new LayoutParams(p);
}
// Override to allow type-checking of LayoutParams.
@Override
protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
 return p instanceof FlowLayout.LayoutParams;
}

1
2
3
4
5

public class CompoundControl
extends LinearLayout
implements android.view.View.OnClickListener
{
...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android">
<LinearLayout
 android:orientation="horizontal"
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
>
<TextView 
	android:id="@+id/fromDate"
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:text="Enter From Date"
 android:layout_weight="70" 
 />
<Button 
	android:id="@+id/fromButton"
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:text="Go"
 android:layout_weight="30" 
 />
</LinearLayout> 
<LinearLayout
 android:orientation="horizontal"
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
>
<TextView 
	android:id="@+id/toDate"
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:text="Enter To Date"
 android:layout_weight="70" 
 />
<Button 
	android:id="@+id/toButton"
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:text="Go"
 android:layout_weight="30" 
 />
</LinearLayout> 
</merge>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public DurationControl(Context context) {
	super(context);
	initialize(context);
}
public DurationControl(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);
	TypedArray t = context.obtainStyledAttributes(attrs,
			R.styleable.DurationComponent, 0, 0);
	durationUnits = t.getInt(R.styleable.DurationComponent_durationUnits,
			durationUnits);
	t.recycle();
	initialize(context);
}
public DurationControl(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
}
private void initialize(Context context) {
	LayoutInflater lif = (LayoutInflater) context
			.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	lif.inflate(R.layout.duration_view_layout, this);
	Button b = (Button) this.findViewById(R.id.fromButton);
	b.setOnClickListener(this);
	b = (Button) this.findViewById(R.id.toButton);
	b.setOnClickListener(this);
	this.setSaveEnabled(true);
}

1
2
3
4

dispatchSaveInstanceState
dispatchFreezeSelfOnly
dispatchRestoreInstanceState
dispatchThawSelfOnly

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ViewGroup.dispatchSaveInstanceState() {
 View.dispatchSaveInstanceState()
 ...ends up calling its own ViewGroup.onSaveInstanceState()
 Children.dispatchSaveInstanceState()
 ...ends up calling children's onSaveInstanceState()
}
View.dispatchSaveInstanceState() {
 onSaveInstanceState()
}
ViewGroup.dispatchFreezeSelfOnly() {
 View.dispatchSaveInstanceState()
 ...ends up calling ViewGroup.onSaveInstanceState()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@Override
protected void dispatchSaveInstanceState(SparseArray<Parcelable> container)
{
 //Don't call this so that children won't be explicitly saved
 //super.dispatchSaveInstanceState(container);
 //Call your self onsavedinstancestate
 super.dispatchFreezeSelfOnly(container);
}
@Override
protected void dispatchRestoreInstanceState(
 SparseArray<Parcelable> container)
{
 //Don't call this so that children won't be explicitly saved
 //super.dispatchRestoreInstanceState(container);
 super.dispatchThawSelfOnly(container);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

@Override
protected void dispatchSaveInstanceState(SparseArray<Parcelable> container) {
	// Don't call this so that children won't be explicitly saved
	// super.dispatchSaveInstanceState(container);
	// Call your self onsavedinstancestate
	super.dispatchFreezeSelfOnly(container);
	Log.d(tag, "in dispatchSaveInstanceState");
}
@Override
protected void dispatchRestoreInstanceState(
		SparseArray<Parcelable> container) {
	// Don't call this so that children won't be explicitly saved
	// .super.dispatchRestoreInstanceState(container);
	super.dispatchThawSelfOnly(container);
	Log.d(tag, "in dispatchRestoreInstanceState");
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
	Log.d(tag, "in onRestoreInstanceState");
	if (!(state instanceof SavedState)) {
		super.onRestoreInstanceState(state);
		return;
	}
	// it is our state
	SavedState ss = (SavedState) state;
	// Peel it and give the child to the super class
	super.onRestoreInstanceState(ss.getSuperState());
	// this.fromDate = ss.fromDate;
	// this.toDate= ss.toDate;
	this.setFromDate(ss.fromDate);
	this.setToDate(ss.toDate);
}
@Override
protected Parcelable onSaveInstanceState() {
	Log.d(tag, "in onSaveInstanceState");
	Parcelable superState = super.onSaveInstanceState();
	SavedState ss = new SavedState(superState);
	ss.fromDate = this.fromDate;
	ss.toDate = this.toDate;
	return ss;
}
/*
 * ***************************************************************
 * Saved State inner static class
 * ***************************************************************
 */
public static class SavedState extends BaseSavedState {
	// null values are allowed
	private Calendar fromDate;
	private Calendar toDate;
	SavedState(Parcelable superState) {
		super(superState);
	}
	SavedState(Parcelable superState, Calendar inFromDate, Calendar inToDate) {
		super(superState);
		fromDate = inFromDate;
		toDate = inToDate;
	}
	@Override
	public void writeToParcel(Parcel out, int flags) {
		super.writeToParcel(out, flags);
		if (fromDate != null) {
			out.writeLong(fromDate.getTimeInMillis());
		} else {
			out.writeLong(-1L);
		}
		if (fromDate != null) {
			out.writeLong(toDate.getTimeInMillis());
		} else {
			out.writeLong(-1L);
		}
	}
	@Override
	public String toString() {
		StringBuffer sb = new StringBuffer("fromDate:"
				+ DurationControl.getDateString(fromDate));
		sb.append("fromDate:" + DurationControl.getDateString(toDate));
		return sb.toString();
	}
	@SuppressWarnings("hiding")
	public static final Parcelable.Creator<SavedState> CREATOR 
	 = new Parcelable.Creator<SavedState>() {
		public SavedState createFromParcel(Parcel in) {
			return new SavedState(in);
		}
		public SavedState[] newArray(int size) {
			return new SavedState[size];
		}
	};
	// Read back the values
	private SavedState(Parcel in) {
		super(in);
		// Read the from date
		long lFromDate = in.readLong();
		if (lFromDate == -1) {
			fromDate = null;
		} else {
			fromDate = Calendar.getInstance();
			fromDate.setTimeInMillis(lFromDate);
		}
		// Read the from date
		long lToDate = in.readLong();
		if (lFromDate == -1) {
			toDate = null;
		} else {
			toDate = Calendar.getInstance();
			toDate.setTimeInMillis(lToDate);
		}
	}
}// eof-state-class

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Override
public void onAttachedToWindow() {
 super.onAttachedToWindow();
 removeCallbacks(mCancel);
 removeCallbacks(mReturnToStartPosition);
}
@Override
public void onDetachedFromWindow() {
 super.onDetachedFromWindow();
 removeCallbacks(mReturnToStartPosition);
 removeCallbacks(mCancel);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
 getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
} 
public static int getDefaultSize(int size, int measureSpec) {
 int result = size;
 int specMode = MeasureSpec.getMode(measureSpec);
 int specSize = MeasureSpec.getSize(measureSpec);
 switch (specMode) {
 case MeasureSpec.UNSPECIFIED:
 result = size;
 break;
 case MeasureSpec.AT_MOST:
 case MeasureSpec.EXACTLY:
 result = specSize;
 break;
 }
 return result;
} 
protected void onDraw(Canvas canvas) {
}

1
2
3
4
5
6
7
8
9
10
11

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 //Get the width measurement
 int widthSize = MeasureUtils.getMeasurement(widthMeasureSpec, getDesiredWidth());
 //Get the height measurement
 int heightSize = MeasureUtils.getMeasurement(heightMeasureSpec, getDesiredHeight());
 //MUST call this to store the measurements
 setMeasuredDimension(widthSize, heightSize);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class MeasureUtils {
 /**
 * Utility to return a view's standard measurement. Uses the
 * supplied size when constraints are given. Attempts to
 * hold to the desired size unless it conflicts with provided
 * constraints.
 *
 * @param measureSpec Constraints imposed by the parent
 * @param contentSize Desired size for the view
 * @return The size the view should be.
 */
 public static int getMeasurement(int measureSpec, int contentSize) {
 int specMode = View.MeasureSpec.getMode(measureSpec);
 int specSize = View.MeasureSpec.getSize(measureSpec);
 int resultSize = 0;
 switch (specMode) {
 case View.MeasureSpec.UNSPECIFIED:
 //Big as we want to be
 resultSize = contentSize;
 break;
 case View.MeasureSpec.AT_MOST:
 //Big as we want to be, up to the spec
 resultSize = Math.min(contentSize, specSize);
 break;
 case View.MeasureSpec.EXACTLY:
 //Must be the spec size
 resultSize = specSize;
 break;
 }
 return resultSize;
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

@Override
public void onDraw(Canvas canvas) {
 super.onDraw(canvas);
 Log.d(tag,"onDraw called");
 int w = this.getWidth();
 int h = this.getHeight();
 int t = this.getTop();
 int l = this.getLeft();
 int ox = w/2;
 int oy = h/2;
 int rad = Math.min(ox,oy)/2;
 canvas.drawCircle(ox, oy, rad, getBrush());
}

1
2
3
4
5
6
7

Listing 1-18. Defining Custom Attributes in attrs.xml
<resources>
<declare-styleable name="CircleView">
 <attr name="strokeWidth" format="integer"/>
 <attr name="strokeColor" format="color|reference" />
</declare-styleable>
</resources>

1
2
3
4
5

R.attr.strokeWidth (int)
R.attr.srokeColor (int)
R.styleable.CircelView (an array of ints)
R.styleable.CircleView_strokeWidth (offset into the array)
R.styleable.CircelView_strokeColor (offset into the array)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public CircleView(Context context, AttributeSet attrs, int defStyle) {
 super(context, attrs, defStyle);
 //Use the array constant to read the bag once
 TypedArray t = context.obtainStyledAttributes(attrs,
 R.styleable.CircleView,
 defStyle, //if any values are in the theme
 0); //Do you have your own style group
 //Use the offset in the bag to get your value
 strokeColor = t.getColor(R.styleable.CircleView_strokeColor, mDefaultStrokeColor);
 strokeWidth = t.getInt(R.styleable.CircleView_strokeWidth, mDefaultStrokeWidth);
 //Recycle the typed array
 t.recycle();
 //Go ahead and initialize your class.
 initCircleView();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

/*
 * ***************************************************************
 * Save and restore work
 * ***************************************************************
 */
@Override
protected void onRestoreInstanceState(Parcelable p)
{
	this.onRestoreInstanceStateStandard(p);
	this.initCircleView();
}
@Override
protected Parcelable onSaveInstanceState()
{
	return this.onSaveInstanceStateStandard();
}
/*
 * ***************************************************************
 * Use a simpler approach
 * ***************************************************************
 */
private void onRestoreInstanceStateSimple(Parcelable p)
{
	if (!(p instanceof Bundle))
	{
		throw new RuntimeException("unexpected bundle");
	}
	Bundle b = (Bundle)p;
	defRadius = b.getInt("defRadius");
	Parcelable sp = b.getParcelable("super");
	//No need to call parent. It is just a base view
	super.onRestoreInstanceState(sp);
}
private Parcelable onSaveInstanceStateSimple()
{
	//Don't call the base class as it will return a null
	Parcelable p = super.onSaveInstanceState();
	Bundle b = new Bundle();
	b.putInt("defRadius",defRadius);
	b.putParcelable("super",p);
	return b;
}
/*
 * ***************************************************************
 * Use a standard approach
 * ***************************************************************
 */
private void onRestoreInstanceStateStandard(Parcelable state)
{
	//If it is not yours doesn't mean it is BaseSavedState
	//You may have a parent in your hierarchy that has their own 
	//state derived from BaseSavedState
	//It is like peeling an onion or a Russian doll
	if (!(state instanceof SavedState)) {
 super.onRestoreInstanceState(state);
 return;
 } 
	//it is our state
	SavedState ss = (SavedState)state;
	//Peel it and give the child to the super class
 super.onRestoreInstanceState(ss.getSuperState());
 defRadius = ss.defRadius;
}
private Parcelable onSaveInstanceStateStandard()
{
	Parcelable superState = super.onSaveInstanceState();
	SavedState ss = new SavedState(superState);
	ss.defRadius = this.defRadius;
	return ss; 	
}
/*
 * ***************************************************************
 * Saved State inner static class
 * ***************************************************************
 */
public static class SavedState extends BaseSavedState {
 int defRadius;
 SavedState(Parcelable superState) {
 super(superState);
 }
 @Override
 public void writeToParcel(Parcel out, int flags) {
 super.writeToParcel(out, flags);
 out.writeInt(defRadius);
 }
 //Read back the values
 private SavedState(Parcel in) {
 super(in);
 defRadius = in.readInt();
 }
 @Override
 public String toString() {
 	return "CircleView defRadius:" + defRadius;
 }
 @SuppressWarnings("hiding")
 public static final Parcelable.Creator<SavedState> CREATOR
 = new Parcelable.Creator<SavedState>() {
 public SavedState createFromParcel(Parcel in) {
 return new SavedState(in);
 }
 public SavedState[] newArray(int size) {
 return new SavedState[size];
 }
 };
}//eof-state-class