एंड्रॉइड - विजेट की तरह कैरोसेल जो बाएं और दाएं तत्वों का एक भाग प्रदर्शित करता है

Question

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

मैं बाएं और साइड विचारों पर कुछ प्रभाव जोड़ना चाहूंगा, जैसे कि थोड़ा और नीचे स्किमिंग। क्या स्टॉक व्यूफ्लिपर या व्यूपेगर के साथ ऐसा करना संभव है या क्या मुझे अपना खुद का व्यू समूह, ला ला कवर फ्लो (http://www.inter-fuser.com/2010/01/android-coverflow-widget.html) रोल करना है?

(पीएस मैं गैलरी विजेट का उपयोग नहीं करना चाहता, वह घटक बेकार है)।

बाईं टूट पड़नेवाला या सही मुख्य दृश्य से ट्रांज़िशन हैं, मंद होने और यह कम करने:

इसी को हम एक दृश्य में चुना गया (बाएँ और दाएँ विचारों अभी भी प्रदर्शित किए जाते हैं) है एक बार प्रदर्शित करने के लिए की जरूरत है थोड़ा और अगले या पिछले दृश्य के साथ विपरीत कर रहा है।

Answer 1

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

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

बाद में हमने व्यूपार्जर के पेज मार्जिन को साइड मार्जिन के आकार के 2 गुना सेट किया। इससे विचार एक साथ वापस आते हैं। हालांकि, इस समय, ViewPager द्वारा एक से अधिक दृश्य प्रदर्शित किए जायेंगे।

आप सभी को छोड़ दिया है या तो बाएं और दाएं (एंड्रॉइड 3.0+) के दृश्यों में एक ट्रांसफॉर्म (स्केल) लागू करना है या उन्हें सही आकार (पूर्व 3.0) में संक्षिप्त करने के लिए उनके चारों ओर कुछ और मार्जिन जोड़ना है। ।

OnPageChangeListener.onPageScrolled() को ViewPager की स्क्रॉलिंग को ट्रैक करने के लिए उपयोग किया जा सकता है। एक चिकनी परिवर्तन प्राप्त किया जा सकता है। कोड इस तरह दिखता है:

private OnPageChangeListener onPageChangeListener = new OnPageChangeListener() { 

    @Override 
    public void onPageSelected(int position) { 
    } 

    @Override 
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 

     // positionOffset varies from 0 to 1 and indicates how far the view is 
     // from the center of the ViewPager. When a view is selected (centered), this 
     // value is 0. 

     // Fades the text in an out while the ViewPager scrolls from one view to another. 
     // On our final design the text views are fixed to the center of the screen and 
     // do not scroll along with the views. 
     if (positionOffset < 0.5) { 
      setTextViewAlpha(1 - positionOffset * 2); 
     } else { 
      setTextViewAlpha((positionOffset - 0.5f) * 2); 
     } 

     // It's surprisingly complicated to get the current object being displayed by 
     // a ViewPager (there's no getCurrentObject method). ScaleableFragment is just 
     // a custom class to allow an adapter to cache it internally and also correctly 
     // manage a fragment's lifecycle and restore from a saved state. 
     ScaleableFragment sampleFragment = (ScaleableFragment) ((ShowHeroShotImageFragmentPagerAdapter) pager 
       .getAdapter()).getItem(position); 

     // Calculates by how much the current view will be scaled down. The RATIO_SCALE 
     // is 0.3 in our case, which makes the side views 70% of the size of the 
     // center view. When centered, the scale will be 1. When 
     // fully scrolled, the scale will be 0.7. 
     float scale = 1 - (positionOffset * RATIO_SCALE); 

     // Just a shortcut to findViewById(R.id.image).setScale(scale); 
     sampleFragment.scaleImage(scale); 


     // Now, if not in the last element, scale the next one up (in opposite direction). 
     if (position + 1 < pager.getAdapter().getCount()) { 
      sampleFragment = (ScaleableFragment) ((ShowHeroShotImageFragmentPagerAdapter) pager.getAdapter()) 
        .getItem(position + 1); 
      scale = positionOffset * RATIO_SCALE + (1 - RATIO_SCALE); 
      sampleFragment.scaleImage(scale); 
     } 
    } 

    // Once scrolling is done. Make sure the views are in the right scale (1 for center, 
    // 0.7 for sides). Required as the onPageScrolled() method does not guarantee it 
    // will interpolate to 1.0 precisely. 
    @Override 
    public void onPageScrollStateChanged(int state) { 
     if (state == ViewPager.SCROLL_STATE_IDLE) { 
      setTextViewAlpha(1); 
      ScaleableFragment sampleFragment = (ScaleableFragment) ((ShowHeroShotImageFragmentPagerAdapter) pager 
        .getAdapter()).getItem(pager.getCurrentItem()); 
      sampleFragment.scaleImage(1); 
      sampleFragment.enableClicks(); 

      if (pager.getCurrentItem() > 0) { 
       sampleFragment = (ScaleableFragment) ((ShowHeroShotImageFragmentPagerAdapter) pager.getAdapter()) 
         .getItem(pager.getCurrentItem() - 1); 
       sampleFragment.scaleImage(1 - RATIO_SCALE); 
       sampleFragment.disableClicks(); 
      } 

      if (pager.getCurrentItem() + 1 < pager.getAdapter().getCount()) { 
       sampleFragment = (ScaleableFragment) ((ShowHeroShotImageFragmentPagerAdapter) pager.getAdapter()) 
         .getItem(pager.getCurrentItem() + 1); 
       sampleFragment.scaleImage(1 - RATIO_SCALE); 
       sampleFragment.disableClicks(); 
      } 
     } 
    } 
}; 

यह है। मैंने पूरा समाधान पोस्ट नहीं किया लेकिन मुझे उम्मीद है कि यह किसी और को शुरू करने के लिए पर्याप्त है।

पीएस 3.0+ पर हार्डवेयर त्वरण सक्षम करें। इसके बिना, स्क्रॉलिंग एक सैमसंग गैलेक्सी टैब 10.1 पर चंचल लग रही थी।

Answer 2

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

संपादित करें: मुझे मूर्खतापूर्ण; जवाब देने से पहले मुझे अंतिम प्रश्न पढ़ना चाहिए। :) मुझे नहीं लगता कि आप दुर्भाग्यवश, व्यूफ्लिपर या व्यूपर के साथ ऐसा कर सकते हैं।

Answer 3

बस व्यूपेजर का उपयोग करें और टुकड़ों और मार्जिन की चौड़ाई के साथ खेलो। मैंने ऐसा किया है और यह ठीक काम करता है।

Answer 4

मैंने इसके साथ कुछ खेला, और मेरा समाधान बहुत आसान है। अगर कोई दिलचस्पी लेता है तो मैं इसे यहां पोस्ट कर रहा हूं।

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

<LinearLayout 
    android:layout_width="0dp" 
    android:layout_height="match_parent" 
    android:layout_weight="0.1" /> 

<LinearLayout 
    android:layout_width="0dp" 
    android:layout_height="match_parent" 
    android:layout_weight="0.8" 
    android:orientation="vertical" > 

    <!-- fragment contents go here --> 

</LinearLayout> 

<LinearLayout 
    android:layout_width="0dp" 
    android:layout_height="match_parent" 
    android:layout_weight="0.1" /> 

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

mPager = (ViewPager) findViewById(R.id.pager); 
    mPager.setAdapter(mAdapter); 
    mPager.setPageMargin(getResources().getDisplayMetrics().widthPixels/-7); 
    mPager.setOffscreenPageLimit(2); 

-7 मूल्य अगले खंड के किनारे को छोड़ देता है, जो आपकी विशिष्ट संरचना के साथ खेलता है। मैं प्रत्येक टुकड़े को तैयार करने की भी सिफारिश करता हूं।