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 çekmeye yönelik 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. CameraX Jetpack kitaplığını veya belirli kullanım alanları için camera2 sınıfını kullanmanızı öneririz. Hem CameraX hem de Camera2, Android 5.0 (API düzeyi 21) ve sonraki sürümlerde çalışır.

Dikkat edilmesi gereken noktalar

Uygulamanızın Android cihazlarda kamera kullanmasını etkinleştirmeden önce, uygulamanızın bu donanım özelliğini nasıl kullanacağıyla ilgili birkaç soruyu göz önünde bulundurmanız gerekir.

• Kamera şartı: Kamera kullanımı, uygulamanız için o kadar önemli midir ki uygulamanızı kamerası olmayan bir cihaza yüklemek istemezsiniz? Bu durumda, kamera şartını manifest dosyanızda belirtmeniz gerekir.
• Hızlı Resim veya Özelleştirilmiş Kamera: Uygulamanız kamerayı nasıl kullanacak? Yalnızca hızlı bir fotoğraf veya video klip çekmek mi istiyorsunuz yoksa uygulamanız kameraları kullanmanın yeni bir yolunu mu sunacak? 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 planda çalışan uygulamalar kameraya erişemez. 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? Uygulamanız kaldırılsa bile fotoğraf ve videoların kullanılabilmesini istiyor musunuz? Bu seçeneklerin nasıl uygulanacağını öğrenmek için Medya Dosyalarını Kaydetme bölümüne göz atın.

Temel bilgiler

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

android.hardware.camera2

Bu paket, cihaz kameralarını kontrol etmek için kullanılan birincil API'dir. Kamera uygulaması geliştirirken fotoğraf veya video çekmek için kullanılabilir.

Camera

Bu sınıf, cihaz kameralarını kontrol etmek için kullanılan eski ve desteği sonlandırılmış 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, cihaz kamerasını kullanmak için izin istemelidir.

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

  Not: Kamerayı mevcut bir kamera uygulamasını çağırarak kullanıyorsanız uygulamanızın bu izni istemesi gerekmez.

• Kamera Özellikleri: Uygulamanız, kamera özelliklerinin kullanıldığı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 sonraki sürümleri hedefliyorsa uygulamanızın cihazın GPS'sini kullandığını da beyan etmeniz gerektiğini unutmayın:

  <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 Konum stratejileri başlıklı makaleyi inceleyin.

Mevcut kamera uygulamalarını kullanma

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, kullanımdan kaldırılmış eski Camera API içindir. Yeni veya gelişmiş kamera uygulamaları için daha yeni android.hardware.camera2 API'nin kullanılması önerilir.

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

• Kameraları algılama ve kameralara erişim: Kamera olup olmadığını kontrol etmek ve erişim isteğinde bulunmak için kod oluşturun.
• Ö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.
• Kayıt için dinleyicileri ayarlama: Kullanıcı işlemlerine (ör. düğmeye basma) yanıt olarak resim veya video kaydını başlatmak için arayüz kontrollerinize dinleyiciler bağlayın.
• Dosya Kaydetme ve Kaydetme: Resim veya video çekme ve çıktıyı kaydetme kodunu oluşturun.
• Kamera'yı serbest bırakma: Uygulamanız, kamerayı kullandıktan sonra diğer uygulamalar tarafından kullanılması için kamerayı uygun şekilde serbest bırakmalıdır.

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ının nasıl algılanacağı, kameraya erişim isteğinin nasıl gönderileceği, fotoğraf veya video çekme ve uygulamanız kamerayı kullanmayı bıraktığında kameranın nasıl serbest bırakılacağı ele alınmaktadır.

Dikkat: Uygulamanız Camera nesnesini kullanmayı tamamladığında Camera.release() işlevini çağırarak nesneyi serbest bırakmayı unutmayın. Uygulamanız kamerayı düzgün bir şekilde serbest bırakmazsa kendi uygulamanız tarafından yapılanlar da dahil olmak üzere kameraya yapılan sonraki tüm erişim girişimleri başarısız olur ve uygulamanızın veya diğer uygulamaların kapatılmasına neden olabilir.

Kamera donanımını algılama

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:

/** 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
    }
}

/** 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 cihazlarda birden fazla kamera bulunabilir. Örneğin, fotoğraf çekmek için arka kamera ve 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öntemini kullanarak bir cihazda bulunan kamera sayısını kontrol etmenize olanak tanır.

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ı yakaladığınızdan emin olun:

/** 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
    }
}

/** 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 her zaman istisna olup olmadığını kontrol edin. Kameranın kullanılıyor veya mevcut olmadığı durumlarda istisnaları kontrol etmezseniz uygulamanız sistem tarafından kapatılır.

Android 2.3 (API düzeyi 9) veya sonraki sürümleri çalıştıran cihazlarda Camera.open(int) kullanarak belirli kameralara erişebilirsiniz. Yukarıdaki örnek kod, birden fazla kamerası olan bir cihazdaki ilk arka kameraya erişir.

Kamera özelliklerini kontrol etme

Bir kameraya eriştikten 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 kodda, View düzenine dahil edilebilecek temel bir kamera önizleme sınıfının nasıl oluşturulacağı gösterilmektedir. Bu sınıf, kamera önizleme girişini atama için gereken görünümü oluşturma ve silme geri çağırma etkinliklerini yakalamak amacıyla SurfaceHolder.Callback'ü uygular.

/** 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}")
            }
        }
    }
}

/** 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 belirlemek istiyorsanız bunu yukarıdaki yorumlarda belirtildiği gibi surfaceChanged() yönteminde ayarlayın. Önizleme boyutunu ayarlarken getSupportedPreviewSizes() içindeki değerleri kullanmanız gerekir. setPreviewSize() yönteminde keyfi değerler ayarlama

Not: Android 7.0 (API düzeyi 24) ve sonraki sürümlerde Çoklu Pencere özelliğinin kullanıma sunulmasıyla birlikte, setDisplayOrientation() çağrısından sonra bile önizlemenin en boy oranının etkinliğinizle aynı olduğunu varsayamazsınız. 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.

Önizlemeyi bir düzene yerleştirme

Önceki bölümde gösterilen örnek gibi bir kamera önizleme sınıfı, fotoğraf veya video çekmek için diğer kullanıcı arayüzü kontrolleriyle birlikte bir etkinliğin düzenine yerleştirilmelidir. Bu bölümde, önizleme için temel bir düzen ve etkinlik oluşturma hakkında bilgi verilmektedir.

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 öğesi, kamera önizleme sınıfının kapsayıcısı olarak kullanılmaktadı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üzende yatay (landscape) bir düzen belirtilmiştir ve aşağıdaki kodda uygulamanın yönü landscape olarak ayarlanmıştır. Kamera önizlemesini oluşturmayı kolaylaştırmak için manifest dosyanıza aşağıdakileri 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 (API düzeyi 8) sürümünden itibaren, önizleme resminin dönüşünü ayarlamak için setDisplayOrientation() yöntemini kullanabilirsiniz. Kullanıcı telefonu yeniden yönlendirdiğinde önizleme yönünü değiştirmek için önizleme sınıfınızın surfaceChanged() yönteminde, önce Camera.stopPreview() ile önizlemeyi durdurun, yönü değiştirin ve ardından Camera.startPreview() ile önizlemeyi 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, duraklatıldığında veya kapatıldığında kameranın serbest bırakılmasını da sağlamalıdır. 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.

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)
        }
    }
}

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.

Resim almak için Camera.takePicture() yöntemini kullanın. Bu yöntem, kameradan veri alan üç parametre alı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 bir uygulamasını göstermektedir.

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}")
    }
}

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.

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

// 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 örnekteki mPicture üyesi, yukarıdaki örnek koda referans verir.

Dikkat: Uygulamanız Camera nesnesini kullanmayı tamamladığında Camera.release() işlevini çağırarak nesneyi serbest bırakmayı unutmayın. Kamerayı nasıl serbest bırakacağınız hakkında bilgi edinmek için Kamerayı serbest bırakma başlıklı makaleyi inceleyin.

Video çekme

Android çerçevesi kullanılarak video yakalama işlemi için Camera nesnesinin dikkatli bir şekilde yönetilmesi ve MediaRecorder sınıfıyla koordinasyon yapılması gerekir. Camera ile video kaydederken Camera.open() ve Camera.release() çağrılarının yanı sıra MediaRecorder'ın kamera donanımına erişmesine izin vermek için Camera.lock() ve Camera.unlock() çağrılarını da yönetmeniz gerekir.

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. Uygulamanızla video çekmeye hazırlanmak ve video çekmek için aşağıda ayrıntılı olarak açıklandığı şekilde belirli bir yürütme sırasını uygulamanız gerekir.

1. Kamera'yı aç: Kamera nesnesinin bir örneğini almak için Camera.open() simgesini kullanın.
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 görüntülerini göstermeye başlamak için Camera.startPreview() numaralı telefonu arayın.
4. Video Kaydı Başlatma: Videoyu başarıyla kaydetmek için aşağıdaki adımların tamamlanması gerekir:
   1. Kameranın kilidini açma: Camera.unlock()'ı arayarak kameranın kilidini MediaRecorder tarafından kullanılması için açın.
   2. MediaRecorder'ı yapılandırma: Aşağıdaki MediaRecorder yöntemleri bu sırayla çağırın. Daha fazla bilgi için MediaRecorder referans dokümanlarını inceleyin.
      1. setCamera(): Kamerayı video kaydı için kullanılacak şekilde ayarlayın. Uygulamanızın mevcut Camera örneğini kullanın.
      2. setAudioSource(): Ses kaynağını ayarlayın, MediaRecorder.AudioSource.CAMCORDER kullanın.
      3. setVideoSource(): Video kaynağını ayarlayın, MediaRecorder.VideoSource.CAMERA kullanın.
      4. Video çıkış biçimini ve kodlamasını ayarlayın. Android 2.2 (API düzeyi 8) ve sonraki sürümler için MediaRecorder.setProfile yöntemini kullanın ve CamcorderProfile.get() kullanarak 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(): Çıkış biçimini ayarlayın, varsayılan ayarı veya MediaRecorder.OutputFormat.MPEG_4'ı belirtin.
         2. setAudioEncoder(): Ses kodlama türünü ayarlayın, varsayılan ayarı veya MediaRecorder.AudioEncoder.AMR_NB'ı belirtin.
         3. setVideoEncoder(): Video kodlama türünü ayarlayın, varsayılan ayarı veya MediaRecorder.VideoEncoder.MPEG_4_SP'ı 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ğırmanız gerekir. Aksi takdirde uygulamanız 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. MediaRecorder'ı durdur: MediaRecorder.stop() çağrısı yaparak video kaydını durdurun.
   2. MediaRecorder'ı sıfırla: İsteğe bağlı olarak MediaRecorder.reset() çağrısını yaparak kaydedicideki yapılandırma ayarlarını kaldırın.
   3. MediaRecorder'ı serbest bırakma: MediaRecorder.release()'ı arayarak MediaRecorder'yi serbest bırakın.
   4. Kamerayı kilitle: Gelecekteki MediaRecorder oturumlarının Camera.lock()'ı çağırarak 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: Etkinliğiniz kamerayı kullanmayı bitirdiğinde Camera.stopPreview() simgesini kullanarak önizlemeyi durdurun.
7. Kamera'yı bırak: Camera.release() çağrısını yaparak diğer uygulamaların kamerayı kullanabilmesi için kamerayı bırakın.

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 açıklanmamaktadır.

İpucu: Uygulamanız genellikle video kaydı 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.

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
}

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österilmektedir:

    // 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)
    }

    // 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 kaydı parametreleri varsayılan ayarlardır ancak bu ayarları uygulamanız için 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ırken ve durdururken aşağıda listelenen belirli bir sırayı uygulamanız 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() simgesini kullanarak kaydı durdurur
6. MediaRecorder.release() ile medya kaydediciyi serbest bırakma
7. Camera.lock()'ü kullanarak kamerayı kilitleme

Aşağıdaki örnek kodda, kamera ve MediaRecorder sınıfını kullanarak video kaydını düzgün bir şekilde başlatmak ve durdurmak için bir düğmenin nasıl bağlanacağı gösterilmektedir.

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

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
        }
    }
}

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 kodu ifade eder. Bu yöntem, kamerayı kilitleme, MediaRecorder örneğini yapılandırma ve hazırlama işlemlerini gerçekleştirir.

Kamerayı serbest bırakma

Kameralar, cihazdaki uygulamalar tarafından paylaşılan bir kaynaktı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.

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
    }
}

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 bir şekilde serbest bırakmazsa kendi uygulamanız tarafından yapılanlar da dahil olmak üzere kameraya yapılan sonraki tüm erişim denemeleri 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ı, sistemde yer açmak ve kullanıcıların cihazları olmadan bu dosyalara erişmesine olanak tanımak için cihazın harici depolama dizinine (SD kart) kaydedilmelidir. Bir cihaza medya dosyası kaydetmek için birçok dizin konumu vardır ancak geliştirici olarak dikkate almanız 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. Kullanıcıların mevcut resim ve videolarını etkilememek için, aşağıdaki kod örneğinde gösterildiği gibi, bu dizin içinde uygulamanızın medya dosyaları için bir alt dizin oluşturmanız gerekir. 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 kaldırılırsa bu konuma kaydedilen tüm dosyalar kaldırılır. Bu konumdaki dosyalar için güvenlik uygulanmaz ve diğer uygulamalar bu dosyaları 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.

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
    }
}

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 sonraki sürümlerde kullanılabilir. 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 başlıklı makaleyi inceleyin.

URI'nin 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.

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 listelenmekte ve 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 aracılığıyla kontrol edilen özelliklerin nasıl kullanılacağı hakkında genel bilgi edinmek için Kamera özelliklerini kullanma bölümünü inceleyin. Kamera parametreleri nesnesi aracılığıyla kontrol edilen özelliklerin nasıl kullanılacağı hakkında daha ayrıntılı bilgi için aşağıdaki özellik listesindeki API referans dokümanlarına giden bağlantıları takip edin.

Tablo 1. Kullanıma sunulduğu Android API düzeyine göre sıralanmış yaygın kamera özellikleri.

Not: Donanım farklılıkları ve yazılım uygulaması nedeniyle bu özellikler tüm cihazlarda desteklenmemektedir. Uygulamanızın çalıştığı cihazda özelliklerin kullanılabilirliğini kontrol etme hakkında bilgi edinmek için Özelliklerin kullanılabilirliğini kontrol etme başlıklı makaleyi inceleyin.

Özellik kullanılabilirliğini kontrol etme

Android cihazlarda kamera özelliklerini kullanmaya başlamadan önce, tüm kamera özelliklerinin tüm cihazlarda desteklenmediğini bilmeniz gerekir. Ayrıca, belirli bir özelliği destekleyen cihazlar bu özellikleri farklı düzeylerde veya farklı seçeneklerle destekleyebilir. Bu nedenle, kamera uygulaması geliştirirken karar verme sürecinizin bir parçası olarak hangi kamera özelliklerini desteklemek istediğinize ve bu özellikleri hangi düzeyde desteklemek istediğinize karar vermeniz gerekir. Bu kararı verdikten sonra, kamera uygulamanıza cihaz donanımının bu özellikleri destekleyip desteklemediğini kontrol eden ve bir özellik kullanılamıyorsa bunu nazikçe bildiren bir kod eklemeyi planlamanız gerekir.

Kameranın parametreler nesnesi örneğini alarak ve ilgili yöntemleri kontrol ederek kamera özelliklerinin kullanılabilirliğini kontrol edebilirsiniz. Aşağıdaki kod örneğinde, Camera.Parameters nesnesini nasıl edineceğiniz ve kameranın otomatik odaklama özelliğini destekleyip desteklemediğini nasıl kontrol edeceğiniz gösterilmektedir:

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
}

// 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. Camera.Parameters nesnesi, bir özelliğin desteklenip desteklenmediğini (ve ne ölçüde desteklendiğini) belirlemek için getSupported...(), is...Supported() veya getMax...() yöntemi sağlar.

Uygulamanızın düzgün çalışması için belirli kamera özellikleri gerekiyorsa bunları uygulama manifestinize ekleme yaparak isteyebilirsiniz. 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. Uygulama manifest dosyanızda beyan edilebilecek kamera özelliklerinin listesi için manifest Özellikleri Referansı'na bakın.

Kamera özelliklerini kullanma

Çoğu kamera özelliği, Camera.Parameters nesnesi kullanılarak etkinleştirilir ve kontrol edilir. Bu nesneyi, önce Camera nesnesinin bir örneğini alarak, getParameters() yöntemini çağırarak, döndürülen parametre nesnesini değiştirerek ve ardından aşağıdaki örnek kodda gösterildiği gibi kamera nesnesine geri ayarlayarak elde edersiniz:

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

// 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 işe yarar ve çoğu parametre, Camera nesnesinin bir örneğini aldıktan sonra dilediğiniz zaman değiştirilebilir. 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 düzeyi 14) sürümünden itibaren, önizleme yeniden başlatılmadan önizleme yönü değiştirilebilir.

Diğer kamera özellikleri için uygulamak üzere daha fazla kod gerekir. Örneğin:

• Ö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çüm ve odak alanları

Bazı fotoğraf çekimi senaryolarında otomatik odaklama ve ışık ölçümü istenen sonuçları vermeyebilir. 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 edilmeleri açısından 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:

// 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
}

// 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ındaki bir alanı belirtmek için bir Rect nesnesi ve kameraya, ışık ölçümü veya odaklama hesaplamalarında bu alana ne kadar önem verilmesi gerektiğini belirten bir ağırlık değeri.

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

Ş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 şekilde, Camera.setDisplayOrientation() kullanılarak resim önizlemesinin döndürülmesi koordinat sistemini yeniden eşlemez.

Yüz algılama

İnsanların yer aldığı resimlerde yüzler genellikle resmin en önemli parçasıdır ve fotoğraf çekerken hem odak hem de beyaz dengeyi 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>)'in hiçbir etkisi olmaz.

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 dinleyicisini kamera nesnenize ekleme
• Ö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 desteklenip desteklenmediğini öğrenmek için getMaxNumDetectedFaces() numaralı telefonu arayabilirsiniz. Bu kontrolün bir örneği, aşağıdaki startFaceDetection() örnek yönteminde gösterilmektedir.

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. Bunun için aşağıdaki örnek kodda gösterildiği gibi Camera.FaceDetectionListener arayüzünü uygulayan bir dinleyici sınıfı oluşturmanız gerekir.

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()}"))
        }
    }
}

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:

camera?.setFaceDetectionListener(MyFaceDetectionListener())

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.

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()
        }
    }
}

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 başlattığınızda (veya yeniden başlattığınızda) her seferinde 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.

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}")
    }
}

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: Bu yöntemi startPreview()'i aradıktan sonra çağırmayı unutmayın. Uygulamanızın yürütülmesinin bu aşamasında önizleme kullanılamayacağından, kamera uygulamanızın ana etkinliğinin onCreate() yönteminde yüz algılamayı başlatmaya çalışmayın.

Zaman atlamalı video

Zaman atlamalı video, kullanıcıların birkaç saniye veya dakika arayla çekilen resimleri birleştiren video klipler oluşturmasına olanak tanır. Bu özellik, zaman atlamalı video sekansı için görüntüleri kaydetmek üzere MediaRecorder kullanır.

MediaRecorder ile zaman atlamalı video kaydetmek için kaydedici nesnesini normal bir video kaydediyormuş gibi yapılandırmanız, saniye başına yakalanan kare sayısını düşük bir sayıya ayarlamanız ve aşağıdaki kod örneğinde gösterildiği gibi zaman atlamalı kalite ayarlarından birini kullanmanız gerekir.

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

// 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 kapsamlı 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 başlıklı makaleyi inceleyin. Yapılandırma tamamlandıktan sonra, normal bir video klip kaydeder gibi video kaydını başlatın. 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ın, getCameraCharacteristics() yönteminin döndürdüğü aşağıdaki alanların değerlerine erişmek için CAMERA iznine sahip olması gerekir:

• 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.