Android - Kamera

Dies sind die folgenden zwei Möglichkeiten, wie Sie die Kamera in Ihrer Anwendung verwenden können

  • Verwenden der vorhandenen Android-Kamera-Anwendung in unserer Anwendung

  • Direkt mit der von Android in unserer Anwendung bereitgestellten Kamera-API

Verwenden der vorhandenen Android-Kamera-Anwendung in unserer Anwendung

Mit MediaStore.ACTION_IMAGE_CAPTURE können Sie eine vorhandene Kameraanwendung starten, die auf Ihrem Telefon installiert ist. Die Syntax ist unten angegeben

Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);

Abgesehen von den oben genannten gibt es weitere verfügbare Absichten, die von MediaStore bereitgestellt werden. Sie sind wie folgt aufgeführt

Sr.Nr. Absichtstyp und Beschreibung
1

ACTION_IMAGE_CAPTURE_SECURE

Es gibt das von der Kamera aufgenommene Bild zurück, wenn das Gerät gesichert ist

2

ACTION_VIDEO_CAPTURE

Es ruft die vorhandene Videoanwendung in Android auf, um Videos aufzunehmen

3

EXTRA_SCREEN_ORIENTATION

Hiermit wird die Ausrichtung des Bildschirms auf vertikal oder im Querformat eingestellt

4

EXTRA_FULL_SCREEN

Es wird verwendet, um die Benutzeroberfläche von ViewImage zu steuern

5

INTENT_ACTION_VIDEO_CAMERA

Diese Absicht wird verwendet, um die Kamera im Videomodus zu starten

6

EXTRA_SIZE_LIMIT

Hiermit wird die Größenbeschränkung für die Größe von Video- oder Bildaufnahmen festgelegt

Jetzt verwenden Sie die Funktion startActivityForResult () , um diese Aktivität zu starten und auf das Ergebnis zu warten. Die Syntax ist unten angegeben

startActivityForResult(intent,0)

Diese Methode wurde in der definiert activityKlasse. Wir nennen es von der Hauptaktivität. In der Aktivitätsklasse sind Methoden definiert, die denselben Job ausführen, jedoch verwendet werden, wenn Sie nicht von der Aktivität, sondern von einem anderen Ort aus aufrufen. Sie sind unten aufgeführt

Sr.Nr. Beschreibung der Aktivitätsfunktion
1

startActivityForResult(Intent intent, int requestCode, Bundle options)

Es startet eine Aktivität, kann jedoch zusätzliche Optionen mit sich bringen

2

startActivityFromChild(Activity child, Intent intent, int requestCode)

Die Aktivität wird gestartet, wenn Ihre Aktivität einer anderen Aktivität untergeordnet ist

3

startActivityFromChild(Activity child, Intent intent, int requestCode, Bundle options)

Es funktioniert wie oben, kann jedoch zusätzliche Werte in Form eines Bündels annehmen

4

startActivityFromFragment(Fragment fragment, Intent intent, int requestCode)

Es startet die Aktivität von dem Fragment, in dem Sie sich gerade befinden

5

startActivityFromFragment(Fragment fragment, Intent intent, int requestCode, Bundle options)

Es startet nicht nur die Aktivität aus dem Fragment, sondern kann zusätzliche Werte mitnehmen

Unabhängig davon, mit welcher Funktion Sie die Aktivität gestartet haben, geben alle das Ergebnis zurück. Das Ergebnis kann durch Überschreiben der Funktion onActivityResult erhalten werden .

Beispiel

In diesem Beispiel wird gezeigt, wie Sie die vorhandene Kameraanwendung starten, um ein Bild aufzunehmen und das Ergebnis in Form einer Bitmap anzuzeigen.

Um mit diesem Beispiel zu experimentieren, müssen Sie dies auf einem tatsächlichen Gerät ausführen, auf dem die Kamera unterstützt wird.

Schritte Beschreibung
1 Sie verwenden die Android Studio-IDE, um eine Android-Anwendung zu erstellen und sie unter com.example.sairamkrishna.myapplication als Kamera zu benennen.
2 Ändern Sie die Datei src / MainActivity.java, um Absichtscode zum Starten der Kamera hinzuzufügen.
3 Ändern Sie die Layout-XML-Datei res / layout / activity_main.xml
4 Fügen Sie die Berechtigung Kamera hinzu, führen Sie die Anwendung aus, wählen Sie ein laufendes Android-Gerät aus, installieren Sie die Anwendung darauf und überprüfen Sie die Ergebnisse.

Es folgt der Inhalt der geänderten Hauptaktivitätsdatei src/MainActivity.java.

package com.example.sairamkrishna.myapplication;

import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;

import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;

import android.net.Uri;
import android.os.Bundle;
import android.provider.Settings;

import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;

public class MainActivity extends AppCompatActivity {
   public static final int MY_PERMISSIONS_REQUEST_CAMERA = 100;
   public static final String ALLOW_KEY = "ALLOWED";
   public static final String CAMERA_PREF = "camera_pref";

   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
         if (getFromPref(this, ALLOW_KEY)) {
            showSettingsAlert();
         } else if (ContextCompat.checkSelfPermission(this,
            Manifest.permission.CAMERA)
            
            != PackageManager.PERMISSION_GRANTED) {
               
               // Should we show an explanation?
               if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                  Manifest.permission.CAMERA)) {
                  showAlert();
               } else {
                  // No explanation needed, we can request the permission.
                  ActivityCompat.requestPermissions(this,
                     new String[]{Manifest.permission.CAMERA},
                     MY_PERMISSIONS_REQUEST_CAMERA);
               }
            }
      } else {
         openCamera();
      }
      
   }
   public static void saveToPreferences(Context context, String key, Boolean allowed) {
      SharedPreferences myPrefs = context.getSharedPreferences(CAMERA_PREF, 
         Context.MODE_PRIVATE);
      SharedPreferences.Editor prefsEditor = myPrefs.edit();
      prefsEditor.putBoolean(key, allowed);
      prefsEditor.commit();
   }
		
   public static Boolean getFromPref(Context context, String key) {
      SharedPreferences myPrefs = context.getSharedPreferences(CAMERA_PREF, 
         Context.MODE_PRIVATE);
      return (myPrefs.getBoolean(key, false));
   }
		
   private void showAlert() {
      AlertDialog alertDialog = new AlertDialog.Builder(MainActivity.this).create();
      alertDialog.setTitle("Alert");
      alertDialog.setMessage("App needs to access the Camera.");
      
      alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE, "DONT ALLOW",
         new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
               dialog.dismiss();
               finish();
            }
      });
			
      alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, "ALLOW",
         new DialogInterface.OnClickListener() {
         
            public void onClick(DialogInterface dialog, int which) {
               dialog.dismiss();
               ActivityCompat.requestPermissions(MainActivity.this,
               new String[]{Manifest.permission.CAMERA},
               MY_PERMISSIONS_REQUEST_CAMERA);
            }
      });
      alertDialog.show();
   }
		
   private void showSettingsAlert() {
      AlertDialog alertDialog = new AlertDialog.Builder(MainActivity.this).create();
      alertDialog.setTitle("Alert");
      alertDialog.setMessage("App needs to access the Camera.");
      
      alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE, "DONT ALLOW",
         new DialogInterface.OnClickListener() {
         
            public void onClick(DialogInterface dialog, int which) {
               dialog.dismiss();
               //finish();
            }
      });
			
      alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, "SETTINGS",
         new DialogInterface.OnClickListener() {
                    
            public void onClick(DialogInterface dialog, int which) {
               dialog.dismiss();
               startInstalledAppDetailsActivity(MainActivity.this);
            }
      });
			
      alertDialog.show();
   }
		
   @Override
   public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
      switch (requestCode) {
         case MY_PERMISSIONS_REQUEST_CAMERA: {
            for (int i = 0, len = permissions.length; i < len; i++) {
               String permission = permissions[i];
            
               if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
                  boolean 
                  showRationale = 
                     ActivityCompat.shouldShowRequestPermissionRationale(
                     this, permission);
                  
                  if (showRationale) {
                     showAlert();
                  } else if (!showRationale) {
                     // user denied flagging NEVER ASK AGAIN
                     // you can either enable some fall back,
                     // disable features of your app
                     // or open another dialog explaining
                     // again the permission and directing to
                     // the app setting
                     saveToPreferences(MainActivity.this, ALLOW_KEY, true);
                  }
               }
            }
         }
         
         // other 'case' lines to check for other
         // permissions this app might request
      }
   }
		
   @Override
   protected void onResume() {
      super.onResume();
   }
		
   public static void startInstalledAppDetailsActivity(final Activity context) {
      if (context == null) {
         return;
      }
			
      final Intent i = new Intent();
      i.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
      i.addCategory(Intent.CATEGORY_DEFAULT);
      i.setData(Uri.parse("package:" + context.getPackageName()));
      i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
      i.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
      i.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
      context.startActivity(i);
   }
		
   private void openCamera() {
      Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
      startActivity(intent);
   }
}

Es folgt der Inhalt von res/layout/activity_main.xml file- -

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
      android:layout_width="match_parent"
   android:layout_height="match_parent" 
   android:paddingLeft="@dimen/activity_horizontal_margin"
   android:paddingRight="@dimen/activity_horizontal_margin"
   android:paddingTop="@dimen/activity_vertical_margin"
   android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">
</RelativeLayout>

Es folgt der Inhalt von res/values/strings.xml eine neue Konstante definieren

<resources>
   <string name="app_name">My Application</string>
</resources>

Es folgt der Standardinhalt von AndroidManifest.xml - -

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.sairamkrishna.myapplication" >
  <uses-permission android:name="android.permission.CAMERA" />
   <application
      android:allowBackup="true"
      android:icon="@drawable/ic_launcher"
      android:label="@string/app_name"
      android:theme="@style/AppTheme" >
      
      <activity
         android:name="com.example.sairamkrishna.myapplication.MainActivity"
         android:label="@string/app_name" >
         
         <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>
         
     </activity>
     
   </application>
</manifest>

Versuchen wir, Ihre Anwendung auszuführen. Ich gehe davon aus, dass Sie Ihr aktuelles Android Mobile-Gerät mit Ihrem Computer verbunden haben. Um die App von Android Studio aus auszuführen, öffnen Sie eine der Aktivitätsdateien Ihres Projekts und klicken Sie in der Symbolleiste auf das

Symbol Ausführen . Vor dem Starten Ihrer Anwendung zeigt Android Studio das folgende Fenster an, in dem Sie eine Option auswählen können, mit der Sie Ihre Android-Anwendung ausführen möchten.

Wählen Sie Ihr Mobilgerät als Option aus und überprüfen Sie dann Ihr Mobilgerät, das die Kamera öffnet und den folgenden Bildschirm anzeigt -