Android में SlideStackView या विस्तार दृश्य समूह (भाग 2)

हाल ही में, मैंने Android के लिए Mail.Ru मोबाइल मेल में SlideStackView विकसित करने में अपने अनुभव के बारे में बात की । तब मैंने वादा किया कि निकट भविष्य में मैं दूसरा भाग तैयार करूंगा, जिसमें मैं इस बारे में बात करूंगा कि प्रोग्रामिंग विज़ुअल घटकों के दृष्टिकोण से सबसे दिलचस्प भाग को कैसे लागू किया जाए। स्वाभाविक रूप से, हम इस बारे में बात करेंगे कि आवेदन में अन्तरक्रियाशीलता क्या है - एनीमेशन के बारे में। हर कोई लंबे समय से इस तथ्य का आदी है कि मोबाइल एप्लिकेशन को उपयोगकर्ता की कार्रवाई के लिए उत्तरदायी होना चाहिए। जाहिर है, अपने आवेदन के साथ बातचीत करने का मुख्य तरीका टच स्क्रीन का उपयोग करना है।

चूंकि हम एक नेविगेशन कंट्रोलर - स्लाइडस्टैक व्यू लिख रहे हैं - हम एप्लिकेशन के मुख्य भागों के बीच एनिमेटेड बदलावों के साथ अन्तरक्रियाशीलता को जोड़ेंगे। Mail.Ru मोबाइल मेल में, ये तीन टुकड़े हैं: एप्लिकेशन में जोड़े गए खातों की एक सूची, चयनित मेलबॉक्स के अंदर फ़ोल्डरों की एक सूची, और एक फ़ोल्डर की सामग्री दिखाने वाले पत्रों की एक सूची।

जैसा कि मैंने पहले भाग में लिखा है, यह सब सीखने के साथ शुरू होता है कि स्थैतिक स्लाइड कैसे करें और आकर्षित करें। अगला कदम यह है कि इन स्लाइडों को कैसे सीखा जाए।

मुझे यकीन है कि अधिकांश डेवलपर्स, जिन कार्यों का सामना कर रहे हैं, उनके फ्रेमवर्क में यह आया है और उन्हें इस बारे में कुछ पता है कि Android फ्रेमवर्क में MotionEvents कैसे संसाधित किए जाते हैं, लेकिन फिर भी, मैं शुरुआत से ही शुरू कर दूंगा।

तो, बेस क्लास व्यू को इस तरह से डिज़ाइन किया गया है, जिसका अर्थ है कि MotionEvents की संभावित प्रोसेसिंग। और इसी कार्रवाई के जवाब में, विजेट इस मोशन को प्राप्त करता है, जो उपयोगकर्ता को टचस्क्रीन के साथ कैसे इंटरैक्ट करता है, इसके बारे में सभी आवश्यक जानकारी संग्रहीत करता है।

हमारे उदाहरण में, हम केवल उन घटनाओं में रुचि रखते हैं जो स्लाइड स्टैक के अंदर स्लाइड को स्क्रॉल करने में मदद करेंगे।

लेकिन कोड लिखना शुरू करने से पहले, मैं हमेशा अपने लिए उपलब्ध सभी डेटा, आवश्यकताओं और इच्छाओं को एक ढेर में इकट्ठा करना पसंद करता हूं ताकि खुद के लिए सबसे सटीक मॉडल बन सके कि क्या हो रहा है, ताकि एक भी विवरण एक तरफ न रह जाए। स्वाभाविक रूप से, एक बार में सभी छोटी चीजों पर विचार करना असंभव है, और जैसा कि आप कोड लिखते हैं, आपको वास्तुकला की सादगी के पक्ष में या विकास के समय को कम करने के लिए किसी भी विचार को छोड़ना होगा। लेकिन, जैसा कि मैंने एक लंबे समय से पहले देखा था, यह कम से कम नुकसान के साथ किया जाता है, यदि आप बैठते हैं, अनुमानित प्रवाह आरेख खींचते हैं, इंटरैक्शन टेबल, बातचीत करने वाले घटकों में एक भारी वर्ग को तोड़ते हैं, जिसका व्यवहार सिस्टम के स्वतंत्र भागों को प्रभावित किए बिना आसानी से बदला जा सकता है। जैसा कि आप अलग-अलग विजेट लिखते हैं, यह समझ स्वाभाविक रूप से अंतर्ज्ञान के स्तर पर आ जाएगी, और आप इस विचार पर अपना सिर नहीं खींचेंगे कि आवश्यक परिवर्तन करने के लिए अब आपको पिछले महीने में लिखे गए सभी कोड को फावड़ा करना होगा। यहाँ, हर प्रोग्रामर के लिए काफी सरल और परिचित नियम सामने आते हैं:

• अनावश्यक कार्यक्षमता के साथ कक्षा को अधिभार न डालें
• अपने कोड को हमेशा रिफलेक्टर करें जब आपको लगता है कि यह हिस्सा बाद में काम आ सकता है
• समय से पहले अनुकूलन न करें
• प्रत्येक क्षेत्र या विधि को घटक से अलग-थलग करते हुए देखने पर हतोत्साहित नहीं होना चाहिए

अंतिम पैराग्राफ के साथ, यह शायद सबसे कठिन होगा, क्योंकि अक्सर वांछित परिणाम प्राप्त करने के लिए एक भीड़ में, सभी प्रोग्रामर समझौता करते हैं, और अक्सर इसे "बस काम" बनाते हैं अब नोट के साथ "मैं बाद में बदलूंगा, जब समय होगा"। मैं यह नहीं कह रहा हूं कि यह बिल्कुल गलत है, मैं सिर्फ आपको चेतावनी देना चाहता हूं कि सबसे अधिक संभावना है कि आप इसे बाद में याद करेंगे, जब किसी चीज को बदलने के लिए पहले से ही बहुत देर हो चुकी है या इससे भी बदतर, यह असंभव है।

और अंतिम बिंदु जिसे मैं नोट करना आवश्यक समझता हूं, थोड़ा विवादास्पद अपील है। उपरोक्त सभी को कट्टरता के बिना करें। यही है, यदि आपको एक विजेट लिखने के कार्य का सामना करना पड़ता है, जिसे आपके एप्लिकेशन की स्क्रीन के बीच नेविगेट करने के लिए एक नियंत्रण के रूप में उपयोग किया जाना चाहिए, और आवश्यकताओं में मुख्य कार्य टच स्क्रीन के माध्यम से संचालन में आसानी है, तो आपको इसे प्राप्त करने से पहले इस पर ध्यान देने की आवश्यकता नहीं है। उदाहरण के लिए, स्पर्श नियंत्रण। बेशक, केवल फोन को घुमाकर या घुमाकर नेविगेट करना बहुत अच्छा है, और सुविधाजनक भी है, लेकिन फिर भी यह मुख्य काम नहीं है, और इसे स्थगित किया जा सकता है, इसलिए "बेहतर समय तक" बोलना।

तो, हमारे मेढ़े वापस।

पहली नज़र में, सब कुछ काफी सरल है, लेकिन यह केवल पहली नज़र में है। यदि आपको पहले स्क्रॉलिंग को संभालना था, तो आप शायद जानते हैं कि सभी प्रकार के मोशनइवेन्ट्स में से उपयोगकर्ता के असली इरादे को निर्धारित करना इतना आसान नहीं है। क्या उसने स्लाइड को साइड में ले जाने का निर्णय लिया, या क्या वह उस तत्व पर क्लिक करता है जो सूची के अंदर है, आदि। इस सभी तर्क को स्लाइड स्टैक से अलग से लागू किया जा सकता है, इसलिए संपूर्ण स्क्रॉलिंग प्रोसेसिंग एल्गोरिथ्म को एक अलग स्लाइडस्टैककॉलर घटक में अलग करना सुविधाजनक होगा।

public static class SlideScroller extends Scroller implements OnTouchListener{ private final ScrollingListener mListener; private final GestureDetector mGestureDetector; public SlideScroller(Context context, ScrollingListener listener, OnGestureListener gestureListener) { super(context); this.mListener = listener; this.mGestureDetector = new GestureDetector(context, gestureListener); mGestureDetector.setIsLongpressEnabled(false); } } 

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

घुमक्कड़ को स्‍लाइडस्‍टैक को एक इंटरफेस प्रदान करना होगा, जिसके माध्‍यम से वह स्‍लाइडस्‍टैक, घटनाओं के दृष्टिकोण से महत्‍वपूर्ण पर रिपोर्ट करेगा:

  public interface ScrollingListener { void onScroll(int distance); void onStarted(); void onFinished(); void onJustify(); } 

स्क्रॉलिंग शुरू होने के बारे में, जब स्लाइड एक निश्चित संख्या में पिक्सेल ले जाती है, तो स्क्रॉलिंग समाप्त हो जाती है और हमें स्लाइड की स्थिति संरेखित करने की आवश्यकता होती है, और यह स्क्रॉल पूरी तरह से पूरा हो जाता है।

स्लाइड स्टैक के दृष्टिकोण से, कुछ भी सरल नहीं हो सकता है, हम बस सभी स्पर्श घटनाओं के प्रसंस्करण को स्कॉलर को सौंपते हैं, और वह यह पता लगाएगा कि वास्तव में क्या हुआ और आवश्यक कॉलबैक का कारण बनता है।

जैसा कि आपने शायद देखा है, सभी प्रतिनिधि android.view.View.OnTouchListener इंटरफ़ेस के onTouch (देखें v, MotionEvent घटना) विधि के माध्यम से होता है।

  @Override public boolean onTouch(View v, MotionEvent event) { switch (event.getAction()) { case MotionEvent.ACTION_DOWN:{ int pointerId = MotionEventCompat.findPointerIndex(event, mActivePointerId); if (pointerId == INVALID_POINTER_ID){ break; } mLastTouchX = MotionEventCompat.getX(event, pointerId); mJustifying = false; forceFinished(true); clearMessages(); break; } case MotionEvent.ACTION_MOVE:{ int pointerId = MotionEventCompat.findPointerIndex(event, mActivePointerId); if (pointerId == INVALID_POINTER_ID){ break; } // perform scrolling float x = MotionEventCompat.getX(event, pointerId); int distanceX = (int)(x - mLastTouchX); if (distanceX != 0) { mTouchScrolling = true; startScrolling(); mListener.onScroll(-distanceX); mLastTouchX = x; } break; } case MotionEvent.ACTION_UP: mTouchScrolling = false; mActivePointerId = INVALID_POINTER_ID; break; } if ((!mGestureDetector.onTouchEvent(event) || ((SlideStackView)v).isOverScrolled()) && (event.getAction() == MotionEvent.ACTION_UP || event.getAction() == MotionEvent.ACTION_CANCEL)){ justify(); } return true; } 

आइए जाने क्रम में:

• ACTION_DOWN हमें बताता है कि उपयोगकर्ता ने कुछ निर्देशांक के साथ किसी क्षेत्र में स्क्रीन को छुआ है। इस मामले में, हमें ऐसे मामलों के लिए एक पूरी तरह से मानक प्रक्रिया करनी चाहिए, अर्थात्, जमीन तैयार करें और स्क्रीन पर बाद के उपयोगकर्ता आंदोलनों के लिए तैयार रहें, जिसके जवाब में हम अपने स्लाइड शो को स्क्रॉल करेंगे। इस स्थिति में, इस प्रक्रिया में प्रारंभिक स्थिति को संग्रहीत करना और सभी झंडे और वर्तमान स्क्रॉल को रीसेट करना शामिल है, अगर यह प्रदर्शन किया गया था
• ACTION_MOVE स्वयं आंदोलन को इंगित करता है, अर्थात, उपयोगकर्ता स्पर्श नए निर्देशांक में चला गया है। यह अनुमान लगाना मुश्किल नहीं है कि अब हमें निर्देशांक में अंतर की गणना करने और उपयोगकर्ता को एक स्क्रॉल बनाने वाले स्लाइड शो को सूचित करने की आवश्यकता है। SlideStackScroller जैसे एक घटक को हाइलाइट करना मोशन इवेंट्स के प्रसंस्करण और स्लाइड स्टैक के आंतरिक तर्क के बीच अत्यधिक युग्मन से बचा जाता है। दूसरे शब्दों में, हम स्लाइड स्टैक की वर्तमान स्थिति के बारे में चिंतित नहीं हैं, चाहे वह एक दिशा में स्क्रॉल कर सकता है या नहीं। हम केवल उसे बताते हैं कि उपयोगकर्ता ने क्या किया है, और क्या इस पर प्रतिक्रिया करनी है और कैसे प्रतिक्रिया करनी है, स्लाइड शो तय करेगा
• ACTION_UP। इसलिए अक्सर स्क्रीन के साथ उपयोगकर्ता की बातचीत समाप्त हो जाती है। लेकिन: इसका मतलब यह नहीं है कि हम आराम कर सकते हैं। शायद काम का केवल सबसे सरल हिस्सा यहां समाप्त होता है। मेरा मतलब है कि एक इशारा जो हर किसी के लिए इस्तेमाल किया जाता है, और इसे आमतौर पर फिंग कहा जाता है। शाब्दिक अनुवाद ("फेंक") हमें इसका मतलब समझने की अनुमति नहीं देता है। इस संदर्भ में, एक इशारा का अर्थ है जिसमें उपयोगकर्ता, स्क्रीन पर अपनी उंगली को घुमाता है, जैसे कि तत्व को तेज करता है, और, स्पर्श करना बंद कर देता है, तत्व को वास्तविक जीवन में भौतिक शरीर के साथ स्थानांतरित करने की अपेक्षा करता है। वह है, जड़ता द्वारा। उदाहरण के लिए, यदि हम किसी अन्य व्यक्ति को टेबल पर धक्का देंगे तो टेलीफोन कैसे स्लाइड करेगा।
• और अंत में, हमें यह तय करने की आवश्यकता है कि क्या इशारा समाप्त हो गया है ताकि हम स्लाइड की स्थिति को संरेखित कर सकें, या यदि उपयोगकर्ता द्वारा किए गए इशारे को फ्लिंग के रूप में व्याख्या किया जा सकता है, और फिर हमें उचित कार्रवाई करनी चाहिए और स्लाइड्स को संरेखित करने से पहले इसे पूरा करने की प्रतीक्षा करें।

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

  if ((!mGestureDetector.onTouchEvent(event) || ((SlideStackView)v).isOverScrolled()) && (event.getAction() == MotionEvent.ACTION_UP || event.getAction() == MotionEvent.ACTION_CANCEL)){ justify(); } 

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

नतीजतन, अगर फ़्लिंग पूरी हो जाती है, तो हमारे लिए सब कुछ समाप्त हो जाएगा (या शुरू करें, जैसा कि आप पसंद करते हैं) ऑनफ्लिंग विधि (MotionEvent e1, MotionEvent e2, फ्लोट वेलोसिटीएक्स, फ्लोट वेलोसिटी) को कॉल करके:

  @Override public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { if (mScroller.isTouchScrolling()){ LOG.w("mTouchScrolling in fling"); } SlideInfo slide = getSlideInfo(mSelected); int dx = getAdjustedTargetX(velocityX) - slide.mOffset; mScroller.fling(-(int)getVelocity(dx)); return true; } 

इस पद्धति में, अंतिम समन्वय पर विचार किया जाता है, जिसे हमें फ़्लिंग पूरा होने के बाद प्राप्त करना होगा, फिर स्लाइड की वर्तमान स्थिति के लिए सुधार किया जाता है, आंदोलन के लिए प्रारंभिक गति की गणना की जाती है, और फ़्लिंग स्वयं शुरू होता है।

अगर हमें पहले ही दिया जा चुका है तो गति क्यों लें? बात यह है कि गति अलग-अलग हो सकती है, लेकिन इस मामले में यह हमारे लिए महत्वपूर्ण है कि किसी भी बिंदु पर एक विशिष्ट बिंदु पर समाप्त होता है, और इस बिंदु की गणना getAdjustedTargetX () विधि में की जाती है:

  /** * Defines target x coordinate of the slide. * It depends on fling direction * <p> * In case right fling it is calculated like this * <pre> * * getLeftEdge() getRightEdge() targetX * _|___________________________|______________________|__ * | | |rightOverScrollInFling| | * | _ _ _ _ _ _ _ _ _ _ _ _ _ _ <--------------------> | * | | | | | * | | * | | | | | * | mSelectedSlide | * | | | | | * | | * | |_ _ _ _ _ _ _ _ _ _ _ _ _ _| | | * | SlideStackView | * |_|___________________________|______________________|__| * </pre> * <p> * In case left fling it is calculated like this * <pre> * 0 * ________________________|_____________________________ * | |leftOverScrollInFling | | * | <--------------------> _ _ _ _ _ _ _ _ _ _ _ _ _ _ | * | | | | | * | | * | | | | | * | mSelectedSlide | * | | | | | * | | * | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _| | * | SlideStackView | * |_|______________________|_____________________________| * </pre> * * @param velocityX velocity that defines direction of the fling * @return delta x in pixels that slide needs to scolled by * @see SlideStackView#getLeftEdge(int) * @see SlideStackView#getRightEdge(int) * @see SlideStackView#mRightOverScrollInFling * @see SlideStackView#mLeftOverScrollInFling */ private int getAdjustedTargetX(float velocityX) { int result = 0; if (velocityX > 0){ result = getRightEdge(mSelected) - getLeftEdge(mSelected) + mRightOverScrollInFling; // LOG.v("onFling " + targetX); } else { // relative to layout position of the slide result = 0 - mLeftOverScrollInFling; } return result; } 

जैसा कि विधि के शरीर से देखा जा सकता है, इस बिंदु की गणना फ़्लिंग की दिशा पर निर्भर करती है, लेकिन अंतिम स्थिति अपरिवर्तित रहती है। दाईं ओर एक फ़्लिंग के मामले में, यह पिक्सेल की संख्या से स्लाइड + "बहाव" की चरम सही स्थिति है जिसके द्वारा स्लाइड अत्यधिक सही स्थिति से आगे उड़ जाएगी। यदि बायीं ओर फड़फड़ाहट होती है, तो यह सबसे बाईं पोजीशन है - स्किडिंग। और यह आंदोलन की किसी भी प्रारंभिक गति पर है। इस तरह के प्रतिबंध को कृत्रिम रूप से बनाया गया था, क्योंकि उपयोगकर्ता के अनुभव के विश्लेषण से पता चला था कि विशेष रूप से इस नियंत्रण के लिए यह व्यवहार अधिक प्राकृतिक दिखता है।

एंड्रॉइड प्लेटफ़ॉर्म पर, एक स्कॉलर घुमने के दौरान किसी तत्व के कीनेमेटिक्स की गणना करने में शामिल होता है। एक मॉडल के रूप में, Google के डेवलपर्स ने स्कूल से ज्ञात समान रूप से त्वरित गति का सूत्र लिया: S = V ₀ * t- (g * t ² ) / 2। हम आंदोलन की प्रारंभिक गति जानते हैं, हम आंदोलन की शुरुआत से समय को माप सकते हैं, यह केवल उस त्वरण को चुनने के लिए रहता है जिसके साथ स्लाइड बंद हो जाएगी।

डेवलपर्स ने अनुमान नहीं लगाया और एक आधार के रूप में मुक्त गिरावट के त्वरण को लिया:

  mDefaultDeceleration = SensorManager.GRAVITY_EARTH // g (m/s^2) * 39.37f // inch/meter * ppi // pixels per inch * ViewConfiguration.getScrollFriction() * 10.0f; 

यदि हम उस कार्यान्वयन से विचलित होते हैं, जिसे हमने रोक दिया था, तो हम 4 संभावित परिदृश्यों को अलग कर सकते हैं जो विभिन्न प्रारंभिक गति के साथ बहने के दौरान होंगे।

खुले और बंद स्लाइड की स्थिति निम्नानुसार है:





मान लीजिए कि हम शुरुआती स्थिति से एक फ्लिंग करते हैं। उल्लिखित 4 संभावित विकल्प बाईं ओर (1 स्क्रीनशॉट) और दायीं ओर (2 स्क्रीनशॉट) स्लाइड पदों के सापेक्ष दूरी तय करके प्राप्त किए जाते हैं। मान लें कि इन पदों के बीच की दूरी एस _एन



एस <एस _एन / 2

यह स्थिति इंगित करती है कि उपयोगकर्ता फ़्लिंग, तत्व को एक प्रारंभिक गति देता है, जो तत्व के लिए पर्याप्त नहीं है कि वह आधी दूरी को अंतिम स्थिति तक पार कर सके। इस मामले में, प्राकृतिक व्यवहार का अनुकरण करने के लिए, आप उस गति से प्रवाह कर सकते हैं जो उपयोगकर्ता ने तत्व दिया था, और, तत्व को रोकने के लिए इंतजार कर रहा है, इसे अपनी मूल स्थिति में लौटाएं, अर्थात। सबसे बाईं स्थिति।



एस _एन / 2 <एस <एस _एन

यहां, तत्व का प्रारंभिक वेग लक्ष्य की आधी दूरी पर काबू पाने के लिए पर्याप्त था, लेकिन अंतिम बिंदु तक पहुंचने के लिए अपर्याप्त था। इसलिए, इस परिदृश्य को निर्धारित करते हुए, आप तत्व को थोड़ी अधिक गति दे सकते हैं - जैसे कि यह गंतव्य पर पहुंचने के लिए पर्याप्त है। इसके लिए, समान रूप से त्वरित गति के भौतिकी को याद करने के लायक है, और, त्वरण और परिणामी दूरी को जानने के साथ, प्रारंभिक गति की गणना करें जिसके साथ फ्लिंग करें।

S _n <S <S _n + ओवरक्रोल

इस परिणाम से पता चलता है कि उपयोगकर्ता ने तत्व को पर्याप्त उच्च गति दी है, जिस पर वह पहले से ही सही बिंदु से परे आंदोलन को समाप्त कर देगा, लेकिन अधिकतम स्वीकार्य स्किड तक नहीं पहुंचेगा। इस मामले में, सब कुछ ठीक उसी तरह होगा जैसे हम इसे चाहते हैं, अर्थात्: उपयोगकर्ता यह देखेगा कि तत्व जैसे कि विदेश में चला गया है, जिसके बाद यह संरेखित होगा और चरम सही स्थिति में वापस आ जाएगा।

एस> एस _एन + ओवरक्रोल

यह स्थिति थोड़ी खराब है। तत्व की प्रारंभिक गति इतनी अधिक है कि यह सबसे सही स्थिति से आगे बढ़ जाएगा, और इसका बहाव अधिकतम स्वीकार्य से अधिक होगा। सैद्धांतिक रूप से, अंतर काफी अधिक हो सकता है, जो एक प्राकृतिक, लेकिन बदसूरत दृश्य प्रभाव पैदा करता है। सकारात्मक बिंदु यह है कि बहुत तेज आंदोलन के साथ, उपयोगकर्ता के लिए यह नोटिस करना अधिक कठिन है कि हम गति को कैसे समायोजित करेंगे - मुख्य बात यह है कि सब कुछ जल्दी से होता है और तत्व स्क्रीन की सीमाओं से बहुत दूर नहीं उड़ता है।

यदि हम दूसरी दिशा में फिंगर्स को डिसाइड करते हैं, तो हम सभी समान मामलों को देखेंगे, सिवाय इसके कि रेफरेंस डिस्टेंस को थोड़ा अलग तरीके से कैलकुलेट किया जाएगा।

तो, कैसे संभाल करने के लिए हम पता लगाया है। अब हमें यह तय करने की आवश्यकता है कि इस तरह के आंदोलन के दौरान एनीमेशन कैसे बनाया जाए। ऐसा करने के लिए, इस विधि पर विचार करें:

  public void fling(int velocity){ mLastX = 0; final int maxX = 0x7FFFFFFF; final int minX = -maxX; fling(mLastX, 0, velocity, 0, minX, maxX, 0, 0); setNextMessage(MSG_SCROLL); } 

यह विधि विशेष रूप से क्षैतिज फ़्लिंग के लिए आवश्यक है और शुरू और अंत की स्थिति को ध्यान में नहीं रखती है। इसलिए, हम केवल प्रारंभिक स्थिति को याद करते हैं, अधिकतम संभव सीमाएं निर्धारित करते हैं, वारिस वर्ग में खुद को शुरू करते हैं और खुद को एक संदेश भेजते हैं कि हमें स्क्रॉल को संसाधित करने की आवश्यकता है।

यह विधि अत्यंत सरल है, इसमें हम पहले से रखे गए सभी संदेशों को साफ कर देते हैं और हैंडलर को केवल एक संदेश भेजते हैं जो वर्तमान में आवश्यक है:

  private final Handler mAnimationHandler = new AnimationHandler(); private void setNextMessage(int message) { clearMessages(); mAnimationHandler.sendEmptyMessage(message); } private void clearMessages() { mAnimationHandler.removeMessages(MSG_SCROLL); mAnimationHandler.removeMessages(MSG_JUSTIFY); } 

mAnimationHandler एक सामान्य सहायक आंतरिक वर्ग है जिसे संदेश मिलता है कि हम किसी प्रकार की स्क्रॉलिंग कर रहे हैं, जो उपयोगकर्ता के संपर्क के बाद किया जाता है टचस्क्रीन:

  private final class AnimationHandler extends Handler { @Override public void handleMessage(Message msg) { computeScrollOffset(); int currX = getCurrX(); int delta = mLastX - currX; mLastX = currX; if (delta != 0) { mListener.onScroll(-delta); } … } } 

सब कुछ बहुत सरल है: सबसे पहले, हम इस संदेश को प्राप्त करने वाले क्षण में एनीमेशन की वर्तमान स्थिति की गणना करने के लिए स्कोरर से पूछते हैं। फिर हम नई स्थिति और हमारे लिए ज्ञात अंतिम के बीच अंतर की गणना करते हैं। अंत में, हम स्लाइडशैक को सूचित करते हैं कि स्क्रॉल पूरा हो गया है। ठीक वैसे ही जैसे हमने onTouchEvent () मेथड की बॉडी से किया था।

अब यह छोटे के बारे में है - इन संदेशों के जवाब में आपको स्क्रीन पर स्लाइड की स्थिति को बदलना होगा। प्रारंभिक बिंदु onScroll () विधि का कार्यान्वयन होगा:

  @Override public void onScroll(int distance) { if (distance == 0){ return; } // LOG.d("onScroll " + distance); doScroll(distance); } 

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

  /** * Performs actual scrolling. Moves the views according * to the current selected slide number and distance * passed to the method. After the scrolling has been * performed method {@link #onScrollPerformed()} will be * called where you can apply some visual effects. * @param distance scroll distance */ private void doScroll(int distance) { adjustScrollDistance(distance); // LOG.d("scroll delta " + mScrollDelta); View selected = getChild(getSelectedViewIndex()); scrollChildBy(selected, mScrollDelta); notifyScrollPerformed(); onScrollPerformed(); fillViewsIn(); if (!mDirty.isEmpty()){ invalidate(mDirty.left, mDirty.top, mDirty.right, mDirty.bottom); mDirty.setEmpty(); } } 

अभी के लिए, हम AdjustScrollDistance () विधि के विवरण में नहीं जाते हैं। मैं केवल यह कह सकता हूं कि यह स्लाइड की स्थिति के आधार पर दूरी के मूल्य को बदलता है, जब मामले में उपयोगकर्ता को अपनी सामान्य स्थिति से परे स्लाइड खींचने की कोशिश होती है।
अगला, हम वर्तमान स्लाइड को ढूंढते हैं, जिसके आंदोलन को उपयोगकर्ता ने पूरा करने की कोशिश की, जिसके परिणामस्वरूप इस पद्धति को कॉल किया गया। इस स्लाइड को पिक्सेल की सापेक्ष संख्या में ले जाएँ। हम स्लाइड शो श्रोता को सूचित करते हैं कि स्लाइड को एक निश्चित स्थान पर स्थानांतरित कर दिया गया है।
मुख्य भाग लगभग समाप्त हो गया है, यह केवल स्लाइड्स को जोड़ने या हटाने के लिए बनी हुई है, उनकी नई स्थिति को ध्यान में रखते हुए, साथ ही साथ वे नए पदों के आधार पर अपनी दृश्यता या अदर्शन को बदलते हैं, जिसमें वे खुद को पाते हैं। आप इस बारे में अधिक पढ़ सकते हैं कि यह लेख के पहले भाग में कैसे किया गया है। खैर, और अब सबसे महत्वपूर्ण बात - हमें स्क्रीन के क्षेत्र को फिर से बनाना होगा जो आंदोलन के कारण बदल गया है।

अब सूचीबद्ध तरीकों के बारे में थोड़ा और अधिक:

  /** * Moves the specified child by some amount of pixels * @param child child to move * @param scrollDelta scrolling delta */ private void scrollChildBy(View child, int scrollDelta) { SlideInfo info = getSlideInfo(child); // LOG.d("apply scroll " + info.mPosition + " delta " + scrollDelta); Rect childDirty = getChildRectWithShadow(child); info.mOffset -= scrollDelta; child.offsetLeftAndRight(-scrollDelta); childDirty.union(getChildRectWithShadow(child)); mDirty.union(childDirty); // LOG.d("apply scroll " + info.mPosition + " newoff " + info.mOffset); } 

जैसा कि मैंने पहले ही लेख के पहले भाग में कहा था, इस मामले में mDirty यह सुनिश्चित करने के लिए कार्य करता है कि हम कई अस्थायी ऑब्जेक्ट नहीं बनाते हैं, लेकिन केवल एक का उपयोग करें। मेमोरी के तर्कसंगत उपयोग के अलावा, यह डीबगिंग को सरल करता है, क्योंकि यह केवल एक वस्तु की निगरानी करने के लिए पर्याप्त है, इसके परिवर्तन और उस तक पहुंच। यह इस संभावना को बहुत कम कर देता है कि त्रुटि किसी का ध्यान नहीं जाएगी।

  /** * Notifies scroll listeners about selected slide has been scrolled. * Do nothing if there is no scroll listener was set earlier. */ private void notifyScrollPerformed() { if (mScrollListener != null){ final float p = getSlidePositionInBounds(mSelected); // LOG.v("notifyScrollPerformed " + mSelected + ", " + p); mScrollListener.onSlideScrolled(mSelected, p); } } /** * Calculates position for the specified slide relative to it's * scrollable bounds. * <p> * <b>Note:</b> Slide position coulld be <code>< 0.0f</code> and * <code> > 1.0f * @param slidePosition * @return */ private float getSlidePositionInBounds(int slidePosition) { SlideInfo info = getSlideInfo(slidePosition); int offset = info.mOffset; int scrollBounds = getWidth() - getRightEdgeDelta(info.mPosition) - getLeftEdge(info.mPosition); float p = ((float) offset) / scrollBounds; return p; } 

अक्सर, जब आप एक घटक डिज़ाइन करते हैं, जिसका पुन: उपयोग करने की आवश्यकता होती है, तो आपको यह सोचने की आवश्यकता है कि कुछ उपयोगकर्ता आपके घटक के अंदर होने वाली घटनाओं के बारे में जानने के लिए इसे कैसे उपयोगी पाएंगे। इस बारे में मत भूलना और, यदि संभव हो तो, अपने वर्ग के उपयोगकर्ताओं को किसी प्रकार के इंटरफ़ेस के साथ प्रदान करें, जिसके उपयोग से वे अंदर क्या हो रहा है, इसके बारे में उच्च-स्तरीय जानकारी प्राप्त कर सकते हैं। मेरे मामले में, ये स्लाइड स्टैक स्क्रॉल करने से संबंधित दो मुख्य घटनाएं हैं। घटनाएं काफी स्पष्ट हैं, अर्थात्:
एक घटना जो उपयोगकर्ता को सूचित करती है कि वर्तमान स्लाइड स्लाइड स्टैक के अंदर बदल गई है, और यह ध्यान रखना महत्वपूर्ण है कि यह घटना उस समय नहीं होती है जब स्लाइड नेत्रहीन रूप से सक्रिय हो गई है, लेकिन केवल उस समय जब स्क्रॉल पूरी तरह से पूरा हो गया है।
एक घटना जो उपयोगकर्ता को सूचित करती है कि स्लाइड की स्थिति इसकी मूल सीमाओं के सापेक्ष बदल गई है। मेरे मामले में, सापेक्ष स्थिति सीमाओं से परे जा सकती है [0, 1], जिसका अर्थ बहुत "बहाव" होगा, जिसके बारे में मैं और अधिक विस्तार से बात करूंगा।

  /** * Listener interface that informs about slide scrolling * related events such as current selected slide has changed, * or current selected slide scroll position has changed. * @author k.kharkov */ public interface OnSlideScrollListener{ /** * Called when the current selected position for slide * has changed. Usually it happen after scrolling finished. * @param selectedSlide */ void onSlideChanged(int selectedSlide); /** * Informs about changing scroll position of the slide. * @param position current selected slide position * @param p position of the slide inside it's scroll * bounds. 0.0f at left edge, 1.0f at right edge. If * <code>p < 0.0f || p > 1.0f</code> the slide is over * scrolled to left or to the right. */ void onSlideScrolled(int position, float p); } 

और अंत में, तीन विधियां हैं जो पहले से ही काफी बार मिल चुकी हैं और एक से अधिक बार मिलेंगी। उनका उद्देश्य स्पष्ट और सत्य है, लेकिन उन लोगों के लिए जिनके लिए कोड इसके चारों ओर अधिक टिप्पणियां बोलता है:

  /** * Retrieves slide's left edge coordinate in opened state * relative to parent. * @param position slide number in adapter's data set * @return coordinate of the slide's left in opened state */ private int getLeftEdge(int position){ return mAdapter == null ? 0 :mAdapter.getSlideOffset(position); } 

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

@Mail.Ru , , . - , , - :

  /** * Retrieves coordinate of the slide's left edge in closed state * relative to parent. * @param position slide number in adapter's data set * @return coordinate of slide's left in closed state. */ private int getRightEdge(int position) { int rightEdge = getRight() - getRightEdgeDelta(position); return rightEdge; } /** * Just calculates delta between child's right edge and * parent's right edge * @param position position of the child (in adapter's * data set indexes) * @return delta in pixels */ private int getRightEdgeDelta(int position){ if (position < 0){ return 0; } int delta = mSlideInvisibleOffsetFirst + mSlideInvisibleOffset * position; return delta; } 

, , . , . . , - , , .

2 : onScrollPerformed(), adjustScrollDistance().

, - . , , , - . , -, . , , , . , . , - .

bouncing effect. , -, . , , Android- , iOS. , . look&feel. , , , iOS , . , . , , ,
, , - , .

, : , . -. adjustScrollDistance():

  /** * Processes scroll distance according to the current scroll * state of the slide stack view. Takes into account * over scrolling, justifying. * @param distance desired distance to scroll. */ private void adjustScrollDistance(int distance) { mScrollDelta = distance; if (mScroller.isJustifying()){ processNonOverScroll(distance); } else if (mScrollDelta < 0 && isRightOverScrolled()){ processOverScroll(distance); } else if (mScrollDelta > 0 && isLeftOverScrolled()){ processOverScroll(distance); } else { processNonOverScroll(distance); } } 

SlideStackView, , , , , , . , , .

. , :

  /** * @return <code>true</code> if slide stack over scrolled * to the right. <code>false</code> otherwise */ private boolean isRightOverScrolled(){ /** * info.mOffset - it is * the latest position of the slide's left side * so if it is over scrolled - return true * _________________ * | _____________|_ * | |lastSlide | | * |<->| | | * | | | | * | |_____________|_| * |_________________| * SlideStack */ SlideInfo info = getSlideInfo(getSelectedViewIndex()); if (mSelected == mFirst + getChildCount() - 1){ if (info.mOffset > getLeftEdge(info.mPosition)){ return true; } } /** * getRightEdge() - it is left bound of the slide * when it is hidden * ___________|______ * | | __|____________ * | | | |anySlide | * | |<->| | | * | | | | | * | | |__|____________| * |___________|______| * SlideStack */ int left = info.mOffset + getLeftEdge(mSelected); if (left > getRightEdge(mSelected)){ return true; } return false; } 

, , :

• , .
  .
• , . — .

  /** * @return <code>true</code> if the slide stack view is * over scrolled to the left. <code>false</code> otherwise. */ private boolean isLeftOverScrolled(){ View selected = getChild(getSelectedViewIndex()); SlideInfo info = getSlideInfo(selected); return selected.getRight() + info.mOffset < getRightEdge(mSelected - 1); } 

, . , , , () . , , (. getRightEdge()).

, , :

  /** * Changes actual scroll delta in case over scroll. * Depends on whether we in fling mode or not. * @param distance */ private void processOverScroll(int distance) { // LOG.d("process overscroll " + distance); //process over scroll while in fling mode; if (!mScroller.isTouchScrolling()){ mScroller.setDecelerationFactor(mDecelerationFactor); } else{ // or just slow down while touch scrolling mOverScrollOffset += distance; int nOffsetAbsolute = (int) (mOverScrollOffset / mOverScrollFactor); int oldOffsetAbsolute = mLastOverScrollOffset; int scrollDelta = nOffsetAbsolute - oldOffsetAbsolute; mLastOverScrollOffset += scrollDelta; mScrollDelta = scrollDelta; } } 

, touchScrolling, , - . , : - , . , . , mOverscrollFactor . . , , . , overscroll factor = 5, , distance = 1. . . , , . , . , 5 , , , 1 . , , .
mOverScrollOffset — , . mLastOverScrollOffset — , . , , .

: , , mOverScrollOffset mLastOverScrollOffset. , ( ), . , . :

  /** * We need assume that actual scroll delta is distance parameter, * we need adjust {@link #mLastOverScroll} if we will not go out * from over scroll mode and over scroll again. * @param distance raw distance passed from the scroller. */ private void processNonOverScroll(int distance) { mScrollDelta = distance; if (isOverScrolled()){ mLastOverScrollOffset += distance; mOverScrollOffset = (int) (mLastOverScrollOffset * mOverScrollFactor); } else { mLastOverScrollOffset = 0; mOverScrollOffset = 0; } } 

: mOverScrollOffset mLastOverScrollOffset , , , , . — .

: , .

, . , ( ) . , , , , Scroller. , :

S=V ₀ *t-(g*t ² )/2 ( )

, , . 3 :

S=V ₀ *t-(g*t ² )/2

,

S2=V _k *t2- ((g*p)*〖t2〗 ² )/2

, , p .

S3=V _k2 *t3- ((g*p*p)*〖t3〗 ² )/2

: , .
, .

mScroller.setDecelerationFactor(mDecelerationFactor);

, . , , :

  /** * Adjusts the current deceleration to slow down more or less. * @param factor if > 1.0 the scroller will slow down more. * if factor < 1.0 the scroller will slow down less. */ public void setDecelerationFactor(float factor){ mVelocity = mVelocity - mDeceleration * mPassed / 1000.0f; float velocity = mVelocity; mDeceleration *= factor; mDuration = (int) (1000.0f * mVelocity / mDeceleration); int startX = mStartX = mCurrX; int startY = mStartY = mCurrY; int totalDistance = (int) ((velocity * velocity) / (2.0f * mDeceleration)); mFinalX = startX + Math.round(totalDistance * mCoeffX); // Pin to mMinX <= mFinalX <= mMaxX mFinalX = Math.min(mFinalX, mMaxX); mFinalX = Math.max(mFinalX, mMinX); mFinalY = startY + Math.round(totalDistance * mCoeffY); // Pin to mMinY <= mFinalY <= mMaxY mFinalY = Math.min(mFinalY, mMaxY); mFinalY = Math.max(mFinalY, mMinY); mStartTime += mPassed; } 

, , , , hide :

  /** * @hide * Returns the current velocity. * * @return The original velocity less the deceleration. Result may be * negative. */ public float getCurrVelocity() { return mVelocity - mDeceleration * timePassed() / 2000.0f; } 

, v(t)=v ₀ +at (1000 — ). - , , .

, event' , . , . , , , . Android Framework , . , . , ViewGroup.dispatchTouchEvent().

. , , . , , :

• child, touchEvent.
• child , event, . , event ViewGroup.
• MotionEvent'a ViewGroup . MotionEvent ViewGroup, child'.

, , View .

, , . , . , event' , : .

. :

  /** * Determines whether the user tries to scroll the slide stack view * or just tries to scroll some scrollable content inside the slide. * <p> * {@inheritDoc} */ @Override public boolean onInterceptTouchEvent(MotionEvent ev) { 

, , , \\ .
, :

  final int action = MotionEventCompat.getActionMasked(ev); if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP){ /* * That means we need to abort all scrolling and return to nearest * stable position in the slide stack. So justify position. */ mBeingDrag = false; mUnableToDrag = false; mScroller.justify(); // LOG.v("OnInterceptTouchEvent: action cancel | up"); return false; } /* * In case we have already determined whether we need this * touch event or not - just return immediately */ if (action != MotionEvent.ACTION_DOWN){ if (mBeingDrag){ // LOG.v("OnInterceptTouchEvent: already dragging"); return true; } if (mUnableToDrag){ // LOG.v("OnInterceptTouchEvent: already unable to drag"); return false; } } 

(, MotionEvent), event' , .

, , , event .

  switch (action){ case MotionEvent.ACTION_DOWN:{ /* * remember the start coordinates for the motion event * in order to determine drag event length */ mInitialX = ev.getX(); mInitialY = ev.getY(); mActivePointerId = MotionEventCompat.getPointerId(ev, 0); /* * pass down event to the scroller after we have decided to intercept, * not here. It helps to start calculation motion event in case we * decide to intercept it. */ mScroller.setActivePointer(mActivePointerId); if (mScroller.isScrolling() || isHiddenSlideMove(false)){ /* * in case the user start the touch while we didn't * accomplish scrolling - intercept touch event. * */ mBeingDrag = true; mUnableToDrag = false; } else { /* * Otherwise let's start the process of detecting * who the touch event belongs to. */ mBeingDrag = false; mUnableToDrag = false; } // LOG.v("OnInterceptTouchEvent: DOWN being drag " + mBeingDrag + // ", unable to drag " + mUnableToDrag); return mBeingDrag; } 

event , . . , MotionEvent.ACTION_DOWN. event' , . , , event' child' . , isHiddenSlideMove(). , event' «», , , . , .

, :

  /** * Defines whether motion events has been started on the closed slide or not * * @param extend * if <code>true</code> it will take into account * {@link #mTouchExtension}. Otherwise this method will only take * into account {@link #mInitialX} and {@link #mInitialY} * @return <code>true</code> in case the motion event has been started to * the right of the last closed slide, <code>false</code> otherwise. */ private boolean isHiddenSlideMove(boolean extend) { int x = (int) mInitialX; int y = (int) mInitialY; Rect rightSide = new Rect(); boolean right = false; for (int i = getLastHiddenSlideIndex(); i >= 0 && !right; i--) { View view = getChild(i); Rect rect = new Rect(); view.getHitRect(rect); rightSide.union(rect); if (rightSide.contains(x, y) || (extend && rightSide.contains(x + mTouchExtension, y))) { right = true; } } return right; } 

— :

  case MotionEvent.ACTION_MOVE:{ final int activePointerId = mActivePointerId; if (activePointerId == INVALID_POINTER_ID) { // If we don't have a valid id, the touch down wasn't on content. break; } final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId); final float x = MotionEventCompat.getX(ev, pointerIndex); final float dx = x - mInitialX; final float xDiff = Math.abs(dx); final float y = MotionEventCompat.getY(ev, pointerIndex); final float dy = y - mInitialY; final float yDiff = Math.abs(dy); if (dx != 0 && canScroll(this, false, (int) dx, (int) x, (int) y)) { // Nested view has scrollable area under this point. Let it be handled there. if(!isHiddenSlideMove(false)) { mUnableToDrag = true; return false; } } // if it seems to be horizontal scroll if (xDiff > mTouchSlop && xDiff * 0.5f > yDiff){ // LOG.v("OnInterceptTouchEvent: MOVE start drag"); ev.setAction(MotionEvent.ACTION_DOWN); adjustSelectedSlide(); mScroller.onTouch(this, ev); mBeingDrag = true; } else if (yDiff > mTouchSlop){ // LOG.v("OnInterceptTouchEvent: MOVE unable to drag"); mUnableToDrag = true; } break; } 

. . -, , , , , ( ). , , . ,
. , . . , , 22,5 , .



, , — . . , .

. , , , ( ), , . , Google (. ViewPager):

  if (dx != 0 && canScroll(this, false, (int) dx, (int) x, (int) y)) { // Nested view has scrollable area under this point. Let it be handled there. if(!isHiddenSlideMove(false)) { mUnableToDrag = true; return false; } } 

  /** * Tests scrollability within child views of v given a delta of dx. * * @param v View to test for horizontal scrollability * @param checkV Whether the view v passed should itself be checked for scrollability (true), * or just its children (false). * @param dx Delta scrolled in pixels * @param x X coordinate of the active touch point * @param y Y coordinate of the active touch point * @return true if child views of v can be scrolled by delta of dx. */ protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) { if (v instanceof ViewGroup) { final ViewGroup group = (ViewGroup) v; final int scrollX = v.getScrollX(); final int scrollY = v.getScrollY(); final int count = group.getChildCount(); // Count backwards - let topmost views consume scroll distance first. for (int i = count - 1; i >= 0; i--) { final View child = group.getChildAt(i); if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() && y + scrollY >= child.getTop() && y + scrollY < child.getBottom() && canScroll(child, true, dx, x + scrollX - child.getLeft(), y + scrollY - child.getTop())) { return true; } } } return (checkV && ViewCompat.canScrollHorizontally(v, -dx)); } 

View, «», , , ViewCompat.canScrollHorizontally(). , , . ViewCompat, .

 public class ViewCompat { public static boolean canScrollHorizontally(View v, int direction){ if (v instanceof QuickActionView){ return ((QuickActionView)v).canScrollHorizontally(direction); } else { return android.support.v4.view.ViewCompat.canScrollHorizontally(v, direction); } } } } 

. .

  /** * {@inheritDoc} */ @Override public boolean onTouchEvent(MotionEvent event) { LOG.i("onTouchEvent: " + event); if (event.getAction() == MotionEvent.ACTION_DOWN && event.getEdgeFlags() != 0) { // Don't handle edge touches immediately -- they may actually belong to one of our // descendants. return false; } if ((event.getAction() & MotionEventCompat.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP){ continueWithSecondPointer(event); return true; } // adjust selected slide in case we didn't it in #onInterceptTouchEvent() method // if we have no touchable child under the touch event for instance if (!mScroller.isScrolling() && event.getAction() == MotionEvent.ACTION_DOWN){ adjustSelectedSlide(); } return mScroller.onTouch(this, event); } 

event' , . , , , View.

  @Override public boolean dispatchTouchEvent(MotionEvent ev) { // LOG.v("dispatchTouchEvent: " + ev); if (getChildCount() == 0){ return false; } return super.dispatchTouchEvent(ev); } 

. - , .

, , , MotionEvent'.

— . dispatchTouchEvent(), onInterceptTouchEvent() onTouchEvent(), , event. , , . developer.android.com , event'.

, . , , .

:)