ক্যামেরা লেন্স এবং ক্ষমতা

দ্রষ্টব্য: এই পৃষ্ঠাটি Camera2 প্যাকেজকে বোঝায়। আপনার অ্যাপের Camera2 থেকে নির্দিষ্ট, নিম্ন-স্তরের বৈশিষ্ট্যের প্রয়োজন না হলে, আমরা CameraX ব্যবহার করার পরামর্শ দিই। CameraX এবং Camera2 উভয়ই Android 5.0 (API স্তর 21) এবং উচ্চতর সমর্থন করে।

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

এই পৃষ্ঠাটি কভার করে যে কীভাবে ক্যামেরা লেন্স এবং তাদের ক্ষমতা তালিকাভুক্ত করা যায় যাতে আপনি একটি নির্দিষ্ট পরিস্থিতিতে কোন লেন্স ব্যবহার করবেন সে সম্পর্কে আপনার অ্যাপের মধ্যে সিদ্ধান্ত নিতে পারেন। নিম্নলিখিত কোড স্নিপেট সমস্ত ক্যামেরার একটি তালিকা পুনরুদ্ধার করে এবং তাদের উপর পুনরাবৃত্তি করে:

try {
    val cameraIdList = cameraManager.cameraIdList // may be empty

    // iterate over available camera devices
    for (cameraId in cameraIdList) {
        val characteristics = cameraManager.getCameraCharacteristics(cameraId)
        val cameraLensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)
        val cameraCapabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)

        // check if the selected camera device supports basic features
        // ensures backward compatibility with the original Camera API
        val isBackwardCompatible = cameraCapabilities?.contains(
            CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) ?: false
        ...
    }
} catch (e: CameraAccessException) {
    e.message?.let { Log.e(TAG, it) }
    ...
}

try {
    String[] cameraIdList = cameraManager.getCameraIdList(); // may be empty

    // iterate over available camera devices
    for (String cameraId : cameraIdList) {
        CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
        int cameraLensFacing = characteristics.get(CameraCharacteristics.LENS_FACING);
        int[] cameraCapabilities =
            characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);

        // check if the selected camera device supports basic features
        // ensures backward compatibility with the original Camera API
        boolean isBackwardCompatible = false;
        for (int capability : cameraCapabilities) {
            if (capability == CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
                isBackwardCompatible = true;
                break;
            }
        }
        ...
    }
} catch (CameraAccessException e) {
    Log.e(TAG, e.getMessage());
    ...
}

পরিবর্তনশীল cameraLensFacing ডিভাইসের পর্দার সাপেক্ষে ক্যামেরা যে দিকে মুখ করে তা বর্ণনা করে এবং নিম্নলিখিত মানগুলির মধ্যে একটি রয়েছে:

• CameraMetadata.LENS_FACING_FRONT
• CameraMetadata.LENS_FACING_BACK
• CameraMetadata.LENS_FACING_EXTERNAL

লেন্স-মুখী কনফিগারেশন সম্পর্কে আরও তথ্যের জন্য, CameraCharacteristics.LENS_FACING দেখুন।

পূর্ববর্তী কোড নমুনা থেকে পরিবর্তনশীল cameraCapabilities বিবিধ ক্ষমতা সম্পর্কে তথ্য ধারণ করে, যার মধ্যে ক্যামেরা আউটপুট হিসাবে স্ট্যান্ডার্ড ফ্রেম তৈরি করতে সক্ষম কিনা (উদাহরণস্বরূপ, শুধুমাত্র গভীরতা সেন্সর ডেটার বিপরীতে)। আপনি CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE কিনা তা দেখতে পারেন। REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE হল ক্যামেরার তালিকাভুক্ত ক্ষমতাগুলির মধ্যে একটি, যা isBackwardCompatible এ একটি পতাকা হিসাবে সংরক্ষণ করা হয়।

বুদ্ধিমান ডিফল্ট নির্বাচন করুন

আপনার অ্যাপে, আপনি সম্ভবত ডিফল্টরূপে একটি নির্দিষ্ট ক্যামেরা খুলতে চান (যদি এটি উপলব্ধ থাকে)। উদাহরণস্বরূপ, একটি সেলফি অ্যাপ সম্ভবত সামনের দিকের ক্যামেরাটি খোলে, যখন একটি অগমেন্টেড রিয়েলিটি অ্যাপ পিছনের ক্যামেরা দিয়ে শুরু হতে পারে। নিম্নলিখিত ফাংশনটি প্রথম ক্যামেরাটি ফেরত দেয় যা একটি প্রদত্ত দিকের মুখোমুখি হয়:

fun getFirstCameraIdFacing(cameraManager: CameraManager,
                           facing: Int = CameraMetadata.LENS_FACING_BACK): String? {
    try {
        // Get list of all compatible cameras
        val cameraIds = cameraManager.cameraIdList.filter {
            val characteristics = cameraManager.getCameraCharacteristics(it)
            val capabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)
            capabilities?.contains(
                    CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) ?: false
        }

        // Iterate over the list of cameras and return the first one matching desired
        // lens-facing configuration
        cameraIds.forEach {
            val characteristics = cameraManager.getCameraCharacteristics(it)
            if (characteristics.get(CameraCharacteristics.LENS_FACING) == facing) {
                return it
            }
        }

        // If no camera matched desired orientation, return the first one from the list
        return cameraIds.firstOrNull()
    } catch (e: CameraAccessException) {
        e.message?.let { Log.e(TAG, it) }
    }
}

public String getFirstCameraIdFacing(CameraManager cameraManager, @Nullable Integer facing) {
    if (facing == null) facing = CameraMetadata.LENS_FACING_BACK;
    String cameraId = null;

    try {
        // Get a list of all compatible cameras
        String[] cameraIdList = cameraManager.getCameraIdList();

        // Iterate over the list of cameras and return the first one matching desired
        // lens-facing configuration and backward compatibility
        for (String id : cameraIdList) {
            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(id);
            int[] capabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
            for (int capability : capabilities) {
                if (capability == CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE
                        && characteristics.get(CameraCharacteristics.LENS_FACING).equals(facing)) {
                    cameraId = id;
                    break;
                }
            }
        }

        // If no camera matches the desired orientation, return the first one from the list
        cameraId = cameraIdList[0];
    } catch (CameraAccessException e) {
        Log.e(TAG, "getFirstCameraIdFacing: " + e.getMessage());
    }

    return cameraId;
}

ক্যামেরা স্যুইচিং সক্ষম করুন

অনেক ক্যামেরা অ্যাপ ব্যবহারকারীদের ক্যামেরার মধ্যে স্যুইচ করার বিকল্প দেয়:

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

যদিও পরবর্তী ক্যামেরা নির্বাচন করার জন্য কোন সর্বজনীন যুক্তি নেই, নিম্নলিখিত কোডটি বেশিরভাগ ব্যবহারের ক্ষেত্রে কাজ করে:

fun filterCompatibleCameras(cameraIds: Array<String>,
                            cameraManager: CameraManager): List<String> {
    return cameraIds.filter {
        val characteristics = cameraManager.getCameraCharacteristics(it)
        characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)?.contains(
                CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) ?: false
    }
}

fun filterCameraIdsFacing(cameraIds: List<String>, cameraManager: CameraManager,
                          facing: Int): List<String> {
    return cameraIds.filter {
        val characteristics = cameraManager.getCameraCharacteristics(it)
        characteristics.get(CameraCharacteristics.LENS_FACING) == facing
    }
}

fun getNextCameraId(cameraManager: CameraManager, currCameraId: String? = null): String? {
    // Get all front, back and external cameras in 3 separate lists
    val cameraIds = filterCompatibleCameras(cameraManager.cameraIdList, cameraManager)
    val backCameras = filterCameraIdsFacing(
            cameraIds, cameraManager, CameraMetadata.LENS_FACING_BACK)
    val frontCameras = filterCameraIdsFacing(
            cameraIds, cameraManager, CameraMetadata.LENS_FACING_FRONT)
    val externalCameras = filterCameraIdsFacing(
            cameraIds, cameraManager, CameraMetadata.LENS_FACING_EXTERNAL)

    // The recommended order of iteration is: all external, first back, first front
    val allCameras = (externalCameras + listOf(
            backCameras.firstOrNull(), frontCameras.firstOrNull())).filterNotNull()

    // Get the index of the currently selected camera in the list
    val cameraIndex = allCameras.indexOf(currCameraId)

    // The selected camera may not be in the list, for example it could be an
    // external camera that has been removed by the user
    return if (cameraIndex == -1) {
        // Return the first camera from the list
        allCameras.getOrNull(0)
    } else {
        // Return the next camera from the list, wrap around if necessary
        allCameras.getOrNull((cameraIndex + 1) % allCameras.size)
    }
}

public List<String> filterCompatibleCameras(CameraManager cameraManager, String[] cameraIds) {
    final List<String> compatibleCameras = new ArrayList<>();

    try {
        for (String id : cameraIds) {
            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(id);
            int[] capabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
            for (int capability : capabilities) {
                if (capability == CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
                    compatibleCameras.add(id);
                }
            }
        }
    } catch (CameraAccessException e) {
        Log.e(TAG, "filterCompatibleCameras: " + e.getMessage());
    }

    return compatibleCameras;
}

public List<String> filterCameraIdsFacing(CameraManager cameraManager, List<String> cameraIds, int lensFacing) {
    final List<String> compatibleCameras = new ArrayList<>();

    try {
        for (String id : cameraIds) {
            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(id);
            if (characteristics.get(CameraCharacteristics.LENS_FACING) == lensFacing) {
                compatibleCameras.add(id);
            }
        }
    } catch (CameraAccessException e) {
        Log.e(TAG, "filterCameraIdsFacing: " + e.getMessage());
    }

    return compatibleCameras;
}

public String getNextCameraId(CameraManager cameraManager, @Nullable String currentCameraId) {
    String nextCameraId = null;

    try {
        // Get all front, back, and external cameras in 3 separate lists
        List<String> compatibleCameraIds = filterCompatibleCameras(cameraManager, cameraManager.getCameraIdList());
        List<String> backCameras = filterCameraIdsFacing(cameraManager, compatibleCameraIds, CameraMetadata.LENS_FACING_BACK);
        List<String> frontCameras = filterCameraIdsFacing(cameraManager, compatibleCameraIds, CameraMetadata.LENS_FACING_FRONT);
        List<String>externalCameras = filterCameraIdsFacing(cameraManager, compatibleCameraIds, CameraMetadata.LENS_FACING_EXTERNAL);

        // The recommended order of iteration is: all external, first back, first front
        List<String> allCameras = new ArrayList<>(externalCameras);
        if (!backCameras.isEmpty()) allCameras.add(backCameras.get(0));
        if (!frontCameras.isEmpty()) allCameras.add(frontCameras.get(0));

        // Get the index of the currently selected camera in the list
        int cameraIndex = allCameras.indexOf(currentCameraId);

        // The selected camera may not be in the list, for example it could be an
        // external camera that has been removed by the user
        if (cameraIndex == -1) {
            // Return the first camera from the list
            nextCameraId = !allCameras.isEmpty() ? allCameras.get(0) : null;
        else {
            if (!allCameras.isEmpty()) {
                // Return the next camera from the list, wrap around if necessary
                nextCameraId = allCameras.get((cameraIndex + 1) % allCameras.size());
            }
        }
    } catch (CameraAccessException e) {
        Log.e(TAG, "getNextCameraId: " + e.getMessage());
    }

    return nextCameraId;
}

এই কোডটি বিভিন্ন কনফিগারেশন সহ একটি বড় সেটের জন্য কাজ করে। এজ কেসগুলির জন্য অ্যাকাউন্টিং সম্পর্কে আরও তথ্যের জন্য, CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA দেখুন।REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA।

সামঞ্জস্যপূর্ণ অ্যাপ তৈরি করুন

অ্যাপের জন্য এখনও অবহেলিত ক্যামেরা API ব্যবহার করে, ক্যামেরার সংখ্যা যে Camera.getNumberOfCameras() প্রদান করে তা OEM বাস্তবায়নের উপর নির্ভর করে। যদি সিস্টেমে একটি লজিক্যাল মাল্টি-ক্যামেরা থাকে, অ্যাপের পিছনের সামঞ্জস্য বজায় রাখতে, এই পদ্ধতিটি প্রতিটি লজিক্যাল ক্যামেরা এবং অন্তর্নিহিত শারীরিক ক্যামেরা গোষ্ঠীর জন্য শুধুমাত্র একটি ক্যামেরা প্রকাশ করবে। সমস্ত ক্যামেরা দেখতে Camera2 API ব্যবহার করুন।

ক্যামেরা ওরিয়েন্টেশন সম্পর্কে আরও ব্যাকগ্রাউন্ড তথ্যের জন্য, Camera.CameraInfo.orientation দেখুন।

সাধারণভাবে, সমস্ত ক্যামেরা orientation অনুসন্ধান করতে Camera.getCameraInfo() API ব্যবহার করুন এবং ক্যামেরাগুলির মধ্যে পরিবর্তন করা ব্যবহারকারীদের কাছে প্রতিটি উপলব্ধ অভিযোজনের জন্য শুধুমাত্র একটি ক্যামেরা প্রকাশ করুন৷

সব ধরনের ডিভাইস মিটমাট

অনুমান করবেন না যে আপনার অ্যাপ সবসময় এক বা দুটি ক্যামেরা সহ একটি হ্যান্ডহেল্ড ডিভাইসে চলে। পরিবর্তে, অ্যাপের জন্য সবচেয়ে উপযুক্ত ক্যামেরা বেছে নিন। আপনার যদি একটি নির্দিষ্ট ক্যামেরার প্রয়োজন না হয়, তবে প্রথম ক্যামেরাটি নির্বাচন করুন যা পছন্দসই দিকের দিকে মুখ করে। যদি একটি বাহ্যিক ক্যামেরা সংযুক্ত থাকে, তাহলে আপনি অনুমান করতে পারেন যে ব্যবহারকারী এটিকে ডিফল্ট হিসেবে পছন্দ করেন।