Kamera API'si

Android çerçevesi, cihazlarda bulunan çeşitli kameralar ve kamera özellikleri için destek içerir. Bu sayede, uygulamalarınızda resim ve video çekebilirsiniz. Bu dokümanda, resim ve video çekmeyle ilgili hızlı ve basit bir yaklaşım ele alınmakta ve kullanıcılarınız için özel kamera deneyimleri oluşturmaya yönelik gelişmiş bir yaklaşımın ana hatları çizilmektedir.

Not: Bu sayfada, desteği sonlandırılmış olan Camera sınıfı açıklanmaktadır. Şunu kullanmanızı öneririz: KameraX Jetpack kitaplığı veya belirli kullanım örnekleri için camera2, sınıfını kullanır. Hem CameraX hem de Camera2, Android 5.0 (API düzeyi 21) ve sonraki sürümlerde çalışır.

Aşağıdaki ilgili kaynaklara bakın:

• MediaPlayer'a genel bakış
• Veri ve dosya depolamaya genel bakış

Dikkat edilmesi gereken noktalar

Uygulamanızın Android cihazlarda kameraları kullanmasını etkinleştirmeden önce birkaç noktayı göz önünde bulundurmalısınız. Uygulamanızın bu donanım özelliğini nasıl kullanmayı amaçladığıyla ilgili sorular.

• Kamera şartı: Uygulamanız için kamera kullanımı o kadar önemli midir ki uygulamanızın kamerası olmayan bir cihaza yüklenmesini istemezsiniz? Öyleyse kamera şartını manifesto içinde yeniden etkinleştirilmelidir.
• Hızlı Resim veya Özelleştirilmiş Kamera: Uygulamanız kamerayı nasıl kullanacak? Sadece hızlı bir resim veya video klip çekmek mi istiyorsunuz yoksa uygulamanız kameraları kullanmak için yeni bir yöntem mi sağlıyor? Hızlı bir fotoğraf veya klip çekmek için Mevcut Kamera Uygulamalarını Kullanabilirsiniz. Özelleştirilmiş bir kamera özelliği geliştirmek için Kamera uygulaması oluşturma bölümüne göz atın.
• Ön Plan Hizmetleri Şartı: Uygulamanız kamerayla ne zaman etkileşime giriyor? Android 9 (API düzeyi 28) ve sonraki sürümlerde arka plan kameraya erişemiyor. Bu nedenle, kamerayı uygulamanız ön plandayken veya bir ön plan hizmeti kapsamında kullanmanız gerekir.
• Depolama alanı: Uygulamanızın oluşturduğu resim veya videolar yalnızca uygulamanız tarafından mı görüntülenecek yoksa Galeri gibi diğer medya ve sosyal medya uygulamalarının da kullanabileceği şekilde mi paylaşılacak? Resimlerin ve videoların, yalnızca kaldırılır mı? Şu işlemler için Medya Dosyalarını Kaydetme bölümüne bakın: nasıl uygulayacağınızı öğrenin.

Temel bilgiler

Android çerçevesi, android.hardware.camera2 API veya kamera Intent aracılığıyla resim ve video çekmeyi destekler. İlgili URL'ler sınıflar:

android.hardware.camera2

Bu paket, cihaz kameralarını kontrol etmek için kullanılan birincil API'dir. Bu rapor, resimler veya videolar paylaşabilirsiniz.

Camera

Bu sınıf, cihaz kameralarını kontrol etmek için desteği sonlandırılmış eski API'dir.

SurfaceView

Bu sınıf, kullanıcıya canlı kamera önizlemesi sunmak için kullanılır.

MediaRecorder

Bu sınıf, kameradan video kaydetmek için kullanılır.

Intent

Camera nesnesini doğrudan kullanmadan resim veya video çekmek için MediaStore.ACTION_IMAGE_CAPTURE ya da MediaStore.ACTION_VIDEO_CAPTURE intent işlem türü kullanılabilir.

Manifest beyanları

Uygulamanızı Camera API ile geliştirmeye başlamadan önce, manifest dosyanızda kamera donanımının ve ilgili diğer özelliklerin kullanımına izin verecek uygun beyanların bulunduğundan emin olmanız gerekir.

• Kamera İzni - Uygulamanızın, bir cihazı kullanmak için izin istemesi gerekir bulun.

  <uses-permission android:name="android.permission.CAMERA" />

  Not: Kamerayı tarafından kullanıyorsanız mevcut bir kamera uygulamasını çağırın uygulamanızın bu izni istemesine gerek yok.

• Kamera Özellikleri: Uygulamanız, kamera özelliklerinin kullanımını da belirtmelidir. Örneğin:

  <uses-feature android:name="android.hardware.camera" />

  Kamera özelliklerinin listesi için manifest Özellikler Referansı'na bakın.

  Manifest dosyanıza kamera özellikleri eklemek, Google Play'in uygulamanızın kamera içermeyen veya belirttiğiniz kamera özelliklerini desteklemeyen cihazlara yüklenmesini engellemesine neden olur. Google Play ile özellik tabanlı filtrelemeyi kullanma hakkında daha fazla bilgi için Google Play ve Özellik Tabanlı Filtreleme başlıklı makaleyi inceleyin.

  Uygulamanız düzgün çalışması için kamera veya kamera özelliğini kullanabilir ancak gerektirmezse android:required özelliğini ekleyerek ve false olarak ayarlayarak bunu manifest dosyasında belirtmeniz gerekir:

  <uses-feature android:name="android.hardware.camera" android:required="false" />

• Depolama izni: Uygulamanız, Android 10 (API düzeyi 29) veya daha eski sürümleri hedefliyorsa ve manifest dosyasında aşağıdakileri belirtiyorsa cihazın harici depolama alanına (SD kart) resim veya video kaydedebilir.

  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

• Ses Kaydı İzni: Video kaydı ile ses kaydı yapmak için uygulamanızın ses kaydı izni istemesi gerekir.

  <uses-permission android:name="android.permission.RECORD_AUDIO" />

• Konum izni: Uygulamanız resimleri GPS konum bilgileriyle etiketliyorsa ACCESS_FINE_LOCATION iznini istemeniz gerekir. Uygulamanız Android 5.0 (API düzeyi 21) veya daha yüksekse uygulamanızın cihazın GPS'ini kullandığını da beyan etmeniz gerekir:

  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  ...
  <!-- Needed only if your app targets Android 5.0 (API level 21) or higher. -->
  <uses-feature android:name="android.hardware.location.gps" />

  Kullanıcının konumunu alma hakkında daha fazla bilgi için bkz. Konum Stratejileri.

Mevcut kamera uygulamalarını kullanarak

Uygulamanızda çok fazla ek kod yazmadan fotoğraf veya video çekmeyi etkinleştirmenin hızlı bir yolu, mevcut bir Android kamera uygulamasını çağırmak için Intent kullanmaktır. Ayrıntılar Basitçe Fotoğraf Çekme ve Basitçe Video Kaydetme eğitim derslerinde açıklanmıştır.

Kamera uygulaması oluşturma

Bazı geliştiriciler, uygulamalarının görünümüne göre özelleştirilmiş veya özel özellikler sunan bir kamera kullanıcı arayüzüne ihtiyaç duyabilir. Kendi fotoğraf çekme kodunuzu yazarak kullanıcılarınıza daha ilgi çekici bir deneyim sunabilirsiniz.

Not: Aşağıdaki kılavuz daha eski, desteği sonlandırılmış Camera içindir API'ye gidin. Yeni veya gelişmiş kamera uygulamaları için daha yeni android.hardware.camera2 API kullanılması önerilir.

Uygulamanız için özel bir kamera arayüzü oluşturmaya yönelik genel adımlar şunlardır:

• Kamerayı Algıla ve Eriş: Mevcut olup olmadığını kontrol etmek için kod oluşturun erişim izni isteyin.
• Önizleme sınıfı oluşturma: SurfaceView sınıfını genişleten ve SurfaceHolder arayüzünü uygulayan bir kamera önizleme sınıfı oluşturun. Bu sınıf, kameradan gelen canlı görüntüleri önizler.
• Önizleme düzeni oluşturma: Kamera önizleme sınıfını oluşturduktan sonra, önizlemeyi ve istediğiniz kullanıcı arayüzü kontrollerini içeren bir görüntüleme düzeni oluşturun.
• Capture için Dinleyicileri Ayarlayın - Arayüzünüz için dinleyicileri bağlayın Kullanıcı işlemlerine yanıt olarak görüntü veya video yakalamayı başlatmaya yönelik kontroller (ör. bir düğmesini tıklayın.
• Dosya Kaydetme ve Kaydetme: Resim veya video çekme ve çıktıyı kaydetme kodunu oluşturun.
• Kamerayı bırakın - Kamerayı kullandıktan sonra uygulamanız diğer uygulamaların kullanımına uygun şekilde serbest bırakabilir.

Kamera donanımı, uygulamanızın da kullanmak isteyebileceği diğer uygulamalarla çakışmaması için dikkatli bir şekilde yönetilmesi gereken paylaşılan bir kaynaktır. Aşağıdaki bölümlerde kamera donanımı nasıl tespit edilir, kameraya erişim nasıl istenir, resim veya video nasıl çekilir ve uygulamanız bittiğinde kamerayı nasıl serbest bırakacağınızı öğrenmek istiyoruz.

Dikkat: Camera etiketini yayınlamayı unutmayın nesnesini tanımlarken Camera.release() öğesini çağırarak bir şey yoktur! Uygulamanız kamerayı düzgün bir şekilde bırakmıyorsa dahil olmak üzere kameraya erişmek için sonraki teşebbüslerin başarısız olması, uygulamalarınızın veya diğer uygulamalarınızın kapatılmasına neden olabilir.

Kamera donanımı algılanıyor

Uygulamanız, manifest beyanı kullanarak kamerayı özellikle gerektirmiyorsa çalışma zamanında kamera olup olmadığını kontrol etmeniz gerekir. Bu kontrolü yapmak için aşağıdaki örnek kodda gösterildiği gibi PackageManager.hasSystemFeature() yöntemini kullanın:

Kotlin

/** Check if this device has a camera */
private fun checkCameraHardware(context: Context): Boolean {
    if (context.packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
        // this device has a camera
        return true
    } else {
        // no camera on this device
        return false
    }
}

Java

/** Check if this device has a camera */
private boolean checkCameraHardware(Context context) {
    if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
        // this device has a camera
        return true;
    } else {
        // no camera on this device
        return false;
    }
}

Android cihazların birden fazla kamerası olabilir. Örneğin, fotoğrafçılık için bir arka kamera ve bir görüntülü görüşmeler için ön kamera. Android 2.3 (API Düzeyi 9) ve sonraki sürümler Camera.getNumberOfCameras() yöntemi kullanılarak cihazda kullanılabilen kamera sayısı.

Kameralara erişme

Uygulamanızın çalıştığı cihazda kamera olduğunu belirlediyseniz Camera örneği alarak kameraya erişme isteğinde bulunmanız gerekir (kameraya erişme intent'i kullanmıyorsanız).

Birincil kameraya erişmek için Camera.open() yöntemini kullanın ve aşağıdaki kodda gösterildiği gibi istisnaları yakalamayı unutmayın:

Kotlin

/** A safe way to get an instance of the Camera object. */
fun getCameraInstance(): Camera? {
    return try {
        Camera.open() // attempt to get a Camera instance
    } catch (e: Exception) {
        // Camera is not available (in use or does not exist)
        null // returns null if camera is unavailable
    }
}

Java

/** A safe way to get an instance of the Camera object. */
public static Camera getCameraInstance(){
    Camera c = null;
    try {
        c = Camera.open(); // attempt to get a Camera instance
    }
    catch (Exception e){
        // Camera is not available (in use or does not exist)
    }
    return c; // returns null if camera is unavailable
}

Dikkat: Camera.open() kullanırken istisnaları her zaman kontrol edin. Kamera açık olduğunda istisnalar kontrol edilemiyor uygulamanızın sistem tarafından kapatılmasına neden olur.

Android 2.3 (API Düzeyi 9) veya sonraki sürümleri çalıştıran cihazlarda belirli kameralara erişmek için şunları kullanabilirsiniz: Camera.open(int) Yukarıdaki örnek kod, birden fazla kamerası olan bir cihazdaki ilk arka kamera.

Kamera özellikleri kontrol ediliyor

Bir kameraya erişim elde ettikten sonra Camera.getParameters() yöntemini kullanarak ve desteklenen özellikler için döndürülen Camera.Parameters nesnesini kontrol ederek kameranın özellikleri hakkında daha fazla bilgi edinebilirsiniz. API 9 veya sonraki bir sürümü kullanıyorsanız kameranın cihazın ön tarafında mı yoksa arka tarafında mı olduğunu ve resmin yönünü belirlemek için Camera.getCameraInfo() simgesini kullanın.

Önizleme sınıfı oluşturma

Kullanıcıların etkili bir şekilde fotoğraf veya video çekmesi için cihaz kamerasının gördüğü alanı görebilmeleri gerekir. Kamera önizleme sınıfı, kameradan gelen canlı görüntü verilerini görüntüleyebilen bir SurfaceView'tır. Böylece kullanıcılar fotoğraf veya video çekebilir.

Aşağıdaki örnek kod, View düzenine dahil edildi. Bu sınıf, geri çağırma etkinliklerini yakalamak için SurfaceHolder.Callback yöntemini uygular kamera önizleme girişini atamak için gerekli olan, görünümü oluşturmak ve yok etmek için kullanılır.

Kotlin

/** A basic Camera preview class */
class CameraPreview(
        context: Context,
        private val mCamera: Camera
) : SurfaceView(context), SurfaceHolder.Callback {

    private val mHolder: SurfaceHolder = holder.apply {
        // Install a SurfaceHolder.Callback so we get notified when the
        // underlying surface is created and destroyed.
        addCallback(this@CameraPreview)
        // deprecated setting, but required on Android versions prior to 3.0
        setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS)
    }

    override fun surfaceCreated(holder: SurfaceHolder) {
        // The Surface has been created, now tell the camera where to draw the preview.
        mCamera.apply {
            try {
                setPreviewDisplay(holder)
                startPreview()
            } catch (e: IOException) {
                Log.d(TAG, "Error setting camera preview: ${e.message}")
            }
        }
    }

    override fun surfaceDestroyed(holder: SurfaceHolder) {
        // empty. Take care of releasing the Camera preview in your activity.
    }

    override fun surfaceChanged(holder: SurfaceHolder, format: Int, w: Int, h: Int) {
        // If your preview can change or rotate, take care of those events here.
        // Make sure to stop the preview before resizing or reformatting it.
        if (mHolder.surface == null) {
            // preview surface does not exist
            return
        }

        // stop preview before making changes
        try {
            mCamera.stopPreview()
        } catch (e: Exception) {
            // ignore: tried to stop a non-existent preview
        }

        // set preview size and make any resize, rotate or
        // reformatting changes here

        // start preview with new settings
        mCamera.apply {
            try {
                setPreviewDisplay(mHolder)
                startPreview()
            } catch (e: Exception) {
                Log.d(TAG, "Error starting camera preview: ${e.message}")
            }
        }
    }
}

Java

/** A basic Camera preview class */
public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
    private SurfaceHolder mHolder;
    private Camera mCamera;

    public CameraPreview(Context context, Camera camera) {
        super(context);
        mCamera = camera;

        // Install a SurfaceHolder.Callback so we get notified when the
        // underlying surface is created and destroyed.
        mHolder = getHolder();
        mHolder.addCallback(this);
        // deprecated setting, but required on Android versions prior to 3.0
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    public void surfaceCreated(SurfaceHolder holder) {
        // The Surface has been created, now tell the camera where to draw the preview.
        try {
            mCamera.setPreviewDisplay(holder);
            mCamera.startPreview();
        } catch (IOException e) {
            Log.d(TAG, "Error setting camera preview: " + e.getMessage());
        }
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        // empty. Take care of releasing the Camera preview in your activity.
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        // If your preview can change or rotate, take care of those events here.
        // Make sure to stop the preview before resizing or reformatting it.

        if (mHolder.getSurface() == null){
          // preview surface does not exist
          return;
        }

        // stop preview before making changes
        try {
            mCamera.stopPreview();
        } catch (Exception e){
          // ignore: tried to stop a non-existent preview
        }

        // set preview size and make any resize, rotate or
        // reformatting changes here

        // start preview with new settings
        try {
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();

        } catch (Exception e){
            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
        }
    }
}

Kamera önizlemeniz için belirli bir boyut ayarlamak isterseniz bunu yukarıdaki yorumlarda belirtildiği gibi surfaceChanged() yönteminde ayarlayın. Önizleme boyutunu ayarlarken getSupportedPreviewSizes() değerlerinden kullanılmalıdır. setPreviewSize() yönteminde keyfi değerler ayarlama

Not: Çoklu Pencere özelliği Android 7.0 (API düzeyi 24) ve sonraki sürümlerde Daha uzun önizlemenin en boy oranının etkinliğinizle aynı olduğunu varsayın setDisplayOrientation() arandıktan sonra bile. Pencere boyutuna ve en boy oranına bağlı olarak, geniş bir kamera önizlemesini dikey yönlü bir düzene veya tam tersi olarak, sinemaskop düzeni kullanarak dikey bir düzene sığdırmanız gerekebilir.

Düzene önizleme yerleştirme

Önceki bölümde gösterilen örnekte gösterildiği gibi bir kamera önizleme sınıfı, Fotoğraf veya video çekmek için kullanılan diğer kullanıcı arayüzü denetimleriyle birlikte bir etkinliğin düzeni. Bu bölümünde, önizleme için temel bir düzenin ve etkinliğin nasıl oluşturulacağı gösterilmektedir.

Aşağıdaki düzen kodu, kamera önizlemesini görüntülemek için kullanılabilecek çok basit bir görünüm sağlar. Bu örnekte, FrameLayout öğesinin amacı kamera önizleme sınıfının kapsayıcısıdır. Bu düzen türü, canlı kamera önizleme resimlerinin üzerine ek resim bilgileri veya kontrollerin yerleştirilebilmesi için kullanılır.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
  <FrameLayout
    android:id="@+id/camera_preview"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:layout_weight="1"
    />

  <Button
    android:id="@+id/button_capture"
    android:text="Capture"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    />
</LinearLayout>

Çoğu cihazda kamera önizlemesinin varsayılan yönü yataydır. Bu örnek düzen bir yatay (yatay) düzeni belirtir ve aşağıdaki kod, yatay olarak kullanılmaktadır. Kamera önizlemesini oluşturmayı kolaylaştırmak için aşağıdakileri manifest dosyanıza ekleyerek uygulamanızın önizleme etkinliği yönünü yatay olarak değiştirmeniz gerekir.

<activity android:name=".CameraActivity"
          android:label="@string/app_name"

          android:screenOrientation="landscape">
          <!-- configure this activity to use landscape orientation -->

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

Not: Kamera önizlemesinin yatay modda olması gerekmez. Android 2.2'den (API Düzeyi 8) başlayarak,setDisplayOrientation() önizleme resminin yönünü değiştirin. Kullanıcı yönünüzü yeniden yönlendirdikçe önizleme yönünü değiştirmek için telefon, önizleme sınıfınızın surfaceChanged() yönteminde ilk olarak Camera.stopPreview() ile önizlemeyi durdurun ve ardından yönü değiştirin önizlemeyi Camera.startPreview() ile tekrar başlatın.

Kamera görüntünüzün etkinliğinde, önizleme sınıfınızı yukarıdaki örnekte gösterilen FrameLayout öğesine ekleyin. Kamera etkinliğiniz de duraklatıldığında veya kapatıldığında kamerayı serbest bıraktığından emin olun. Aşağıdaki örnekte, Önizleme sınıfı oluşturma bölümünde gösterilen önizleme sınıfını eklemek için bir kamera etkinliğinin nasıl değiştirileceği gösterilmektedir.

Kotlin

class CameraActivity : Activity() {

    private var mCamera: Camera? = null
    private var mPreview: CameraPreview? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Create an instance of Camera
        mCamera = getCameraInstance()

        mPreview = mCamera?.let {
            // Create our Preview view
            CameraPreview(this, it)
        }

        // Set the Preview view as the content of our activity.
        mPreview?.also {
            val preview: FrameLayout = findViewById(R.id.camera_preview)
            preview.addView(it)
        }
    }
}

Java

public class CameraActivity extends Activity {

    private Camera mCamera;
    private CameraPreview mPreview;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Create an instance of Camera
        mCamera = getCameraInstance();

        // Create our Preview view and set it as the content of our activity.
        mPreview = new CameraPreview(this, mCamera);
        FrameLayout preview = (FrameLayout) findViewById(R.id.camera_preview);
        preview.addView(mPreview);
    }
}

Not: Yukarıdaki örnekteki getCameraInstance() yöntemi, Kameralara erişme bölümünde gösterilen örnek yöntemi ifade eder.

Fotoğraf çekme

Bir önizleme sınıfı ve bu sınıfı görüntüleyeceğiniz bir görüntüleme düzeni oluşturduktan sonra uygulamanızla resim çekmeye başlayabilirsiniz. Uygulama kodunuzda, kullanıcı arayüzü kontrollerinizin kullanıcı işlemine yanıt olarak fotoğraf çekerek yanıt vermesi için dinleyiciler ayarlamanız gerekir.

Bir resmi almak için Camera.takePicture() yöntemini kullanın. Bu yöntemde kameradan veri alan üç parametre kullanılır. Verileri JPEG biçiminde almak için resim verilerini alıp bir dosyaya yazmak üzere bir Camera.PictureCallback arayüzü uygulamanız gerekir. Aşağıdaki kod, kameradan alınan bir resmi kaydetmek için Camera.PictureCallback arayüzünün temel uygulamasını göstermektedir.

Kotlin

private val mPicture = Camera.PictureCallback { data, _ ->
    val pictureFile: File = getOutputMediaFile(MEDIA_TYPE_IMAGE) ?: run {
        Log.d(TAG, ("Error creating media file, check storage permissions"))
        return@PictureCallback
    }

    try {
        val fos = FileOutputStream(pictureFile)
        fos.write(data)
        fos.close()
    } catch (e: FileNotFoundException) {
        Log.d(TAG, "File not found: ${e.message}")
    } catch (e: IOException) {
        Log.d(TAG, "Error accessing file: ${e.message}")
    }
}

Java

private PictureCallback mPicture = new PictureCallback() {

    @Override
    public void onPictureTaken(byte[] data, Camera camera) {

        File pictureFile = getOutputMediaFile(MEDIA_TYPE_IMAGE);
        if (pictureFile == null){
            Log.d(TAG, "Error creating media file, check storage permissions");
            return;
        }

        try {
            FileOutputStream fos = new FileOutputStream(pictureFile);
            fos.write(data);
            fos.close();
        } catch (FileNotFoundException e) {
            Log.d(TAG, "File not found: " + e.getMessage());
        } catch (IOException e) {
            Log.d(TAG, "Error accessing file: " + e.getMessage());
        }
    }
};

Camera.takePicture() yöntemini çağırarak resim çekmeyi tetikleyin. Aşağıdaki örnek kodda, bu yöntemin bir View.OnClickListener düğmesinden nasıl çağrılacağı gösterilmektedir.

Kotlin

val captureButton: Button = findViewById(R.id.button_capture)
captureButton.setOnClickListener {
    // get an image from the camera
    mCamera?.takePicture(null, null, picture)
}

Java

// Add a listener to the Capture button
Button captureButton = (Button) findViewById(R.id.button_capture);
captureButton.setOnClickListener(
    new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            // get an image from the camera
            mCamera.takePicture(null, null, picture);
        }
    }
);

Not: Aşağıdaki örnekte mPicture üyesi, yukarıdaki örnek koda referans verir.

Dikkat: Camera etiketini yayınlamayı unutmayın nesnesini tanımlarken Camera.release() öğesini çağırarak bir şey yoktur! Kamerayı nasıl serbest bırakacağınız hakkında bilgi edinmek için Kamerayı serbest bırakma başlıklı makaleyi inceleyin.

Video yakalama

Android çerçevesi kullanılarak video yakalama işlemi, Camera nesnesinin dikkatli bir şekilde yönetilmesini ve MediaRecorder ile koordinasyonunu gerektirir. sınıfını kullanır. Camera ile video kaydederken MediaRecorder uygulamasının kamera donanımına erişmesine izin vermek için Camera.lock() ve Camera.unlock() çağrılarını yönetmeniz gerekir. ve Camera.open() ve Camera.release() çağrılarına ek olarak.

Not: Android 4.0 (API düzeyi 14) ve sonraki sürümlerde Camera.lock() ve Camera.unlock() çağrıları sizin için otomatik olarak yönetilir.

Cihaz kamerasıyla fotoğraf çekmenin aksine, video çekmek için çok özel bir çağrı sırası gerekir. Video çekimine başarıyla hazırlanmak ve video çekmek için belirli bir uygulama sırası izlemelisiniz. başvurunuzla birlikte aşağıda açıklandığı şekildedir.

1. Kamerayı açın - Camera.open() uygulamasını kullanın kamera nesnesinin bir örneğini almak için kullanılır.
2. Bağlantı Önizlemesi: Camera.setPreviewDisplay() kullanarak kameraya bir SurfaceView bağlayarak canlı kamera görüntüsü önizlemesi hazırlayın.
3. Önizlemeyi Başlat - Canlı kamera resimlerini göstermeye başlamak için Camera.startPreview() numaralı telefonu arayın.
4. Video Kaydını Başlat: Aşağıdaki adımlar Sırala'yı seçin:
   1. Kameranın Kilidini Açın - Camera.unlock() numaralı telefonu arayarak MediaRecorder tarafından kullanılmak üzere kameranın kilidini açın.
   2. MediaRecorder'ı yapılandırın - Aşağıdaki MediaRecorder yöntemlerini bu sırayla çağırın. Daha fazla bilgi için MediaRecorder referans dokümanlarını inceleyin.
      1. setCamera() - Video çekimi için kullanılacak kamerayı ayarlayın, uygulamanızın mevcut örneğini kullanın / Camera.
      2. setAudioSource() - ses kaynağı, MediaRecorder.AudioSource.CAMCORDER kullan.
      3. setVideoSource(): Video kaynağını ayarlayın, MediaRecorder.VideoSource.CAMERA kullanın.
      4. Video çıkış biçimini ve kodlamayı ayarlayın. Android 2.2 (API Düzeyi 8) ve daha yüksek ise MediaRecorder.setProfile yöntemini kullanın ve CamcorderProfile.get() ile bir profil örneği alın. Android 2.2'den önceki sürümlerde video çıkış biçimini ve kodlama parametrelerini ayarlamanız gerekir:
         1. setOutputFormat() - Ayarla çıkış biçimini, varsayılan ayarı veya MediaRecorder.OutputFormat.MPEG_4 değerini belirtin.
         2. setAudioEncoder(): Ses kodlama türünü ayarlayın, varsayılan ayarı veya MediaRecorder.AudioEncoder.AMR_NB'ı belirtin.
         3. setVideoEncoder() - Ayarla video kodlama türünü, varsayılan ayarı veya MediaRecorder.VideoEncoder.MPEG_4_SP değerini belirtin.
      5. setOutputFile(): çıkış dosyasını ayarlayın. Medya Dosyalarını Kaydetme bölümündeki örnek yöntemdeki getOutputMediaFile(MEDIA_TYPE_VIDEO).toString() değerini kullanın.
      6. setPreviewDisplay(): Uygulamanız için SurfaceView önizleme düzeni öğesini belirtin. Bağlantı Önizlemesi için belirttiğiniz nesneyi kullanın.

      Dikkat: Bu MediaRecorder yapılandırma yöntemlerini bu sırayla çağırmalısınız. Aksi takdirde Bu durumda uygulama hatalarla karşılaşır ve kayıt başarısız olur.

   3. MediaRecorder'ı hazırlama: MediaRecorder.prepare() çağrısını yaparak MediaRecorder'yi sağlanan yapılandırma ayarlarıyla hazırlayın.
   4. MediaRecorder'ı başlatın: MediaRecorder.start() çağrısını yaparak video kaydetmeye başlayın.
5. Video kaydını durdurma: Video kaydını başarıyla tamamlamak için aşağıdaki yöntemleri sırayla çağırın:
   1. Stop MediaRecorder: MediaRecorder.stop() çağrısı yaparak video kaydını durdurun.
   2. MediaRecorder'ı Sıfırla: İsteğe bağlı olarak, yapılandırma ayarlarını şuradan kaldırın: MediaRecorder.reset() numaralı telefonu arayarak kaydediciyi tekrar kullanabilirsiniz.
   3. MediaRecorder'ı Yayınlayın - MediaRecorder öğesini yayınlayın MediaRecorder.release() numaralı telefonu arayarak.
   4. Kamerayı Kilitleyin - Sonraki MediaRecorder oturumlarının Camera.lock() numaralı telefonu arayarak kamerayı kullanabilmesi için kamerayı kilitleyin. Android 4.0 (API düzeyi 14) sürümünden itibaren, MediaRecorder.prepare() çağrısı başarısız olmadığı sürece bu çağrı gerekli değildir.
6. Önizlemeyi durdurma: Kamerayı kullanmayı bitirdiğinizde Camera.stopPreview() simgesini kullanarak önizlemeyi durdurun.
7. Kamerayı Bırak - Diğer uygulamaların kullanabilmesi için kamerayı serbest bırakın Camera.release() numaralı telefonu arayarak.

Not: Önce kamera önizlemesi oluşturmadan ve bu işlemin ilk birkaç adımını atlayarak MediaRecorderkullanılabilir. Ancak kullanıcılar genellikle kayıt işlemine başlamadan önce önizleme görmeyi tercih ettiğinden bu işlem burada ele alınmamaktadır.

İpucu: Uygulamanız genellikle video kaydetmek için kullanılıyorsa önizlemenizi başlatmadan önce setRecordingHint(boolean) değerini true olarak ayarlayın. Bu ayar, kayda başlama süresini kısaltmaya yardımcı olabilir.

MediaRecorder'ı yapılandırma

Video kaydetmek için MediaRecorder sınıfını kullanırken yapılandırma adımlarını belirli bir sırayla uygulamanız ve ardından yapılandırmayı kontrol edip uygulamak için MediaRecorder.prepare() yöntemini çağırmanız gerekir. Aşağıdaki örnek kodda, MediaRecorder sınıfının video kaydı için nasıl doğru şekilde yapılandırılacağı ve hazırlanacağı gösterilmektedir.

Kotlin

private fun prepareVideoRecorder(): Boolean {
    mediaRecorder = MediaRecorder()

    mCamera?.let { camera ->
        // Step 1: Unlock and set camera to MediaRecorder
        camera?.unlock()

        mediaRecorder?.run {
            setCamera(camera)

            // Step 2: Set sources
            setAudioSource(MediaRecorder.AudioSource.CAMCORDER)
            setVideoSource(MediaRecorder.VideoSource.CAMERA)

            // Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
            setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH))

            // Step 4: Set output file
            setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString())

            // Step 5: Set the preview output
            setPreviewDisplay(mPreview?.holder?.surface)

            setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
            setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT)
            setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT)


            // Step 6: Prepare configured MediaRecorder
            return try {
                prepare()
                true
            } catch (e: IllegalStateException) {
                Log.d(TAG, "IllegalStateException preparing MediaRecorder: ${e.message}")
                releaseMediaRecorder()
                false
            } catch (e: IOException) {
                Log.d(TAG, "IOException preparing MediaRecorder: ${e.message}")
                releaseMediaRecorder()
                false
            }
        }

    }
    return false
}

Java

private boolean prepareVideoRecorder(){

    mCamera = getCameraInstance();
    mediaRecorder = new MediaRecorder();

    // Step 1: Unlock and set camera to MediaRecorder
    mCamera.unlock();
    mediaRecorder.setCamera(mCamera);

    // Step 2: Set sources
    mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
    mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);

    // Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
    mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH));

    // Step 4: Set output file
    mediaRecorder.setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString());

    // Step 5: Set the preview output
    mediaRecorder.setPreviewDisplay(mPreview.getHolder().getSurface());

    // Step 6: Prepare configured MediaRecorder
    try {
        mediaRecorder.prepare();
    } catch (IllegalStateException e) {
        Log.d(TAG, "IllegalStateException preparing MediaRecorder: " + e.getMessage());
        releaseMediaRecorder();
        return false;
    } catch (IOException e) {
        Log.d(TAG, "IOException preparing MediaRecorder: " + e.getMessage());
        releaseMediaRecorder();
        return false;
    }
    return true;
}

Android 2.2 (API düzeyi 8) öncesinde, CamcorderProfile kullanmak yerine çıkış biçimi ve kodlama biçimleri parametrelerini doğrudan ayarlamanız gerekir. Bu yaklaşım aşağıdaki kodda gösterildiği gibidir:

Kotlin

    // Step 3: Set output format and encoding (for versions prior to API Level 8)
    mediaRecorder?.apply {
        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT)
        setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT)
    }

Java

    // Step 3: Set output format and encoding (for versions prior to API Level 8)
    mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
    mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
    mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT);

MediaRecorder için aşağıdaki video kayıt parametreleri verilmiştir ancak, uygulamanız için bu ayarları düzenlemek isteyebilirsiniz:

• setVideoEncodingBitRate()
• setVideoSize()
• setVideoFrameRate()
• setAudioEncodingBitRate()
• setAudioChannels()
• setAudioSamplingRate()

MediaRecorder'ı başlatma ve durdurma

MediaRecorder sınıfını kullanarak video kaydını başlatır ve durdururken: aşağıda listelenen belirli bir sırayı takip etmeniz gerekir.

1. Camera.unlock() ile kameranın kilidini açma
2. MediaRecorder öğesini yukarıdaki kod örneğinde gösterildiği gibi yapılandırın
3. MediaRecorder.start()'ü kullanarak kayıt başlatma
4. Videoyu kaydetme
5. MediaRecorder.stop() uygulamasını kullanarak kaydı durdur
6. MediaRecorder.release() ile medya kaydediciyi serbest bırakma
7. Camera.lock()'ü kullanarak kamerayı kilitleme

Aşağıdaki örnek kod, bir düğmeyi doğru şekilde başlatmak ve durdurmak için nasıl bağlayacağınızı gösterir MediaRecorder sınıfını kullanarak video kaydı yapmasına izin veriliyor.

Not: Video kaydını tamamlarken kamerayı bırakmayın. Aksi takdirde önizlemeniz durdurulur.

Kotlin

var isRecording = false
val captureButton: Button = findViewById(R.id.button_capture)
captureButton.setOnClickListener {
    if (isRecording) {
        // stop recording and release camera
        mediaRecorder?.stop() // stop the recording
        releaseMediaRecorder() // release the MediaRecorder object
        mCamera?.lock() // take camera access back from MediaRecorder

        // inform the user that recording has stopped
        setCaptureButtonText("Capture")
        isRecording = false
    } else {
        // initialize video camera
        if (prepareVideoRecorder()) {
            // Camera is available and unlocked, MediaRecorder is prepared,
            // now you can start recording
            mediaRecorder?.start()

            // inform the user that recording has started
            setCaptureButtonText("Stop")
            isRecording = true
        } else {
            // prepare didn't work, release the camera
            releaseMediaRecorder()
            // inform user
        }
    }
}

Java

private boolean isRecording = false;

// Add a listener to the Capture button
Button captureButton = (Button) findViewById(id.button_capture);
captureButton.setOnClickListener(
    new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (isRecording) {
                // stop recording and release camera
                mediaRecorder.stop();  // stop the recording
                releaseMediaRecorder(); // release the MediaRecorder object
                mCamera.lock();         // take camera access back from MediaRecorder

                // inform the user that recording has stopped
                setCaptureButtonText("Capture");
                isRecording = false;
            } else {
                // initialize video camera
                if (prepareVideoRecorder()) {
                    // Camera is available and unlocked, MediaRecorder is prepared,
                    // now you can start recording
                    mediaRecorder.start();

                    // inform the user that recording has started
                    setCaptureButtonText("Stop");
                    isRecording = true;
                } else {
                    // prepare didn't work, release the camera
                    releaseMediaRecorder();
                    // inform user
                }
            }
        }
    }
);

Not: Yukarıdaki örnekte, prepareVideoRecorder() yöntemi, MediaRecorder'ı Yapılandırma bölümünde gösterilen örnek kod anlamına gelir. Bu yöntem, kamerayı kilitleme, MediaRecorder örneğini yapılandırma ve hazırlama işlemlerini gerçekleştirir.

Kamera serbest bırakma

Kameralar, bir cihazdaki uygulamalar tarafından paylaşılan kaynaklardır. Uygulamanız, Camera örneği aldıktan sonra kamerayı kullanabilir. Uygulamanız kamerayı kullanmayı bıraktığında ve duraklatıldığında (Activity.onPause()) kamera nesnesini serbest bırakma konusunda özellikle dikkatli olmanız gerekir. Uygulamanız kamerayı düzgün şekilde serbest bırakmazsa kendi uygulamanız tarafından yapılanlar da dahil olmak üzere kameraya erişmeyle ilgili sonraki tüm girişimler başarısız olur ve sizin veya diğer uygulamaların kapatılmasına neden olabilir.

Camera nesnesinin bir örneğini serbest bırakmak için aşağıdaki örnek kodda gösterildiği gibi Camera.release() yöntemini kullanın.

Kotlin

class CameraActivity : Activity() {
    private var mCamera: Camera?
    private var preview: SurfaceView?
    private var mediaRecorder: MediaRecorder?

    override fun onPause() {
        super.onPause()
        releaseMediaRecorder() // if you are using MediaRecorder, release it first
        releaseCamera() // release the camera immediately on pause event
    }

    private fun releaseMediaRecorder() {
        mediaRecorder?.reset() // clear recorder configuration
        mediaRecorder?.release() // release the recorder object
        mediaRecorder = null
        mCamera?.lock() // lock camera for later use
    }

    private fun releaseCamera() {
        mCamera?.release() // release the camera for other applications
        mCamera = null
    }
}

Java

public class CameraActivity extends Activity {
    private Camera mCamera;
    private SurfaceView preview;
    private MediaRecorder mediaRecorder;

    ...

    @Override
    protected void onPause() {
        super.onPause();
        releaseMediaRecorder();       // if you are using MediaRecorder, release it first
        releaseCamera();              // release the camera immediately on pause event
    }

    private void releaseMediaRecorder(){
        if (mediaRecorder != null) {
            mediaRecorder.reset();   // clear recorder configuration
            mediaRecorder.release(); // release the recorder object
            mediaRecorder = null;
            mCamera.lock();           // lock camera for later use
        }
    }

    private void releaseCamera(){
        if (mCamera != null){
            mCamera.release();        // release the camera for other applications
            mCamera = null;
        }
    }
}

Dikkat: Uygulamanız kamerayı düzgün şekilde serbest bırakmazsa kendi uygulamanız tarafından yapılanlar da dahil olmak üzere kameraya erişmeyle ilgili sonraki tüm girişimler başarısız olur ve uygulamanızın veya diğer uygulamaların kapatılmasına neden olabilir.

Medya dosyalarını kaydetme

Kullanıcılar tarafından oluşturulan resim ve video gibi medya dosyaları, cihazın harici depolama dizinini (SD Kart) kullanarak sistem alanından tasarruf etmek ve kullanıcıların bu dosyalara erişmesini sağlamak paylaşma fırsatınız olacak. Medya dosyalarını bir cihaza kaydetmek için pek çok olası dizin konumu vardır. Ancak geliştirici olarak düşünmeniz gereken yalnızca iki standart konum vardır:

• Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES): Bu yöntem, resim ve videoları kaydetmek için standart, paylaşılan ve önerilen konumu döndürür. Bu dizin paylaşılır (herkese açıktır). Bu nedenle, diğer uygulamalar bu konuma kaydedilen dosyaları kolayca bulabilir, okuyabilir, değiştirebilir ve silebilir. Uygulamanız kullanıcı tarafından kaldırılırsa bu konuma kaydedilen medya dosyaları kaldırılmaz. Kaçınılması gerekenler müdahale etmek için, kullanıcılarınızın mevcut resimlerine ve videolarına müdahale etmek istiyorsanız, aşağıdaki kod örneğinde gösterildiği gibi, bu dizin içindeki uygulamanın medya dosyalarını da destekler. Bu yöntem Android 2.2'de (API düzeyi 8) kullanılabilir. Önceki API sürümlerindeki eşdeğer çağrılar için Paylaşılan Dosyaları Kaydetme bölümüne bakın.
• Context.getExternalFilesDir(Environment.DIRECTORY_PICTURES): Bu yöntem, uygulamanızla ilişkili resim ve videoları kaydetmek için standart bir konum döndürür. Uygulamanızın yüklemesi kaldırılırsa bu konuma kaydedilen tüm dosyalar kaldırılır. Bu konum ve diğer uygulamalar bunları okuyabilir, değiştirebilir ve silebilir.

Aşağıdaki örnek kodda, bir cihazın kamerasını Intent ile çağırırken veya Kamera Uygulaması Oluşturma kapsamında kullanabileceğiniz bir medya dosyası için File veya Uri konumunun nasıl oluşturulacağı gösterilmektedir.

Kotlin

val MEDIA_TYPE_IMAGE = 1
val MEDIA_TYPE_VIDEO = 2

/** Create a file Uri for saving an image or video */
private fun getOutputMediaFileUri(type: Int): Uri {
    return Uri.fromFile(getOutputMediaFile(type))
}

/** Create a File for saving an image or video */
private fun getOutputMediaFile(type: Int): File? {
    // To be safe, you should check that the SDCard is mounted
    // using Environment.getExternalStorageState() before doing this.

    val mediaStorageDir = File(
            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
            "MyCameraApp"
    )
    // This location works best if you want the created images to be shared
    // between applications and persist after your app has been uninstalled.

    // Create the storage directory if it does not exist
    mediaStorageDir.apply {
        if (!exists()) {
            if (!mkdirs()) {
                Log.d("MyCameraApp", "failed to create directory")
                return null
            }
        }
    }

    // Create a media file name
    val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date())
    return when (type) {
        MEDIA_TYPE_IMAGE -> {
            File("${mediaStorageDir.path}${File.separator}IMG_$timeStamp.jpg")
        }
        MEDIA_TYPE_VIDEO -> {
            File("${mediaStorageDir.path}${File.separator}VID_$timeStamp.mp4")
        }
        else -> null
    }
}

Java

public static final int MEDIA_TYPE_IMAGE = 1;
public static final int MEDIA_TYPE_VIDEO = 2;

/** Create a file Uri for saving an image or video */
private static Uri getOutputMediaFileUri(int type){
      return Uri.fromFile(getOutputMediaFile(type));
}

/** Create a File for saving an image or video */
private static File getOutputMediaFile(int type){
    // To be safe, you should check that the SDCard is mounted
    // using Environment.getExternalStorageState() before doing this.

    File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(
              Environment.DIRECTORY_PICTURES), "MyCameraApp");
    // This location works best if you want the created images to be shared
    // between applications and persist after your app has been uninstalled.

    // Create the storage directory if it does not exist
    if (! mediaStorageDir.exists()){
        if (! mediaStorageDir.mkdirs()){
            Log.d("MyCameraApp", "failed to create directory");
            return null;
        }
    }

    // Create a media file name
    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
    File mediaFile;
    if (type == MEDIA_TYPE_IMAGE){
        mediaFile = new File(mediaStorageDir.getPath() + File.separator +
        "IMG_"+ timeStamp + ".jpg");
    } else if(type == MEDIA_TYPE_VIDEO) {
        mediaFile = new File(mediaStorageDir.getPath() + File.separator +
        "VID_"+ timeStamp + ".mp4");
    } else {
        return null;
    }

    return mediaFile;
}

Not: Environment.getExternalStoragePublicDirectory(), Android 2.2 (API Düzeyi 8) veya daha yüksek olabilir. Android'in önceki sürümlerini çalıştıran cihazları hedefliyorsanız bunun yerine Environment.getExternalStorageDirectory() kullanın. Daha fazla bilgi için Paylaşılan Dosyaları Kaydetme konusuna bakın.

URI'nın iş profillerini desteklemesi için önce dosya URI'sini içerik URI'sine dönüştürün. Ardından, içerik URI'sini bir Intent'in EXTRA_OUTPUT bölümüne ekleyin.

Bir Android cihaza dosya kaydetme hakkında daha fazla bilgi için Veri Depolama başlıklı makaleyi inceleyin.

Kamera özellikleri

Android, kamera uygulamanızla kontrol edebileceğiniz resim biçimi, flaş modu, odak ayarları ve daha birçok kamera özelliğini destekler. Bu bölümde, yaygın kamera özellikleri listelenip bunların nasıl kullanılacağı kısaca açıklanmaktadır. Çoğu kamera özelliğine Camera.Parameters nesnesi aracılığıyla erişilebilir ve bu nesne kullanılarak ayarlanabilir. Ancak Camera.Parameters'te basit ayarlardan daha fazlasını gerektiren birkaç önemli özellik vardır. Bu özellikler aşağıdaki bölümlerde ele alınmıştır:

• Ölçüm ve odak alanları
• Yüz algılama
• Zaman atlamalı video

Camera.Parameters üzerinden kontrol edilen özelliklerin nasıl kullanılacağı hakkında genel bilgi için Kamerayı kullanma özellikler bölümüne bakın. kamera parametreleri nesnesi olarak), API referansı için aşağıdaki özellik listesinde bulunan bağlantıları izleyin belgelerinden faydalanabilirsiniz.

Tablo 1. Yaygın olarak kullanılan kamera özellikleri, Android API Düzeyi'ne göre sıralanmıştır. tanıtıldı.

Özellik	API Düzeyi	Açıklama
Yüz Algılama	14	Bir resimdeki insan yüzlerini tanımlayıp odaklama, ölçüm ve beyaz denge için kullanın
Ölçüm Alanları	14	Beyaz dengeyi hesaplamak için resimde bir veya daha fazla alan belirtin
Odak Alanları	14	Odaklanmak için resimdeki bir veya daha fazla alanı ayarlayın
White Balance Lock	14	Otomatik beyaz dengesi ayarlamalarını durdurma veya başlatma
Exposure Lock	14	Otomatik pozlama ayarlarını durdurma veya başlatma
Video Snapshot	14	Video çekerken fotoğraf çekme (kareyi yakalama)
Zaman Atlamalı Video	11	Zaman atlamalı video kaydetmek için kareleri ayarlanmış gecikmelerle kaydedin
Multiple Cameras	9	Ön ve arka kameralar dahil olmak üzere cihazda birden fazla kamera desteği
Focus Distance	9	Kamera ile odakta olduğu görülen nesneler arasındaki mesafeleri bildirir
Zoom	8	Resim büyütme oranını ayarlama
Exposure Compensation	8	Işık pozlama seviyesini artır veya azalt
GPS Data	5	Resme coğrafi konum verilerini dahil etme veya hariç tutma
White Balance	5	Çekilen resimdeki renk değerlerini etkileyen beyaz denge modunu ayarlama
Focus Mode	5	Kameranın otomatik, sabit, makro veya sonsuzluk gibi bir özneye nasıl odaklanacağını ayarlayın
Scene Mode	5	Gece, plaj, kar gibi belirli fotoğrafçılık durumu türleri için önceden ayarlanmış bir mod uygula veya mum ışığı sahneleri
JPEG Quality	5	JPEG resminin sıkıştırma düzeyini ayarlayarak resim çıkış dosyası kalitesini ve boyutunu artırın veya azaltın
Flash Mode	5	Flaşı açma, kapatma veya otomatik ayarı kullanma
Color Effects	5	Çekilen resme siyah beyaz, sepya veya negatif gibi bir renk efekti uygulayın.
Anti-Banding	5	JPEG sıkıştırması nedeniyle renk gradyanlarındaki bant etkisini azaltır
Picture Format	1	Resmin dosya biçimini belirtin
Picture Size	1	Kayıtlı resmin piksel boyutlarını belirtin

Not: Bu özellikler aşağıdaki nedenlerden dolayı tüm cihazlarda desteklenmez: donanım farklılıkları ve yazılım uygulaması. Müsaitlik durumunu kontrol etme hakkında bilgi için özellikleri hakkında bilgi edinmek için Kontrol etme özellik kullanılabilirliği hakkında daha fazla bilgi edinin.

Özelliklerin kullanılabilirliği kontrol ediliyor

Android cihazlarda kamera özelliklerini kullanmak için ilk başlamanız gereken şey şu: tüm kamera özellikleri her cihazda desteklenmez. Ayrıca, belirli bir özelliği destekleyen cihazlar bu özellikleri farklı düzeylerde veya farklı seçeneklerle destekleyebilir. Bu nedenle, karar süreci, yeni bir kamera uygulaması geliştirmek istediğiniz kamera özelliklerine karar vermektir. hangi seviyeye taşındığını anlamanızı sağlar. Bu kararı verdikten sonra web sitenize kod eklemeyi cihaz donanımının bu özellikleri destekleyip desteklemediğini kontrol eden ve başarısız olduğunu kontrol eden kamera uygulaması veya mevcut bir özellik yoksa da

Kameranın parametreler nesnesini örnekleyerek ve ilgili yöntemleri kontrol ederek kamera özelliklerinin kullanılabilir olup olmadığını kontrol edebilirsiniz. Aşağıdaki kod örneğinde, bir Camera.Parameters nesne seçin ve kameranın otomatik odaklamayı destekleyip desteklemediğini kontrol edin özellik:

Kotlin

val params: Camera.Parameters? = camera?.parameters
val focusModes: List<String>? = params?.supportedFocusModes
if (focusModes?.contains(Camera.Parameters.FOCUS_MODE_AUTO) == true) {
    // Autofocus mode is supported
}

Java

// get Camera parameters
Camera.Parameters params = camera.getParameters();

List<String> focusModes = params.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
  // Autofocus mode is supported
}

Çoğu kamera özelliği için yukarıda gösterilen tekniği kullanabilirsiniz. İlgili içeriği oluşturmak için kullanılan Camera.Parameters nesnesi, bir özelliğin başarılı olup olmadığını (ve ne ölçüde) belirlemek için bir getSupported...(), is...Supported() veya getMax...() yöntemi sağlar desteklenir.

Uygulamanızın düzgün çalışması için belirli kamera özellikleri gerekiyorsa şunları yapabilirsiniz: uygulama manifestinize eklenerek bunları gerekli kılmayı amaçlar. Flaş ve otomatik odaklama gibi belirli kamera özelliklerinin kullanıldığını beyan ettiğinizde Google Play, uygulamanızın bu özellikleri desteklemeyen cihazlara yüklenmesini kısıtlar. Dahil olan kamera özelliklerinin uygulama manifestinizde beyan edilebilir. Manifest'e bakın. Özellikleri Referans.

Kamera özelliklerini kullanma

Çoğu kamera özelliği, Camera.Parameters nesnesi kullanılarak etkinleştirilir ve kontrol edilir. Bu nesneyi, önce Camera nesnesini değiştirerek getParameters() yöntemini çağırarak döndürülen parametrenin değiştirilmesi ardından aşağıdaki örnekte gösterildiği gibi, nesneye alıp tekrar kamera nesnesine yerleştirmek kod:

Kotlin

val params: Camera.Parameters? = camera?.parameters
params?.focusMode = Camera.Parameters.FOCUS_MODE_AUTO
camera?.parameters = params

Java

// get Camera parameters
Camera.Parameters params = camera.getParameters();
// set the focus mode
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
// set Camera parameters
camera.setParameters(params);

Bu teknik neredeyse tüm kamera özellikleri için geçerlidir ve çoğu parametre herhangi bir zamanda değiştirilebilir Camera nesnesinin bir örneğini aldıktan sonra geçen süre. Parametrelerde yapılan değişiklikler, genellikle kullanıcı tarafından uygulamanın kamera önizlemesinde hemen görülebilir. Yazılım tarafında, kamera donanımı yeni talimatları işleyip güncellenmiş görüntü verilerini gönderdiği için parametre değişikliklerinin geçerlilik kazanması birkaç kare sürebilir.

Önemli: Bazı kamera özellikleri isteğe bağlı olarak değiştirilemez. Özellikle kamera önizlemesinin boyutunu veya yönünü değiştirmek için önce önizlemeyi durdurmanız, önizleme boyutunu değiştirmeniz ve ardından önizlemeyi yeniden başlatmanız gerekir. Android 4.0 (API) sürümünden itibaren 14. Seviye) önizleme yönü, önizleme yeniden başlatılmadan değiştirilebilir.

Aşağıdakiler gibi diğer kamera özelliklerinin uygulanması için daha fazla kod gerekir:

• Ölçüm ve odaklanma alanları
• Yüz algılama
• Zaman atlamalı video

Aşağıdaki bölümlerde bu özelliklerin nasıl uygulanacağına dair kısa bir özet verilmiştir.

Ölçme ve odak alanları

Bazı fotoğrafik senaryolarda, otomatik odaklanma ve ışık sayacı yardımcı olur. Android 4.0'dan (API düzeyi 14) itibaren kamera uygulamanız, uygulamanızın veya kullanıcılarınızın odak veya ışık seviyesi ayarlarını belirlemek için bir resimdeki alanları belirtmesine ve bu değerleri resim veya video çekmek için kamera donanımına iletmesine olanak tanıyan ek kontroller sağlayabilir.

Ölçüm ve odaklama alanları, Camera.Parameters nesnesindeki yöntemler aracılığıyla kontrol edildikleri için diğer kamera özelliklerine çok benzer şekilde çalışır. Aşağıdaki kodda, Camera örneği için iki ışık ölçümü alanı ayarlanması gösterilmektedir:

Kotlin

// Create an instance of Camera
camera = getCameraInstance()

// set Camera parameters
val params: Camera.Parameters? = camera?.parameters

params?.apply {
    if (maxNumMeteringAreas > 0) { // check that metering areas are supported
        meteringAreas = ArrayList<Camera.Area>().apply {
            val areaRect1 = Rect(-100, -100, 100, 100) // specify an area in center of image
            add(Camera.Area(areaRect1, 600)) // set weight to 60%
            val areaRect2 = Rect(800, -1000, 1000, -800) // specify an area in upper right of image
            add(Camera.Area(areaRect2, 400)) // set weight to 40%
        }
    }
    camera?.parameters = this
}

Java

// Create an instance of Camera
camera = getCameraInstance();

// set Camera parameters
Camera.Parameters params = camera.getParameters();

if (params.getMaxNumMeteringAreas() > 0){ // check that metering areas are supported
    List<Camera.Area> meteringAreas = new ArrayList<Camera.Area>();

    Rect areaRect1 = new Rect(-100, -100, 100, 100);    // specify an area in center of image
    meteringAreas.add(new Camera.Area(areaRect1, 600)); // set weight to 60%
    Rect areaRect2 = new Rect(800, -1000, 1000, -800);  // specify an area in upper right of image
    meteringAreas.add(new Camera.Area(areaRect2, 400)); // set weight to 40%
    params.setMeteringAreas(meteringAreas);
}

camera.setParameters(params);

Camera.Area nesnesi iki veri parametresi içerir: Kameranın görüş alanı içinde bir alan belirtmek için kullanılan Rect nesnesi ve bir ağırlık değeri (kameraya bu alanın ışık sayacında hangi önem düzeyinin verilmesi gerektiğini söyler) ya da odak hesaplamalarını kullanın.

Camera.Area nesnesinde Rect alanı, 2000 x 2000 birimlik bir ızgara üzerinde eşlenen dikdörtgen bir şekli tanımlar. -1000, -1000 koordinatları , kamera görüntüsünün üst, sol köşesini ve 1000, 1000 koordinatları aşağıdaki resimde gösterildiği gibi kamera resminin sağ alt köşesine dokunun.

Şekil 1. Kırmızı çizgiler, kamera önizlemesinde Camera.Area belirtmek için kullanılan koordinat sistemini gösterir. Mavi kutu, Rect değerleri 333,333,667,667 olan bir kamera alanının konumunu ve şeklini gösterir.

Bu koordinat sisteminin sınırları, kamera önizlemesinde görünen görüntünün dış kenarına her zaman karşılık gelir ve yakınlaştırma düzeyiyle küçülüp genişlemez. Benzer bir şekilde, resim Camera.setDisplayOrientation() uygulamasını kullanarak önizle koordinat sistemini yeniden eşlemez.

Yüz algılama

Kişi içeren resimlerde yüzler genellikle resmin en önemli kısmıdır ve özelliği, resim çekerken hem odak hem de beyaz dengesini belirlemek için kullanılmalıdır. Android 4.0 (API düzeyi 14) çerçevesi, yüz tanıma teknolojisini kullanarak yüzleri tanımlamak ve resim ayarlarını hesaplamak için API'ler sağlar.

Not: Yüz algılama özelliği çalışırken setWhiteBalance(String), setFocusAreas(List<Camera.Area>) ve setMeteringAreas(List<Camera.Area>) özelliğinin herhangi bir etkisi yok.

Kamera uygulamanızda yüz algılama özelliğini kullanmak için birkaç genel adım gerekir:

• Cihazınızda yüz algılamanın desteklenip desteklenmediğini kontrol edin
• Yüz algılama dinleyicisi oluşturma
• Yüz algılama dinleyiciyi kameranızdaki nesneye ekleyin
• Önizlemeden sonra (ve her önizleme yeniden başlatıldıktan sonra) yüz algılamayı başlatma

Yüz algılama özelliği tüm cihazlarda desteklenmez. Bu özelliğin, yeni özellikler olup olmadığını getMaxNumDetectedFaces() numaralı telefon aranarak desteklenir. Bu kontrolün örneği, aşağıdaki startFaceDetection() örnek yönteminde gösterilmiştir.

Bildirim almak ve yüz algılamasına yanıt vermek için kamera uygulamanızın yüz algılama etkinlikleri için bir dinleyici ayarlaması gerekir. Bunu yapmak için şu özelliklere sahip bir işleyici sınıfı oluşturmanız gerekir: Camera.FaceDetectionListener arayüzünü aşağıda gösterildiği gibi uygular aşağıdaki örnek kodu kullanabilirsiniz.

Kotlin

internal class MyFaceDetectionListener : Camera.FaceDetectionListener {

    override fun onFaceDetection(faces: Array<Camera.Face>, camera: Camera) {
        if (faces.isNotEmpty()) {
            Log.d("FaceDetection", ("face detected: ${faces.size}" +
                    " Face 1 Location X: ${faces[0].rect.centerX()}" +
                    "Y: ${faces[0].rect.centerY()}"))
        }
    }
}

Java

class MyFaceDetectionListener implements Camera.FaceDetectionListener {

    @Override
    public void onFaceDetection(Face[] faces, Camera camera) {
        if (faces.length > 0){
            Log.d("FaceDetection", "face detected: "+ faces.length +
                    " Face 1 Location X: " + faces[0].rect.centerX() +
                    "Y: " + faces[0].rect.centerY() );
        }
    }
}

Bu sınıfı oluşturduktan sonra, aşağıdaki örnek kodda gösterildiği gibi uygulamanızın Camera nesnesine ayarlarsınız:

Kotlin

camera?.setFaceDetectionListener(MyFaceDetectionListener())

Java

camera.setFaceDetectionListener(new MyFaceDetectionListener());

Uygulamanız, kamera önizlemesini her başlattığınızda (veya yeniden başlattığınızda) yüz algılama işlevini başlatmalıdır. Aşağıdaki örnek kodda gösterildiği gibi, gerektiğinde çağırabilmeniz için yüz algılamayı başlatmaya yönelik bir yöntem oluşturun.

Kotlin

fun startFaceDetection() {
    // Try starting Face Detection
    val params = mCamera?.parameters
    // start face detection only *after* preview has started

    params?.apply {
        if (maxNumDetectedFaces > 0) {
            // camera supports face detection, so can start it:
            mCamera?.startFaceDetection()
        }
    }
}

Java

public void startFaceDetection(){
    // Try starting Face Detection
    Camera.Parameters params = mCamera.getParameters();

    // start face detection only *after* preview has started
    if (params.getMaxNumDetectedFaces() > 0){
        // camera supports face detection, so can start it:
        mCamera.startFaceDetection();
    }
}

Kamera önizlemesini her başlattığınızda yüz algılamayı başlatmanız gerekir. Önizleme sınıfı oluşturma bölümünde gösterilen önizleme sınıfını kullanıyorsanız startFaceDetection() yönteminizi, aşağıdaki örnek kodda gösterildiği gibi önizleme sınıfınızdaki hem surfaceCreated() hem de surfaceChanged() yöntemlerine ekleyin.

Kotlin

override fun surfaceCreated(holder: SurfaceHolder) {
    try {
        mCamera.setPreviewDisplay(holder)
        mCamera.startPreview()

        startFaceDetection() // start face detection feature
    } catch (e: IOException) {
        Log.d(TAG, "Error setting camera preview: ${e.message}")
    }
}

override fun surfaceChanged(holder: SurfaceHolder, format: Int, w: Int, h: Int) {
    if (holder.surface == null) {
        // preview surface does not exist
        Log.d(TAG, "holder.getSurface() == null")
        return
    }
    try {
        mCamera.stopPreview()
    } catch (e: Exception) {
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error stopping camera preview: ${e.message}")
    }
    try {
        mCamera.setPreviewDisplay(holder)
        mCamera.startPreview()

        startFaceDetection() // re-start face detection feature
    } catch (e: Exception) {
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error starting camera preview: ${e.message}")
    }
}

Java

public void surfaceCreated(SurfaceHolder holder) {
    try {
        mCamera.setPreviewDisplay(holder);
        mCamera.startPreview();

        startFaceDetection(); // start face detection feature

    } catch (IOException e) {
        Log.d(TAG, "Error setting camera preview: " + e.getMessage());
    }
}

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {

    if (holder.getSurface() == null){
        // preview surface does not exist
        Log.d(TAG, "holder.getSurface() == null");
        return;
    }

    try {
        mCamera.stopPreview();

    } catch (Exception e){
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error stopping camera preview: " + e.getMessage());
    }

    try {
        mCamera.setPreviewDisplay(holder);
        mCamera.startPreview();

        startFaceDetection(); // re-start face detection feature

    } catch (Exception e){
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error starting camera preview: " + e.getMessage());
    }
}

Not: Çağrı yaptıktan sonra bu yöntemi çağırmayı unutmayın. startPreview(). Yüz algılamayı başlatmaya çalışmayın kamera uygulamanızın ana etkinliğinin onCreate() yönteminde önizleme, uygulamanızın yürütmesinde bu noktada kullanılamaz.

Zaman atlamalı video

Zaman atlamalı video, kullanıcıların birkaç saniye veya birkaç saniyede çekilen resimleri birleştiren video klipler oluşturmasına olanak tanır. dakika arayla. Bu özellik, resimleri belirli bir süreliğine kaydetmek için MediaRecorder kullanır atlama dizisidir.

MediaRecorder ile zaman atlamalı video kaydetmek için kaydedici nesnesini kullanabilirsiniz. Saniyedeki kare sayısını en yüksek değere aşağıdaki kod örneğinde gösterildiği gibi, zaman atlamalı kalite ayarlarından birini kullanarak düşük bir sayı seçin ve zaman atlamalı kalite ayarlarından birini kullanın.

Kotlin

mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_TIME_LAPSE_HIGH))
mediaRecorder.setCaptureRate(0.1) // capture a frame every 10 seconds

Java

// Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_TIME_LAPSE_HIGH));
...
// Step 5.5: Set the video capture rate to a low number
mediaRecorder.setCaptureRate(0.1); // capture a frame every 10 seconds

Bu ayarlar, MediaRecorder için daha büyük bir yapılandırma prosedürü kapsamında yapılmalıdır. Tam yapılandırma kodu örneği için MediaRecorder'ı Yapılandırma bölümüne bakın. Yapılandırma tamamlandıktan sonra Video kaydını normal bir video klip kaydeder gibi başlatırsınız. MediaRecorder'ü yapılandırma ve çalıştırma hakkında daha fazla bilgi için Video çekme başlıklı makaleyi inceleyin.

Camera2Video ve HdrViewfinder örneklerinde, bu sayfada ele alınan API'lerin kullanımı daha ayrıntılı olarak gösterilmektedir.

İzin gerektiren kamera alanları

Android 10 (API düzeyi 29) veya sonraki sürümleri çalıştıran uygulamalar CAMERA iznini kullanarak aşağıdaki alanların değerlerine getCameraCharacteristics() yöntemi şunu döndürür:

• LENS_POSE_ROTATION
• LENS_POSE_TRANSLATION
• LENS_INTRINSIC_CALIBRATION
• LENS_RADIAL_DISTORTION
• LENS_POSE_REFERENCE
• LENS_DISTORTION
• LENS_INFO_HYPERFOCAL_DISTANCE
• LENS_INFO_MINIMUM_FOCUS_DISTANCE
• SENSOR_REFERENCE_ILLUMINANT1
• SENSOR_REFERENCE_ILLUMINANT2
• SENSOR_CALIBRATION_TRANSFORM1
• SENSOR_CALIBRATION_TRANSFORM2
• SENSOR_COLOR_TRANSFORM1
• SENSOR_COLOR_TRANSFORM2
• SENSOR_FORWARD_MATRIX1
• SENSOR_FORWARD_MATRIX2

Ek örnek kod

Örnek uygulamaları indirmek için Camera2Basic örneğine ve Resmi CameraX örnek uygulamasına bakın.