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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.camera.ui;
import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.RectF;
import android.hardware.Camera.Face;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import com.android.camera.PhotoUI;
import com.android.camera.Util;
import com.android.gallery3d.R;
import com.android.gallery3d.common.ApiHelper;
@TargetApi(ApiHelper.VERSION_CODES.ICE_CREAM_SANDWICH)
public class FaceView extends View
implements FocusIndicator, Rotatable,
PhotoUI.SurfaceTextureSizeChangedListener {
private static final String TAG = "CAM FaceView";
private final boolean LOGV = false;
// The value for android.hardware.Camera.setDisplayOrientation.
private int mDisplayOrientation;
// The orientation compensation for the face indicator to make it look
// correctly in all device orientations. Ex: if the value is 90, the
// indicator should be rotated 90 degrees counter-clockwise.
private int mOrientation;
private boolean mMirror;
private boolean mPause;
private Matrix mMatrix = new Matrix();
private RectF mRect = new RectF();
// As face detection can be flaky, we add a layer of filtering on top of it
// to avoid rapid changes in state (eg, flickering between has faces and
// not having faces)
private Face[] mFaces;
private Face[] mPendingFaces;
private int mColor;
private final int mFocusingColor;
private final int mFocusedColor;
private final int mFailColor;
private Paint mPaint;
private volatile boolean mBlocked;
private int mUncroppedWidth;
private int mUncroppedHeight;
private static final int MSG_SWITCH_FACES = 1;
private static final int SWITCH_DELAY = 70;
private boolean mStateSwitchPending = false;
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_SWITCH_FACES:
mStateSwitchPending = false;
mFaces = mPendingFaces;
invalidate();
break;
}
}
};
public FaceView(Context context, AttributeSet attrs) {
super(context, attrs);
Resources res = getResources();
mFocusingColor = res.getColor(R.color.face_detect_start);
mFocusedColor = res.getColor(R.color.face_detect_success);
mFailColor = res.getColor(R.color.face_detect_fail);
mColor = mFocusingColor;
mPaint = new Paint();
mPaint.setAntiAlias(true);
mPaint.setStyle(Style.STROKE);
mPaint.setStrokeWidth(res.getDimension(R.dimen.face_circle_stroke));
}
@Override
public void onSurfaceTextureSizeChanged(int uncroppedWidth, int uncroppedHeight) {
mUncroppedWidth = uncroppedWidth;
mUncroppedHeight = uncroppedHeight;
}
public void setFaces(Face[] faces) {
if (LOGV) Log.v(TAG, "Num of faces=" + faces.length);
if (mPause) return;
if (mFaces != null) {
if ((faces.length > 0 && mFaces.length == 0)
|| (faces.length == 0 && mFaces.length > 0)) {
mPendingFaces = faces;
if (!mStateSwitchPending) {
mStateSwitchPending = true;
mHandler.sendEmptyMessageDelayed(MSG_SWITCH_FACES, SWITCH_DELAY);
}
return;
}
}
if (mStateSwitchPending) {
mStateSwitchPending = false;
mHandler.removeMessages(MSG_SWITCH_FACES);
}
mFaces = faces;
invalidate();
}
public void setDisplayOrientation(int orientation) {
mDisplayOrientation = orientation;
if (LOGV) Log.v(TAG, "mDisplayOrientation=" + orientation);
}
@Override
public void setOrientation(int orientation, boolean animation) {
mOrientation = orientation;
invalidate();
}
public void setMirror(boolean mirror) {
mMirror = mirror;
if (LOGV) Log.v(TAG, "mMirror=" + mirror);
}
public boolean faceExists() {
return (mFaces != null && mFaces.length > 0);
}
@Override
public void showStart() {
mColor = mFocusingColor;
invalidate();
}
// Ignore the parameter. No autofocus animation for face detection.
@Override
public void showSuccess(boolean timeout) {
mColor = mFocusedColor;
invalidate();
}
// Ignore the parameter. No autofocus animation for face detection.
@Override
public void showFail(boolean timeout) {
mColor = mFailColor;
invalidate();
}
@Override
public void clear() {
// Face indicator is displayed during preview. Do not clear the
// drawable.
mColor = mFocusingColor;
mFaces = null;
invalidate();
}
public void pause() {
mPause = true;
}
public void resume() {
mPause = false;
}
public void setBlockDraw(boolean block) {
mBlocked = block;
}
@Override
protected void onDraw(Canvas canvas) {
if (!mBlocked && (mFaces != null) && (mFaces.length > 0)) {
int rw, rh;
rw = mUncroppedWidth;
rh = mUncroppedHeight;
// Prepare the matrix.
if (((rh > rw) && ((mDisplayOrientation == 0) || (mDisplayOrientation == 180)))
|| ((rw > rh) && ((mDisplayOrientation == 90) || (mDisplayOrientation == 270)))) {
int temp = rw;
rw = rh;
rh = temp;
}
Util.prepareMatrix(mMatrix, mMirror, mDisplayOrientation, rw, rh);
int dx = (getWidth() - rw) / 2;
int dy = (getHeight() - rh) / 2;
// Focus indicator is directional. Rotate the matrix and the canvas
// so it looks correctly in all orientations.
canvas.save();
mMatrix.postRotate(mOrientation); // postRotate is clockwise
canvas.rotate(-mOrientation); // rotate is counter-clockwise (for canvas)
for (int i = 0; i < mFaces.length; i++) {
// Filter out false positives.
if (mFaces[i].score < 50) continue;
// Transform the coordinates.
mRect.set(mFaces[i].rect);
if (LOGV) Util.dumpRect(mRect, "Original rect");
mMatrix.mapRect(mRect);
if (LOGV) Util.dumpRect(mRect, "Transformed rect");
mPaint.setColor(mColor);
mRect.offset(dx, dy);
canvas.drawOval(mRect, mPaint);
}
canvas.restore();
}
super.onDraw(canvas);
}
}
|
