कैमरे की झलक

ध्यान दें: यह पेज Camera2 पैकेज के बारे में है. हमारा सुझाव है कि अगर आपके ऐप्लिकेशन को Camera2 में खास और कम लेवल की सुविधाओं की ज़रूरत न हो, तो हमारा सुझाव है कि आप CameraX इस्तेमाल करें. CameraX और Camera2, दोनों ही Android 5.0 (एपीआई लेवल 21) और इसके बाद वाले वर्शन पर काम करते हैं.

Android पर, कैमरे और कैमरे की झलक हमेशा अलग-अलग ओरिएंटेशन में नहीं होती हैं डिवाइस.

डिवाइस पर कैमरा एक तय जगह पर रहता है, भले ही डिवाइस फ़ोन, टैबलेट या कंप्यूटर हो. डिवाइस का ओरिएंटेशन बदलने पर, कैमरे की स्क्रीन की दिशा में बदलाव.

इस वजह से, कैमरा ऐप्लिकेशन आम तौर पर डिवाइस का ओरिएंटेशन और कैमरे की झलक का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) जब फ़ोन की स्क्रीन पोर्ट्रेट ओरिएंटेशन में हो और कैमरे की झलक ज़्यादा बड़ी हो वह चौड़ा है. जब फ़ोन (और कैमरे) को लैंडस्केप मोड में घुमाया जाता है, तो कैमरे की झलक की चौड़ाई, इसकी लंबाई से ज़्यादा हो सकती है.

हालांकि, फ़ोल्ड किए जा सकने वाले डिवाइस जैसे डिवाइस के नाप या आकार के लिए, इन अनुमानों को चुनौती दी जा रही है डिवाइस और डिसप्ले मोड जैसे कि मल्टी-विंडो और मल्टी-डिसप्ले. फ़ोल्ड किए जा सकने वाले डिवाइसों के डिसप्ले का साइज़ और आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) बिना बदलाव किए बदल जाता है स्क्रीन की दिशा. मल्टी-विंडो मोड, कैमरा ऐप्लिकेशन को साथ ही, कैमरा झलक को स्केल करता है, भले ही डिवाइस ओरिएंटेशन कुछ भी हो. मल्टी-डिसप्ले मोड की मदद से, ऐसे सेकंडरी डिसप्ले का इस्तेमाल किया जा सकता है जो शायद उसी ओरिएंटेशन में होना चाहिए जिस पर प्राइमरी डिसप्ले है.

कैमरा एडजस्ट करें

कॉन्टेंट बनाने Android पर काम करने के तरीके की परिभाषा यह बताता है कि कैमरा इमेज सेंसर "ओरिएंटेड होना चाहिए, ताकि कैमरे का डाइमेंशन, स्क्रीन के लंबे डाइमेंशन के साथ अलाइन हो जाता है. इसका मतलब है कि जब डिवाइस को लैंडस्केप ओरिएंटेशन में रखा गया है. इसलिए, कैमरों को सिर्फ़ लैंडस्केप लेआउट का इस्तेमाल करके बनाया जा सकता है. यह सेटिंग, हर तरह के डिवाइस पर लागू होती है. भले ही, स्क्रीन की दिशा; इसका मतलब है कि यह लैंडस्केप डिवाइसों के साथ-साथ, पोर्ट्रेट-प्राइमरी डिवाइस."

कैमरे से स्क्रीन पर दिखाने की सुविधा चालू करने पर, कैमरे का डिसप्ले एरिया ज़्यादा हो जाता है कैमरा ऐप्लिकेशन में व्यूफ़ाइंडर. साथ ही, इमेज सेंसर आम तौर पर अपना डेटा लैंडस्केप आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) 4:3 होना सबसे सामान्य है.

कैमरा सेंसर का नैचुरल ओरिएंटेशन (स्क्रीन की दिशा) लैंडस्केप होता है. पहली इमेज में, सेंसर सामने वाला कैमरा है (कैमरा जो उसी दिशा में संकेत कर रहा है डिस्प्ले) को फ़ोन से 270 डिग्री घुमाया जाता है, ताकि Android के साथ काम करने की परिभाषा.

ऐप्लिकेशन को सेंसर घुमाने के लिए, camera2 एपीआई में SENSOR_ORIENTATION कॉन्स्टेंट. ज़्यादातर फ़ोन और टैबलेट के लिए, डिवाइस सेंसर ओरिएंटेशन की रिपोर्ट करता है का 270 डिग्री ( सामने का कैमरा) और 90 डिग्री ( डिवाइस के पिछले हिस्से पर) का इस्तेमाल करें. सेंसर भी मौजूद है. लैपटॉप कैमरे आम तौर पर सेंसर ओरिएंटेशन 0 या 180 डिग्री.

क्योंकि कैमरा इमेज सेंसर सेंसर के प्राकृतिक ओरिएंटेशन (लैंडस्केप) का इस्तेमाल करते हैं, तो इमेज बफ़र को कैमरा प्रीव्यू के लिए SENSOR_ORIENTATION की ओर से बताई गई डिग्री की संख्या डिवाइस के प्राकृतिक ओरिएंटेशन में सीधा दिखता है. सामने वाले कैमरों के लिए, इसे घड़ी की उलटी दिशा में घुमाया जाता है; में कर सकते हैं.

उदाहरण के लिए, पहली इमेज में सामने वाले कैमरे के लिए इमेज बफ़र कैमरा सेंसर से बनी हुई चीज़ इस तरह दिखती है:

चित्र को घड़ी की विपरीत दिशा में 270 डिग्री घुमाना चाहिए ताकि पूर्वावलोकन का ओरिएंटेशन, डिवाइस ओरिएंटेशन से मेल खाता है:

पीछे वाला कैमरा, समान ओरिएंटेशन वाला इमेज बफ़र जनरेट करेगा जैसा कि ऊपर बफ़र में है, लेकिन SENSOR_ORIENTATION का साइज़ 90 डिग्री है. इस वजह से, बफ़र को घड़ी की सुई की दिशा में 90 डिग्री घुमाया गया.

डिवाइस को घुमाना

डिवाइस को घुमाना वह संख्या है जिससे डिवाइस को अपनी सामान्य सेटिंग के हिसाब से घुमाया जाता है स्क्रीन की दिशा. उदाहरण के लिए, लैंडस्केप ओरिएंटेशन में दिख रहे फ़ोन में डिवाइस है 90 या 270 डिग्री का घूर्णन, जो घूर्णन की दिशा पर निर्भर करता है.

कैमरा सेंसर के इमेज बफ़र को डिवाइस का रोटेशन (सेंसर ओरिएंटेशन की डिग्री के अतिरिक्त) कैमरा झलक को सीधा दिखाने के लिए.

ओरिएंटेशन कैलकुलेशन

कैमरे की झलक का सही ओरिएंटेशन, सेंसर को ध्यान में रखता है स्क्रीन की दिशा और डिवाइस रोटेशन.

सेंसर इमेज बफ़र के कुल रोटेशन का पता लगाने के लिए, नीचे दिया गया फ़ॉर्मूला:

rotation = (sensorOrientationDegrees - deviceOrientationDegrees * sign + 360) % 360

जहां sign, सामने वाले कैमरों के लिए 1 और पीछे वाले कैमरों के लिए -1 है.

सामने के कैमरों के लिए, चित्र बफ़र को घड़ी की विपरीत दिशा में घुमाया जाता है (से सेंसर का सामान्य ओरिएंटेशन. पीछे के कैमरे के लिए, सेंसर चित्र बफ़र को घड़ी की सुई की दिशा में घुमाया जाता है.

deviceOrientationDegrees * sign + 360 एक्सप्रेशन, डिवाइस के रोटेशन को बदलता है पीछे वाले कैमरों के लिए घड़ी की विपरीत दिशा में से घड़ी की विपरीत दिशा में (उदाहरण के लिए, 270 डिग्री को घड़ी की उलटी दिशा में 90 डिग्री में बदल रहा है). द मॉड्यूलो संक्रिया, परिणाम को 360 डिग्री से कम पर स्केल करती है (उदाहरण के लिए, 540 को स्केल करना) 180 पर रोटेशन की डिग्री).

अलग-अलग एपीआई, डिवाइस के रोटेशन की रिपोर्ट अलग-अलग तरीके से करते हैं:

• Display#getRotation() इसकी मदद से, डिवाइस को घड़ी की उलटी दिशा में घुमाया जाता है (उपयोगकर्ता के पॉइंट से व्यू के साथ). यह वैल्यू जैसा है उसे ऊपर दिए गए फ़ॉर्मूला में लागू किया जाता है.
• OrientationEventListener#onOrientationChanged() डिवाइस को घड़ी की दिशा में घुमाता है (उपयोगकर्ता के हिसाब से). ऊपर दिए गए फ़ॉर्मूला में इस्तेमाल करने के लिए वैल्यू को हटाएं.

सामने के कैमरे

दूसरी इमेज में कैमरा सेंसर से बनाया गया इमेज बफ़र दिया गया है:

सेंसर को अडजस्ट करने के लिए, बफ़र को घड़ी की उलटी दिशा में 270 डिग्री घुमाना चाहिए स्क्रीन की दिशा (ऊपर कैमरा ओरिएंटेशन देखें):

फिर बफ़र को घड़ी की उलटी दिशा में 90 डिग्री घुमाया जाता है से डिवाइस को घुमाया जाएगा. इससे डिवाइस की स्क्रीन की दिशा सही हो जाएगी दूसरी इमेज में कैमरे की झलक:

यहां कैमरा दाईं ओर लैंडस्केप ओरिएंटेशन में सेट किया गया है:

इमेज बफ़र की जानकारी यहां दी गई है:

सेंसर को अडजस्ट करने के लिए, बफ़र को घड़ी की उलटी दिशा में 270 डिग्री घुमाना चाहिए स्क्रीन की दिशा:

फिर बफ़र को घड़ी की विपरीत दिशा में 270 डिग्री घुमाया जाता है, ताकि डिवाइस को घुमाने के लिए:

पीछे के कैमरे

आम तौर पर, पीछे के कैमरे का सेंसर ओरिएंटेशन 90 डिग्री होता है (जैसा कि जिन्हें डिवाइस के पीछे से देखा गया हो). कैमरा पूर्वावलोकन को घुमाते समय, सेंसर इमेज बफ़र को सेंसर के रोटेशन की मात्रा के हिसाब से घड़ी की सुई की दिशा में घुमाया जाता है (सामने वाले कैमरे की तरह घड़ी की उलटी दिशा में नहीं) और फिर इमेज बफ़र को डिवाइस के रोटेशन की मात्रा के हिसाब से घड़ी की उलटी दिशा में घुमाया जाता है.

यहां चौथी इमेज में कैमरा सेंसर से इमेज बफ़र की जानकारी दी गई है:

सेंसर को अडजस्ट करने के लिए, बफ़र को घड़ी की सुई की दिशा में 90 डिग्री घुमाना ज़रूरी है स्क्रीन की दिशा:

फिर बफ़र को डिवाइस के हिसाब से 270 डिग्री घड़ी की उलटी दिशा में घुमाया जाता है घुमाव:

आसपेक्ट रेशियो

डिवाइस का ओरिएंटेशन बदलने पर, आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) बदलने पर भी आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) बदलता है मल्टी-विंडो में विंडो का साइज़ बदलने पर, फ़ोल्ड किए जा सकने वाले डिवाइस को फ़ोल्ड और अनफ़ोल्ड करना और जब ऐप्लिकेशन सेकंडरी डिसप्ले पर खुलेंगे.

कैमरा सेंसर के इमेज बफ़र का ओरिएंटेशन सही होना चाहिए और उसे इस तरह से स्केल किया जाना चाहिए यूज़र इंटरफ़ेस (यूआई) के तौर पर व्यूफ़ाइंडर यूज़र इंटरफ़ेस (यूआई) एलिमेंट का ओरिएंटेशन और आसपेक्ट रेशियो डिवाइस की स्क्रीन को बदलने के साथ या उसके बिना, स्क्रीन की दिशा को डाइनैमिक तौर पर बदलता है स्क्रीन की दिशा.

डिवाइस के नए नाप या आकार या मल्टी-विंडो या मल्टी-डिसप्ले में, अगर आपके ऐप्लिकेशन को लगता है कि कैमरे की झलक की स्क्रीन की दिशा वही है जो डिवाइस की है ऐसा हो सकता है कि आपकी झलक (पोर्ट्रेट या लैंडस्केप) का फ़ॉर्मैट गलत हो या फिर दोनों का इस्तेमाल करते हैं.

पांचवीं इमेज में, ऐप्लिकेशन ने गलती से यह मान लिया था कि डिवाइस को 90 घुमाया गया है डिग्री वामावर्त; इसलिए, ऐप्लिकेशन ने झलक को बराबर घुमाया है.

छठी इमेज में, ऐप्लिकेशन ने इमेज बफ़र के आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) में, इस तरह बदलाव नहीं किया इसे कैमरे की झलक के यूज़र इंटरफ़ेस (यूआई) के नए डाइमेंशन के हिसाब से सही तरीके से फ़िट करने के लिए चालू किया गया है एलिमेंट.

आम तौर पर, फ़िक्स्ड ओरिएंटेशन वाले कैमरा ऐप्लिकेशन में, फ़ोल्ड किए जा सकने वाले डिवाइस और बड़ी स्क्रीन वाले अन्य डिवाइस, जैसे कि लैपटॉप:

सातवीं इमेज में, कैमरा ऐप्लिकेशन का यूज़र इंटरफ़ेस (यूआई) तिरछा है, क्योंकि ऐप्लिकेशन का ओरिएंटेशन केवल पोर्ट्रेट तक सीमित है. व्यूफ़ाइंडर इमेज का ओरिएंटेशन सही हो की तुलना में आसानी से किया जा सकता है.

इनसेट पोर्ट्रेट मोड

मल्टी-विंडो मोड के साथ काम न करने वाले कैमरा ऐप्लिकेशन (resizeableActivity="false") और उनके ओरिएंटेशन को सीमित करें (screenOrientation="portrait" या screenOrientation="landscape") पूरी तरह से ओरिएंटेशन के लिए बड़ी स्क्रीन वाले डिवाइसों पर इनसेट पोर्ट्रेट मोड में रखा जा सकता है कैमरे की झलक.

पोर्ट्रेट मोड में पोर्ट्रेट मोड में लेटरबॉक्स (इनसेट) पोर्ट्रेट मोड में सिर्फ़ पोर्ट्रेट मोड में इस्तेमाल होने वाले ऐप्लिकेशन स्क्रीन की दिशा, भले ही डिसप्ले का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) लैंडस्केप हो. सिर्फ़ लैंडस्केप मोड वाले ऐप्लिकेशन, लैंडस्केप ओरिएंटेशन में लेटरबॉक्स किए गए होते हैं डिसप्ले का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) पोर्ट्रेट है. अलाइन करने के लिए कैमरा इमेज को घुमाया गया ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) से, जिसे कैमरे की झलक के आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) के हिसाब से काटा गया हो और फिर झलक को भरने के लिए स्केल किया गया हो.

इनसेट पोर्ट्रेट मोड तब ट्रिगर होता है, जब कैमरे की इमेज का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) सेंसर और ऐप्लिकेशन की प्राथमिक गतिविधि का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) मेल नहीं खाते.

आठवीं इमेज में, सिर्फ़ पोर्ट्रेट मोड में इस्तेमाल किए जाने वाले कैमरा ऐप्लिकेशन को यूज़र इंटरफ़ेस (यूआई) दिखाने के लिए घुमाया गया है लैपटॉप की स्क्रीन पर दिख रहा होगा. अंतर की वजह से, ऐप्लिकेशन को लेटरबॉक्स किया गया है आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) में होगा. कैमरा ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) रोटेशन की भरपाई करने के लिए झलक इमेज को घुमा दिया गया है (इस वजह से इनसेट पोर्ट्रेट मोड) में जोड़ा जाता है. साथ ही, इमेज को काटकर, इमेज के साइज़ में फ़िट करने के लिए बदलाव किया गया है पोर्ट्रेट ओरिएंटेशन से, फ़ील्ड ऑफ़ व्यू को कम किया जा सकता है.

घुमाएं, काटें, स्केल करें

डिसप्ले पर सिर्फ़ पोर्ट्रेट मोड में सेट किए गए कैमरा ऐप्लिकेशन के लिए, इनसेट पोर्ट्रेट मोड शुरू किया गया जिनका आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) लैंडस्केप मोड में है:

ऐप्लिकेशन को पोर्ट्रेट ओरिएंटेशन में लेटरबॉक्स किया गया है:

फ़ोटो की दिशा बदलने के लिए उसे 90 डिग्री घुमाया गया ऐप्लिकेशन:

इमेज को कैमरे की झलक के आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) के हिसाब से काटकर, उसका साइज़ इतना बढ़ाया जाता है: झलक भरें (फ़ील्ड ऑफ़ व्यू कम कर दिया गया है):

फ़ोल्ड किए जा सकने वाले डिवाइसों पर, कैमरे के सेंसर की स्क्रीन की दिशा पोर्ट्रेट हो सकती है डिसप्ले का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) लैंडस्केप होता है:

सेंसर की स्क्रीन की दिशा को अडजस्ट करने के लिए, कैमरे की झलक को घुमाया गया. व्यूफ़ाइंडर में इमेज सही दिशा में है, लेकिन सिर्फ़ पोर्ट्रेट मोड में काम करने वाला ऐप्लिकेशन है तिरछा है.

इनसेट पोर्ट्रेट मोड में ऐप्लिकेशन को सिर्फ़ पोर्ट्रेट ओरिएंटेशन में लेटरबॉक्स करना होगा ऐप्लिकेशन और कैमरे की झलक को ठीक से ओरिएंटेशन में लाने के लिए:

एपीआई

Android 12 (एपीआई लेवल 31) के वर्शन वाले ऐप्लिकेशन, इनसेट पोर्ट्रेट को भी साफ़ तौर पर कंट्रोल कर सकते हैं मोड SCALER_ROTATE_AND_CROP CaptureRequest की प्रॉपर्टी क्लास.

डिफ़ॉल्ट मान यह है SCALER_ROTATE_AND_CROP_AUTO, इससे सिस्टम को इनसेट पोर्ट्रेट मोड शुरू करने में मदद मिलती है. SCALER_ROTATE_AND_CROP_90 इनसेट पोर्ट्रेट मोड की तरह ही काम करता है.

सभी डिवाइसों पर, सभी SCALER_ROTATE_AND_CROP वैल्यू काम नहीं करती हैं. सूची बनाने के लिए इस्तेमाल की जा सकने वाली वैल्यू, रेफ़रंस CameraCharacteristics#SCALER_AVAILABLE_ROTATE_AND_CROP_MODES.

कैमराएक्स

Jetpack CameraX लाइब्रेरी से कैमरा व्यूफ़ाइंडर बनाया जाता है, जो सेंसर ओरिएंटेशन के साथ फ़िट हो जाता है और डिवाइस को घुमाना एक आसान काम है.

PreviewView लेआउट एलिमेंट इससे कैमरे की झलक दिखती है, जो सेंसर ओरिएंटेशन के लिए अपने-आप अडजस्ट हो जाती है. और स्केलिंग. PreviewView कैमरा चित्र को लागू करके FILL_CENTER स्केल टाइप, जो इमेज को सेंटर में लाता है, लेकिन वह डाइमेंशन से मेल खाने के लिए उसे काट सकता है PreviewView में से. कैमरा इमेज को लेटरबॉक्स करने के लिए, स्केल टाइप को FIT_CENTER.

PreviewView की मदद से कैमरा प्रीव्यू बनाने की बुनियादी बातें जानने के लिए, देखें झलक लागू करना.

सैंपल लागू करने के बारे में जानने के लिए, इसे देखें CameraXBasic GitHub पर डेटा स्टोर करने की जगह.

कैमरा व्यूफ़ाइंडर

झलक इस्तेमाल के उदाहरण की तरह ही, कैमराव्यूफ़ाइंडर लाइब्रेरी में ऐसे टूल का सेट मौजूद है जिनकी मदद से कैमरा प्रीव्यू बनाना आसान हो जाता है. यह CameraX Core पर निर्भर नहीं होता है, इसलिए इसे अपने मौजूदा Camera2 कोड बेस है.

Google Analytics 4 पर माइग्रेट करने के बजाय Surface तो आप इसका उपयोग कर सकते हैं CameraViewfinder विजेट को कैमरा 2 के लिए कैमरा फ़ीड दिखाने के लिए सेट करें.

CameraViewfinder, TextureView या SurfaceView का इस्तेमाल करता है और उन पर ज़रूरी ट्रांसफ़ॉर्मेशन ऐक्शन लागू करता है व्यूफ़ाइंडर को सही ढंग से दिखाएं. इसमें उनका आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात), स्केल, और रोटेशन ठीक करना शामिल है.

CameraViewfinder ऑब्जेक्ट से सरफ़ेस का अनुरोध करने के लिए, आपको ये काम करने होंगे ViewfinderSurfaceRequest बनाएं.

इस अनुरोध में सरफ़ेस रिज़ॉल्यूशन और कैमरे डिवाइस के लिए ज़रूरी शर्तें शामिल हैं CameraCharacteristics से मिली जानकारी.

requestSurfaceAsync() को कॉल किया जा रहा है प्लैटफ़ॉर्म उपलब्ध कराने वाले को अनुरोध भेजता है, जो कि TextureView या SurfaceView और Surface का ListenableFuture पाएं.

markSurfaceSafeToRelease() को कॉल किया जा रहा है प्लैटफ़ॉर्म उपलब्ध कराने वाली कंपनी को यह सूचना देता है कि इस प्लैटफ़ॉर्म की ज़रूरत नहीं है और यह जानकारी एक-दूसरे से जुड़ी हुई है संसाधन रिलीज़ किए जा सकते हैं.

fun startCamera(){
    val previewResolution = Size(width, height)
    val viewfinderSurfaceRequest =
        ViewfinderSurfaceRequest(previewResolution, characteristics)
    val surfaceListenableFuture =
        cameraViewfinder.requestSurfaceAsync(viewfinderSurfaceRequest)

    Futures.addCallback(surfaceListenableFuture, object : FutureCallback<Surface> {
        override fun onSuccess(surface: Surface) {
            /* create a CaptureSession using this surface as usual */
        }
        override fun onFailure(t: Throwable) { /* something went wrong */}
    }, ContextCompat.getMainExecutor(context))
}

    void startCamera(){
        Size previewResolution = new Size(width, height);
        ViewfinderSurfaceRequest viewfinderSurfaceRequest =
                new ViewfinderSurfaceRequest(previewResolution, characteristics);
        ListenableFuture<Surface> surfaceListenableFuture =
                cameraViewfinder.requestSurfaceAsync(viewfinderSurfaceRequest);

        Futures.addCallback(surfaceListenableFuture, new FutureCallback<Surface>() {
            @Override
            public void onSuccess(Surface result) {
                /* create a CaptureSession using this surface as usual */
            }
            @Override public void onFailure(Throwable t) { /* something went wrong */}
        },  ContextCompat.getMainExecutor(context));
    }

SurfaceView

SurfaceView इसका इस्तेमाल करके, आसानी से कैमरा प्रीव्यू बनाया जा सकता है. इसके लिए प्रोसेसिंग की ज़रूरत होती है और इसे ऐनिमेट नहीं किया जाता.

SurfaceView, मिलान करने के लिए कैमरा सेंसर की इमेज बफ़र को अपने-आप घुमाता है डिसप्ले ओरिएंटेशन, जिसमें सेंसर ओरिएंटेशन और डिवाइस, दोनों शामिल हों घुमाव. हालांकि, इमेज बफ़र को SurfaceView के साइज़ में फ़िट करने के लिए स्केल किया जाता है ये डाइमेंशन, आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) पर ध्यान नहीं देते.

आपको यह पक्का करना होगा कि इमेज बफ़र का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) और आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) मैच करता हो SurfaceView का अनुपात होता है, जिसे कॉन्टेंट को स्केल करके हासिल किया जा सकता है कॉम्पोनेंट के SurfaceView में से onMeasure() तरीका:

(computeRelativeRotation() का सोर्स कोड इसमें है नीचे सापेक्ष रोटेशन.)

override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
    val width = MeasureSpec.getSize(widthMeasureSpec)
    val height = MeasureSpec.getSize(heightMeasureSpec)

    val relativeRotation = computeRelativeRotation(characteristics, surfaceRotationDegrees)

    if (previewWidth > 0f && previewHeight > 0f) {
        /* Scale factor required to scale the preview to its original size on the x-axis. */
        val scaleX =
            if (relativeRotation % 180 == 0) {
                width.toFloat() / previewWidth
            } else {
                width.toFloat() / previewHeight
            }
        /* Scale factor required to scale the preview to its original size on the y-axis. */
        val scaleY =
            if (relativeRotation % 180 == 0) {
                height.toFloat() / previewHeight
            } else {
                height.toFloat() / previewWidth
            }

        /* Scale factor required to fit the preview to the SurfaceView size. */
        val finalScale = min(scaleX, scaleY)

        setScaleX(1 / scaleX * finalScale)
        setScaleY(1 / scaleY * finalScale)
    }
    setMeasuredDimension(width, height)
}

@Override
void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int width = MeasureSpec.getSize(widthMeasureSpec);
    int height = MeasureSpec.getSize(heightMeasureSpec);

    int relativeRotation = computeRelativeRotation(characteristics, surfaceRotationDegrees);

    if (previewWidth > 0f && previewHeight > 0f) {

        /* Scale factor required to scale the preview to its original size on the x-axis. */
        float scaleX = (relativeRotation % 180 == 0)
                       ? (float) width / previewWidth
                       : (float) width / previewHeight;

        /* Scale factor required to scale the preview to its original size on the y-axis. */
        float scaleY = (relativeRotation % 180 == 0)
                       ? (float) height / previewHeight
                       : (float) height / previewWidth;

        /* Scale factor required to fit the preview to the SurfaceView size. */
        float finalScale = Math.min(scaleX, scaleY);

        setScaleX(1 / scaleX * finalScale);
        setScaleY(1 / scaleY * finalScale);
    }
    setMeasuredDimension(width, height);
}

SurfaceView को कैमरे की झलक के तौर पर लागू करने के बारे में ज़्यादा जानकारी के लिए, यह देखें कैमरे की स्क्रीन की दिशा.

टेक्स्चर व्यू

TextureView की परफ़ॉर्मेंस इससे कम है SurfaceView—और ज़्यादा काम—लेकिन TextureView आपको ज़्यादा से ज़्यादा कैमरे की झलक कंट्रोल कर सकती है.

TextureView, सेंसर ओरिएंटेशन के आधार पर सेंसर इमेज बफ़र को घुमाता है लेकिन डिवाइस रोटेशन या पूर्वावलोकन स्केलिंग को हैंडल नहीं करता है.

स्केलिंग और रोटेशन मैट्रिक्स ट्रांसफ़ॉर्मेशन. यह जानने के लिए कि TextureView को सही तरीके से स्केल और घुमाएं. कैमरा ऐप्लिकेशन में साइज़ बदले जा सकने वाले प्लैटफ़ॉर्म इस्तेमाल किए जा सकते हैं

रिलेटिव रोटेशन

कैमरा सेंसर का रिलेटिव रोटेशन वह मात्रा है जो कैमरा सेंसर के आउटपुट को डिवाइस की स्क्रीन की दिशा के साथ अलाइन करें.

रिलेटिव रोटेशन का इस्तेमाल SurfaceView और TextureView जैसे कॉम्पोनेंट करते हैं x और y स्केलिंग फ़ैक्टर तय करने के लिए. इसका इस्तेमाल इन कामों के लिए भी किया जाता है सेंसर इमेज बफ़र के रोटेशन की जानकारी दें.

कॉन्टेंट बनाने CameraCharacteristics और Surface क्लास कैमरा सेंसर का रिलेटिव रोटेशन:

/**
 * Computes rotation required to transform the camera sensor output orientation to the
 * device's current orientation in degrees.
 *
 * @param characteristics The CameraCharacteristics to query for the sensor orientation.
 * @param surfaceRotationDegrees The current device orientation as a Surface constant.
 * @return Relative rotation of the camera sensor output.
 */
public fun computeRelativeRotation(
    characteristics: CameraCharacteristics,
    surfaceRotationDegrees: Int
): Int {
    val sensorOrientationDegrees =
        characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    // Reverse device orientation for back-facing cameras.
    val sign = if (characteristics.get(CameraCharacteristics.LENS_FACING) ==
        CameraCharacteristics.LENS_FACING_FRONT
    ) 1 else -1

    // Calculate desired orientation relative to camera orientation to make
    // the image upright relative to the device orientation.
    return (sensorOrientationDegrees - surfaceRotationDegrees * sign + 360) % 360
}

/**
 * Computes rotation required to transform the camera sensor output orientation to the
 * device's current orientation in degrees.
 *
 * @param characteristics The CameraCharacteristics to query for the sensor orientation.
 * @param surfaceRotationDegrees The current device orientation as a Surface constant.
 * @return Relative rotation of the camera sensor output.
 */
public int computeRelativeRotation(
    CameraCharacteristics characteristics,
    int surfaceRotationDegrees
){
    Integer sensorOrientationDegrees =
        characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);

    // Reverse device orientation for back-facing cameras.
    int sign = characteristics.get(CameraCharacteristics.LENS_FACING) ==
        CameraCharacteristics.LENS_FACING_FRONT ? 1 : -1;

    // Calculate desired orientation relative to camera orientation to make
    // the image upright relative to the device orientation.
    return (sensorOrientationDegrees - surfaceRotationDegrees * sign + 360) % 360;
}

विंडो की मेट्रिक

कैमरे के डाइमेंशन तय करने के लिए, स्क्रीन के साइज़ का इस्तेमाल नहीं किया जाना चाहिए व्यूफ़ाइंडर; कैमरा ऐप्लिकेशन, स्क्रीन के एक हिस्से में चल रहा होगा, या को मोबाइल डिवाइस पर मल्टी-विंडो मोड में या ChromeOS पर फ़्री-फ़्रॉम मोड में ऐक्सेस किया जा सकता है.

WindowManager#getCurrentWindowMetrics() (एपीआई लेवल 30 में जोड़ा गया) नतीजे के तौर पर, ऐप्लिकेशन विंडो का साइज़ स्क्रीन का साइज़. Jetpack WindowManager लाइब्रेरी के तरीके WindowMetricsCalculator#computeCurrentWindowMetrics() और WindowInfoTracker#currentWindowMetrics() एपीआई लेवल 14 के पुराने सिस्टम के साथ काम करने की सुविधा के साथ भी मिलती है.

180 डिग्री का रोटेशन

किसी डिवाइस का 180 डिग्री का रोटेशन (उदाहरण के लिए, प्राकृतिक ओरिएंटेशन से लेकर प्राकृतिक ओरिएंटेशन उलटा) onConfigurationChanged() कॉलबैक. इस वजह से, कैमरे की झलक उल्टी हो सकती है.

180 डिग्री के घुमाव का पता लगाने के लिए, DisplayListener और आपके Display#getRotation() में onDisplayChanged() कॉलबैक.

खास संसाधन

Android 10 से पहले के वर्शन में, मल्टी-विंडो में सिर्फ़ सबसे ऊपर दिखने वाली गतिविधि दिखती थी वातावरण RESUMED स्थिति में था. यह लोगों के लिए उलझन भरा था, क्योंकि सिस्टम ने इस बात का कोई संकेत नहीं दिया कि कौनसी गतिविधि फिर से शुरू हो गई है.

Android 10 (एपीआई लेवल 29) के लिए, मल्टी-रिज़्यूम की सुविधा लॉन्च की गई, जहां सभी दिखने वाली गतिविधियां RESUMED की स्थिति में हैं. लोगों को दिखने वाली गतिविधियां, PAUSED में अब भी जा सकती हैं उदाहरण के लिए, अगर गतिविधि के ऊपर कोई पारदर्शी गतिविधि होती है, तो गतिविधि पर फ़ोकस नहीं किया जा सकता, जैसे कि 'पिक्चर में पिक्चर' मोड में (देखें पिक्चर में पिक्चर की सुविधा).

कैमरा, माइक्रोफ़ोन या किसी भी खास या एपीआई लेवल 29 या उसके बाद के लेवल पर सिंगलटन संसाधन को मल्टी-रिज़्यूम के साथ काम करना चाहिए. इसके लिए उदाहरण के लिए, अगर फिर से शुरू की गई तीन गतिविधियों के लिए कैमरे का इस्तेमाल करना है, तो सिर्फ़ एक ताकि आपको इस खास संसाधन का ऐक्सेस मिल सके. हर गतिविधि के लिए, onDisconnected() कॉलबैक का इस्तेमाल करें, ताकि ज़्यादा प्राथमिकता के आधार पर कैमरे का ऐक्सेस पहले से ही उपलब्ध रखा जा सके गतिविधि.

ज़्यादा जानकारी के लिए, यह देखें एक से ज़्यादा बार फिर से शुरू करें.

अन्य संसाधन

• Camera2 का सैंपल देखने के लिए, Camera2 Basic ऐप्लिकेशन देखें GitHub पर.
• CameraX के इस्तेमाल के उदाहरण के बारे में जानने के लिए, CameraX देखें झलक लागू करना.
• CameraX कैमरे की झलक का सैंपल लागू करने के लिए, इसे देखें CameraXBasic GitHub पर डेटा स्टोर करने की जगह.
• ChromeOS पर कैमरे की झलक के बारे में जानकारी के लिए, यहां देखें कैमरे की दिशा.
• फ़ोल्ड किए जा सकने वाले डिवाइसों को डेवलप करने के बारे में जानकारी के लिए, यहां देखें फ़ोल्ड किए जा सकने वाले डिवाइसों के बारे में जानें.