Android多媒体一：使用Android 5.0的Camera v2拍照
Android 5.0对拍照API进行了全新的设计，新增了全新设计的Camera v2 API，这些API不仅大幅提高了Android系统拍照的功能，还能支持RAW照片输出，
甚至允许程序调整相机的对焦模式、曝光模式、快门等。
Android 5.0的Camera v2主要涉及如下API。
Ø CameraManager：摄像头管理器。这是一个全新的系统管理器，专门用于检测系统摄像头、打开系统摄像头。除此之外，调用CameraManager的getCameraCharacteristics(String)方法即可获取指定摄像头的相关特性。
Ø CameraCharacteristics：摄像头特性。该对象通过CameraManager来获取，用于描述特定摄像头所支持的各种特性。
Ø CameraDevice：代表系统摄像头。该类的功能类似于早期的Camera类。
Ø CameraCaptureSession：这是一个非常重要的API，当程序需要预览、拍照时，都需要先通过该类的实例创建Session。而且不管预览还是拍照，
也都是由该对象的方法进行控制的，其中控制预览的方法为setRepeatingRequest()；控制拍照的方法为capture()。
为了监听CameraCaptureSession的创建过程，以及监听CameraCaptureSession的拍照过程，Camera v2 API为CameraCaptureSession提供了
StateCallback、CaptureCallback等内部类。
Ø CameraRequest和CameraRequest.Builder：当程序调用setRepeatingRequest()方法进行预览时，或调用capture()方法进行拍照时，都需要传入CameraRequest参数。
CameraRequest代表了一次捕获请求，用于描述捕获图片的各种参数设置，比如对焦模式、曝光模式……总之，程序需要对照片所做的各种控制，
都通过CameraRequest参数进行设置。CameraRequest.Builder则负责生成CameraRequest对象。
控制拍照的步骤大致如下。
1，调用CameraManager的openCamera(String cameraId, CameraDevice.StateCallback callback, Handler handler)方法打开指定摄像头。
第一个参数代表要打开的摄像头ID；
第二个参数用于监听摄像头的状态；
第三个参数代表执行callback的Handler，如果程序希望直接在当前线程中执行callback，则可将handler参数设为null。
2，当摄像头被打开之后，程序即可获取CameraDevice—即根据摄像头ID获取了指定摄像头设备，然后调用CameraDevice的
createCaptureSession(List<Surface> outputs, CameraCaptureSession. StateCallback callback，Handler handler)方法来创建CameraCaptureSession。
第一个参数是一个List集合，封装了所有需要从该摄像头获取图片的Surface
第二个参数用于监听CameraCaptureSession的创建过程；
第三个参数代表执行callback的Handler，如果程序希望直接在当前线程中执行callback，则可将handler参数设为null。
3，不管预览还是拍照，程序都调用CameraDevice的createCaptureRequest(int templateType)方法创建CaptureRequest.Builder，
该方法支持TEMPLATE_PREVIEW（预览）、TEMPLATE_RECORD（拍摄视频）、TEMPLATE_STILL_CAPTURE（拍照）等参数。
4，通过第3步所调用方法返回的CaptureRequest.Builder设置拍照的各种参数，比如对焦模式、曝光模式等。
5，调用CaptureRequest.Builder的build()方法即可得到CaptureRequest对象，接下来程序可通过CameraCaptureSession的setRepeatingRequest()方法开始预览，
或调用capture()方法拍照。
实例：拍照时自动对焦
AutoFitTextureView
com/example/administrator/AutoFitTextureView.java
package com.example.administrator;
import android.content.Context;
import android.util.AttributeSet;
import android.view.TextureView;
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);
}
}
}
}
com/example/administrator/MainActivity.java
package com.example.administrator;
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 com.example.administrator.Permission.PermissionManager;
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, PermissionManager.PermissionsResultListener {
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);
PermissionManager.requestPermission(this, "申请摄像头权限", 0, this, Manifest.permission.CAMERA);
textureView = 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);
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;
}
try {
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();
}
}
/**
* 摄像头的配置
* @param width
* @param height
*/
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, "出现错误");
}
}
/**
* 获取最佳的预览尺寸
* @param choices
* @param width
* @param height
* @param aspectRatio
* @return
*/
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];
}
}
@Override
public void onPermissionGranted(int requestCode) {
}
@Override
public void onPermissionDenied(int requestCode) {
}
// 为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());
}
}
}
com/example/administrator/Permission/PermissionManager.java
package com.example.administrator.Permission;
import android.app.Activity;
import android.content.Context;
import android.content.DialogInterface;
import android.content.pm.PackageManager;
import android.os.Build;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AlertDialog;
import java.util.concurrent.ConcurrentHashMap;
/**
* @time 2017/2/20
* @fuction 动态权限管理封装类
* @use 1. 在BaseActivity和BaseFragment重写onRequestPermissionsResult ,并实现如下代码PermissionManager.onRequestResult(requestCode, permissions, grantResults);
* 2. 然后需要请求权限的时候调用requestPermission方法 即可
*/
public class PermissionManager {
//维护的每个Activity的申请权限的监听
//便于清除释放
private static ConcurrentHashMap<Integer, PermissionsResultListener> mListenerMap = new ConcurrentHashMap<>();
/**
* 权限申请
*
* @param context Activity
* @param desc 再次申请权限的提示语
* @param requestCode
* @param permissionsListener
* @param permissions
*/
public static void requestPermission(Activity context,
String desc,
int requestCode,
PermissionsResultListener permissionsListener,
String... permissions) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
mListenerMap.put(requestCode, permissionsListener);
if (checkEachSelfPermission(context, permissions)) {
requestEachPermission(context, desc, permissions, requestCode);
} else {
mListenerMap.get(requestCode).onPermissionGranted(requestCode);
}
}
}
/**
* 权限申请
*
* @param context Fragment
* @param desc 再次申请权限的提示语
* @param requestCode
* @param permissionsListener
* @param permissions
*/
public static void requestPermission(Fragment context,
String desc,
int requestCode,
PermissionsResultListener permissionsListener,
String... permissions) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
mListenerMap.put(requestCode, permissionsListener);
if (checkEachSelfPermission(context.getActivity(), permissions)) {
requestEachPermission(context, desc, permissions, requestCode);
} else {
mListenerMap.get(requestCode).onPermissionGranted(requestCode);
}
}
}
/**
* 权限请求
*
* @param context Activity
* @param desc 再次申请权限的提示语
* @param permissions
* @param requestCode
*/
private static void requestEachPermission(final Activity context, String desc, final String[] permissions, final int requestCode) {
if (shouldShowRequestPermissionRationale(context, permissions)) {
AlertDialog.Builder builder = new AlertDialog.Builder(context);
builder.setTitle("权限申请")
.setMessage(desc)
.setPositiveButton("确认", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
ActivityCompat.requestPermissions(context, permissions, requestCode);
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
dialogInterface.dismiss();
}
})
.setCancelable(false)
.show();
} else {
ActivityCompat.requestPermissions(context, permissions, requestCode);
}
}
/**
* 权限请求
*
* @param context Fragment
* @param desc 再次申请权限的提示语
* @param permissions
* @param requestCode
*/
private static void requestEachPermission(final Fragment context, String desc, final String[] permissions, final int requestCode) {
if (shouldShowRequestPermissionRationale(context, permissions)) {
AlertDialog.Builder builder = new AlertDialog.Builder(context.getActivity());
builder.setTitle("权限申请")
.setMessage(desc)
.setPositiveButton("确认", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
context.requestPermissions(permissions, requestCode);
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
dialogInterface.dismiss();
}
})
.setCancelable(false)
.show();
} else {
context.requestPermissions(permissions, requestCode);
}
}
/**
* 再次申请权限时，是否需要声明
*
* @param context Activity
* @param permissions
* @return
*/
private static boolean shouldShowRequestPermissionRationale(Activity context, String[] permissions) {
for (String permission : permissions) {
if (ActivityCompat.shouldShowRequestPermissionRationale(context, permission)) {
return true;
}
}
return false;
}
/**
* 再次申请权限时，是否需要声明
*
* @param context Fragment
* @param permissions
* @return
*/
private static boolean shouldShowRequestPermissionRationale(Fragment context, String[] permissions) {
for (String permission : permissions) {
if (context.shouldShowRequestPermissionRationale(permission)) {
return true;
}
}
return false;
}
/**
* 检察每个权限是否申请
*
* @param permissions
* @return true 需要申请权限,false 已申请权限
*/
private static boolean checkEachSelfPermission(Context context, String[] permissions) {
for (String permission : permissions) {
if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
return true;
}
}
return false;
}
/**
* 权限申请处理回调
* 写在Activity或者Fragment的onRequestPermissionsResult 方法内
*
* @param requestCode
* @param permissions
* @param grantResults
*/
public static void onRequestResult(int requestCode,
@NonNull String[] permissions,
@NonNull int[] grantResults) {
PermissionsResultListener permissionsResultListener = mListenerMap.get(requestCode);
if (permissionsResultListener == null) {
return;
}
if (grantResults.length > 0 &&
grantResults[0] == PackageManager.PERMISSION_GRANTED) {
permissionsResultListener.onPermissionGranted(requestCode);
} else {
permissionsResultListener.onPermissionDenied(requestCode);
}
}
/**
* 清除掉已用完的Listner
*/
public static void clearListner(int requestCode) {
if (mListenerMap.get(requestCode) != null) {
mListenerMap.remove(requestCode);
}
}
public interface PermissionsResultListener {
/**
* 权限申请成功回调
*/
void onPermissionGranted(int requestCode);
/**
* 权限申请失败回调
*/
void onPermissionDenied(int requestCode);
}
/**
* 危险权限 授权一个就等于同组都授权了
* Manifest.permission.XXX
*
* group:android.permission-group.CONTACTS
permission:android.permission.WRITE_CONTACTS
permission:android.permission.GET_ACCOUNTS
permission:android.permission.READ_CONTACTS
group:android.permission-group.PHONE
permission:android.permission.READ_CALL_LOG
permission:android.permission.READ_PHONE_STATE
permission:android.permission.CALL_PHONE
permission:android.permission.WRITE_CALL_LOG
permission:android.permission.USE_SIP
permission:android.permission.PROCESS_OUTGOING_CALLS
permission:com.android.voicemail.permission.ADD_VOICEMAIL
group:android.permission-group.CALENDAR
permission:android.permission.READ_CALENDAR
permission:android.permission.WRITE_CALENDAR
group:android.permission-group.CAMERA
permission:android.permission.CAMERA
group:android.permission-group.SENSORS
permission:android.permission.BODY_SENSORS
group:android.permission-group.LOCATION
permission:android.permission.ACCESS_FINE_LOCATION
permission:android.permission.ACCESS_COARSE_LOCATION
group:android.permission-group.STORAGE
permission:android.permission.READ_EXTERNAL_STORAGE
permission:android.permission.WRITE_EXTERNAL_STORAGE
group:android.permission-group.MICROPHONE
permission:android.permission.RECORD_AUDIO
group:android.permission-group.SMS
permission:android.permission.READ_SMS
permission:android.permission.RECEIVE_WAP_PUSH
permission:android.permission.RECEIVE_MMS
permission:android.permission.RECEIVE_SMS
permission:android.permission.SEND_SMS
permission:android.permission.READ_CELL_BROADCASTS
*/
}
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
