SurfaceFlinger, बफ़र स्वीकार करता है, बफ़र बनाता है, और बफ़र को डिसप्ले पर भेजता है. WindowManager, SurfaceFlinger को बफ़र और विंडो मेटाडेटा उपलब्ध कराता है. SurfaceFlinger, इस डेटा का इस्तेमाल करके डिसप्ले पर सर्फ़ेस को कंपोज़ करता है.
SurfaceFlinger
SurfaceFlinger, बफ़र को दो तरीकों से स्वीकार कर सकता है: BufferQueue और SurfaceControl के ज़रिए या ASurfaceControl के ज़रिए.
SurfaceFlinger, BufferQueue और SurfaceControl के ज़रिए बफ़र स्वीकार करता है. जब कोई ऐप्लिकेशन फ़ोरग्राउंड में आता है, तो वह WindowManager से बफ़र का अनुरोध करता है. इसके बाद, WindowManager SurfaceFlinger से लेयर का अनुरोध करता है. लेयर, सरफ़ेस और SurfaceControl इंस्टेंस का कॉम्बिनेशन होती है. सरफ़ेस में BufferQueue होता है और SurfaceControl इंस्टेंस में लेयर का मेटाडेटा होता है. जैसे, डिसप्ले फ़्रेम.
SurfaceFlinger, लेयर बनाता है और उसे WindowManager को भेजता है. WindowManager
इसके बाद, यह ऐप्लिकेशन को सर्फ़ेस भेजता है. हालांकि, यह SurfaceControl इंस्टेंस को
स्क्रीन पर ऐप्लिकेशन के दिखने के तरीके में बदलाव करने के लिए रखता है.
Android 10 में ASurfaceControl जोड़ा गया है. यह एक और तरीका है जिससे SurfaceFlinger, बफ़र स्वीकार कर सकता है. ASurfaceControl, एक ही लेन-देन वाले पैकेज में एक SurfaceControl इंस्टेंस और एक सरफेस को जोड़ता है. इस पैकेज को SurfaceFlinger को भेजा जाता है. ASurfaceControl किसी लेयर से जुड़ा होता है. ऐप्लिकेशन, ASurfaceTransaction इंस्टेंस के ज़रिए इस लेयर को अपडेट करते हैं. इसके बाद, ऐप्लिकेशन को ASurfaceTransaction इंस्टेंस के बारे में जानकारी मिलती है. यह जानकारी, कॉलबैक के ज़रिए मिलती है. कॉलबैक, ASurfaceTransactionStats पास करते हैं. इनमें जानकारी होती है. जैसे, लैच टाइम, ऐक्वायर टाइम वगैरह.
यहां दी गई टेबल में, ASurfaceControl और इससे जुड़े कॉम्पोनेंट के बारे में ज़्यादा जानकारी दी गई है:
| कॉम्पोनेंट | ब्यौरा |
|---|---|
ASurfaceControl |
यह SurfaceControl करता है और किसी ऐप्लिकेशन को SurfaceControl इंस्टेंस बनाने की अनुमति देता है. ये इंस्टेंस, डिसप्ले पर मौजूद लेयर से मेल खाते हैं.इसे ANativeWindow के चाइल्ड के तौर पर या किसी अन्य ASurfaceControl इंस्टेंस के चाइल्ड के तौर पर बनाया जा सकता है. |
ASurfaceTransaction |
यह Transaction को रैप करता है, ताकि क्लाइंट किसी लेयर की जानकारी देने वाली प्रॉपर्टी में बदलाव कर सके. जैसे, ज्यामिति. साथ ही, यह अपडेट किए गए बफ़र को SurfaceFlinger को भेजता है. |
ASurfaceTransactionStats
| यह कुकी, लेन-देन की जानकारी को किसी ऐप्लिकेशन को भेजती है. जैसे, लैच टाइम, खरीदारी का समय, और पिछली रिलीज़ फ़ेंस. यह जानकारी, पहले से रजिस्टर किए गए कॉलबैक के ज़रिए भेजी जाती है. |
ऐप्लिकेशन, बफ़र कभी भी सबमिट कर सकते हैं. हालांकि, SurfaceFlinger सिर्फ़ डिसप्ले रीफ़्रेश के बीच बफ़र स्वीकार करने के लिए चालू होता है. यह डिवाइस के हिसाब से अलग-अलग हो सकता है. इससे मेमोरी का इस्तेमाल कम होता है. साथ ही, स्क्रीन पर दिखने वाली इमेज में गड़बड़ी नहीं होती. ऐसा तब हो सकता है, जब डिसप्ले को रीफ़्रेश करने के दौरान अपडेट किया जा रहा हो.
डिसप्ले रीफ़्रेश होने के दौरान, डिसप्ले SurfaceFlinger को VSync सिग्नल भेजता है. वीसिंक सिग्नल से पता चलता है कि डिसप्ले को बिना किसी रुकावट के रीफ़्रेश किया जा सकता है. जब SurfaceFlinger को VSync सिग्नल मिलता है, तब SurfaceFlinger अपनी लेयर की सूची में नए बफ़र ढूंढता है. अगर SurfaceFlinger को कोई नया बफ़र मिलता है, तो SurfaceFlinger उस बफ़र को हासिल कर लेता है. अगर ऐसा नहीं होता है, तो SurfaceFlinger पहले से हासिल किए गए बफ़र का इस्तेमाल करता रहता है. SurfaceFlinger को हमेशा कुछ न कुछ दिखाना होता है. इसलिए, यह एक बफ़र पर टिका रहता है. अगर किसी लेयर पर कभी भी बफ़र सबमिट नहीं किए गए हैं, तो उस लेयर को अनदेखा कर दिया जाता है.
SurfaceFlinger, दिखने वाली लेयर के सभी बफ़र इकट्ठा करने के बाद, Hardware Composer (HWC) से पूछता है कि कंपोज़िशन कैसे की जानी चाहिए. अगर एचडब्ल्यूसी, लेयर कंपोज़िशन टाइप को क्लाइंट कंपोज़िशन के तौर पर मार्क करता है, तो SurfaceFlinger उन लेयर को कंपोज़ करता है. इसके बाद, SurfaceFlinger, आउटपुट बफ़र को HWC को पास करता है.
WindowManager
WindowManager, Window ऑब्जेक्ट को कंट्रोल करता है. ये ऑब्जेक्ट, View ऑब्जेक्ट के लिए कंटेनर होते हैं. Window ऑब्जेक्ट हमेशा Surface ऑब्जेक्ट के साथ काम करते हैं.
WindowManager विंडो के लाइफ़साइकल, इनपुट और फ़ोकस इवेंट, स्क्रीन ओरिएंटेशन, ट्रांज़िशन, ऐनिमेशन, पोज़िशन, ट्रांसफ़ॉर्म, z-ऑर्डर, और कई अन्य पहलुओं को मैनेज करता है. WindowManager, विंडो के सभी मेटाडेटा को SurfaceFlinger को भेजता है, ताकि SurfaceFlinger उस डेटा का इस्तेमाल करके डिसप्ले पर कंपोज़िट सर्फ़ेस बना सके.
प्री-रोटेशन
कई हार्डवेयर ओवरले, रोटेशन की सुविधा के साथ काम नहीं करते. अगर वे काम करते भी हैं, तो इससे प्रोसेसिंग पावर पर असर पड़ता है. इसका समाधान यह है कि बफ़र को SurfaceFlinger तक पहुंचने से पहले ट्रांसफ़ॉर्म किया जाए. Android, ANativeWindow में क्वेरी हिंट (NATIVE_WINDOW_TRANSFORM_HINT) का इस्तेमाल करने की सुविधा देता है. इससे SurfaceFlinger को यह पता चलता है कि बफ़र पर कौनसी ट्रांसफ़ॉर्मेशन लागू होने की सबसे ज़्यादा संभावना है. GL ड्राइवर इस हिंट का इस्तेमाल करके, SurfaceFlinger तक पहुंचने से पहले बफ़र को पहले से ट्रांसफ़ॉर्म कर सकते हैं. इससे, बफ़र के पहुंचने पर उसे सही तरीके से ट्रांसफ़ॉर्म किया जा सकेगा.
उदाहरण के लिए, जब 90 डिग्री घुमाने का सुझाव मिलता है, तब बफ़र में एक मैट्रिक्स जनरेट करें और उसे लागू करें, ताकि वह पेज के आखिर से बाहर न निकल जाए. बैटरी बचाने के लिए, रोटेशन से पहले ऐसा करें. ज़्यादा जानकारी के लिए, system/core/include/system/window.h में तय किया गया ANativeWindow इंटरफ़ेस देखें.