Camera1 কে CameraX এ স্থানান্তর করুন

যদি আপনার অ্যাপটি আসল Camera ক্লাস ("ক্যামেরা1") ব্যবহার করে, যেটি Android 5.0 (API লেভেল 21) থেকে অবহেলিত হয়েছে, তাহলে আমরা একটি আধুনিক অ্যান্ড্রয়েড ক্যামেরা এপিআইতে আপডেট করার পরামর্শ দিই। অ্যান্ড্রয়েড ক্যামেরাএক্স (একটি প্রমিত, শক্তিশালী জেটপ্যাক ক্যামেরা API) এবং Camera2 (একটি নিম্ন-স্তরের, ফ্রেমওয়ার্ক API) অফার করে। বেশিরভাগ ক্ষেত্রে, আমরা আপনার অ্যাপটিকে CameraX-এ স্থানান্তরিত করার পরামর্শ দিই। কারণটা এখানে:

• ব্যবহারের সহজলভ্য: CameraX নিম্ন-স্তরের বিবরণ পরিচালনা করে, যাতে আপনি স্ক্র্যাচ থেকে ক্যামেরার অভিজ্ঞতা তৈরিতে কম ফোকাস করতে পারেন এবং আপনার অ্যাপকে আলাদা করার জন্য আরও বেশি মনোযোগ দিতে পারেন।
• CameraX আপনার জন্য ফ্র্যাগমেন্টেশন পরিচালনা করে: CameraX দীর্ঘমেয়াদী রক্ষণাবেক্ষণ খরচ এবং ডিভাইস-নির্দিষ্ট কোড হ্রাস করে, ব্যবহারকারীদের জন্য উচ্চ মানের অভিজ্ঞতা নিয়ে আসে। এই বিষয়ে আরও জানতে, ক্যামেরাএক্স ব্লগ পোস্টের সাথে আমাদের আরও ভাল ডিভাইসের সামঞ্জস্যতা দেখুন।
• উন্নত ক্ষমতা: CameraX যত্ন সহকারে ডিজাইন করা হয়েছে যাতে করে উন্নত কার্যকারিতা আপনার অ্যাপে অন্তর্ভুক্ত করা যায়। উদাহরণস্বরূপ, আপনি ক্যামেরাএক্স এক্সটেনশনগুলির সাথে আপনার ফটোগুলিতে সহজেই Bokeh, ফেস রিটাচ, HDR (হাই ডাইনামিক রেঞ্জ), এবং কম-আলো-উজ্জ্বল নাইট ক্যাপচার মোড প্রয়োগ করতে পারেন।
• আপডেটযোগ্যতা: Android সারা বছর ধরে CameraX-এ নতুন ক্ষমতা এবং বাগ ফিক্স প্রকাশ করে। CameraX-এ স্থানান্তরিত করার মাধ্যমে, আপনার অ্যাপটি প্রতিটি CameraX রিলিজের সাথে সর্বশেষ Android ক্যামেরা প্রযুক্তি পায়, শুধুমাত্র বার্ষিক Android সংস্করণ রিলিজে নয়।

এই নির্দেশিকাটিতে, আপনি ক্যামেরা অ্যাপ্লিকেশনগুলির জন্য সাধারণ পরিস্থিতিগুলি খুঁজে পাবেন৷ প্রতিটি দৃশ্যে একটি Camera1 বাস্তবায়ন এবং তুলনা করার জন্য একটি CameraX বাস্তবায়ন অন্তর্ভুক্ত।

যখন মাইগ্রেশনের কথা আসে, কখনও কখনও আপনার বিদ্যমান কোডবেসের সাথে সংহত করার জন্য অতিরিক্ত নমনীয়তার প্রয়োজন হয়। এই নির্দেশিকাতে থাকা সমস্ত CameraX কোডে একটি CameraController প্রয়োগ রয়েছে—আপনি যদি CameraX ব্যবহার করার সবচেয়ে সহজ উপায় চান—এবং একটি CameraProvider ইমপ্লিমেন্টেশন চান তাহলে দুর্দান্ত—আপনার যদি আরও নমনীয়তার প্রয়োজন হয়। আপনার জন্য কোনটি সঠিক তা সিদ্ধান্ত নিতে আপনাকে সাহায্য করতে, এখানে প্রতিটির সুবিধা রয়েছে:

ক্যামেরা কন্ট্রোলার	ক্যামেরা প্রদানকারী
সামান্য সেটআপ কোড প্রয়োজন	আরও নিয়ন্ত্রণের জন্য অনুমতি দেয়
CameraX কে আরও বেশি সেটআপ প্রক্রিয়া পরিচালনা করার অনুমতি দেওয়ার অর্থ হল ট্যাপ-টু-ফোকাস এবং পিঞ্চ-টু-জুম স্বয়ংক্রিয়ভাবে কাজ করার মতো কার্যকারিতা	যেহেতু অ্যাপ ডেভেলপার সেটআপ পরিচালনা করে, তাই কনফিগারেশন কাস্টমাইজ করার আরও সুযোগ রয়েছে, যেমন আউটপুট ইমেজ রোটেশন সক্ষম করা বা ImageAnalysis আউটপুট ইমেজ ফর্ম্যাট সেট করা
ক্যামেরা প্রিভিউয়ের জন্য PreviewView প্রয়োজন হলে CameraX-কে আমাদের ML কিট ইন্টিগ্রেশনের মতো বিরামহীন এন্ড-টু-এন্ড ইন্টিগ্রেশন অফার করতে দেয় যা ML মডেল ফলাফল স্থানাঙ্ক (যেমন ফেস বাউন্ডিং বক্স) সরাসরি প্রিভিউ কোঅর্ডিনেটে ম্যাপ করতে পারে।	ক্যামেরা পূর্বরূপের জন্য একটি কাস্টম `সারফেস` ব্যবহার করার ক্ষমতা আরও নমনীয়তার জন্য অনুমতি দেয়, যেমন আপনার বিদ্যমান `সারফেস` কোড ব্যবহার করা যা আপনার অ্যাপের অন্যান্য অংশে একটি ইনপুট হতে পারে

আপনি মাইগ্রেট করার চেষ্টায় আটকে গেলে, CameraX আলোচনা গ্রুপে আমাদের সাথে যোগাযোগ করুন।

আপনি মাইগ্রেট করার আগে

CameraX এর সাথে Camera1 ব্যবহার করুন

যদিও কোডটি ভিন্ন দেখাতে পারে, ক্যামেরা1 এবং ক্যামেরাএক্সের অন্তর্নিহিত ধারণাগুলি খুব একই রকম। CameraX সাধারণ ক্যামেরা কার্যকারিতাকে ব্যবহারের ক্ষেত্রে বিমূর্ত করে , এবং ফলস্বরূপ, Camera1-এ বিকাশকারীর কাছে ছেড়ে দেওয়া অনেকগুলি কাজ CameraX দ্বারা স্বয়ংক্রিয়ভাবে পরিচালনা করা হয়। CameraX-এ চারটি UseCase রয়েছে, যা আপনি ক্যামেরার বিভিন্ন কাজের জন্য ব্যবহার করতে পারেন: Preview , ImageCapture , VideoCapture , এবং ImageAnalysis ৷

ডেভেলপারদের জন্য নিম্ন-স্তরের বিবরণ পরিচালনা করার CameraX একটি উদাহরণ হল ViewPort যা সক্রিয় UseCase s-এর মধ্যে শেয়ার করা হয়। এটি নিশ্চিত করে যে সমস্ত UseCase গুলি একই পিক্সেল দেখতে পায়৷ Camera1-এ, আপনাকে এই বিশদ বিবরণগুলি নিজেই পরিচালনা করতে হবে এবং ডিভাইসের ক্যামেরা সেন্সর এবং স্ক্রীন জুড়ে আকৃতির অনুপাতের পরিবর্তনশীলতার প্রেক্ষিতে, ক্যাপচার করা ফটো এবং ভিডিওগুলির সাথে আপনার পূর্বরূপ মেলে তা নিশ্চিত করা কঠিন হতে পারে।

অন্য একটি উদাহরণ হিসেবে, CameraX Lifecycle ইন্সট্যান্সে Lifecycle কলব্যাকগুলি স্বয়ংক্রিয়ভাবে পরিচালনা করে যা আপনি পাস করেন। এর মানে CameraX পুরো অ্যান্ড্রয়েড অ্যাক্টিভিটি লাইফসাইকেলের সময় ক্যামেরার সাথে আপনার অ্যাপের সংযোগ পরিচালনা করে, নিম্নলিখিত কেসগুলি সহ: আপনার অ্যাপ ব্যাকগ্রাউন্ডে গেলে ক্যামেরা বন্ধ করা; ক্যামেরা প্রিভিউ অপসারণ যখন স্ক্রীনে আর এটি প্রদর্শনের প্রয়োজন হয় না; এবং ক্যামেরা প্রিভিউ বিরাম দেওয়া যখন অন্য একটি কার্যকলাপ ফোরগ্রাউন্ড অগ্রাধিকার নেয়, যেমন একটি ইনকামিং ভিডিও কল।

অবশেষে, CameraX আপনার পক্ষ থেকে কোনো অতিরিক্ত কোডের প্রয়োজন ছাড়াই ঘূর্ণন এবং স্কেলিং পরিচালনা করে। একটি আনলক করা অভিযোজন সহ একটি Activity ক্ষেত্রে, প্রতিবার ডিভাইসটি ঘোরানোর সময় UseCase সেটআপ করা হয়, কারণ সিস্টেম অভিযোজন পরিবর্তনের Activity ধ্বংস করে এবং পুনরায় তৈরি করে। এর ফলে UseCases তাদের লক্ষ্য ঘূর্ণন সেট করে প্রতিবার ডিফল্টরূপে ডিসপ্লের ওরিয়েন্টেশনের সাথে মেলে। CameraX এ ঘূর্ণন সম্পর্কে আরও পড়ুন ।

বিশদে ঝাঁপিয়ে পড়ার আগে, এখানে CameraX-এর UseCase এবং একটি Camera1 অ্যাপ কীভাবে সম্পর্কিত হবে তার একটি উচ্চ-স্তরের চেহারা রয়েছে। (ক্যামেরাএক্স ধারণাগুলি নীল এবং ক্যামেরা 1 ধারণাগুলি সবুজ রঙে ।)

CameraX-এ সামঞ্জস্য এবং কর্মক্ষমতা

CameraX Android 5.0 (API লেভেল 21) এবং উচ্চতর চলমান ডিভাইসগুলিকে সমর্থন করে৷ এটি বিদ্যমান অ্যান্ড্রয়েড ডিভাইসের 98% এরও বেশি প্রতিনিধিত্ব করে। CameraX স্বয়ংক্রিয়ভাবে ডিভাইসগুলির মধ্যে পার্থক্যগুলি পরিচালনা করার জন্য তৈরি করা হয়েছে, আপনার অ্যাপে ডিভাইস-নির্দিষ্ট কোডের প্রয়োজনীয়তা হ্রাস করে৷ উপরন্তু, আমরা আমাদের CameraX টেস্ট ল্যাবে 5.0 থেকে সমস্ত Android সংস্করণে 150টিরও বেশি শারীরিক ডিভাইস পরীক্ষা করি। আপনি বর্তমানে টেস্ট ল্যাবে থাকা ডিভাইসগুলির সম্পূর্ণ তালিকা পর্যালোচনা করতে পারেন।

CameraX ক্যামেরা স্ট্যাক চালানোর জন্য একটি Executor ব্যবহার করে। আপনার অ্যাপের নির্দিষ্ট থ্রেডিং প্রয়োজনীয়তা থাকলে আপনি CameraX-এ আপনার নিজস্ব নির্বাহক সেট করতে পারেন। সেট না থাকলে, CameraX একটি অপ্টিমাইজ করা ডিফল্ট ইন্টারনাল Executor তৈরি করে এবং ব্যবহার করে। অনেক প্ল্যাটফর্ম API যার উপর CameraX তৈরি করা হয়েছে তাদের হার্ডওয়্যার সহ আন্তঃপ্রসেস কমিউনিকেশন (IPC) ব্লক করা প্রয়োজন যা কখনও কখনও প্রতিক্রিয়া জানাতে শত শত মিলিসেকেন্ড সময় নিতে পারে। এই কারণে, CameraX শুধুমাত্র এই APIগুলিকে ব্যাকগ্রাউন্ড থ্রেড থেকে কল করে, যা নিশ্চিত করে যে মূল থ্রেডটি ব্লক করা হয়নি এবং UI তরল থাকে। থ্রেড সম্পর্কে আরও পড়ুন ।

যদি আপনার অ্যাপের টার্গেট মার্কেটে লো-এন্ড ডিভাইস থাকে, CameraX একটি ক্যামেরা লিমিটার দিয়ে সেটআপের সময় কমানোর একটি উপায় প্রদান করে। যেহেতু হার্ডওয়্যার উপাদানগুলির সাথে সংযোগ করার প্রক্রিয়াটি একটি অ-তুচ্ছ পরিমাণ সময় নিতে পারে, বিশেষত নিম্ন-সম্পন্ন ডিভাইসগুলিতে, আপনি আপনার অ্যাপের প্রয়োজনীয় ক্যামেরাগুলির সেট নির্দিষ্ট করতে পারেন৷ CameraX শুধুমাত্র সেটআপের সময় এই ক্যামেরাগুলির সাথে সংযোগ করে৷ উদাহরণস্বরূপ, যদি অ্যাপ্লিকেশনটি শুধুমাত্র পিছনের দিকের ক্যামেরা ব্যবহার করে, তবে এটি এই কনফিগারেশনটি DEFAULT_BACK_CAMERA এর সাথে সেট করতে পারে এবং তারপর CameraX লেটেন্সি কমাতে সামনের দিকের ক্যামেরা শুরু করা এড়িয়ে যায়৷

অ্যান্ড্রয়েড বিকাশের ধারণা

এই নির্দেশিকাটি Android বিকাশের সাথে একটি সাধারণ পরিচিতি অনুমান করে৷ মৌলিক বিষয়গুলির বাইরে, এখানে কয়েকটি ধারণা রয়েছে যা নীচের কোডে ঝাঁপিয়ে পড়ার আগে বুঝতে সহায়ক:

• ভিউ বাইন্ডিং আপনার XML লেআউট ফাইলগুলির জন্য একটি বাইন্ডিং ক্লাস তৈরি করে, যা আপনাকে অ্যাক্টিভিটি-তে আপনার মতামতকে সহজে উল্লেখ করতে দেয়, যেমনটি নীচের কয়েকটি কোড স্নিপেটে করা হয়েছে। ভিউ বাইন্ডিং এবং findViewById() (ভিউ রেফারেন্স করার পূর্বের উপায়) এর মধ্যে কিছু পার্থক্য রয়েছে, কিন্তু নীচের কোডে আপনি একটি অনুরূপ findViewById() কল দিয়ে ভিউ বাইন্ডিং লাইন প্রতিস্থাপন করতে সক্ষম হবেন।
• অ্যাসিঙ্ক্রোনাস কোরোটিনগুলি হল কোটলিন 1.3-এ যোগ করা একটি কনকারেন্সি ডিজাইন প্যাটার্ন যা ক্যামেরাএক্স পদ্ধতিগুলি পরিচালনা করতে ব্যবহার করা যেতে পারে যা একটি ListenableFuture প্রদান করে। এটিকে জেটপ্যাক কনকারেন্ট লাইব্রেরি 1.1.0 সংস্করণের মাধ্যমে সহজ করা হয়েছে। আপনার অ্যাপে একটি অ্যাসিঙ্ক্রোনাস কোরোটিন যোগ করতে:
  1. আপনার Gradle ফাইলে implementation("androidx.concurrent:concurrent-futures-ktx:1.1.0") যোগ করুন।
  2. একটি launch ব্লক বা সাসপেন্ডিং ফাংশনে ListenableFuture প্রদান করে এমন যেকোনো CameraX কোড রাখুন।
  3. ফাংশন কলে একটি await() কল যোগ করুন যা একটি ListenableFuture প্রদান করে।
  4. কোরোটিনগুলি কীভাবে কাজ করে তা গভীরভাবে বোঝার জন্য, একটি করুটিন গাইড শুরু করুন।

সাধারণ পরিস্থিতিতে স্থানান্তর করুন

এই বিভাগটি ব্যাখ্যা করে কিভাবে সাধারণ পরিস্থিতি Camera1 থেকে CameraX এ স্থানান্তর করা যায়। প্রতিটি দৃশ্যকল্প একটি Camera1 বাস্তবায়ন, একটি CameraX CameraProvider বাস্তবায়ন, এবং একটি CameraX CameraController বাস্তবায়ন কভার করে।

একটি ক্যামেরা নির্বাচন করা হচ্ছে

আপনার ক্যামেরা অ্যাপ্লিকেশনে, আপনি প্রথমে যে জিনিসগুলি অফার করতে চান তা হল বিভিন্ন ক্যামেরা নির্বাচন করার একটি উপায়৷

ক্যামেরা ১

Camera1-এ, আপনি প্রথম ব্যাক-ফেসিং ক্যামেরা খুলতে কোন প্যারামিটার ছাড়াই Camera.open() কল করতে পারেন, অথবা আপনি যে ক্যামেরাটি খুলতে চান তার জন্য একটি পূর্ণসংখ্যা আইডি পাস করতে পারেন। এটি দেখতে কেমন হতে পারে তার একটি উদাহরণ এখানে:

// Camera1: select a camera from id.

// Note: opening the camera is a non-trivial task, and it shouldn't be
// called from the main thread, unlike CameraX calls, which can be
// on the main thread since CameraX kicks off background threads
// internally as needed.

private fun safeCameraOpen(id: Int): Boolean {
    return try {
        releaseCameraAndPreview()
        camera = Camera.open(id)
        true
    } catch (e: Exception) {
        Log.e(TAG, "failed to open camera", e)
        false
    }
}

private fun releaseCameraAndPreview() {
    preview?.setCamera(null)
    camera?.release()
    camera = null
}

ক্যামেরাএক্স: ক্যামেরা কন্ট্রোলার

CameraX-এ, ক্যামেরা নির্বাচন CameraSelector ক্লাস দ্বারা পরিচালিত হয়। CameraX ডিফল্ট ক্যামেরা ব্যবহার করার সাধারণ ক্ষেত্রে সহজ করে তোলে। আপনি ডিফল্ট ফ্রন্ট ক্যামেরা চান নাকি ডিফল্ট ব্যাক ক্যামেরা চান তা নির্দিষ্ট করতে পারেন। উপরন্তু, CameraX-এর CameraControl অবজেক্ট আপনাকে সহজেই আপনার অ্যাপের জন্য জুম লেভেল সেট করতে দেয়, তাই যদি আপনার অ্যাপটি এমন কোনো ডিভাইসে চলছে যা লজিক্যাল ক্যামেরা সমর্থন করে, তাহলে এটি সঠিক লেন্সে চলে যাবে।

CameraController সাথে ডিফল্ট ব্যাক ক্যামেরা ব্যবহার করার জন্য এখানে CameraX কোড রয়েছে:

// CameraX: select a camera with CameraController

var cameraController = LifecycleCameraController(baseContext)
val selector = CameraSelector.Builder()
    .requireLensFacing(CameraSelector.LENS_FACING_BACK).build()
cameraController.cameraSelector = selector

ক্যামেরাএক্স: ক্যামেরা প্রদানকারী

এখানে CameraProvider সাথে ডিফল্ট ফ্রন্ট ক্যামেরা নির্বাচন করার একটি উদাহরণ দেওয়া হল (সামনের বা পিছনের ক্যামেরাটি হয় CameraController বা CameraProvider এর সাথে ব্যবহার করা যেতে পারে):

// CameraX: select a camera with CameraProvider.

// Use await() within a suspend function to get CameraProvider instance.
// For more details on await(), see the "Android development concepts"
// section above.
private suspend fun startCamera() {
    val cameraProvider = ProcessCameraProvider.getInstance(this).await()

    // Set up UseCases (more on UseCases in later scenarios)
    var useCases:Array = ...

    // Set the cameraSelector to use the default front-facing (selfie)
    // camera.
    val cameraSelector = CameraSelector.DEFAULT_FRONT_CAMERA

    try {
        // Unbind UseCases before rebinding.
        cameraProvider.unbindAll()

        // Bind UseCases to camera. This function returns a camera
        // object which can be used to perform operations like zoom,
        // flash, and focus.
        var camera = cameraProvider.bindToLifecycle(
            this, cameraSelector, useCases)

    } catch(exc: Exception) {
        Log.e(TAG, "UseCase binding failed", exc)
    }
})

...

// Call startCamera in the setup flow of your app, such as in onViewCreated.
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

    ...

    lifecycleScope.launch {
        startCamera()
    }
}

আপনি যদি কোন ক্যামেরা নির্বাচন করা হয় তা নিয়ন্ত্রণ করতে চান, তাহলে CameraX-এও এটি সম্ভব যদি আপনি getAvailableCameraInfos() কল করে CameraProvider ব্যবহার করেন, যা আপনাকে isFocusMeteringSupported() এর মতো নির্দিষ্ট ক্যামেরা বৈশিষ্ট্যগুলি পরীক্ষা করার জন্য একটি CameraInfo অবজেক্ট দেয়। তারপরে আপনি CameraInfo.getCameraSelector() পদ্ধতির সাহায্যে উপরের উদাহরণগুলির মতো ব্যবহার করার জন্য এটিকে একটি CameraSelector এ রূপান্তর করতে পারেন।

আপনি Camera2CameraInfo ক্লাস ব্যবহার করে প্রতিটি ক্যামেরা সম্পর্কে আরও বিশদ পেতে পারেন। আপনি যে ক্যামেরা ডেটা চান তার জন্য একটি কী সহ getCameraCharacteristic() এ কল করুন। আপনি যে সমস্ত কীগুলির জন্য অনুসন্ধান করতে পারেন তার একটি তালিকার জন্য CameraCharacteristics ক্লাসটি দেখুন৷

এখানে একটি কাস্টম checkFocalLength() ফাংশন ব্যবহার করে একটি উদাহরণ রয়েছে যা আপনি নিজেকে সংজ্ঞায়িত করতে পারেন:

// CameraX: get a cameraSelector for first camera that matches the criteria
// defined in checkFocalLength().

val cameraInfo = cameraProvider.getAvailableCameraInfos()
    .first { cameraInfo ->
        val focalLengths = Camera2CameraInfo.from(cameraInfo)
            .getCameraCharacteristic(
                CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS
            )
        return checkFocalLength(focalLengths)
    }
val cameraSelector = cameraInfo.getCameraSelector()

একটি পূর্বরূপ দেখাচ্ছে

বেশিরভাগ ক্যামেরা অ্যাপ্লিকেশনগুলিকে কোনও সময়ে ক্যামেরা ফিড অন-স্ক্রীন দেখাতে হবে। Camera1 এর সাথে, আপনাকে সঠিকভাবে লাইফসাইকেল কলব্যাকগুলি পরিচালনা করতে হবে এবং আপনাকে আপনার পূর্বরূপের জন্য ঘূর্ণন এবং স্কেলিং নির্ধারণ করতে হবে৷

উপরন্তু, Camera1-এ আপনাকে TextureView বা SurfaceView আপনার প্রিভিউ সারফেস হিসেবে ব্যবহার করতে হবে কিনা তা স্থির করতে হবে। উভয় বিকল্পই ট্রেডঅফের সাথে আসে এবং উভয় ক্ষেত্রেই, ক্যামেরা1 আপনাকে সঠিকভাবে ঘূর্ণন এবং স্কেলিং পরিচালনা করতে হবে। ক্যামেরাএক্সের PreviewView , অন্যদিকে, TextureView এবং SurfaceView উভয়ের জন্যই অন্তর্নিহিত বাস্তবায়ন রয়েছে। ডিভাইসের ধরন এবং আপনার অ্যাপটি যে অ্যান্ড্রয়েড সংস্করণে চলছে তার উপর নির্ভর করে ক্যামেরাএক্স সিদ্ধান্ত নেয় কোনটি বাস্তবায়ন সবচেয়ে ভালো। যদি উভয়টি বাস্তবায়ন সামঞ্জস্যপূর্ণ হয়, আপনি PreviewView.ImplementationMode এর সাথে আপনার পছন্দ ঘোষণা করতে পারেন। COMPATIBLE বিকল্পটি পূর্বরূপের জন্য একটি TextureView ব্যবহার করে এবং PERFORMANCE মান একটি SurfaceView ব্যবহার করে (যখন সম্ভব হয়)।

ক্যামেরা ১

একটি প্রিভিউ দেখাতে, আপনাকে android.view.SurfaceHolder.Callback ইন্টারফেসের বাস্তবায়ন সহ আপনার নিজস্ব Preview ক্লাস লিখতে হবে, যা ক্যামেরা হার্ডওয়্যার থেকে অ্যাপ্লিকেশনে ইমেজ ডেটা পাস করতে ব্যবহৃত হয়। তারপর, আপনি লাইভ ইমেজ প্রিভিউ শুরু করার আগে, Preview ক্লাসটি অবশ্যই Camera অবজেক্টে পাস করতে হবে।

// Camera1: set up a camera preview.

class Preview(
        context: Context,
        private val camera: Camera
) : SurfaceView(context), SurfaceHolder.Callback {

    private val holder: SurfaceHolder = holder.apply {
        addCallback(this@Preview)
        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.
        camera.apply {
            try {
                setPreviewDisplay(holder)
                startPreview()
            } catch (e: IOException) {
                Log.d(TAG, "error setting camera preview", e)
            }
        }
    }

    override fun surfaceDestroyed(holder: SurfaceHolder) {
        // 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 (holder.surface == null) {
            return  // The preview surface does not exist.
        }

        // Stop preview before making changes.
        try {
            camera.stopPreview()
        } catch (e: Exception) {
            // Tried to stop a non-existent preview; nothing to do.
        }

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

        // Start preview with new settings.
        camera.apply {
            try {
                setPreviewDisplay(holder)
                startPreview()
            } catch (e: Exception) {
                Log.d(TAG, "error starting camera preview", e)
            }
        }
    }
}

class CameraActivity : AppCompatActivity() {
    private lateinit var viewBinding: ActivityMainBinding
    private var camera: Camera? = null
    private var preview: Preview? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        viewBinding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(viewBinding.root)

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

        preview = camera?.let {
            // Create the Preview view.
            Preview(this, it)
        }

        // Set the Preview view as the content of the activity.
        val cameraPreview: FrameLayout = viewBinding.cameraPreview
        cameraPreview.addView(preview)
    }
}

ক্যামেরাএক্স: ক্যামেরা কন্ট্রোলার

CameraX-এ, আপনার, বিকাশকারী, পরিচালনা করার জন্য অনেক কম। আপনি যদি একটি CameraController ব্যবহার করেন, তাহলে আপনাকে অবশ্যই PreviewView ব্যবহার করতে হবে। এর মানে হল Preview UseCase নিহিত, সেটআপটি অনেক কম কাজ করে:

// CameraX: set up a camera preview with a CameraController.

class MainActivity : AppCompatActivity() {
    private lateinit var viewBinding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        viewBinding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(viewBinding.root)

        // Create the CameraController and set it on the previewView.
        var cameraController = LifecycleCameraController(baseContext)
        cameraController.bindToLifecycle(this)
        val previewView: PreviewView = viewBinding.cameraPreview
        previewView.controller = cameraController
    }
}

ক্যামেরাএক্স: ক্যামেরা প্রদানকারী

CameraX-এর CameraProvider এর সাথে, আপনাকে PreviewView ব্যবহার করতে হবে না, কিন্তু এটি এখনও Camera1-এর উপর প্রিভিউ সেটআপকে ব্যাপকভাবে সরল করে। প্রদর্শনের উদ্দেশ্যে, এই উদাহরণটি একটি PreviewView ব্যবহার করে, কিন্তু আপনার যদি আরও জটিল প্রয়োজন থাকে তাহলে আপনি setSurfaceProvider() -এ পাস করার জন্য একটি কাস্টম SurfaceProvider লিখতে পারেন।

এখানে, Preview UseCase CameraController মতো উহ্য নয়, তাই আপনাকে এটি সেট আপ করতে হবে:

// CameraX: set up a camera preview with a CameraProvider.

// Use await() within a suspend function to get CameraProvider instance.
// For more details on await(), see the "Android development concepts"
// section above.
private suspend fun startCamera() {
    val cameraProvider = ProcessCameraProvider.getInstance(this).await()

    // Create Preview UseCase.
    val preview = Preview.Builder()
        .build()
        .also {
            it.setSurfaceProvider(
                viewBinding.viewFinder.surfaceProvider
            )
        }

    // Select default back camera.
    val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

    try {
        // Unbind UseCases before rebinding.
        cameraProvider.unbindAll()

        // Bind UseCases to camera. This function returns a camera
        // object which can be used to perform operations like zoom,
        // flash, and focus.
        var camera = cameraProvider.bindToLifecycle(
            this, cameraSelector, useCases)

    } catch(exc: Exception) {
        Log.e(TAG, "UseCase binding failed", exc)
    }
})

...

// Call startCamera() in the setup flow of your app, such as in onViewCreated.
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

    ...

    lifecycleScope.launch {
        startCamera()
    }
}

ফোকাস করতে ট্যাপ করুন

যখন আপনার ক্যামেরা প্রিভিউ স্ক্রিনে থাকে, তখন ব্যবহারকারী যখন প্রিভিউতে ট্যাপ করে তখন ফোকাস পয়েন্ট সেট করা একটি সাধারণ নিয়ন্ত্রণ।

ক্যামেরা ১

ক্যামেরা 1-এ ট্যাপ-টু-ফোকাস প্রয়োগ করতে, Camera কোথায় ফোকাস করার চেষ্টা করা উচিত তা নির্দেশ করার জন্য আপনাকে সর্বোত্তম ফোকাস Area গণনা করতে হবে। এই Area setFocusAreas() এ পাস করা হয়। এছাড়াও, আপনাকে অবশ্যই Camera একটি সামঞ্জস্যপূর্ণ ফোকাস মোড সেট করতে হবে। বর্তমান ফোকাস মোড FOCUS_MODE_AUTO , FOCUS_MODE_MACRO , FOCUS_MODE_CONTINUOUS_VIDEO , বা FOCUS_MODE_CONTINUOUS_PICTURE হলেই ফোকাস ক্ষেত্রটি প্রভাব ফেলবে৷

প্রতিটি Area নির্দিষ্ট ওজন সহ একটি আয়তক্ষেত্র। ওজন হল 1 এবং 1000 এর মধ্যে একটি মান, এবং একাধিক সেট করা থাকলে এটি ফোকাস Areas অগ্রাধিকার দিতে ব্যবহৃত হয়। এই উদাহরণটি শুধুমাত্র একটি Area ব্যবহার করে, তাই ওজন মান কোন ব্যাপার না। আয়তক্ষেত্রের স্থানাঙ্ক -1000 থেকে 1000 পর্যন্ত। উপরের বাম বিন্দু হল (-1000, -1000)। নীচের ডান বিন্দু হল (1000, 1000)। দিকটি সেন্সর ওরিয়েন্টেশনের সাথে আপেক্ষিক, অর্থাৎ সেন্সর যা দেখে। দিকটি Camera.setDisplayOrientation() এর ঘূর্ণন বা মিররিং দ্বারা প্রভাবিত হয় না, তাই আপনাকে স্পর্শ ইভেন্ট স্থানাঙ্কগুলিকে সেন্সর স্থানাঙ্কে রূপান্তর করতে হবে।

// Camera1: implement tap-to-focus.

class TapToFocusHandler : Camera.AutoFocusCallback {
    private fun handleFocus(event: MotionEvent) {
        val camera = camera ?: return
        val parameters = try {
            camera.getParameters()
        } catch (e: RuntimeException) {
            return
        }

        // Cancel previous auto-focus function, if one was in progress.
        camera.cancelAutoFocus()

        // Create focus Area.
        val rect = calculateFocusAreaCoordinates(event.x, event.y)
        val weight = 1  // This value's not important since there's only 1 Area.
        val focusArea = Camera.Area(rect, weight)

        // Set the focus parameters.
        parameters.setFocusMode(Parameters.FOCUS_MODE_AUTO)
        parameters.setFocusAreas(listOf(focusArea))

        // Set the parameters back on the camera and initiate auto-focus.
        camera.setParameters(parameters)
        camera.autoFocus(this)
    }

    private fun calculateFocusAreaCoordinates(x: Int, y: Int) {
        // Define the size of the Area to be returned. This value
        // should be optimized for your app.
        val focusAreaSize = 100

        // You must define functions to rotate and scale the x and y values to
        // be values between 0 and 1, where (0, 0) is the upper left-hand side
        // of the preview, and (1, 1) is the lower right-hand side.
        val normalizedX = (rotateAndScaleX(x) - 0.5) * 2000
        val normalizedY = (rotateAndScaleY(y) - 0.5) * 2000

        // Calculate the values for left, top, right, and bottom of the Rect to
        // be returned. If the Rect would extend beyond the allowed values of
        // (-1000, -1000, 1000, 1000), then crop the values to fit inside of
        // that boundary.
        val left = max(normalizedX - (focusAreaSize / 2), -1000)
        val top = max(normalizedY - (focusAreaSize / 2), -1000)
        val right = min(left + focusAreaSize, 1000)
        val bottom = min(top + focusAreaSize, 1000)

        return Rect(left, top, left + focusAreaSize, top + focusAreaSize)
    }

    override fun onAutoFocus(focused: Boolean, camera: Camera) {
        if (!focused) {
            Log.d(TAG, "tap-to-focus failed")
        }
    }
}

ক্যামেরাএক্স: ক্যামেরা কন্ট্রোলার

CameraController স্বয়ংক্রিয়ভাবে ট্যাপ-টু-ফোকাস পরিচালনা করতে PreviewView -এর টাচ ইভেন্ট শোনে। আপনি setTapToFocusEnabled() দিয়ে ট্যাপ-টু-ফোকাস সক্ষম এবং নিষ্ক্রিয় করতে পারেন এবং সংশ্লিষ্ট গেটার isTapToFocusEnabled() দিয়ে মান পরীক্ষা করতে পারেন।

getTapToFocusState() পদ্ধতি CameraController ফোকাস অবস্থায় পরিবর্তনগুলি ট্র্যাক করার জন্য একটি LiveData অবজেক্ট প্রদান করে।

// CameraX: track the state of tap-to-focus over the Lifecycle of a PreviewView,
// with handlers you can define for focused, not focused, and failed states.

val tapToFocusStateObserver = Observer { state ->
    when (state) {
        CameraController.TAP_TO_FOCUS_NOT_STARTED ->
            Log.d(TAG, "tap-to-focus init")
        CameraController.TAP_TO_FOCUS_STARTED ->
            Log.d(TAG, "tap-to-focus started")
        CameraController.TAP_TO_FOCUS_FOCUSED ->
            Log.d(TAG, "tap-to-focus finished (focus successful)")
        CameraController.TAP_TO_FOCUS_NOT_FOCUSED ->
            Log.d(TAG, "tap-to-focus finished (focused unsuccessful)")
        CameraController.TAP_TO_FOCUS_FAILED ->
            Log.d(TAG, "tap-to-focus failed")
    }
}

cameraController.getTapToFocusState().observe(this, tapToFocusStateObserver)

ক্যামেরাএক্স: ক্যামেরা প্রদানকারী

CameraProvider ব্যবহার করার সময়, ট্যাপ-টু-ফোকাস কাজ করার জন্য কিছু সেটআপ প্রয়োজন। এই উদাহরণটি অনুমান করে আপনি PreviewView ব্যবহার করছেন। যদি তা না হয়, তাহলে আপনার কাস্টম Surface প্রয়োগ করার জন্য আপনাকে যুক্তিটিকে মানিয়ে নিতে হবে।

PreviewView ব্যবহার করার সময় এখানে পদক্ষেপগুলি রয়েছে:

1. ট্যাপ ইভেন্টগুলি পরিচালনা করতে একটি অঙ্গভঙ্গি সনাক্তকারী সেট আপ করুন৷
2. ট্যাপ ইভেন্টের সাথে, MeteringPointFactory.createPoint() ব্যবহার করে একটি MeteringPoint তৈরি করুন।
3. MeteringPoint দিয়ে, একটি FocusMeteringAction তৈরি করুন।
4. আপনার Camera CameraControl অবজেক্টের সাহায্যে ( bindToLifecycle() থেকে ফিরে এসেছে), startFocusAndMetering() কে কল করুন, FocusMeteringAction এ পাস করুন।
5. (ঐচ্ছিক) FocusMeteringResult এ সাড়া দিন।
6. PreviewView.setOnTouchListener() এ স্পর্শ ইভেন্টগুলিতে প্রতিক্রিয়া জানাতে আপনার অঙ্গভঙ্গি সনাক্তকারী সেট করুন।

// CameraX: implement tap-to-focus with CameraProvider.

// Define a gesture detector to respond to tap events and call
// startFocusAndMetering on CameraControl. If you want to use a
// coroutine with await() to check the result of focusing, see the
// "Android development concepts" section above.
val gestureDetector = GestureDetectorCompat(context,
    object : SimpleOnGestureListener() {
        override fun onSingleTapUp(e: MotionEvent): Boolean {
            val previewView = previewView ?: return
            val camera = camera ?: return
            val meteringPointFactory = previewView.meteringPointFactory
            val focusPoint = meteringPointFactory.createPoint(e.x, e.y)
            val meteringAction = FocusMeteringAction
                .Builder(meteringPoint).build()
            lifecycleScope.launch {
                val focusResult = camera.cameraControl
                    .startFocusAndMetering(meteringAction).await()
                if (!result.isFocusSuccessful()) {
                    Log.d(TAG, "tap-to-focus failed")
                }
            }
        }
    }
)

...

// Set the gestureDetector in a touch listener on the PreviewView.
previewView.setOnTouchListener { _, event ->
    // See pinch-to-zooom scenario for scaleGestureDetector definition.
    var didConsume = scaleGestureDetector.onTouchEvent(event)
    if (!scaleGestureDetector.isInProgress) {
        didConsume = gestureDetector.onTouchEvent(event)
    }
    didConsume
}

জুম ইন করো

একটি প্রিভিউ জুম ইন এবং আউট করা হল ক্যামেরা প্রিভিউ এর আরেকটি সাধারণ সরাসরি ম্যানিপুলেশন। ডিভাইসগুলিতে ক্রমবর্ধমান ক্যামেরার সংখ্যার সাথে, ব্যবহারকারীরা আশা করেন যে সেরা ফোকাল দৈর্ঘ্যের লেন্সগুলি জুম করার ফলাফল হিসাবে স্বয়ংক্রিয়ভাবে নির্বাচন করা হবে।

ক্যামেরা ১

ক্যামেরা 1 ব্যবহার করে জুম করার দুটি উপায় রয়েছে। Camera.startSmoothZoom() পদ্ধতিটি বর্তমান জুম স্তর থেকে আপনি পাস করা জুম স্তরে অ্যানিমেট করে৷ Camera.Parameters.setZoom() পদ্ধতিটি সরাসরি জুম স্তরে চলে যায় যা আপনি পাস করেন৷ যেকোনো একটি ব্যবহার করার আগে, isSmoothZoomSupported() বা কল করুন isZoomSupported() , যথাক্রমে, আপনার প্রয়োজনীয় জুম পদ্ধতিগুলি আপনার ক্যামেরায় উপলব্ধ রয়েছে তা নিশ্চিত করতে।

পিঞ্চ-টু-জুম বাস্তবায়নের জন্য, এই উদাহরণটি setZoom() ব্যবহার করে কারণ প্রিভিউ সারফেসে টাচ লিসেনার ক্রমাগতভাবে ইভেন্টগুলিকে ফায়ার করে যখন পিঞ্চ জেসচার ঘটে, তাই এটি প্রতিবার জুম লেভেল অবিলম্বে আপডেট করে। ZoomTouchListener ক্লাসটি নীচে সংজ্ঞায়িত করা হয়েছে, এবং এটি আপনার পূর্বরূপ পৃষ্ঠের স্পর্শ শ্রোতাকে কলব্যাক হিসাবে সেট করা উচিত।

// Camera1: implement pinch-to-zoom.

// Define a scale gesture detector to respond to pinch events and call
// setZoom on Camera.Parameters.
val scaleGestureDetector = ScaleGestureDetector(context,
    object : ScaleGestureDetector.OnScaleGestureListener {
        override fun onScale(detector: ScaleGestureDetector): Boolean {
            val camera = camera ?: return false
            val parameters = try {
                camera.parameters
            } catch (e: RuntimeException) {
                return false
            }

            // In case there is any focus happening, stop it.
            camera.cancelAutoFocus()

            // Set the zoom level on the Camera.Parameters, and set
            // the Parameters back onto the Camera.
            val currentZoom = parameters.zoom
            parameters.setZoom(detector.scaleFactor * currentZoom)
        camera.setParameters(parameters)
            return true
        }
    }
)

// Define a View.OnTouchListener to attach to your preview view.
class ZoomTouchListener : View.OnTouchListener {
    override fun onTouch(v: View, event: MotionEvent): Boolean =
        scaleGestureDetector.onTouchEvent(event)
}

// Set a ZoomTouchListener to handle touch events on your preview view
// if zoom is supported by the current camera.
if (camera.getParameters().isZoomSupported()) {
    view.setOnTouchListener(ZoomTouchListener())
}

ক্যামেরাএক্স: ক্যামেরা কন্ট্রোলার

ট্যাপ-টু-ফোকাসের মতো, CameraController পিঞ্চ-টু-জুম স্বয়ংক্রিয়ভাবে পরিচালনা করতে প্রিভিউ-এর টাচ ইভেন্ট শোনে। আপনি setPinchToZoomEnabled() দিয়ে পিঞ্চ-টু-জুম সক্ষম এবং নিষ্ক্রিয় করতে পারেন এবং সংশ্লিষ্ট গেটার isPinchToZoomEnabled() দিয়ে মান পরীক্ষা করতে পারেন।

getZoomState() পদ্ধতি CameraController ZoomState এ পরিবর্তনগুলি ট্র্যাক করার জন্য একটি LiveData অবজেক্ট প্রদান করে।

// CameraX: track the state of pinch-to-zoom over the Lifecycle of
// a PreviewView, logging the linear zoom ratio.

val pinchToZoomStateObserver = Observer { state ->
    val zoomRatio = state.getZoomRatio()
    Log.d(TAG, "ptz-zoom-ratio $zoomRatio")
}

cameraController.getZoomState().observe(this, pinchToZoomStateObserver)

ক্যামেরাএক্স: ক্যামেরা প্রদানকারী

CameraProvider এর সাথে পিঞ্চ-টু-জুম কাজ করার জন্য, কিছু সেটআপ প্রয়োজন। আপনি যদি PreviewView ব্যবহার না করে থাকেন, তাহলে আপনার কাস্টম Surface প্রয়োগ করার জন্য আপনাকে লজিক মানিয়ে নিতে হবে।

PreviewView ব্যবহার করার সময় এখানে পদক্ষেপগুলি রয়েছে:

1. পিঞ্চ ইভেন্টগুলি পরিচালনা করতে একটি স্কেল অঙ্গভঙ্গি আবিষ্কারক সেট আপ করুন৷
2. Camera.CameraInfo অবজেক্ট থেকে ZoomState পান, যেখানে আপনি bindToLifecycle() কল করলে Camera ইনস্ট্যান্স ফেরত দেওয়া হয়।
3. ZoomState একটি zoomRatio মান থাকলে, বর্তমান জুম অনুপাত হিসাবে এটি সংরক্ষণ করুন। ZoomState এ কোন zoomRatio না থাকলে, ক্যামেরার ডিফল্ট জুম রেট (1.0) ব্যবহার করুন।
4. নতুন জুম অনুপাত নির্ধারণ করতে scaleFactor সাথে বর্তমান জুম অনুপাতের পণ্যটি নিন এবং এটি CameraControl.setZoomRatio() এ পাস করুন।
5. PreviewView.setOnTouchListener() এ স্পর্শ ইভেন্টগুলিতে প্রতিক্রিয়া জানাতে আপনার অঙ্গভঙ্গি সনাক্তকারী সেট করুন।

// CameraX: implement pinch-to-zoom with CameraProvider.

// Define a scale gesture detector to respond to pinch events and call
// setZoomRatio on CameraControl.
val scaleGestureDetector = ScaleGestureDetector(context,
    object : SimpleOnGestureListener() {
        override fun onScale(detector: ScaleGestureDetector): Boolean {
            val camera = camera ?: return
            val zoomState = camera.cameraInfo.zoomState
            val currentZoomRatio: Float = zoomState.value?.zoomRatio ?: 1f
            camera.cameraControl.setZoomRatio(
                detector.scaleFactor * currentZoomRatio
            )
        }
    }
)

...

// Set the scaleGestureDetector in a touch listener on the PreviewView.
previewView.setOnTouchListener { _, event ->
    var didConsume = scaleGestureDetector.onTouchEvent(event)
    if (!scaleGestureDetector.isInProgress) {
        // See pinch-to-zooom scenario for gestureDetector definition.
        didConsume = gestureDetector.onTouchEvent(event)
    }
    didConsume
}

একটি ছবি তুলছি

এই বিভাগটি দেখায় কিভাবে ফটো ক্যাপচার ট্রিগার করতে হয়, আপনাকে এটি একটি শাটার বোতাম টিপে, একটি টাইমার শেষ হওয়ার পরে বা আপনার পছন্দের অন্য কোনো ইভেন্টে করতে হবে কিনা।

ক্যামেরা ১

Camera1-এ, আপনি প্রথমে একটি Camera.PictureCallback সংজ্ঞায়িত করেন যখন এটি অনুরোধ করা হয় তখন ছবির ডেটা পরিচালনা করতে। এখানে JPEG ইমেজ ডেটা পরিচালনার জন্য PictureCallback এর একটি সহজ উদাহরণ:

// Camera1: define a Camera.PictureCallback to handle JPEG data.

private val picture = 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)
    } catch (e: IOException) {
        Log.d(TAG, "error accessing file", e)
    }
}

তারপর, যখনই আপনি একটি ছবি তুলতে চান, আপনি আপনার Camera উদাহরণে takePicture() পদ্ধতিতে কল করুন। এই takePicture() পদ্ধতিতে বিভিন্ন ধরনের ডেটার জন্য তিনটি ভিন্ন প্যারামিটার রয়েছে। প্রথম প্যারামিটারটি হল একটি ShutterCallback এর জন্য (যা এই উদাহরণে সংজ্ঞায়িত করা হয়নি)। দ্বিতীয় প্যারামিটারটি হল একটি PictureCallback কাঁচা (অসংকুচিত) ক্যামেরা ডেটা পরিচালনা করার জন্য। তৃতীয় প্যারামিটারটি এই উদাহরণটি ব্যবহার করে, যেহেতু এটি JPEG ইমেজ ডেটা পরিচালনা করার জন্য একটি PictureCallback ।

// Camera1: call takePicture on Camera instance, passing our PictureCallback.

camera?.takePicture(null, null, picture)

ক্যামেরাএক্স: ক্যামেরা কন্ট্রোলার

CameraX এর CameraController নিজস্ব একটি takePicture() পদ্ধতি প্রয়োগ করে ছবি তোলার জন্য Camera1 এর সরলতা বজায় রাখে। এখানে, MediaStore এন্ট্রি কনফিগার করার জন্য একটি ফাংশন সংজ্ঞায়িত করুন এবং সেখানে সংরক্ষণ করার জন্য একটি ফটো তুলুন।

// CameraX: define a function that uses CameraController to take a photo.

private val FILENAME_FORMAT = "yyyy-MM-dd-HH-mm-ss-SSS"

private fun takePhoto() {
   // Create time stamped name and MediaStore entry.
   val name = SimpleDateFormat(FILENAME_FORMAT, Locale.US)
              .format(System.currentTimeMillis())
   val contentValues = ContentValues().apply {
       put(MediaStore.MediaColumns.DISPLAY_NAME, name)
       put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
       if(Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
           put(MediaStore.Images.Media.RELATIVE_PATH, "Pictures/CameraX-Image")
       }
   }

   // Create output options object which contains file + metadata.
   val outputOptions = ImageCapture.OutputFileOptions
       .Builder(context.getContentResolver(),
            MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
       .build()

   // Set up image capture listener, which is triggered after photo has
   // been taken.
   cameraController.takePicture(
       outputOptions,
       ContextCompat.getMainExecutor(this),
       object : ImageCapture.OnImageSavedCallback {
           override fun onError(e: ImageCaptureException) {
               Log.e(TAG, "photo capture failed", e)
           }

           override fun onImageSaved(
               output: ImageCapture.OutputFileResults
           ) {
               val msg = "Photo capture succeeded: ${output.savedUri}"
               Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
               Log.d(TAG, msg)
           }
       }
   )
}

ক্যামেরাএক্স: ক্যামেরা প্রদানকারী

CameraProvider এর সাহায্যে ছবি তোলা প্রায় CameraController এর মতোই কাজ করে, কিন্তু takePicture() এ কল করার জন্য আপনাকে প্রথমে একটি ImageCapture UseCase তৈরি এবং বাঁধতে হবে:

// CameraX: create and bind an ImageCapture UseCase.

// Make a reference to the ImageCapture UseCase at a scope that can be accessed
// throughout the camera logic in your app.
private var imageCapture: ImageCapture? = null

...

// Create an ImageCapture instance (can be added with other
// UseCase definitions).
imageCapture = ImageCapture.Builder().build()

...

// Bind UseCases to camera (adding imageCapture along with preview here, but
// preview is not required to use imageCapture). This function returns a camera
// object which can be used to perform operations like zoom, flash, and focus.
var camera = cameraProvider.bindToLifecycle(
    this, cameraSelector, preview, imageCapture)

তারপর, যখনই আপনি একটি ছবি তুলতে চান, আপনি ImageCapture.takePicture() কল করতে পারেন। takePhoto() ফাংশনের সম্পূর্ণ উদাহরণের জন্য এই বিভাগে CameraController কোডটি দেখুন।

// CameraX: define a function that uses CameraController to take a photo.

private fun takePhoto() {
    // Get a stable reference of the modifiable ImageCapture UseCase.
    val imageCapture = imageCapture ?: return

    ...

    // Call takePicture on imageCapture instance.
    imageCapture.takePicture(
        ...
    )
}

একটি ভিডিও রেকর্ডিং

একটি ভিডিও রেকর্ড করা এখন পর্যন্ত দেখা পরিস্থিতির তুলনায় যথেষ্ট জটিল। প্রক্রিয়াটির প্রতিটি অংশ অবশ্যই সঠিকভাবে সেট আপ করতে হবে, সাধারণত একটি নির্দিষ্ট ক্রমে। এছাড়াও, আপনাকে যাচাই করতে হতে পারে যে ভিডিও এবং অডিও সিঙ্কে আছে বা অতিরিক্ত ডিভাইসের অসঙ্গতিগুলি মোকাবেলা করতে হবে।

আপনি দেখতে পাবেন, CameraX আবার আপনার জন্য এই জটিলতার অনেকটাই পরিচালনা করে।

ক্যামেরা ১

Camera1 ব্যবহার করে ভিডিও ক্যাপচারের জন্য Camera এবং MediaRecorder এর যত্নশীল ব্যবস্থাপনার প্রয়োজন, এবং পদ্ধতিগুলিকে একটি নির্দিষ্ট ক্রমে কল করতে হবে। আপনার আবেদনটি সঠিকভাবে কাজ করার জন্য আপনাকে অবশ্যই এই আদেশটি অনুসরণ করতে হবে:

1. ক্যামেরা খুলুন।
2. একটি পূর্বরূপ প্রস্তুত করুন এবং শুরু করুন (যদি আপনার অ্যাপটি ভিডিও রেকর্ড করা দেখায়, যা সাধারণত হয়)।
3. Camera.unlock() কল করে MediaRecorder দ্বারা ব্যবহারের জন্য ক্যামেরাটি আনলক করুন৷
4. MediaRecorder এ এই পদ্ধতিগুলি কল করে রেকর্ডিং কনফিগার করুন:
   1. setCamera(camera) দিয়ে আপনার Camera উদাহরণ সংযুক্ত করুন।
   2. কল setAudioSource(MediaRecorder.AudioSource.CAMCORDER) ।
   3. setVideoSource(MediaRecorder.VideoSource.CAMERA) ।
   4. মান সেট করতে setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_1080P)) কল করুন। সমস্ত মানের বিকল্পের জন্য CamcorderProfile দেখুন।
   5. setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString()) কল করুন।
   6. যদি আপনার অ্যাপে ভিডিওটির একটি প্রিভিউ থাকে, setPreviewDisplay(preview?.holder?.surface) কল করুন।
   7. setOutputFormat(MediaRecorder.OutputFormat.MPEG_4) কল করুন।
   8. কল setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT) ।
   9. কল setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT) ।
   10. আপনার MediaRecorder কনফিগারেশন চূড়ান্ত করতে prepare() কল করুন।
5. রেকর্ডিং শুরু করতে, MediaRecorder.start() কল করুন।
6. রেকর্ডিং বন্ধ করতে, এই পদ্ধতিগুলি কল করুন। আবার, এই সঠিক আদেশ অনুসরণ করুন:
   1. MediaRecorder.stop() এ কল করুন।
   2. ঐচ্ছিকভাবে, MediaRecorder.reset() কল করে বর্তমান MediaRecorder কনফিগারেশন মুছে ফেলুন।
   3. MediaRecorder.release() কল করুন।
   4. ক্যামেরা লক করুন যাতে ভবিষ্যতে MediaRecorder সেশন Camera.lock() কল করে এটি ব্যবহার করতে পারে।
7. প্রিভিউ বন্ধ করতে, Camera.stopPreview() কল করুন।
8. অবশেষে, Camera রিলিজ করতে যাতে অন্যান্য প্রসেস এটি ব্যবহার করতে পারে, Camera.release() কল করুন।

এখানে এই সমস্ত পদক্ষেপ একত্রিত করা হয়েছে:

// Camera1: set up a MediaRecorder and a function to start and stop video
// recording.

// Make a reference to the MediaRecorder at a scope that can be accessed
// throughout the camera logic in your app.
private var mediaRecorder: MediaRecorder? = null
private var isRecording = false

...

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

    // Unlock and set camera to MediaRecorder.
    camera?.unlock()

    mediaRecorder?.run {
        setCamera(camera)

        // Set the audio and video sources.
        setAudioSource(MediaRecorder.AudioSource.CAMCORDER)
        setVideoSource(MediaRecorder.VideoSource.CAMERA)

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

        // Set the output file.
        setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString())

        // Set the preview output.
        setPreviewDisplay(preview?.holder?.surface)

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

        // Prepare configured MediaRecorder.
        return try {
            prepare()
            true
        } catch (e: IllegalStateException) {
            Log.d(TAG, "preparing MediaRecorder failed", e)
            releaseMediaRecorder()
            false
        } catch (e: IOException) {
            Log.d(TAG, "setting MediaRecorder file failed", e)
            releaseMediaRecorder()
            false
        }
    }
    return false
}

private fun releaseMediaRecorder() {
    mediaRecorder?.reset()
    mediaRecorder?.release()
    mediaRecorder = null
    camera?.lock()
}

private fun startStopVideo() {
    if (isRecording) {
        // Stop recording and release camera.
        mediaRecorder?.stop()
        releaseMediaRecorder()
        camera?.lock()
        isRecording = false

        // This is a good place to inform user that video recording has stopped.
    } else {
        // Initialize video camera.
        if (prepareVideoRecorder()) {
            // Camera is available and unlocked, MediaRecorder is prepared, now
            // you can start recording.
            mediaRecorder?.start()
            isRecording = true

            // This is a good place to inform the user that recording has
            // started.
        } else {
            // Prepare didn't work, release the camera.
            releaseMediaRecorder()

            // Inform user here.
        }
    }
}

ক্যামেরাএক্স: ক্যামেরা কন্ট্রোলার

CameraX-এর CameraController সাহায্যে, আপনি ImageCapture , VideoCapture , এবং ImageAnalysis UseCase গুলিকে স্বাধীনভাবে টগল করতে পারেন, যতক্ষণ না UseCases-এর তালিকা একসাথে ব্যবহার করা যায় । ImageCapture এবং ImageAnalysis UseCase ডিফল্টরূপে সক্রিয় থাকে, এই কারণেই আপনাকে একটি ছবি তোলার জন্য setEnabledUseCases() কল করতে হবে না৷

ভিডিও রেকর্ডিংয়ের জন্য একটি CameraController ব্যবহার করতে, আপনাকে প্রথমে VideoCapture UseCase অনুমতি দিতে setEnabledUseCases() ব্যবহার করতে হবে।

// CameraX: Enable VideoCapture UseCase on CameraController.

cameraController.setEnabledUseCases(VIDEO_CAPTURE);

আপনি যখন ভিডিও রেকর্ডিং শুরু করতে চান, তখন আপনি CameraController.startRecording() ফাংশনে কল করতে পারেন। এই ফাংশনটি রেকর্ড করা ভিডিওটিকে একটি File সংরক্ষণ করতে পারে, যেমন আপনি নীচের উদাহরণে দেখতে পারেন৷ উপরন্তু, আপনাকে একটি Executor এবং একটি ক্লাস পাস করতে হবে যা সফলতা এবং ত্রুটি কলব্যাকগুলি পরিচালনা করতে OnVideoSavedCallback প্রয়োগ করে। রেকর্ডিং শেষ হলে, CameraController.stopRecording() কল করুন।

দ্রষ্টব্য: আপনি যদি CameraX 1.3.0-alpha02 বা তার পরে ব্যবহার করেন তবে একটি অতিরিক্ত AudioConfig প্যারামিটার রয়েছে যা আপনাকে আপনার ভিডিওতে অডিও রেকর্ডিং সক্ষম বা অক্ষম করতে দেয়৷ অডিও রেকর্ডিং সক্ষম করতে, আপনাকে নিশ্চিত করতে হবে যে আপনার কাছে মাইক্রোফোনের অনুমতি রয়েছে৷ অতিরিক্তভাবে, stopRecording() পদ্ধতিটি 1.3.0-alpha02-এ মুছে ফেলা হয়, এবং startRecording() একটি Recording অবজেক্ট প্রদান করে যা ভিডিও রেকর্ডিং বিরতি, পুনরায় শুরু এবং বন্ধ করার জন্য ব্যবহার করা যেতে পারে।

// CameraX: implement video capture with CameraController.

private val FILENAME_FORMAT = "yyyy-MM-dd-HH-mm-ss-SSS"

// Define a VideoSaveCallback class for handling success and error states.
class VideoSaveCallback : OnVideoSavedCallback {
    override fun onVideoSaved(outputFileResults: OutputFileResults) {
        val msg = "Video capture succeeded: ${outputFileResults.savedUri}"
        Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
        Log.d(TAG, msg)
    }

    override fun onError(videoCaptureError: Int, message: String,
                         cause: Throwable?) {
        Log.d(TAG, "error saving video: $message", cause)
    }
}

private fun startStopVideo() {
    if (cameraController.isRecording()) {
        // Stop the current recording session.
        cameraController.stopRecording()
        return
    }

    // Define the File options for saving the video.
    val name = SimpleDateFormat(FILENAME_FORMAT, Locale.US)
        .format(System.currentTimeMillis())

    val outputFileOptions = OutputFileOptions
        .Builder(File(this.filesDir, name))
        .build()

    // Call startRecording on the CameraController.
    cameraController.startRecording(
        outputFileOptions,
        ContextCompat.getMainExecutor(this),
        VideoSaveCallback()
    )
}

ক্যামেরাএক্স: ক্যামেরা প্রদানকারী

আপনি যদি একটি CameraProvider ব্যবহার করেন, তাহলে আপনাকে একটি VideoCapture UseCase তৈরি করতে হবে এবং একটি Recorder অবজেক্টে পাস করতে হবে। Recorder.Builder এ, আপনি ভিডিওর গুণমান সেট করতে পারেন এবং, ঐচ্ছিকভাবে, একটি FallbackStrategy , যেটি এমন ক্ষেত্রে পরিচালনা করে যখন একটি ডিভাইস আপনার পছন্দসই গুণমানের বৈশিষ্ট্যগুলি পূরণ করতে পারে না৷ তারপর VideoCapture ইনস্ট্যান্সটিকে CameraProvider আপনার অন্যান্য UseCase গুলির সাথে আবদ্ধ করুন।

// CameraX: create and bind a VideoCapture UseCase with CameraProvider.

// Make a reference to the VideoCapture UseCase and Recording at a
// scope that can be accessed throughout the camera logic in your app.
private lateinit var videoCapture: VideoCapture
private var recording: Recording? = null

...

// Create a Recorder instance to set on a VideoCapture instance (can be
// added with other UseCase definitions).
val recorder = Recorder.Builder()
    .setQualitySelector(QualitySelector.from(Quality.FHD))
    .build()
videoCapture = VideoCapture.withOutput(recorder)

...

// Bind UseCases to camera (adding videoCapture along with preview here, but
// preview is not required to use videoCapture). This function returns a camera
// object which can be used to perform operations like zoom, flash, and focus.
var camera = cameraProvider.bindToLifecycle(
    this, cameraSelector, preview, videoCapture)

এই মুহুর্তে, Recorder videoCapture.output প্রপার্টিতে অ্যাক্সেস করা যেতে পারে। Recorder ভিডিও রেকর্ডিং শুরু করতে পারে যা একটি File , ParcelFileDescriptor , বা MediaStore এ সংরক্ষিত হয়৷ এই উদাহরণটি MediaStore ব্যবহার করে।

Recorder , এটি প্রস্তুত করতে কল করার জন্য বিভিন্ন পদ্ধতি রয়েছে। MediaStore আউটপুট বিকল্পগুলি সেট করতে prepareRecording() কল করুন। যদি আপনার অ্যাপের ডিভাইসের মাইক্রোফোন ব্যবহার করার অনুমতি থাকে, তাহলে withAudioEnabled() দিয়েও কল করুন। তারপর, রেকর্ডিং শুরু করতে start() কল করুন, একটি প্রেক্ষাপটে পাস করা এবং ভিডিও রেকর্ড ইভেন্টগুলি পরিচালনা করার জন্য একজন Consumer<VideoRecordEvent> ইভেন্ট শ্রোতা। সফল হলে, প্রত্যাবর্তিত Recording বিরতি, পুনরায় শুরু করতে বা রেকর্ডিং বন্ধ করতে ব্যবহার করা যেতে পারে।

// CameraX: implement video capture with CameraProvider.

private val FILENAME_FORMAT = "yyyy-MM-dd-HH-mm-ss-SSS"

private fun startStopVideo() {
   val videoCapture = this.videoCapture ?: return

   if (recording != null) {
       // Stop the current recording session.
       recording.stop()
       recording = null
       return
   }

   // Create and start a new recording session.
   val name = SimpleDateFormat(FILENAME_FORMAT, Locale.US)
       .format(System.currentTimeMillis())
   val contentValues = ContentValues().apply {
       put(MediaStore.MediaColumns.DISPLAY_NAME, name)
       put(MediaStore.MediaColumns.MIME_TYPE, "video/mp4")
       if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
           put(MediaStore.Video.Media.RELATIVE_PATH, "Movies/CameraX-Video")
       }
   }

   val mediaStoreOutputOptions = MediaStoreOutputOptions
       .Builder(contentResolver, MediaStore.Video.Media.EXTERNAL_CONTENT_URI)
       .setContentValues(contentValues)
       .build()

   recording = videoCapture.output
       .prepareRecording(this, mediaStoreOutputOptions)
       .withAudioEnabled()
       .start(ContextCompat.getMainExecutor(this)) { recordEvent ->
           when(recordEvent) {
               is VideoRecordEvent.Start -> {
                   viewBinding.videoCaptureButton.apply {
                       text = getString(R.string.stop_capture)
                       isEnabled = true
                   }
               }
               is VideoRecordEvent.Finalize -> {
                   if (!recordEvent.hasError()) {
                       val msg = "Video capture succeeded: " +
                           "${recordEvent.outputResults.outputUri}"
                       Toast.makeText(
                           baseContext, msg, Toast.LENGTH_SHORT
                       ).show()
                       Log.d(TAG, msg)
                   } else {
                       recording?.close()
                       recording = null
                       Log.e(TAG, "video capture ends with error",
                             recordEvent.error)
                   }
                   viewBinding.videoCaptureButton.apply {
                       text = getString(R.string.start_capture)
                       isEnabled = true
                   }
               }
           }
       }
}

অতিরিক্ত সম্পদ

আমাদের ক্যামেরা নমুনা গিটহাব রিপোজিটরিতে আমাদের বেশ কয়েকটি সম্পূর্ণ ক্যামেরাএক্স অ্যাপ রয়েছে। এই নমুনাগুলি আপনাকে দেখায় যে এই গাইডের দৃশ্যগুলি একটি সম্পূর্ণরূপে উন্নত Android অ্যাপে কীভাবে ফিট করে৷

আপনি যদি CameraX-এ স্থানান্তরিত করার জন্য অতিরিক্ত সমর্থন চান বা Android Camera API-এর স্যুট সম্পর্কিত প্রশ্ন থাকলে, অনুগ্রহ করে CameraX আলোচনা গোষ্ঠীতে আমাদের সাথে যোগাযোগ করুন৷