मैं चाहता हूं कि Animationजब Viewयह दृश्यता के लिए सेट हो जाए तो मैं इसके लिए तैयार करना चाहता हूं GONE। केवल Viewविघटन के बजाय, 'पतन' होना चाहिए। मैं एक के साथ यह कोशिश की, ScaleAnimationलेकिन फिर Viewढह रही है, लेकिन लेआउट केवल (या पहले) Animationस्टॉप (या शुरू होता है) के बाद यह जगह का आकार बदल जाएगा ।
मैं ऐसा कैसे कर सकता हूं Animation, जबकि एनिमेशन करते समय, निचला Views रिक्त स्थान होने के बजाय, सीधे सामग्री से नीचे रहेगा?
जवाबों:
एपीआई के माध्यम से ऐसा करने का एक आसान तरीका नहीं लगता है, क्योंकि एनीमेशन सिर्फ दृश्य के रेंडर मैट्रिक्स को बदलता है, न कि वास्तविक आकार को। लेकिन हम लियरलेयआउट को मूर्ख बनाने के लिए एक नकारात्मक मार्जिन सेट कर सकते हैं, यह सोचकर कि दृश्य छोटा हो रहा है।
इसलिए मैं स्केलमैनिएशन के आधार पर अपना स्वयं का एनीमेशन वर्ग बनाने की सलाह दूंगा, और नए मार्जिन सेट करने और लेआउट को अपडेट करने के लिए "applyTransformation" विधि को ओवरराइड करूंगा। इस कदर...
public class Q2634073 extends Activity implements OnClickListener {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.q2634073);
findViewById(R.id.item1).setOnClickListener(this);
}
@Override
public void onClick(View view) {
view.startAnimation(new MyScaler(1.0f, 1.0f, 1.0f, 0.0f, 500, view, true));
}
public class MyScaler extends ScaleAnimation {
private View mView;
private LayoutParams mLayoutParams;
private int mMarginBottomFromY, mMarginBottomToY;
private boolean mVanishAfter = false;
public MyScaler(float fromX, float toX, float fromY, float toY, int duration, View view,
boolean vanishAfter) {
super(fromX, toX, fromY, toY);
setDuration(duration);
mView = view;
mVanishAfter = vanishAfter;
mLayoutParams = (LayoutParams) view.getLayoutParams();
int height = mView.getHeight();
mMarginBottomFromY = (int) (height * fromY) + mLayoutParams.bottomMargin - height;
mMarginBottomToY = (int) (0 - ((height * toY) + mLayoutParams.bottomMargin)) - height;
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
super.applyTransformation(interpolatedTime, t);
if (interpolatedTime < 1.0f) {
int newMarginBottom = mMarginBottomFromY
+ (int) ((mMarginBottomToY - mMarginBottomFromY) * interpolatedTime);
mLayoutParams.setMargins(mLayoutParams.leftMargin, mLayoutParams.topMargin,
mLayoutParams.rightMargin, newMarginBottom);
mView.getParent().requestLayout();
} else if (mVanishAfter) {
mView.setVisibility(View.GONE);
}
}
}
}
सामान्य चेतावनी लागू होती है: क्योंकि हम एक संरक्षित पद्धति (एपट्रांसफॉर्मेशन) से आगे निकल रहे हैं, यह भविष्य के एंड्रॉइड के संस्करणों में काम करने की गारंटी नहीं है।
0 - में निकालना पड़ा marginBottomToY।
MarginLayoutParamsइसे एक विशिष्ट LayoutParamप्रकार की ढलाई के बजाय सामान्य प्रकार का उपयोग किया जाए ।
अगर यह नहीं है और android:animateLayoutChanges="true"उस लेआउट के लिए सेट एक लेआउट में दृश्य रखो ।
मैंने उसी तकनीक का इस्तेमाल किया जैसा कि एंडी ने यहां प्रस्तुत किया है। मैंने उसके लिए अपना स्वयं का एनीमेशन वर्ग लिखा, जो मार्जिन के मूल्य को चेतन करता है, जिससे आइटम का प्रभाव गायब हो जाता है / दिखाई देता है। यह इस तरह दिख रहा है:
public class ExpandAnimation extends Animation {
// Initializations...
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
super.applyTransformation(interpolatedTime, t);
if (interpolatedTime < 1.0f) {
// Calculating the new bottom margin, and setting it
mViewLayoutParams.bottomMargin = mMarginStart
+ (int) ((mMarginEnd - mMarginStart) * interpolatedTime);
// Invalidating the layout, making us seeing the changes we made
mAnimatedView.requestLayout();
}
}
}
मेरे पास एक पूर्ण उदाहरण है जो मेरे ब्लॉग पोस्ट http://udinic.wordpress.com/2011/09/03/expanding-listview-it// पर काम करता है
मैंने एंडी के रूप में एक ही तकनीक का उपयोग किया, और इसे परिष्कृत किया ताकि इसका उपयोग ग्लिट्स के बिना विस्तार और ढहने के लिए किया जा सके, यहां वर्णित तकनीक का उपयोग भी किया जा सकता है: https://stackoverflow.com/a/11426510/1317564
import android.view.View;
import android.view.ViewTreeObserver;
import android.view.animation.ScaleAnimation;
import android.view.animation.Transformation;
import android.widget.LinearLayout;
class LinearLayoutVerticalScaleAnimation extends ScaleAnimation {
private final LinearLayout view;
private final LinearLayout.LayoutParams layoutParams;
private final float beginY;
private final float endY;
private final int originalBottomMargin;
private int expandedHeight;
private boolean marginsInitialized = false;
private int marginBottomBegin;
private int marginBottomEnd;
private ViewTreeObserver.OnPreDrawListener preDrawListener;
LinearLayoutVerticalScaleAnimation(float beginY, float endY,
LinearLayout linearLayout) {
super(1f, 1f, beginY, endY);
this.view = linearLayout;
this.layoutParams = (LinearLayout.LayoutParams) linearLayout.getLayoutParams();
this.beginY = beginY;
this.endY = endY;
this.originalBottomMargin = layoutParams.bottomMargin;
if (view.getHeight() != 0) {
expandedHeight = view.getHeight();
initializeMargins();
}
}
private void initializeMargins() {
final int beginHeight = (int) (expandedHeight * beginY);
final int endHeight = (int) (expandedHeight * endY);
marginBottomBegin = beginHeight + originalBottomMargin - expandedHeight;
marginBottomEnd = endHeight + originalBottomMargin - expandedHeight;
marginsInitialized = true;
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
super.applyTransformation(interpolatedTime, t);
if (!marginsInitialized && preDrawListener == null) {
// To avoid glitches, don't draw until we've initialized everything.
preDrawListener = new ViewTreeObserver.OnPreDrawListener() {
@Override
public boolean onPreDraw() {
if (view.getHeight() != 0) {
expandedHeight = view.getHeight();
initializeMargins();
adjustViewBounds(0f);
view.getViewTreeObserver().removeOnPreDrawListener(this);
}
return false;
}
};
view.getViewTreeObserver().addOnPreDrawListener(preDrawListener);
}
if (interpolatedTime < 1.0f && view.getVisibility() != View.VISIBLE) {
view.setVisibility(View.VISIBLE);
}
if (marginsInitialized) {
if (interpolatedTime < 1.0f) {
adjustViewBounds(interpolatedTime);
} else if (endY <= 0f && view.getVisibility() != View.GONE) {
view.setVisibility(View.GONE);
}
}
}
private void adjustViewBounds(float interpolatedTime) {
layoutParams.bottomMargin =
marginBottomBegin + (int) ((marginBottomEnd - marginBottomBegin) * interpolatedTime);
view.getParent().requestLayout();
}
}