Android में ध्वज विशेषताएँ - उनका उपयोग कैसे करें

मुझे यकीन है कि आपने अपने विचारों या लेआउट के लिए XML विशेषताओं को लिखते समय बहुत बार निम्न पंक्ति की तरह कुछ देखा है।

गुण = "OPTION1 | OPTION2"

नोटिस | विकल्पों के बीच। यह न केवल एक फैंसी विभाजक है, यह एक बिटवाइज़ ऑपरेटर है जो दो विकल्पों को एक एकल मूल्य में विलय करता है।

निम्नलिखित बताएंगे कि वास्तव में बिट फ्लैग्स क्या हैं, कस्टम एक्सएमएल ध्वज विशेषताओं की घोषणा कैसे करें और कोड में उनके साथ कैसे पढ़ें और काम करें।

बिट फ्लैग्स क्या हैं?

आम तौर पर आप बिट फ्लैग को एक ही मूल्य में संग्रहीत कई बूलियन मानों के रूप में देख सकते हैं।

बाइनरी सिस्टम में थोड़ा सा दो राज्य हैं: चालू और बंद। अब बिट्स की एक पंक्ति के बारे में सोचें जहां हर बिट आपके विकल्पों में से एक के लिए एक संकेतक है। जब विकल्प सेट किया जाता है, तो बिट का मान 1 होता है। यदि नहीं, तो इसका मान 0 है।

110

इसे हम दाएं से बाएं पढ़ते हैं।
हमारे पहले विकल्प के लिए बिट 0. है। इसका मतलब है कि विकल्प सेट नहीं है। जबकि दूसरे और तीसरे विकल्प के लिए बिट्स हैं 1. इसका मतलब है कि वे सेट हैं।

हर पूर्णांक मान बाइनरी सिस्टम में एक प्रतिनिधित्व है और इसके विपरीत।

0 = 0 * 2 = + 0 * 2² + 0 * 2 0 + 0 * 2 00 = 0000
1 = 0 * 2 = + 0 * 2² + 0 * 2 1 + 1 * 2 00 = 0001
2 = 0 * 2 = + 0 * 2² + 1 * 2 0 + 0 * 2 00 = 0010
4 = 0 * 2 = + 1 * 2² + 0 * 2 0 + 0 * 2 0 = 0100
8 = 1 * 2 = + 0 * 2² + 0 * 2 0 + 0 * 2 1000 = 1000

इसका मतलब है कि हम अपने बिट फ्लैग मूल्य को एक सादे पूर्णांक मूल्य के रूप में संग्रहीत कर सकते हैं। और हम सीधे पूर्णांक मानों पर बिटवाइज़ ऑपरेटरों (बाद में उनके बारे में अधिक) का उपयोग कर सकते हैं।

घोषित XML ध्वज विशेषताएँ

अब, मान लेते हैं कि हम एक कस्टम दृश्य बनाना चाहते हैं जिसे MyView कहा जाता है जो अपने चारों ओर एक सीमा खींच सकता है, और यह कि हम किन साइटों (ऊपर, दाएं, नीचे, बाएं) पर निर्दिष्ट करना चाहते हैं कि यह XML ध्वज विशेषता का उपयोग करके सीमाओं को आकर्षित करे। ।
मैं यह नहीं समझाऊंगा कि वास्तव में किसी चीज़ को कैसे आकर्षित किया जाए, मैं केवल यह समझाऊंगा कि झंडे के साथ कैसे काम किया जाए।

हम किसी भी अन्य विशेषता की तरह XML ध्वज विशेषताओं की घोषणा कर सकते हैं। आप यहां एक आधिकारिक दस्तावेज पा सकते हैं।

हमारे मूल्यों / attrs.xml फ़ाइल में हम अपने दृश्य के लिए नई विशेषता घोषित करते हैं जिसे MyView कहा जाता है।

<संसाधनों>
    <घोषणा-योग्य नाम = "MyView">
        
            <ध्वज नाम = "कोई नहीं" मूल्य = "0" />
            <ध्वज नाम = "शीर्ष" मान = "1" />
            <ध्वज नाम = "सही" मान = "2" />
            <ध्वज नाम = "निचला" मान = "4" />
            <ध्वज नाम = "वाम" मान = "8" />
            <ध्वज नाम = "सभी" मूल्य = "15" />
        
        ...
    

विकल्पों के लिए हमने जो मूल्य निर्धारित किए हैं, उन्हें बिल्कुल देखें।
हमारे पास अनिवार्य रूप से 4 विकल्प हैं (शीर्ष, दाएं, नीचे, बाएं)। अन्य दो विकल्पों का उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि कोई विकल्प निर्धारित नहीं है या सभी विकल्प सेट हैं।
4 विकल्पों के लिए मान चुने गए हैं, ताकि जब आप उन्हें बाइनरी सिस्टम में लिखते हैं, तो ये दो कथन पूरे होते हैं:

  • प्रत्येक मान में ठीक एक बिट होता है जिसे 1 पर सेट किया जाता है। अन्य सभी बिट्स 0 हैं।
  • कोई भी मान 1 के समान नहीं है।

विकल्प 4 का उपयोग यह दर्शाने के लिए नहीं किया जाता है कि 4 विकल्पों में से कोई भी सेट नहीं है। और विकल्प सभी 4 विकल्पों के मूल्यों का योग है और इंगित करता है कि सभी 4 विकल्प सेट हैं।

अब हम अपने कस्टम विशेषता का उपयोग अपने कस्टम दृश्य में इस तरह कर सकते हैं:

XML ध्वज विशेषताएँ पढ़ें

हमारे कस्टम व्यू के लिए बुनियादी कक्षा से शुरू करें। हमें अपने प्रत्येक विकल्प के लिए एक समान मूल्य के साथ एक निरंतर घोषित करना चाहिए जैसा कि ऊपर घोषित किया गया है। और एक्सएमएल विशेषता पढ़ने से मिलने वाले मूल्य के लिए एक चर। यहाँ विशेषताओं को कैसे पढ़ा जाए, इस बारे में आपकी नज़र हो सकती है।

सार्वजनिक MyView का विस्तार
    // झंडे के लिए लगातार
    निजी स्थिर अंतिम int BORDER_NONE_DEFAULT = 0;
    निजी स्थिर अंतिम int BORDER_TOP = 1;
    निजी स्थिर अंतिम int BORDER_RIGHT = 2;
    निजी स्थिर अंतिम int BORDER_BOTTOM = 4;
    निजी स्थिर अंतिम int BORDER_LEFT = 8;
    // वर्तमान मूल्य के लिए परिवर्तनीय
    निजी int mDrawBorder = BORDER_NONE_DEFAULT;
    सार्वजनिक MyView (संदर्भ संदर्भ) {
        // अगले कंस्ट्रक्टर को सौंपें
        यह (संदर्भ, अशक्त);
    }
    सार्वजनिक MyView (संदर्भ प्रसंग, गुणसंग्रह Attrs) {
        // अगले कंस्ट्रक्टर को सौंपें
        यह (संदर्भ, गुण, 0);
    }
    सार्वजनिक MyView (संदर्भ प्रसंग, गुणसमूह अटेंड,
            int defStyleAttr) {
        सुपर (संदर्भ, attrs, defStyleAttr);
        // पढ़ें विशेषताएँ
        TypedArray a = reference.getTheme ()। AchStyledAttributes (
                Attrs, R.styleable.MyView);
        प्रयत्न {
            mDrawBorder = a.getInteger (
                    R.styleable.MyView_drawBorder,
                    BORDER_NONE_DEFAULT);
        } आखिरकार {
            a.recycle ();
        }
    }
    ...
}

अब हमने XML लेआउट फ़ाइल में निर्दिष्ट मान को mDrawBorder चर में सौंपा है। यदि विशेषता लेआउट में मौजूद नहीं है तो BORDER_NONE_DEFAULT मान का उपयोग किया जाता है।

बिट फ्लैग्स के साथ काम करना

ठीक है, हमें कैसे पता चलेगा कि हमारे कौन से विकल्प सेट किए गए थे जब हमें केवल एक मूल्य मिला था? इसलिए हमने अपने विकल्पों के लिए स्थिरांक को परिभाषित किया है।

बिटवाइज ऑपरेटर हैं जिनका उपयोग हम यह जांचने के लिए कर सकते हैं कि क्या कोई विकल्प वर्तमान mDrawBorder मान में निहित है और किसी विकल्प को सक्षम या अक्षम या टॉगल करने के लिए। आइए उन पर एक नज़र डालें:

| (तार्किक रूप से या)
उदाहरण: 100 | 001 = 101
परिणाम में 1 उस स्थिति पर होता है जहां कम से कम एक मान 1 होता है।
और (बिटवाइज़ तार्किक रूप से)
उदाहरण: १०० और १०१ = १००
परिणाम में उस स्थिति पर 1 होता है जहां दोनों मानों में 1 होता है।
~ (बिटवाइज़ उलटा)
उदाहरण: ~ १०० = ०११
सभी बिट्स उल्टे हो जाते हैं।
^ (बिटवाइज एक्सक्लूसिव या)
उदाहरण: 100 ^ 101 = 001
परिणाम में उस स्थिति पर 1 होता है जहां एक मान में 1 होता है जबकि दूसरे मान में 0 होता है।

चलिए मान लेते हैं कि हमने निम्नलिखित दो तरीकों से विशेषता का उपयोग किया है। हां, तकनीकी रूप से वे सही हैं, लेकिन वे अजीब लग सकते हैं are।

उदाहरण 1: ऐप: drawBorder = "कोई नहीं | शीर्ष"

इस पहले उदाहरण में कोई नहीं (0 = 000) और शीर्ष (1 = 001) का मान तार्किक या ऑपरेटर द्वारा संयुक्त हो जाता है। मान के लिए (001 = 1)। परिणाम में अभी भी शीर्ष के लिए ध्वज मान है (जो 1 है)। और किसी के लिए भी (जो 0 है) क्योंकि हर ध्वज-सेट में हर समय 0-ध्वज होता है।

उदाहरण 2: ऐप: drawBorder = "निचला | सभी"

इस दूसरे उदाहरण में नीचे (3 = 0011) और सभी (15 = 1111) के मान संयुक्त रूप से (1111 = 15) हो जाते हैं। परिणाम में अभी भी नीचे के लिए ध्वज है क्योंकि सभी 4 विकल्पों में से सभी के लिए बिट्स को सक्षम करता है।

जाँच करें कि क्या एक ध्वज सेट में निहित है

अब हमें यह जांचने की आवश्यकता है कि कौन सा विकल्प mDrawBorder चर के मूल्य में निहित है। हम निम्नलिखित विधि को कॉल करके ऐसा करते हैं:

निजी बूलियन में फ़्लैग (इंट फ्लैगसेट, इंट फ्लैग) {
    return (flagSet | flag) == flagSet;
}
// विधि कॉल
बूलियन ड्रॉबॉर्डरटॉप = इसमें फ़्लाग (mDrawBorder, BORDER_TOP);

हम ध्वज को मौजूदा ध्वज-सेट में जोड़ने का प्रयास करते हैं और यदि ध्वज-सेट का मूल्य नहीं बदलता है, तो हम यह जोड़ सकते हैं कि ध्वज पहले से ही समाहित था।

सेट में एक ध्वज जोड़ें

ध्वज जोड़ना बहुत सरल है। हम XML विशेषताओं की तरह एक ही ऑपरेटर (तार्किक रूप से या ऑपरेटर) का उपयोग करते हैं:

निजी int addFlag (int flagSet, int flag) {
    वापसी फ्लैगसेट
}
// विधि कॉल
mDrawBorder = addFlag (mDrawBorder, BORDER_LEFT);

हमें यह जाँचने की आवश्यकता नहीं है कि ध्वज-सेट में पहले से ही ध्वज है जिसे हम जोड़ना चाहते हैं। जब यह पहले से ही सम्‍मिलित है, तो मान समान रूप से रहता है।

सेट में एक झंडा टॉगल करें

टॉगल करना भी बहुत सरल है।

निजी int टॉगलफ्लैग (int flagSet, int flag) {
    वापसी फ्लैगसेट ^ फ्लैग;
}
// विधि कॉल
mDrawBorder = toggleFlag (mDrawBorder, BORDER_LEFT);

चूंकि अनन्य या ऑपरेटर ^ केवल बिट्स को रखता है जहां दोनों बिट्स अलग-अलग हैं, यह ध्वज में सेट किए गए बिट्स को हटा देगा, जब वे पहले से ही फ्लैग-सेट में सेट हो जाएंगे। और यह उन्हें जोड़ देगा यदि वे ध्वज-सेट में सेट नहीं हैं।

उदाहरण 1: 110 ^ 010 = 100 (बाइनरी)
            6 ^ 2 = 4 (दशमलव)
उदाहरण 2: 100 ^ 010 = 110 (बाइनरी)
            4 ^ 2 = 6 (दशमलव)

सेट से एक ध्वज निकालें

ध्वज को हटाना कुछ अधिक जटिल है (हमें दो बिटवाइज़ ऑपरेटरों की आवश्यकता है), लेकिन फिर भी आसान है।

निजी int हटानेफ्लैग (int flagSet, int flag) {
    वापसी फ्लैगसेट & (~ ध्वज);
}
// विधि कॉल
mDrawBorder = removeFlag (mDrawBorder, BORDER_LEFT);

पहले हम उस झंडे को उल्टा करते हैं जिसे हम हटाना चाहते हैं। फिर हम इसे वर्तमान ध्वज-सेट के साथ जोड़ते हैं। इसका मतलब केवल यह है कि जहां ध्वज में बिट सेट किया गया था, हमारे पास अब 0. है और इसीलिए अंतिम परिणाम में भी हमारे पास इस स्थान पर 0 है। बाकी परिणाम मूल ध्वज-सेट के समान है। इस उदाहरण पर एक नज़र डालें:

110 और (~ 010) = 110 और 101 = 100 (बाइनरी)
 6 & (~ 2) = 6 और 5 = 4 (दशमलव)

बिट फ्लैग भी एक अच्छा विकल्प है यदि आपके पास बूलियन मूल्य हैं और खासकर यदि आप उन्हें किसी भी तरह से स्टोर करना चाहते हैं। बहुत सारे बूलियनों को बचाने के बजाय आपको केवल एक पूर्णांक मान को बचाने की आवश्यकता है।

अब आपको अपने स्वयं के ध्वज विशेषताओं को परिभाषित करने और अपने आवेदन में उनके साथ काम करने में सक्षम होना चाहिए। आपको कई फ्लैगल्स के विकल्प के रूप में बिट फ्लैग्स का उपयोग करने में सक्षम होना चाहिए।
जब आप इस ट्यूटोरियल को free हिट करने के लिए स्वतंत्र महसूस उपयोगी पाते हैं।

यदि आपके पास इस ट्यूटोरियल को बेहतर बनाने या गलती पाए जाने के बारे में कोई सुझाव है, तो आप विशिष्ट स्थिति में एक निजी नोट छोड़ सकते हैं।

हैप्पी कोडिंग ।