精华内容
下载资源
问答
  • 带有Java的Android CameraX简介

    千次阅读 2020-08-24 19:05:56
    Welcome! In this tutorial, we are going to build a fun application that detects your ... 在本教程中,我们将构建一个有趣的应用程序, 使用 CameraX 检测相机的方向 。 We’ll take it step by step and y...

    Welcome! In this tutorial, we are going to build a fun application that detects your camera’s orientation with CameraX.

    欢迎! 在本教程中,我们将构建一个有趣的应用程序, 使用 CameraX 检测相机的方向

    We’ll take it step by step and you can pause at any section if you feel like it. However, there are some prerequisites if you want to follow along without a headache.

    我们将逐步进行,如果您愿意,可以在任何部分停下来。 但是,如果您想不费吹灰之力地进行操作,则有一些先决条件。

    You can find the source code on my Github repository. Let me know if something is unclear/doesn’t work for you.

    您可以在我的Github存储库中找到源代码。 让我知道不清楚的地方/对您不起作用。

    先决条件 (Prerequisites)

    1. Previous experience with Android Development or Java to understand the syntax and structure.

      具有Android开发或Java的先前经验,以了解语法和结构。
    2. Access to Android Studio and an emulator or an android device with a camera.

      使用相机访问Android Studio和仿真器或android设备。
    3. Ability to follow instructions.

      能够遵循指示。

    Now that we got that out of the way, it’s time to get our hands dirty.

    现在我们已经解决了这个问题,现在该弄脏我们的手了。

    建立 (Set Up)

    1. Create a New Project in Android Studio and choose the Empty Activity when prompted.

      在Android Studio中创建一个新项目 ,并在出现提示时选择清空活动

    2. In the Project Configuration window select Java as the language and API 22: Android 5.1 (Lollipop) as the Minimum SDK.

      在“项目配置”窗口中,选择Java作为语言,并选择API 22:Android 5.1(Lollipop)作为最低SDK。

    Important: Make sure that you have the latest Android SDK installed on your system.

    重要提示:请确保您已在系统上安装了最新的Android SDK。

    Image for post
    Project Configuration Settings
    项目配置设置

    依存关系和权限 (Dependencies & Permissions)

    1. Find the build.gradle(Module:app) file under the Gradle Scripts directory.

      Gradle Scripts目录下找到build.gradle(Module:app)文件。

    2. Scroll to the bottom of the file and find the dependencies block. Add the following CameraX dependencies.

    2.滚动到文件底部,找到依赖关系块。 添加以下CameraX依赖项。

    def camerax_version = "1.0.0-beta07"implementation "androidx.camera:camera-camera2:$camerax_version"implementation "androidx.camera:camera-lifecycle:$camerax_version"implementation "androidx.camera:camera-view:1.0.0-alpha14"
    Image for post
    build.gradle(Module:app) dependencies
    build.gradle(Module:app)依赖项

    3. In the same file, find the android block and add the following to the bottom before the closing bracket.

    3.在同一文件中,找到android块,并将以下内容添加到右括号之前的底部。

    compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8}
    Image for post
    Compile Options in build.gradle(Module:app)
    在build.gradle(Module:app)中编译选项

    4. Now, let’s add the camera permissions. Open the AndroidManifest.xml under the Manifests directory and add the following lines.

    4.现在,让我们添加摄像头权限。 打开Manifests目录下的AndroidManifest.xml并添加以下行。

    <uses-feature android:name="android.hardware.camera.any" />
    <uses-permission android:name="android.permission.CAMERA" />
    Image for post
    Example AndroidManifest.xml with camera permissions
    具有相机权限的示例AndroidManifest.xml

    5. Sync Gradle settings by pressing on the toolbar icon.

    5.通过按工具栏上的图标来同步Gradle设置。

    Image for post
    Sync files with Gradle settings
    使用Gradle设置同步文件

    And that’s it. We’re done with the dependencies and permissions. The next steps involve coding the logic and connecting it to the user interface.

    就是这样。 我们已经完成了依赖性和权限。 下一步涉及对逻辑进行编码并将其连接到用户界面。

    步骤1:提示用户输入摄像头权限 (Step 1: Prompt the user for camera permission)

    If we don’t give camera access to our application, we can’t do anything. Luckily, Android already provides us with the logic we need for this part.

    如果我们不让相机访问我们的应用程序,那么我们将无能为力。 幸运的是,Android已经为我们提供了这部分所需的逻辑。

    权限逻辑 (Permission Logic)

    • Check if the permission has been granted

      检查是否已授予权限
    • If yes, enable camera; otherwise, ask for permission

      是=>开启摄像头; 否则,请寻求许可
    1. Find the MainActivity.java file under the app/java/{package_name} directory.

      app / java / {package_name}目录下找到MainActivity.java文件。

    In my case, it’s app/java/com.camerax.tutorial

    就我而言,它是app / java / com.camerax.tutorial

    2. Add the following code block in the onCreate method.

    2.在onCreate方法中添加以下代码块。

    Button enableCamera = findViewById(R.id.enableCamera);
    enableCamera.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    if (hasCameraPermission()) {
    enableCamera();
    } else {
    requestPermission();
    }
    }
    });

    This adds a listener to the button that we’re going to create in the user interface. When a user clicks it, the permission logic is invoked.

    这会将侦听器添加到我们将要在用户界面中创建的按钮上。 当用户单击它时,将调用权限逻辑。

    Now, we need to actually implement these methods. All of them are in the same file (MainActivity.java).

    现在,我们需要实际实现这些方法。 它们都在同一个文件(MainActivity.java)中。

    方法1:hasCameraPermission() (Method 1: hasCameraPermission())

    Returns a boolean value (True/False) depending on whether the user has given camera permission to our app.

    根据用户是否向我们的应用授予了相机许可,返回一个布尔值(真/假)。

    private boolean hasCameraPermission() {
    return ContextCompat.checkSelfPermission(
    this,
    Manifest.permission.CAMERA
    ) == PackageManager.PERMISSION_GRANTED;
    }

    方法2:requestPermission() (Method 2: requestPermission())

    Requests permission from the user so that our app can access the device’s camera and perform the image analysis.

    请求用户许可,以便我们的应用可以访问设备的相机并执行图像分析。

    private void requestPermission() {
    ActivityCompat.requestPermissions(
    this,
    CAMERA_PERMISSION,
    CAMERA_REQUEST_CODE
    );
    }

    方法3:enableCamera() (Method 3: enableCamera())

    Creates a new Intent object to start a CameraActivity.

    创建一个新的Intent对象以启动CameraActivity。

    Don’t worry about the CameraActivity class, we will create it in the next steps.

    不用担心CameraActivity类,我们将在下一步中创建它。

    private void enableCamera() {
    Intent intent = new Intent(this, CameraActivity.class);
    startActivity(intent);
    }

    The code so far:

    到目前为止的代码:

    public class MainActivity extends AppCompatActivity {
    private static final String[] CAMERA_PERMISSION = new String[]{Manifest.permission.CAMERA};
    private static final int CAMERA_REQUEST_CODE = 10;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Button enableCamera = findViewById(R.id.enableCamera);
    enableCamera.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    if (hasCameraPermission()) {
    enableCamera();
    } else {
    requestPermission();
    }
    }
    });
    }
    private boolean hasCameraPermission() {
    return ContextCompat.checkSelfPermission(
    this,
    Manifest.permission.CAMERA
    ) == PackageManager.PERMISSION_GRANTED;
    }
    private void requestPermission() {
    ActivityCompat.requestPermissions(
    this,
    CAMERA_PERMISSION,
    CAMERA_REQUEST_CODE
    );
    }
    private void enableCamera() {
    Intent intent = new Intent(this, CameraActivity.class);
    startActivity(intent);
    }
    }

    步骤2:创建CameraActivity类 (Step 2: Create the CameraActivity class)

    This activity is responsible for three main tasks. Initialize a camera provider, bind the image analysis case to the camera provider so that we can use the camera and analyse images (pretty self-explanatory), and keep track of the device’s camera rotation.

    此活动负责三个主要任务。 初始化相机提供程序,将图像分析用例绑定到相机提供程序,以便我们可以使用相机并分析图像(不言自明),并跟踪设备的相机旋转情况。

    To start fleshing out the code, let’s start with a few simple steps.

    为了充实代码,让我们从几个简单的步骤开始。

    1. Create a new CameraActivity class that extends AppCompatActivity in the same directory as the MainActivity class.

      在与MainActivity类相同的目录中创建一个扩展AppCompatActivity的新CameraActivity类。
    2. Define the following instance variables.

      定义以下实例变量。
    private PreviewView previewView;private ListenableFuture<ProcessCameraProvider> cameraProviderFuture;private TextView textView;

    Now, we have to implement the onCreate method which exists by default in the MainActivity class.

    现在,我们必须实现onCreate方法,该方法默认存在于MainActivity类中。

    方法1:onCreate() (Method 1: onCreate())

    Initializes the instance variables and binds a camera provider so that we can bind the image analysis case to it.

    初始化实例变量并绑定相机提供程序,以便我们可以将图像分析案例绑定到它。

    @Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_camera);
    previewView = findViewById(R.id.previewView);
    cameraProviderFuture = ProcessCameraProvider.getInstance(this);
    textView = findViewById(R.id.orientation);
    cameraProviderFuture.addListener(new Runnable() {
    @Override
    public void run() {
    try {
    ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
    bindImageAnalysis(cameraProvider);
    } catch (ExecutionException | InterruptedException e) {
    e.printStackTrace();
    }
    }
    }, ContextCompat.getMainExecutor(this));
    }

    Now that we have our onCreate method, we can implement the method that does all the hard work: the bindImageAnalysis method.

    现在我们有了onCreate方法,我们可以实现完成所有艰苦工作的方法:bindImageAnalysis方法。

    方法2:bindImageAnalysis() (Method 2: bindImageAnalysis())

    Binds the ImageAnalyzer to the camera provider created in the onCreate method and listens for changes in the camera’s rotation.

    将ImageAnalyzer绑定到在onCreate方法中创建的相机提供程序,并侦听相机旋转的变化。

    private void bindImageAnalysis(@NonNull ProcessCameraProvider cameraProvider) {
    ImageAnalysis imageAnalysis =
    new ImageAnalysis.Builder().setTargetResolution(new Size(1280, 720))
    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST).build();
    imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(this), new ImageAnalysis.Analyzer() {
    @Override
    public void analyze(@NonNull ImageProxy image) {
    image.close();
    }
    });
    OrientationEventListener orientationEventListener = new OrientationEventListener(this) {
    @Override
    public void onOrientationChanged(int orientation) {
    textView.setText(Integer.toString(orientation));
    }
    };
    orientationEventListener.enable();
    Preview preview = new Preview.Builder().build();
    CameraSelector cameraSelector = new CameraSelector.Builder()
    .requireLensFacing(CameraSelector.LENS_FACING_BACK).build();
    preview.setSurfaceProvider(previewView.createSurfaceProvider());
    cameraProvider.bindToLifecycle((LifecycleOwner)this, cameraSelector,
    imageAnalysis, preview);
    }

    The code so far:

    到目前为止的代码:

    public class CameraActivity extends AppCompatActivity {
    private PreviewView previewView;
    private ListenableFuture<ProcessCameraProvider> cameraProviderFuture;
    private TextView textView;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_camera);
    previewView = findViewById(R.id.previewView);
    cameraProviderFuture = ProcessCameraProvider.getInstance(this);
    textView = findViewById(R.id.orientation);
    cameraProviderFuture.addListener(new Runnable() {
    @Override
    public void run() {
    try {
    ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
    bindImageAnalysis(cameraProvider);
    } catch (ExecutionException | InterruptedException e) {
    e.printStackTrace();
    }
    }
    }, ContextCompat.getMainExecutor(this));
    }
    private void bindImageAnalysis(@NonNull ProcessCameraProvider cameraProvider) {
    ImageAnalysis imageAnalysis =
    new ImageAnalysis.Builder().setTargetResolution(new Size(1280, 720))
    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST).build();
    imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(this), new ImageAnalysis.Analyzer() {
    @Override
    public void analyze(@NonNull ImageProxy image) {
    image.close();
    }
    });
    OrientationEventListener orientationEventListener = new OrientationEventListener(this) {
    @Override
    public void onOrientationChanged(int orientation) {
    textView.setText(Integer.toString(orientation));
    }
    };
    orientationEventListener.enable();
    Preview preview = new Preview.Builder().build();
    CameraSelector cameraSelector = new CameraSelector.Builder()
    .requireLensFacing(CameraSelector.LENS_FACING_BACK).build();
    preview.setSurfaceProvider(previewView.createSurfaceProvider());
    cameraProvider.bindToLifecycle((LifecycleOwner)this, cameraSelector,
    imageAnalysis, preview);
    }
    }

    We are now done with the logic. It’s time to move on to the user interface and connect it to our logic.

    现在,我们已经完成了逻辑。 现在是时候进入用户界面并将其连接到我们的逻辑了。

    步骤3:定义用户界面 (Step 3: Defining the user interface)

    Before we do any changes in the layout folder, we need to register our new CameraActivity activity in the AndroidManifest.xml we edited in previous steps.

    在布局文件夹中进行任何更改之前,我们需要在之前步骤中编辑的AndroidManifest.xml中注册新的CameraActivity活动。

    1. Put the following snippet in the application block of your AndroidManifest.xml.

      将以下代码段放入AndroidManifest.xml的应用程序块中。
    <activity android:name=".CameraActivity"/>
    Image for post
    Registered CameraActivity in AndroidManifest.xml
    在AndroidManifest.xml中注册了CameraActivity

    Awesome! We’re almost there.

    太棒了! 我们快到了。

    屏幕1:activity_main.xml (Screen 1: activity_main.xml)

    In our MainActivity class we defined a Button named “enableCamera”. Now, it’s time to create it in the activity_main.xml.

    在我们的MainActivity类中,我们定义了一个名为“ enableCamera”的按钮。 现在,是时候在activity_main.xml中创建它了。

    1. Find the activity_main.xml file under the res/layout directory.

      在res / layout目录下找到activity_main.xml文件。
    2. Replace the code with the following snippet.

      将代码替换为以下代码段。
    <?xml version="1.0" encoding="utf-8"?>
    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <TextView
    android:layout_width="match_parent"
    android:layout_height="500dp"
    android:id="@+id/container"
    android:textSize="20sp"
    android:layout_gravity="center"
    android:text="This is a CameraX test app!"
    android:gravity="center">
    </TextView>
    <Button
    android:id="@+id/enableCamera"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:text="Open Camera" />
    </LinearLayout>
    </androidx.constraintlayout.widget.ConstraintLayout>

    The Button component is connected to our logic through the id attribute.

    Button组件通过id属性连接到我们的逻辑。

    When clicked, it either asks the user for permission or it enables the camera.

    单击后,它会询问用户许可或启用相机。

    But, we have also a CameraActivity class that also needs a user interface.

    但是,我们还有一个CameraActivity类,它也需要一个用户界面。

    Image for post
    Screen 1: Main Activity
    屏幕1:主要活动
    Image for post
    Ask user permission
    询问用户权限

    屏幕2:activity_camera.xml (Screen 2: activity_camera.xml)

    We need two components here. The “viewfinder” in which we can see the camera’s live feed and a text view so that we can show the camera’s orientation.

    这里我们需要两个组件。 在“取景器”中,我们可以看到摄像机的实时供稿和文本视图,从而可以显示摄像机的方向。

    1. In the same folder as activity_main.xml, create a new file named activity_camera.xml.

      在与activity_main.xml相同的文件夹中,创建一个名为activity_camera.xml的新文件。
    2. Copy the following code.

      复制以下代码。
    <?xml version="1.0" encoding="utf-8"?>
    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".CameraActivity">
    <FrameLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:id="@+id/container">
    <androidx.camera.view.PreviewView
    android:id="@+id/previewView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>
    </FrameLayout>
    <LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <TextView
    android:id="@+id/orientation"
    android:layout_width="match_parent"
    android:layout_height="300dp"
    android:layout_gravity="center"
    android:gravity="center"
    android:textSize="100sp"
    android:textColor="#9999ff"/>
    </LinearLayout>
    </androidx.constraintlayout.widget.ConstraintLayout>

    In the FrameLayout, we have a PreviewView that shows the camera’s live feed. The TextView component in the LinearLayout displays the changing orientation of the camera. You can customize the xml files as you wish, but you should keep in mind that if you change the id attribute here, you also have to change it in each class accordingly.

    在FrameLayout中,我们有一个PreviewView来显示摄像机的实时供稿。 LinearLayout中的TextView组件显示摄影机的变化方向。 您可以根据需要自定义xml文件,但是请记住,如果在此处更改id属性,则还必须在每个类中进行相应的更改。

    Image for post
    Screen 2: Camera Activity
    屏幕2:摄像机活动

    As you can see in the preview, the counter says 0 because the emulator’s default orientation is 0.

    如您在预览中所见,计数器的值为0,因为仿真器的默认方向为0。

    I recommend you test this application on your device so that you see the number change.

    我建议您在设备上测试此应用程序,以便看到号码更改。

    And that’s it! We’re done.

    就是这样! 大功告成

    I hope you learned something with this tutorial.

    我希望您通过本教程学到了一些东西。

    If you’ve made it this far, thank you. In case you have any questions or any trouble setting things up, don’t hesitate to contact me. I’ll be glad to help you out.

    如果您已经做到了这一点,谢谢。 如果您有任何疑问或在设置方面遇到任何麻烦,请随时与我联系。 我很高兴为您提供帮助。

    🌹

    🌹

    翻译自: https://medium.com/swlh/introduction-to-androids-camerax-with-java-ca384c522c5

    展开全文
  • android-camerax-java 使用Java实现Android CameraX的简单演示教程
  • java camera.rar

    2019-09-05 09:16:35
    在idea2019使用javaFX与java SDK12实现mediaplayer 操作camera
  • Java USB Camera Tools-开源

    2021-05-09 13:47:57
    该项目建立在jUSB API的基础上,最初支持Linux上USB上的图片传输协议(PTP)。 该软件是GPL发行的,包括一个可扩展的核心库(供开发人员使用),命令行支持和用户工具。
  • CameraX 是一个 Google 推出的 JetPack 组件。今天给大家分享JetPack之使用CameraX完成拍照和拍视频,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧
  • java swing界面调用本地摄像头,demo可以直接导入eclipse运行,直接运行CameraFrame.java即可。
  • Camera.open打开摄像头报错 java.lang.RuntimeException: Fail to connect to camera service 在Android 6.0或以上系统中,先检查AndroidManifest有没有设置权限 Android6.0及以上系统中需要动态权限申请。 接下来...

    Camera.open打开摄像头报错 java.lang.RuntimeException: Fail to connect to camera service
    在Android 6.0或以上系统中,先检查AndroidManifest有没有设置权限

    Android6.0及以上系统中需要动态权限申请。
    接下来本文通过Android原生API、EasyPermissions框架、RxPermissions框架等三种方式介绍怎么在开发过程中动态申请危险权限。

    以下内容转自https://www.jianshu.com/p/20ebbafe3189

    一、原生API实现动态权限申请
    1、判断是否拥有权限,使用ActivityCompat类中的checkSelfPermission方法,仅支持检测单个权限,如果需要检测多个权限,则使用逻辑运算符实现,这里以检测是否具有写存储空间权限和相机权限为例:

    if (!(ActivityCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED){
        //没有权限,申请权限
     	 String[] permissions = {Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA};
    	 //申请权限,其中RC_PERMISSION是权限申请码,用来标志权限申请的
    		ActivityCompat.requestPermissions(MainActivity.this,permissions, RC_PERMISSION);
    	}else {
           //拥有权限
    }
    

    申请权限的结果我们可以在onRequestPermissionsResult方法中进行分析

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    
          if (requestCode == RC_PERMISSION && grantResults.length == 2
                  && grantResults[0] == PackageManager.PERMISSION_GRANTED
                  && grantResults[1] == PackageManager.PERMISSION_GRANTED) {
              Log.e(TAG, "权限申请成功");
          }else {
              Log.e(TAG, "权限申请失败");
          }
    }
    

    参数解释

    requestCode:权限申请码,标志是哪次权限申请
    permissions:申请权限的字符串数组
    grantResults:权限申请的结果,是一个整型数组,这个数组的长度就是申请权限的个数,并且数组元素就是对应每个权限的申请结果
    2、用户点击“不再提醒”处理
    在权限申请过程中,如果第一次权限申请被用户拒绝了,那么第二次申请该权限的时候,在权限申请框上会出现一个“不再询问”的勾选,如果用户勾选了这个选项并拒绝的时候,那以后每次申请权限都直接返回权限拒绝
    点击了不再提示之后,权限申请时不会再弹出权限申请提示框了,而是直接返回失败,在这种情况下,我们应该引导用户去设置里把权限打开,但是android API中并没有判断用户是否勾选了“不再询问”的监听,那我们开发者怎么去判断用户是否勾选了“不再询问”呢?
    这个可以通过shouldShowRequestPermissionRationale(),这个访问的作用是是否需要向用户解释为何需要申请该权限,当首次申请权限时,该方法返回false,第二次申请权限会返回true。当第二次申请权限并且用户勾选了“不再询问”时该方法返回的是false,因此我们可以推导出,如果用户第二次申请权限被拒绝并且shouldShowRequestPermissionRationale()返回false,那么用户一定是勾选了不再询问,接下来可以通过以下代码引导用户前往设置页面打开权限:

    new AppSettingsDialog.Builder(this)
                        .setTitle("权限申请")
                        .setRationale("应用程序运行缺少必要的权限,请前往设置页面打开")
                        .setPositiveButton("去设置")
                        .setNegativeButton("取消")
                        .setRequestCode(RC_SETTINGS_SCREEN)
                        .build()
                        .show();
    /**
    *从设置页面返回,可以再次检查权限是否已打开
    */
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
    
        if (requestCode == AppConstants.RC_SETTINGS_SCREEN) {
            // Do something after user returned from app settings screen, like showing a Toast.
            LG.e("权限申请结果: 从设置页面返回");
        }
    }
    

    三、权限申请框架EasyPermissions简单使用
    EasyPermissions是Google官方推荐的简化权限申请的第三方框架,下面简单介绍该框架的使用:
    首先先在项目中添加依赖:
    implementation ‘pub.devrel:easypermissions:2.0.0’

    1.检查是否拥有权限
    String[] permissions = {Manifest.permission.WRITE_EXTERNAL_STORAGE,
    Manifest.permission.CAMERA};
    boolean hasPermissions = EasyPermissions.hasPermissions(EasyPermissionActivity.this, permissions);
    if (hasPermissions) {
    //拥有权限
    }else {
    //没有权限
    }

    2.申请权限

    首先重写onRequestPermissionsResult方法,将权限申请结果交给EasyPermissions处理

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        //Forward results to EasyPermissions
        EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
    }
    

    让Activity或者是Fragment实现EasyPermissions.PermissionCallbacks接口,实现这个接口的onPermissionsGranted和onPermissionsDenied方法,这两个方法是EasyPermissions处理权限申请结果的回调

    @Override
    public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
    
    }
    
    @Override
    public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
        if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) {
            //用户勾选了“不再询问”,引导用户去设置页面打开权限
            new AppSettingsDialog.Builder(this)
                    .setTitle("权限申请")
                    .setRationale("应用程序运行缺少必要的权限,请前往设置页面打开")
                    .setPositiveButton("去设置")
                    .setNegativeButton("取消")
                    .setRequestCode(RC_SETTINGS_SCREEN)
                    .build()
                    .show();
        }
    }
    
    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
    
        if (requestCode == RC_SETTINGS_SCREEN) {
            //用户从设置页面返回,可以在这里检测用户是否打开了权限
        }
    }
    

    在需要申请权限的地方调用以下方法

    @AfterPermissionGranted(RC_PERMISSIONS)
    private void requestStoreAndCameraPermission() {
        String[] permissions = {Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA};
        if (EasyPermissions.hasPermissions(this, permissions)) {
            //权限获取成功
        }else {
            //没有权限,调用方法申请权限
            EasyPermissions.requestPermissions(this, "程序运行需要存储权限和相机权限", RC_PERMISSIONS, permissions);
        }
    }
    

    添加AfterPermissionGranted注解的作用是,当权限申请成功之后,系统会自动调用一次该方法,这样会直接走权限获取成功的业务逻辑;
    EasyPermissions.requestPermissions方法的第二个参数的意义是当用户第一次拒绝了权限之后,第二次调用该方法获取权限时,会先弹出一个对话框向用户解释为何需要该权限,对话框的内容就是这个参数(弹出的对话框样式在这里无法自己定义)
    三、权限申请框架RxPermissions简单使用
    RxPermissions也是一款比较好用的权限申请框架,可以搭配着RxJava等一起使用,RxPermissions没有检测是否拥有权限的api,使用的时候是直接调用申请权限的方法。

    首先引入RxPermissions依赖包

    //项目Project的build.gradle文件
    allprojects {
    repositories {

    maven { url ‘https://jitpack.io’ }
    }
    }

    //模块app的build.gralde文件
    dependencies {
    implementation ‘com.github.tbruyelle:rxpermissions:0.10.2’
    }

    申请单个权限,这个方法没有处理用户勾选“不再询问”的处理

        RxPermissions rxPermissions = new RxPermissions(this);
        rxPermissions.request(Manifest.permission.CAMERA)
                .subscribe(granted -> {
                    if (granted) {
                        //拥有权限,在系统版本小于M时granted恒为true
                    } else {
                        //权限拒绝
                    }
                });
    

    申请多个权限,并且每个权限申请的结果分别返回

        RxPermissions rxPermissions = new RxPermissions(this);
        //在这里申请两个权限,两个申请结果分别返回,即回调两次
        rxPermissions.requestEach(Manifest.permission.WRITE_EXTERNAL_STORAGE,
                Manifest.permission.CAMERA)
                .subscribe(permission -> {
                    if (permission.granted) {
                        //获得权限成功
                    } else if (permission.shouldShowRequestPermissionRationale) {
                        //获取权限失败,但是用户没有勾选”不再询问“,在这里应该弹出对话框向用户解释为何需要该权限
                    }else {
                        //权限申请失败,用户勾选了“不再询问”,在这里应该引导用户去设置页面打开权限
                    }
                });
    

    申请多个权限,并且所有权限结果统一为一个返回,即要不返回成功,要不失败

        RxPermissions rxPermissions = new RxPermissions(this);
        rxPermissions.requestEachCombined(Manifest.permission.WRITE_EXTERNAL_STORAGE,
                Manifest.permission.CAMERA)
                .subscribe(permission -> {   //只回调一次
                    if (permission.granted) {
                        //全部权限获取成功
                    } else if (permission.shouldShowRequestPermissionRationale) {
                        //至少一个权限获取失败,但是用户没有勾选”不再询问“,在这里应该弹出对话框向用户解释为何需要该权限
                    }else {
                        //至少一个权限申请失败,用户勾选了“不再询问”,在这里应该引导用户去设置页面打开权限
                    }
                });
    

    四、总结
    本文记录了三种方式进行android 6.0动态权限申请,但是目前我比较常用的是RxPermissions 这个库,使用起来比较简便,而且也可以对用户勾选“不再询问”的操作进行处理。

    展开全文
  • 一个简单的Camera App,使用Camera2 Api捕获图像并拍摄视频。 截屏: 描述 从屏幕截图可以清楚地看到,它既可以拍摄图像又可以拍摄视频,并且还可以在捕获图像或视频时调整其亮度。 它还显示了最近捕获的图像。该...
  • Camera2Activity.java

    2020-01-21 09:57:30
    Camera2拍照工具类,申请相机权限操作,查看照片,兼容安卓10,做了沙盒处理。判断是否有SD卡,优先使用SD卡存储,当没有SD卡时使用手机存储。
  • 使用Java的摄像机 要求: JDK IDE,例如Netbeans或Eclipse 这里的Javacv jars 谢谢 TableLayout小组致力于通过挥杆使设计变得更容易。 步骤视频
  • 使用camera2 API的Android相机应用 #MIT许可证 版权所有(c)2017#Vishal Kumar 特此免费授予获得此软件和相关文档文件(“软件”)副本的任何人无限制地处理软件的权利,包括但不限于使用,复制,修改,合并的...
  • 调用本地电脑摄像头窗口视频。。。。。。。。。。
  • Android使用内置摄像头应用程序集成了摄像头功能。
  • CameraX Java 1.0.0-alpha10 安卓开发

    千次阅读 2020-03-28 17:31:17
    安卓的CameraX,目前使用的版本是1.0.0-alpha10 def camerax_version = "1.0.0-alpha10" implementation "androidx.camera:camera-camera2:${camerax_version}" // If you want to use the CameraX View class ...

    学习一下CameraX,目前使用的版本是1.0.0-alpha10

    def camerax_version = "1.0.0-alpha10"
        implementation "androidx.camera:camera-camera2:${camerax_version}"
        // If you want to use the CameraX View class
        implementation "androidx.camera:camera-view:1.0.0-alpha08"
        // If you want to use the CameraX Extensions library
        implementation "androidx.camera:camera-extensions:1.0.0-alpha08"
        // If you want to use the CameraX Lifecycle library
        implementation "androidx.camera:camera-lifecycle:${camerax_version}"
    

    还有这个也莫忘记了

    compileOptions {
            sourceCompatibility JavaVersion.VERSION_1_8
            targetCompatibility JavaVersion.VERSION_1_8
        }
    

    简单些,直接放代码。我只写了预览功能,如果需要别的功能建议看一下文档或者官方的实例(非java写的,但是结构差不太多,对照着写就好啦)
    这里建议下用java的同学,就不用看CameraX稍微早一点的教程了,这东西一版本一个样,说不定过几天我这篇也报废了(@_@;)
    早一点的,例如PreviewConfig,textureView都没了,变成了新的东西又加了一堆东西。

    public class MainActivity extends AppCompatActivity {
        PreviewView Mpreview;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            Mpreview = findViewById(R.id.view_finder);
    
            Mpreview.post(new Runnable() {
                @Override
                public void run() {
                    startCamera(MainActivity.this);
                }
            });
    
        }
    
       
        private void startCamera(Context context) {
            ListenableFuture cameraProviderFuture = ProcessCameraProvider.getInstance(context);
            cameraProviderFuture.addListener(new Runnable() {
                @Override
                public void run() {
                    try {
                        ProcessCameraProvider processCameraProvider= (ProcessCameraProvider) cameraProviderFuture.get();
                        Preview preview = new Preview.Builder()
                                .setTargetAspectRatio(AspectRatio.RATIO_16_9)
                                .setTargetRotation(Mpreview.getDisplay().getRotation())
                                .build();
    
                        preview.setSurfaceProvider(Mpreview.getPreviewSurfaceProvider());
                        processCameraProvider.bindToLifecycle((LifecycleOwner) context, CameraSelector.DEFAULT_FRONT_CAMERA,preview);
                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                }
            }, ContextCompat.getMainExecutor(context));
        }
    }
    
    <androidx.camera.view.PreviewView
            android:id="@+id/view_finder"
            android:layout_width="match_parent"
            android:layout_height="400dp"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintEnd_toEndOf="parent" />
    

    相机权限也别忘记啦,能学到这个库的想必也都早就会了,我就不放设置权限的代码了😂
    指纹已经抹掉了

    展开全文
  • camera2和三星api相机示例 简单的例子,如何使用camera2和三星camera api
  • Java技术开发的camera

    2011-07-28 22:19:42
    使用Java技术对Camera进行开发,界面很好
  • 一般调用系统进行拍照裁剪就能满足平时的需求,但有些场景或者特殊情况下如:持续不间断拍多张照片或者是进行人脸识别的时候,这时候之间调用系统原生相机拍照时不能满足自己的开发需求,就需要使用原生Camera来进行...
  • java调用摄像头方法

    千次阅读 2020-07-21 16:52:29
    java调用摄像头方法 import org.bytedeco.javacv.*; import javax.swing.*; public class JavaCVTest { public static void main(String[] args) throws FrameGrabber.Exception, ...
    java调用摄像头方法

    import org.bytedeco.javacv.*;

    import javax.swing.*;

    public class JavaCVTest {

        public static void main(String[] args) throws FrameGrabber.Exception, InterruptedException {
            testCamera();
        }

    //方法一:

        public static void testCamera() throws InterruptedException, FrameGrabber.Exception {
            OpenCVFrameGrabber grabber = new OpenCVFrameGrabber(0);
            grabber.start();   //开始获取摄像头数据
            CanvasFrame canvas = new CanvasFrame("摄像头");//新建一个窗口
            canvas.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
            canvas.setAlwaysOnTop(true);
            while (true) {
                if (!canvas.isDisplayable()) {//窗口是否关闭
                    grabber.stop();//停止抓取
                    System.exit(-1);//退出
                }

                Frame frame = grabber.grab();

                canvas.showImage(frame);//获取摄像头图像并放到窗口上显示, 这里的Frame frame=grabber.grab(); frame是一帧视频图像
                Thread.sleep(50);//50毫秒刷新一次图像
            }
        }

    //方法二:

        public void testCamera1() throws FrameGrabber.Exception, InterruptedException {
            VideoInputFrameGrabber grabber = VideoInputFrameGrabber.createDefault(0);
            grabber.start();
            CanvasFrame canvasFrame = new CanvasFrame("摄像头");
            canvasFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
            canvasFrame.setAlwaysOnTop(true);
            while (true) {
                if (!canvasFrame.isDisplayable()) {
                    grabber.stop();
                    System.exit(-1);
                }
                Frame frame = grabber.grab();
                canvasFrame.showImage(frame);
                Thread.sleep(30);
            }
        }
    }


     

    两个方法都可以用

    展开全文
  • 前言 笔者因为项目需要自定义相机,...首先来大致了解一下调用 camera2 的流程,方便我们理清思路。 要显示相机捕捉的画面,只需要三步:初始化相机,预览,更新预览。也就是上图中左侧的部分。要实现这三步,需要用
  • Android 调用opencv camera

    2018-03-01 13:21:21
    简单的Android opencv 摄像头调用的demo 适合新手学习。行如逆水行舟,不进则退。
  • 一般调用系统进行拍照裁剪就能满足平时的需求,但有些场景或者特殊情况下如:持续不间断拍多张照片或者是进行人脸识别的时候,这时候之间调用系统原生相机拍照时不能满足自己的开发需求,就需要使用原生Camera来进行...
  • Android Camera2 调用摄像头显示预览与拍照CameraFragment.javaMainActivity.java CameraFragment.java package com.example.customcamaratest; import android.Manifest; import android.content.Context; import ...
  • Camera.jar

    2019-08-13 23:40:38
    是关于java实现多种图像处理以及调用摄像头。
  • camera2.zip

    2020-05-12 01:17:04
    基于Camera2实现了预览功能,可直接运行使用,该项目可在安卓4.0至安卓10.0同步使用,独立剥离了预览功能,同时支持前后摄像头无缝切换。
  • CameraX 使用报错

    2021-06-03 17:47:39
    at androidx.camera.core.CameraX.lambda$initAndRetryRecursively$9$CameraX(CameraX.java:569) at androidx.camera.core.-$$Lambda$CameraX$u-Xx2b6YXY5GXNXRh-mDiDnHdpQ.run(Unknown Source:10) at java.util....
  • 使用Android CAMERA2 API从所有可用的照相机中秘密地拍照(无需预览或启动设备的照相机应用程序)。 取代了不赞成使用Camera类。 我如何支持这个项目? 如果您喜欢这个项目,并且可以帮助您创建项目,构建应用...
  • Android Camera 二 JNI JAVA和C/CPP图像数据传输流程分析 Android CameraCameraService 和 Client 链接到 HAL Android CameraCamera HAL 分析 Android CameraCamera HAL v1 Linux v4l2 一 应用层 ...
  • Android Camera 调用流程

    千次阅读 2016-06-16 17:56:13
    一:Camera的执行流程: 1.总体介绍 ...,主要包括Java代码和一些native层的c/c++代码;另一个是service进程,属于服务端,是native c/c++代码, 主要负责和linux kernel中的camera driver交互,搜
  • 一般调用系统进行拍照裁剪就能满足平时的需求,但有些场景或者特殊情况下如:持续不间断拍多张照片或者是进行人脸识别的时候,这时候之间调用系统原生相机拍照时不能满足自己的开发需求,就需要使用原生Camera来进行...
  • 安卓系统,各种Manager提供了系统层的控制接口,CameraManager也不例外,除去apk,那camera framework应该从CameraManager入口开始。 一般:CameraManager manager =(CameraManager)Context.getSystemService...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,444
精华内容 14,177
关键字:

java调用camera

java 订阅