SurfaceFlinger, बफ़र स्वीकार करता है, बफ़र बनाता है, और बफ़र को डिसप्ले पर भेजता है. WindowManager, SurfaceFlinger को बफ़र और विंडो के मेटाडेटा की जानकारी देता है. SurfaceFlinger इस जानकारी का इस्तेमाल, डिसप्ले पर कॉम्पोज़िट किए गए सर्वर के हिस्सों को दिखाने के लिए करता है.
SurfaceFlinger
SurfaceFlinger, बफ़र को दो तरीकों से स्वीकार कर सकता है: BufferQueue और
SurfaceControl के ज़रिए या ASurfaceControl के ज़रिए.
SurfaceFlinger, BufferQueue और
SurfaceControl की मदद से बफ़र स्वीकार करता है. जब कोई ऐप्लिकेशन फ़ोरग्राउंड में आता है, तो वह WindowManager से बफ़र का अनुरोध करता है. इसके बाद, WindowManager, SurfaceFlinger से लेयर का अनुरोध करता है. लेयर, सर्फ़ेस और SurfaceControl इंस्टेंस का कॉम्बिनेशन होती है. सर्फ़ेस में BufferQueue होता है और इंस्टेंस में लेयर का मेटाडेटा होता है, जैसे कि डिसप्ले फ़्रेम.
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 सिग्नल भेजता है. VSync सिग्नल से पता चलता है कि डिसप्ले को टियरिंग के बिना रीफ़्रेश किया जा सकता है. जब SurfaceFlinger को VSync सिग्नल मिलता है, तो वह नई बफ़र खोजने के लिए, लेयर की सूची में जाता है. अगर SurfaceFlinger को कोई नया बफ़र मिलता है, तो वह उसे हासिल कर लेता है. अगर ऐसा नहीं होता है, तो वह पहले हासिल किए गए बफ़र का इस्तेमाल करता रहता है. SurfaceFlinger को हमेशा कुछ दिखाना चाहिए, ताकि वह एक बफ़र पर बने रहे. अगर किसी लेयर पर कभी कोई बफ़र सबमिट नहीं किया गया है, तो उस लेयर को अनदेखा कर दिया जाता है.
SurfaceFlinger, दिखने वाली लेयर के लिए सभी बफ़र इकट्ठा करने के बाद, हार्डवेयर कंपोजर (एचडब्ल्यूसी) से पूछता है कि कॉम्पोज़िशन कैसे किया जाना चाहिए. अगर 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 इंटरफ़ेस देखें.