व्यू ग्रुप के एक एनिमेट लेआउट गुण कैसे करता है?

Question

मैं निम्नलिखित लेआउट है

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
       android:layout_height="match_parent" 
       android:layout_width="match_parent"> 

    <FrameLayout android:id="@+id/viewgroup_left" 
       android:layout_height="match_parent" 
       android:layout_weight="2" 
       android:layout_width="0dp"> 

     ... children ... 

    </FrameLayout> 

    <LinearLayout android:id="@+id/viewgroup_right" 
        android:layout_height="match_parent" 
        android:layout_weight="1" 
        android:layout_width="0dp" 
        android:orientation="vertical"> 

     ... children ... 

    </LinearLayout> 

</LinearLayout> 

मैं कुछ इस तरह के साथ अंत:

+------------------------+------------+ 
    |      |   | 
    |      |   | 
    |   Left   | Right | 
    |      |   | 
    |      |   | 
    +------------------------+------------+ 

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

मैंने अपना खुद का एनीमेशन लिखने की कोशिश की है जो View.getWidth() पर कॉल करता है लेकिन जब मैं उस मान पर वापस एनिमेट करता हूं (View.getLayoutParams().width सेट करके) यह शुरू होने से भी बड़ा है। मुझे संदेह है कि मैं बस गलत कर रहा हूं। मैंने हनीकॉम्ब एनीमेशन सामान पर सभी दस्तावेज भी पढ़े हैं, लेकिन मैं अनुवाद या स्केल नहीं करना चाहता ... मैं लेआउट चौड़ाई संपत्ति को एनिमेट करना चाहता हूं। मुझे इसका एक उदाहरण नहीं मिल रहा है।

ऐसा करने का सही तरीका क्या है?

Answer 1

के बाद से कोई भी अभी तक आप मदद की है और मेरा पहला जवाब मैं सही जवाब आप इस समय ;-)

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

लेकिन वैसे भी, यह कोड पूरी तरह से ठीक काम करता है (आप इसे एनिमेट करते समय भी टॉगल कर सकते हैं)।

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

लेआउट:

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android" 
    android:orientation="horizontal" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent" 
    android:weightSum="10" 
    android:id="@+id/slide_layout"> 
    <TextView 
     android:layout_weight="7" 
     android:padding="10dip" 
     android:id="@+id/left" 
     android:layout_width="0dip" 
     android:layout_height="fill_parent"></TextView> 
    <TextView 
     android:layout_weight="3" 
     android:padding="10dip" 
     android:id="@+id/right" 
     android:layout_width="0dip" 
     android:layout_height="fill_parent"></TextView> 
</LinearLayout> 

गतिविधि: -

public class TestActivity extends Activity { 

    private static final int ANIMATION_DURATION = 1000; 

    private View mSlidingLayout; 
    private View mLeftView; 
    private View mRightView; 

    private boolean mAnimating = false; 
    private boolean mLeftExpand = true; 
    private float mLeftStartWeight; 
    private float mLayoutWeightSum; 
    private Handler mAnimationHandler = new Handler(); 
    private long mAnimationTime; 

    private Runnable mAnimationStep = new Runnable() { 
     @Override 
     public void run() { 
      long currentTime = System.currentTimeMillis(); 
      float animationStep = (currentTime - mAnimationTime) * 1f/ANIMATION_DURATION; 
      float weightOffset = animationStep * (mLayoutWeightSum - mLeftStartWeight); 

      LinearLayout.LayoutParams leftParams = (LinearLayout.LayoutParams) 
        mLeftView.getLayoutParams(); 
      LinearLayout.LayoutParams rightParams = (LinearLayout.LayoutParams) 
        mRightView.getLayoutParams(); 

      leftParams.weight += mLeftExpand ? weightOffset : -weightOffset; 
      rightParams.weight += mLeftExpand ? -weightOffset : weightOffset; 

      if (leftParams.weight >= mLayoutWeightSum) { 
       mAnimating = false; 
       leftParams.weight = mLayoutWeightSum; 
       rightParams.weight = 0; 
      } else if (leftParams.weight <= mLeftStartWeight) { 
       mAnimating = false; 
       leftParams.weight = mLeftStartWeight; 
       rightParams.weight = mLayoutWeightSum - mLeftStartWeight; 
      } 

      mSlidingLayout.requestLayout(); 

      mAnimationTime = currentTime; 

      if (mAnimating) { 
       mAnimationHandler.postDelayed(mAnimationStep, 30); 
      } 
     } 
    }; 

    private void toggleExpand(boolean expand) { 
     mLeftExpand = expand; 

     if (!mAnimating) { 
      mAnimating = true; 
      mAnimationTime = System.currentTimeMillis(); 
      mAnimationHandler.postDelayed(mAnimationStep, 30); 
     } 
    } 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.slide_test); 

     mLeftView = findViewById(R.id.left); 
     mRightView = findViewById(R.id.right); 
     mSlidingLayout = findViewById(R.id.slide_layout); 

     mLeftStartWeight = ((LinearLayout.LayoutParams) 
       mLeftView.getLayoutParams()).weight; 
     mLayoutWeightSum = ((LinearLayout) mSlidingLayout).getWeightSum(); 
    } 
} 

Answer 2

बस Knickedi उत्तम जवाब करने के लिए यहाँ मेरी 2 सेंट जोड़ने सिर्फ मामले में किसी को इसकी आवश्यकता है:

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

और, इन सब बातों के साथ क्या करना है, इसकी हमेशा बेहतर ObjectAnimator और AnimatorSet (आप उन्हें का उपयोग कर सकते हैं) के लिए, की तरह MarginProxy

Answer 3

समाधान द्वारा पोस्ट की गई एक अलग रास्ता तय करने के लिए कुछ उपयोगिता कक्षाओं के साथ @ knickedi Runnable के बजाय ऑब्जेक्टएनिमीटर का उपयोग करना है। विचार बाएं और दाएं दृश्यों के वजन को समायोजित करने के लिए ऑब्जेक्टएनिमीटर का उपयोग करना है। हालांकि, विचारों को अनुकूलित करने की आवश्यकता है ताकि ऑब्जेक्टएनिमीटर को एनिमेट करने के लिए वजन को संपत्ति के रूप में उजागर किया जा सके।, तब

public class CustomLinearLayout extends LinearLayout { 
    public CustomLinearLayout(Context context) { 
     super(context); 
    } 

    public CustomLinearLayout(Context context, AttributeSet attrs) { 
     super(context, attrs); 
    } 

    public CustomLinearLayout(Context context, AttributeSet attrs, int defStyleAttr) { 
     super(context, attrs, defStyleAttr); 
    } 

    public void setMyWeight(float value) { 
     LinearLayout.LayoutParams p = (LinearLayout.LayoutParams)getLayoutParams(); 
     p.weight = value; 
     requestLayout(); 
    } 
} 

इस कस्टम रेखीय लेआउट का उपयोग करने लेआउट एक्सएमएल अद्यतन:

तो सबसे पहले, (एक LinearLayout एक उदाहरण के रूप का प्रयोग करके) अनुकूलित दृश्य परिभाषित करते हैं।

फिर, जब आप एनीमेशन टॉगल करने के लिए की जरूरत है, ObjectAnimator का उपयोग करें:

ObjectAnimator rightView = ObjectAnimator.ofFloat(viewgroup_right, "MyWeight", 0.5f, 1.0f); 
ObjectAnimator leftView = ObjectAnimator.ofFloat(viewgroup_left, "MyWeight", 0.5f, 0.0f); 
AnimatorSet animatorSet = new AnimatorSet(); 
animatorSet.setDuration(1000); // 1 second of animation 
animatorSet.playTogether(rightView, leftView); 
animatorSet.start(); 

ऊपर कोड मान लिया गया है दोनों विचारों रेखीय लेआउट कर रहे हैं और वजन के साथ शुरू करने के लिए आधा कर रहे हैं। एनीमेशन सही दृश्य को पूर्ण वजन तक बढ़ाएगा (इसलिए बायां छुपा हुआ है)। ध्यान दें कि ऑब्जेक्टएनिमीटर अनुकूलित रैखिक लेआउट की "MyWeight" प्रॉपर्टी का उपयोग करके एनिमेटेड है। एनीमेटरसेट का उपयोग बाएं और दाएं ऑब्जेक्टएनिमीटर दोनों को एक साथ बांधने के लिए किया जाता है, इसलिए एनीमेशन चिकनी दिखता है।

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