Android实现调用摄像头进行拍照功能

现在Android智能手机的像素都会提供照相的功能,大部分的手机的摄像头的像素都在1000万以上的像素,有的甚至会更高。它们大多都会支持光学变焦、曝光以及快门等等。

下面的程序Demo实例示范了使用Camera v2来进行拍照,当用户按下拍照键时,该应用会自动对焦,当对焦成功时拍下照片。

layout/activity_main.xml界面布局代码如下:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="com.fukaimei.camerav2test">

 <!-- 授予该程序使用摄像头的权限 -->
 <uses-permission android:name="android.permission.CAMERA" />

 <application
  android:allowBackup="true"
  android:icon="@mipmap/ic_launcher"
  android:label="@string/app_name"
  android:roundIcon="@mipmap/ic_launcher_round"
  android:supportsRtl="true"
  android:theme="@style/AppTheme">
  <activity android:name=".MainActivity">
   <intent-filter>
    <action android:name="android.intent.action.MAIN" />

    <category android:name="android.intent.category.LAUNCHER" />
   </intent-filter>
  </activity>
 </application>

</manifest>

上面的程序的界面提供了一个自定义TextureView来显示预览取景,十分简单。该自定义TextureView类的代码如下:

AutoFitTextureView.java逻辑代码如下:

package com.fukaimei.camerav2test;

import android.content.Context;
import android.util.AttributeSet;
import android.view.TextureView;

/**
 * Created by FuKaimei on 2017/9/29.
 */

public class AutoFitTextureView extends TextureView {

 private int mRatioWidth = 0;
 private int mRatioHeight = 0;

 public AutoFitTextureView(Context context, AttributeSet attrs) {
  super(context, attrs);
 }

 public void setAspectRatio(int width, int height) {
  mRatioWidth = width;
  mRatioHeight = height;
  requestLayout();
 }

 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  int width = MeasureSpec.getSize(widthMeasureSpec);
  int height = MeasureSpec.getSize(heightMeasureSpec);
  if (0 == mRatioWidth || 0 == mRatioHeight) {
   setMeasuredDimension(width, height);
  } else {
   if (width < height * mRatioWidth / mRatioHeight) {
    setMeasuredDimension(width, width * mRatioHeight / mRatioWidth);
   } else {
    setMeasuredDimension(height * mRatioWidth / mRatioHeight, height);
   }
  }
 }
}

接来了的MainActivity.java程序将会使用CameraManager来打开CameraDevice,并通过CameraDevice创建CameraCaptureSession,然后即可通过CameraCaptureSession进行预览或拍照了。

MainActivity.java逻辑代码如下:

package com.fukaimei.camerav2test;

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.graphics.ImageFormat;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CameraMetadata;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.TotalCaptureResult;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.Image;
import android.media.ImageReader;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.RequiresApi;
import android.support.v4.app.ActivityCompat;
import android.util.Log;
import android.util.Size;
import android.util.SparseIntArray;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Toast;

import java.io.File;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public class MainActivity extends Activity implements View.OnClickListener {

 private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
 private static final String TAG = "MainActivity";

 static {
  ORIENTATIONS.append(Surface.ROTATION_0, 90);
  ORIENTATIONS.append(Surface.ROTATION_90, 0);
  ORIENTATIONS.append(Surface.ROTATION_180, 270);
  ORIENTATIONS.append(Surface.ROTATION_270, 180);
 }

 private AutoFitTextureView textureView;
 // 摄像头ID(通常0代表后置摄像头,1代表前置摄像头)
 private String mCameraId = "0";
 // 定义代表摄像头的成员变量
 private CameraDevice cameraDevice;
 // 预览尺寸
 private Size previewSize;
 private CaptureRequest.Builder previewRequestBuilder;
 // 定义用于预览照片的捕获请求
 private CaptureRequest previewRequest;
 // 定义CameraCaptureSession成员变量
 private CameraCaptureSession captureSession;
 private ImageReader imageReader;
 private final TextureView.SurfaceTextureListener mSurfaceTextureListener
   = new TextureView.SurfaceTextureListener() {
  @Override
  public void onSurfaceTextureAvailable(SurfaceTexture texture
    , int width, int height) {
   // 当TextureView可用时,打开摄像头
   openCamera(width, height);
  }

  @Override
  public void onSurfaceTextureSizeChanged(SurfaceTexture texture
    , int width, int height) {
  }

  @Override
  public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
   return true;
  }

  @Override
  public void onSurfaceTextureUpdated(SurfaceTexture texture) {
  }
 };
 private final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
  // 摄像头被打开时激发该方法
  @Override
  public void onOpened(CameraDevice cameraDevice) {
   MainActivity.this.cameraDevice = cameraDevice;
   // 开始预览
   createCameraPreviewSession(); // ②
  }

  // 摄像头断开连接时激发该方法
  @Override
  public void onDisconnected(CameraDevice cameraDevice) {
   cameraDevice.close();
   MainActivity.this.cameraDevice = null;
  }

  // 打开摄像头出现错误时激发该方法
  @Override
  public void onError(CameraDevice cameraDevice, int error) {
   cameraDevice.close();
   MainActivity.this.cameraDevice = null;
   MainActivity.this.finish();
  }
 };

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  textureView = (AutoFitTextureView) findViewById(R.id.texture);
  // 为该组件设置监听器
  textureView.setSurfaceTextureListener(mSurfaceTextureListener);
  findViewById(R.id.capture).setOnClickListener(this);
 }

 @Override
 public void onClick(View view) {
  captureStillPicture();
 }

 private void captureStillPicture() {
  try {
   if (cameraDevice == null) {
    return;
   }
   // 创建作为拍照的CaptureRequest.Builder
   final CaptureRequest.Builder captureRequestBuilder =
     cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
   // 将imageReader的surface作为CaptureRequest.Builder的目标
   captureRequestBuilder.addTarget(imageReader.getSurface());
   // 设置自动对焦模式
   captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
     CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
   // 设置自动曝光模式
   captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
     CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
   // 获取设备方向
   int rotation = getWindowManager().getDefaultDisplay().getRotation();
   // 根据设备方向计算设置照片的方向
   captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION
     , ORIENTATIONS.get(rotation));
   // 停止连续取景
   captureSession.stopRepeating();
   // 捕获静态图像
   captureSession.capture(captureRequestBuilder.build()
     , new CameraCaptureSession.CaptureCallback() // ⑤
     {
      // 拍照完成时激发该方法
      @Override
      public void onCaptureCompleted(CameraCaptureSession session
        , CaptureRequest request, TotalCaptureResult result) {
       try {
        // 重设自动对焦模式
        previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
          CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
        // 设置自动曝光模式
        previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
          CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
        // 打开连续取景模式
        captureSession.setRepeatingRequest(previewRequest, null,
          null);
       } catch (CameraAccessException e) {
        e.printStackTrace();
       }
      }
     }, null);
  } catch (CameraAccessException e) {
   e.printStackTrace();
  }
 }

 // 打开摄像头
 private void openCamera(int width, int height) {
  setUpCameraOutputs(width, height);
  CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  try {
   // 打开摄像头
   if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
    // TODO: Consider calling
    // ActivityCompat#requestPermissions
    // here to request the missing permissions, and then overriding
    // public void onRequestPermissionsResult(int requestCode, String[] permissions,
    //           int[] grantResults)
    // to handle the case where the user grants the permission. See the documentation
    // for ActivityCompat#requestPermissions for more details.
    return;
   }
   manager.openCamera(mCameraId, stateCallback, null); // ①
  } catch (CameraAccessException e) {
   e.printStackTrace();
  }
 }

 private void createCameraPreviewSession() {
  try {
   SurfaceTexture texture = textureView.getSurfaceTexture();
   texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
   Surface surface = new Surface(texture);
   // 创建作为预览的CaptureRequest.Builder
   previewRequestBuilder = cameraDevice
     .createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
   // 将textureView的surface作为CaptureRequest.Builder的目标
   previewRequestBuilder.addTarget(new Surface(texture));
   // 创建CameraCaptureSession,该对象负责管理处理预览请求和拍照请求
   cameraDevice.createCaptureSession(Arrays.asList(surface
     , imageReader.getSurface()), new CameraCaptureSession.StateCallback() // ③
     {
      @Override
      public void onConfigured(CameraCaptureSession cameraCaptureSession) {
       // 如果摄像头为null,直接结束方法
       if (null == cameraDevice) {
        return;
       }

       // 当摄像头已经准备好时,开始显示预览
       captureSession = cameraCaptureSession;
       try {
        // 设置自动对焦模式
        previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
          CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        // 设置自动曝光模式
        previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
          CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
        // 开始显示相机预览
        previewRequest = previewRequestBuilder.build();
        // 设置预览时连续捕获图像数据
        captureSession.setRepeatingRequest(previewRequest,
          null, null); // ④
       } catch (CameraAccessException e) {
        e.printStackTrace();
       }
      }

      @Override
      public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
       Toast.makeText(MainActivity.this, "配置失败!"
         , Toast.LENGTH_SHORT).show();
      }
     }, null
   );
  } catch (CameraAccessException e) {
   e.printStackTrace();
  }
 }

 private void setUpCameraOutputs(int width, int height) {
  CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  try {
   // 获取指定摄像头的特性
   CameraCharacteristics characteristics
     = manager.getCameraCharacteristics(mCameraId);
   // 获取摄像头支持的配置属性
   StreamConfigurationMap map = characteristics.get(
     CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

   // 获取摄像头支持的最大尺寸
   Size largest = Collections.max(
     Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)),
     new CompareSizesByArea());
   // 创建一个ImageReader对象,用于获取摄像头的图像数据
   imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(),
     ImageFormat.JPEG, 2);
   imageReader.setOnImageAvailableListener(
     new ImageReader.OnImageAvailableListener() {
      // 当照片数据可用时激发该方法
      @Override
      public void onImageAvailable(ImageReader reader) {
       // 获取捕获的照片数据
       Image image = reader.acquireNextImage();
       ByteBuffer buffer = image.getPlanes()[0].getBuffer();
       byte[] bytes = new byte[buffer.remaining()];
       // 使用IO流将照片写入指定文件
       File file = new File(getExternalFilesDir(null), "pic.jpg");
       buffer.get(bytes);
       try (
         FileOutputStream output = new FileOutputStream(file)) {
        output.write(bytes);
        Toast.makeText(MainActivity.this, "保存: " + file, Toast.LENGTH_LONG).show();
       } catch (Exception e) {
        e.printStackTrace();
       } finally {
        image.close();
       }
      }
     }, null);

   // 获取最佳的预览尺寸
   previewSize = chooseOptimalSize(map.getOutputSizes(
     SurfaceTexture.class), width, height, largest);
   // 根据选中的预览尺寸来调整预览组件(TextureView的)的长宽比
   int orientation = getResources().getConfiguration().orientation;
   if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
    textureView.setAspectRatio(
      previewSize.getWidth(), previewSize.getHeight());
   } else {
    textureView.setAspectRatio(
      previewSize.getHeight(), previewSize.getWidth());
   }
  } catch (CameraAccessException e) {
   e.printStackTrace();
  } catch (NullPointerException e) {
   Log.d(TAG, "出现错误");
  }
 }

 private static Size chooseOptimalSize(Size[] choices
   , int width, int height, Size aspectRatio) {
  // 收集摄像头支持的打过预览Surface的分辨率
  List<Size> bigEnough = new ArrayList<>();
  int w = aspectRatio.getWidth();
  int h = aspectRatio.getHeight();
  for (Size option : choices) {
   if (option.getHeight() == option.getWidth() * h / w &&
     option.getWidth() >= width && option.getHeight() >= height) {
    bigEnough.add(option);
   }
  }
  // 如果找到多个预览尺寸,获取其中面积最小的。
  if (bigEnough.size() > 0) {
   return Collections.min(bigEnough, new CompareSizesByArea());
  } else {
   System.out.println("找不到合适的预览尺寸!!!");
   return choices[0];
  }
 }

 // 为Size定义一个比较器Comparator
 static class CompareSizesByArea implements Comparator<Size> {
  @Override
  public int compare(Size lhs, Size rhs) {
   // 强转为long保证不会发生溢出
   return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
     (long) rhs.getWidth() * rhs.getHeight());
  }
 }
}

上面的程序中序号①的代码是用于打开系统摄像头,openCamera()方法的第一个参数代表请求打开的摄像头ID,此处传入的摄像头ID为“0”,这代表打开设备后置摄像头;如果需要打开设备指定摄像头(比如前置摄像头),可以在调用openCamera()方法时传入相应的摄像头ID。

注意:由于该程序需要使用手机的摄像头,因此还需要在清单文件AndroidManifest.xml文件中授权相应的权限:

<!-- 授予该程序使用摄像头的权限 -->
 <uses-permission android:name="android.permission.CAMERA" />

Demo程序运行效果界面截图如下:

Demo程序源码下载地址

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

您可能感兴趣的文章:

  • Android 实现调用系统照相机拍照和录像的功能
  • Android 调用系统照相机拍照和录像
  • Android自定义照相机倒计时拍照
  • Android调用系统摄像头拍照并显示在ImageView上
  • Android实现调用摄像头拍照与视频功能
  • Android实现摄像头拍照功能
  • Android调用摄像头拍照开发教程
  • Android实现拍照、选择图片并裁剪图片功能
  • Android调用系统照相机拍照与摄像的方法
时间: 2018-04-24

Android调用系统照相机拍照与摄像的方法

前言 在很多场景中,都需要用到摄像头去拍摄照片或视频,在照片或视频的基础之上进行处理.但是Android系统源码是开源的,很多设备厂商均可使用,并且定制比较混乱.一般而言,在需要用到摄像头拍照或摄像的时候,均会直接调用系统现有的相机应用,去进行拍照或摄像,我们只取它拍摄的结果进行处理,这样避免了不同设备的摄像头的一些细节问题.本篇博客将介绍在Android应用中,如何调用系统现有的相机应用去拍摄照片与短片,并对其进行处理,最后均会以一个简单的Demo来演示效果. 1.系统现有相机应用的调用 对于

Android调用摄像头拍照开发教程

现在很多应用中都会要求用户上传一张图片来作为头像,首先我在这接收使用相机拍照和在相册中选择图片.接下来先上效果图: 接下来看代码: 1.布局文件: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schem

Android调用系统摄像头拍照并显示在ImageView上

简介 现在市面上的apk只要涉及用户中心都会有头像,而且这个头像也是可自定义的,有的会采取读取相册选择其中一张作为需求照片,另一种就是调用系统摄像头拍照并获取即时照片,本博文就是讲述如何调用摄像头拍照并显示在指定的控件上. 先来看看效果图 由于这里我用的是模拟器没有摄像头,所以拍照是黑的,至于里面2个红色圆圈那是Genymotion自带的标志. 实现起来比较简单: activity_main.xml <?xml version="1.0" encoding="utf-8

Android实现拍照、选择图片并裁剪图片功能

一. 实现拍照.选择图片并裁剪图片效果 按照之前博客的风格,首先看下实现效果. 二. uCrop项目应用 想起之前看到的Yalantis/uCrop效果比较绚,但是研究源码之后发现在定制界面方面还是有一点的限制,于是在它的基础上做了修改Android-Crop,把定制界面独立出来,让用户去自由设置.下图为使用Android-Crop实现的模仿微信选择图片并裁剪Demo. 三. 实现思路 比较简单的选择设备图片裁剪,并将裁剪后的图片保存到指定路径: 调用系统拍照,将拍照图片保存在SD卡,然后裁剪图

Android实现摄像头拍照功能

应用场景: 在Android开发过程中,有时需要调用手机自身设备的功能,本文侧重摄像头拍照功能的调用. 知识点介绍: 使用权限:调用手机自身设备功能(摄像头拍照功能),应该确保已经在AndroidManifest.xml中正确声明了对摄像头的使用及其它相关的feature. <!--摄像头权限 --> <uses-permission android:name="android.permission.CAMERA" /> <!--存储权限 SD卡读写权限

Android实现调用摄像头拍照与视频功能

应用场景: 在Android开发过程中,有时需要调用手机自身设备的功能,上篇文章主要侧重摄像头拍照功能的调用.本篇文章将综合实现拍照与视频的操作. 知识点介绍: 该部分请阅读 [Android 调用摄像头功能] 使用方式: 第一步: 新建一个Android项目CameraPhotoVedio,包含两个Activity: MainActivity.CameraActivity. 第二步: activity_main.xml <RelativeLayout xmlns:android="htt

Android 实现调用系统照相机拍照和录像的功能

本文实现android系统照相机的调用来拍照 项目的布局相当简单,只有一个Button: <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_heig

Android 调用系统照相机拍照和录像

本文实现android系统照相机的调用来拍照 项目的布局相当简单,只有一个Button: <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_heig

Android自定义照相机倒计时拍照

自定义拍照会用到SurfaceView控件显示照片的预览区域,以下是布局文件: 两个TextView是用来显示提示信息和倒计时的秒数的 相关教程:Android开发从相机或相册获取图片裁剪 Android启动相机拍照并返回图片 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools&qu

Android自定义照相机详解

几乎每个APP都会用的相机功能,下面小编把内容整理分享到我们平台,供大家参考,感兴趣的朋友一起学习吧! 启动相机的两种方式 1.直接启动系统相机 <code class="hljs avrasm"> Intent intent = new Intent(); intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE); startActivity(intent);</code> 或者指定返回图片的名称mCurrentPho

Android自定义照相机Camera出现黑屏的解决方法

本文实例讲述了Android自定义照相机Camera出现黑屏的解决方法.分享给大家供大家参考,具体如下: 对于一些手机,像HTC,当自定义Camera时,调用Camera.Parameters的 parameters.setPreviewSize(width, height)方法时,如果width和height为奇数情况下,则会出现黑屏现象,解决办法可参考SDK提供的ApiDemos中关于Camera的 例子: List<Size> sizes = parameters.getSupporte

Android自定义照相机的实例

Android自定义照相机实现 近期小巫在学校有一个创新项目,也不是最近,是一个拖了很久的项目,之前一直没有去搞,最近因为要中期检查,搞得我跟小组成员一阵忙活,其实开发一款照相机软件并不太难,下面就是通过自定义的方式来实现手机照相的功能. 创建一个项目:FingerTakePicture 首先来搞一下界面: <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools=&qu

Android自定义View倒计时圆

本文实例为大家分享了Android自定义View倒计时圆的具体代码,供大家参考,具体内容如下 创建attr <?xml version="1.0" encoding="utf-8"?> <resources> <declare-styleable name="CountDownView"> <!--颜色--> <attr name="ringColor" format=&q

Android自定义圆环倒计时控件

本文实例为大家分享了Android自定义圆环倒计时控件的具体代码,供大家参考,具体内容如下 先来一张最终效果图: 主要思路: 在画渐变色圆环的时候,设置一个属性动画,根据属性动画的执行时长,来作为倒计时的时长.监听属性动画的进度,来达到 倒计时的目的. 二话不说,直接贴代码.具体实现思路都在注释上. 自定义属性: <declare-styleable name="CountDownProgressBar"> <attr name="countDown_cir

android自定义圆形倒计时显示控件

本文实例为大家分享了android自定义圆形倒计时显示控件的具体代码,供大家参考,具体内容如下 先上效果图 - 倒计时结束 代码块 attr.xml 控件需要用到的属性: <?xml version="1.0" encoding="utf-8"?> <resources> <declare-styleable name="CountDownView"> <!--颜色--> <attr name

Android自定义扇形倒计时实例代码

一.概述 严格来说,我是Android小白,写的目的只是想作为知识储备而已-.但是想到别人或许会不小心搜到我的这篇,如果我只是简单的描述,别人有可能看不懂,说不定还被吐槽,那岂不是很冤吗? 所以,我还是把问题及过程描述清楚,这也是对自己的一个交代,同时,这也是我的第一篇,我应该做好它; 先说一下需求: 最近工作中需要做一个倒计时,是那种一个圆,慢慢的被吃掉的动画倒计时,由于自己知识不是很足,只知道要用Canvas来画,在网上搜了一圈,发现要么是静态的画了一个扇形,要么是不能控制控件的位置大小-.

Android自定义Camera实现拍照功能

本文记录了用自定义Camera实现的简单拍照功能. Camera类在5.0以后不推荐使用了,取而代之的是android.hardware.camera2包下的类,本文使用Camera. 我们首先自定义一个View去继承SurfaceView: public class CameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback, Camera.AutoFocusCallback { private Surface

Android自定义圆形倒计时进度条

效果预览 源代码传送门:https://github.com/yanzhenjie/CircleTextProgressbar 实现与原理 这个文字圆形的进度条我们在很多APP中看到过,比如APP欢迎页倒计时,下载文件倒计时等. 分析下原理,可能有的同学一看到这个自定义View就慌了,这个是不是要继承View啊,是不是要绘制啊之类的,答案是:是的.但是我们也不要担心,实现这个效果实在是so easy.下面就跟我一起来看看核心分析和代码吧. 原理分析 首先我们观察上图,需要几个部分组成: 1. 外