| /* |
| * Copyright (C) 2014 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.systemui.statusbar.phone; |
| |
| import com.android.systemui.R; |
| |
| import android.content.Context; |
| import android.content.res.TypedArray; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapShader; |
| import android.graphics.Canvas; |
| import android.graphics.Matrix; |
| import android.graphics.Paint; |
| import android.graphics.Shader; |
| import android.graphics.drawable.Drawable; |
| import android.util.AttributeSet; |
| import android.view.View; |
| |
| /** |
| * A view that displays a user image cropped to a circle with a frame. |
| */ |
| public class UserAvatarView extends View { |
| |
| private int mActiveFrameColor; |
| private int mFrameColor; |
| private float mFrameWidth; |
| private float mFramePadding; |
| private Bitmap mBitmap; |
| private Drawable mDrawable; |
| |
| private final Paint mFramePaint = new Paint(); |
| private final Paint mBitmapPaint = new Paint(); |
| private final Matrix mDrawMatrix = new Matrix(); |
| |
| private float mScale = 1; |
| |
| public UserAvatarView(Context context, AttributeSet attrs, |
| int defStyleAttr, |
| int defStyleRes) { |
| super(context, attrs, defStyleAttr, defStyleRes); |
| final TypedArray a = context.obtainStyledAttributes( |
| attrs, R.styleable.UserAvatarView, defStyleAttr, defStyleRes); |
| final int N = a.getIndexCount(); |
| for (int i = 0; i < N; i++) { |
| int attr = a.getIndex(i); |
| switch (attr) { |
| case R.styleable.UserAvatarView_frameWidth: |
| setFrameWidth(a.getDimension(attr, 0)); |
| break; |
| case R.styleable.UserAvatarView_framePadding: |
| setFramePadding(a.getDimension(attr, 0)); |
| break; |
| case R.styleable.UserAvatarView_activeFrameColor: |
| setActiveFrameColor(a.getColor(attr, 0)); |
| break; |
| case R.styleable.UserAvatarView_frameColor: |
| setFrameColor(a.getColor(attr, 0)); |
| break; |
| } |
| } |
| a.recycle(); |
| |
| mFramePaint.setAntiAlias(true); |
| mFramePaint.setStyle(Paint.Style.STROKE); |
| mBitmapPaint.setAntiAlias(true); |
| } |
| |
| public UserAvatarView(Context context, AttributeSet attrs, int defStyleAttr) { |
| this(context, attrs, defStyleAttr, 0); |
| } |
| |
| public UserAvatarView(Context context, AttributeSet attrs) { |
| this(context, attrs, 0); |
| } |
| |
| public UserAvatarView(Context context) { |
| this(context, null); |
| } |
| |
| public void setBitmap(Bitmap bitmap) { |
| setDrawable(null); |
| mBitmap = bitmap; |
| if (mBitmap != null) { |
| mBitmapPaint.setShader(new BitmapShader( |
| bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)); |
| } else { |
| mBitmapPaint.setShader(null); |
| } |
| configureBounds(); |
| invalidate(); |
| } |
| |
| public void setFrameColor(int frameColor) { |
| mFrameColor = frameColor; |
| invalidate(); |
| } |
| |
| public void setActiveFrameColor(int activeFrameColor) { |
| mActiveFrameColor = activeFrameColor; |
| invalidate(); |
| } |
| |
| public void setFrameWidth(float frameWidth) { |
| mFrameWidth = frameWidth; |
| invalidate(); |
| } |
| |
| public void setFramePadding(float framePadding) { |
| mFramePadding = framePadding; |
| invalidate(); |
| } |
| |
| @Override |
| protected void onLayout(boolean changed, int left, int top, int right, int bottom) { |
| super.onLayout(changed, left, top, right, bottom); |
| configureBounds(); |
| } |
| |
| public void configureBounds() { |
| int vwidth = getWidth() - mPaddingLeft - mPaddingRight; |
| int vheight = getHeight() - mPaddingTop - mPaddingBottom; |
| |
| int dwidth; |
| int dheight; |
| if (mBitmap != null) { |
| dwidth = mBitmap.getWidth(); |
| dheight = mBitmap.getHeight(); |
| } else if (mDrawable != null) { |
| vwidth -= 2 * (mFrameWidth - 1); |
| vheight -= 2 * (mFrameWidth - 1); |
| dwidth = vwidth; |
| dheight = vheight; |
| mDrawable.setBounds(0, 0, dwidth, dheight); |
| } else { |
| return; |
| } |
| |
| float scale; |
| float dx; |
| float dy; |
| |
| scale = Math.min((float) vwidth / (float) dwidth, |
| (float) vheight / (float) dheight); |
| |
| dx = (int) ((vwidth - dwidth * scale) * 0.5f + 0.5f); |
| dy = (int) ((vheight - dheight * scale) * 0.5f + 0.5f); |
| |
| mDrawMatrix.setScale(scale, scale); |
| mDrawMatrix.postTranslate(dx, dy); |
| mScale = scale; |
| } |
| |
| @Override |
| protected void onDraw(Canvas canvas) { |
| int frameColor = isActivated() ? mActiveFrameColor : mFrameColor; |
| float halfW = getWidth() / 2f; |
| float halfH = getHeight() / 2f; |
| float halfSW = Math.min(halfH, halfW); |
| if (mBitmap != null && mScale > 0) { |
| int saveCount = canvas.getSaveCount(); |
| canvas.save(); |
| canvas.translate(mPaddingLeft, mPaddingTop); |
| canvas.concat(mDrawMatrix); |
| float halfBW = mBitmap.getWidth() / 2f; |
| float halfBH = mBitmap.getHeight() / 2f; |
| float halfBSW = Math.min(halfBH, halfBW); |
| canvas.drawCircle(halfBW, halfBH, halfBSW - mFrameWidth / mScale + 1, mBitmapPaint); |
| canvas.restoreToCount(saveCount); |
| } else if (mDrawable != null && mScale > 0) { |
| int saveCount = canvas.getSaveCount(); |
| canvas.save(); |
| canvas.translate(mPaddingLeft, mPaddingTop); |
| canvas.translate(mFrameWidth - 1, mFrameWidth - 1); |
| canvas.concat(mDrawMatrix); |
| mDrawable.draw(canvas); |
| canvas.restoreToCount(saveCount); |
| } |
| if (frameColor != 0) { |
| mFramePaint.setColor(frameColor); |
| mFramePaint.setStrokeWidth(mFrameWidth); |
| canvas.drawCircle(halfW, halfH, halfSW + (mFramePadding - mFrameWidth) / 2f, |
| mFramePaint); |
| } |
| } |
| |
| public void setDrawable(Drawable d) { |
| if (mDrawable != null) { |
| mDrawable.setCallback(null); |
| unscheduleDrawable(mDrawable); |
| } |
| mDrawable = d; |
| if (d != null) { |
| d.setCallback(this); |
| if (d.isStateful()) { |
| d.setState(getDrawableState()); |
| } |
| d.setLayoutDirection(getLayoutDirection()); |
| configureBounds(); |
| } |
| if (d != null) { |
| mBitmap = null; |
| } |
| configureBounds(); |
| invalidate(); |
| } |
| |
| @Override |
| public void invalidateDrawable(Drawable dr) { |
| if (dr == mDrawable) { |
| invalidate(); |
| } else { |
| super.invalidateDrawable(dr); |
| } |
| } |
| |
| @Override |
| protected boolean verifyDrawable(Drawable who) { |
| return who == mDrawable || super.verifyDrawable(who); |
| } |
| |
| @Override |
| protected void drawableStateChanged() { |
| super.drawableStateChanged(); |
| if (mDrawable != null && mDrawable.isStateful()) { |
| mDrawable.setState(getDrawableState()); |
| } |
| } |
| } |