Examples with AnimationListener android.view.animation.Animation.AnimationListener used on opensource projects

Example 16 with AnimationListener

use of android.view.animation.Animation.AnimationListener in project KeepScore by nolanlawson.

the class MainActivity method startHideButtonRowAnimation.

private void startHideButtonRowAnimation() {
    Animation animation = AnimationUtils.loadAnimation(this, R.anim.slide_top_to_bottom);
    animation.setAnimationListener(new AnimationListener() {

        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            buttonRow.setVisibility(View.GONE);
        }
    });
    spacerView.setVisibility(View.GONE);
    buttonRow.setAnimation(animation);
    buttonRow.startAnimation(animation);
}

Example 17 with AnimationListener

use of android.view.animation.Animation.AnimationListener in project mobile-android by photo.

the class FeatherActivity method hideProgressLoader.

/**
	 * Hide progress loader.
	 */
private void hideProgressLoader() {
    Animation fadeout = new AlphaAnimation(1, 0);
    fadeout.setDuration(getResources().getInteger(R.integer.feather_config_mediumAnimTime));
    fadeout.setAnimationListener(new AnimationListener() {

        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            mInlineProgressLoader.setVisibility(View.GONE);
        }
    });
    mInlineProgressLoader.startAnimation(fadeout);
}

Example 18 with AnimationListener

use of android.view.animation.Animation.AnimationListener in project mobile-android by photo.

the class BordersPanel method onLoadComplete.

@SuppressWarnings("deprecation")
@Override
public void onLoadComplete(final ImageView view, Bitmap bitmap, int tag) {
    if (!isActive())
        return;
    View parent = (View) view.getParent();
    if (null != bitmap) {
        view.setImageDrawable(new BitmapDrawable(bitmap));
    } else {
        view.setImageResource(R.drawable.feather_iap_dialog_image_na);
    }
    if (parent != null && parent.findViewById(R.id.progress) != null) {
        parent.findViewById(R.id.progress).setVisibility(View.GONE);
    }
    if (!mEnableEffectAnimation) {
        view.setVisibility(View.VISIBLE);
        return;
    }
    if (null != view && parent != null) {
        if (mHList.getScrollX() == 0) {
            if (parent.getLeft() < mHList.getRight()) {
                ScaleAnimation anim = new ScaleAnimation(0, 1, 0, 1, Animation.RELATIVE_TO_SELF, (float) 0.5, Animation.RELATIVE_TO_SELF, (float) 0.5);
                anim.setAnimationListener(new AnimationListener() {

                    @Override
                    public void onAnimationStart(Animation animation) {
                        view.setVisibility(View.VISIBLE);
                    }

                    @Override
                    public void onAnimationRepeat(Animation animation) {
                    }

                    @Override
                    public void onAnimationEnd(Animation animation) {
                    }
                });
                anim.setDuration(100);
                anim.setStartOffset(mHList.getScreenPositionForView(view) * 100);
                view.startAnimation(anim);
                view.setVisibility(View.INVISIBLE);
                return;
            }
        }
        view.setVisibility(View.VISIBLE);
    }
}

Example 19 with AnimationListener

use of android.view.animation.Animation.AnimationListener in project mobile-android by photo.

the class IapNotificationLayout method hide.

public void hide(long delayMillis) {
    if (getHandler() == null)
        return;
    if (getParent() == null)
        return;
    if (getVisibility() == View.GONE)
        return;
    AnimationListener listener = new AnimationListener() {

        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            setVisibility(View.GONE);
        }
    };
    float currentAlpha = 1.0f;
    final Animation animation = getAnimation();
    if (animation != null) {
        if (animation instanceof CustomAlphaAnimation) {
            currentAlpha = ((CustomAlphaAnimation) animation).getAlpha();
        }
        getAnimation().setAnimationListener(null);
        clearAnimation();
    }
    Animation newAnimation = new AlphaAnimation(currentAlpha, 0);
    newAnimation.setDuration(mIapHideDuration);
    newAnimation.setStartOffset(delayMillis);
    newAnimation.setAnimationListener(listener);
    startAnimation(newAnimation);
}

Example 20 with AnimationListener

use of android.view.animation.Animation.AnimationListener in project android-support-v4-googlemaps by petedoyle.

the class FragmentManagerImpl method moveToState.

void moveToState(Fragment f, int newState, int transit, int transitionStyle, boolean keepActive) {
    // Fragments that are not currently added will sit in the onCreate() state.
    if ((!f.mAdded || f.mDetached) && newState > Fragment.CREATED) {
        newState = Fragment.CREATED;
    }
    if (f.mRemoving && newState > f.mState) {
        // While removing a fragment, we can't change it to a higher state.
        newState = f.mState;
    }
    // if it's not already started.
    if (f.mDeferStart && f.mState < Fragment.STARTED && newState > Fragment.STOPPED) {
        newState = Fragment.STOPPED;
    }
    if (f.mState < newState) {
        // being reloaded from the layout.
        if (f.mFromLayout && !f.mInLayout) {
            return;
        }
        if (f.mAnimatingAway != null) {
            // The fragment is currently being animated...  but!  Now we
            // want to move our state back up.  Give up on waiting for the
            // animation, move to whatever the final state should be once
            // the animation is done, and then we can proceed from there.
            f.mAnimatingAway = null;
            moveToState(f, f.mStateAfterAnimating, 0, 0, true);
        }
        switch(f.mState) {
            case Fragment.INITIALIZING:
                if (DEBUG)
                    Log.v(TAG, "moveto CREATED: " + f);
                if (f.mSavedFragmentState != null) {
                    f.mSavedViewState = f.mSavedFragmentState.getSparseParcelableArray(FragmentManagerImpl.VIEW_STATE_TAG);
                    f.mTarget = getFragment(f.mSavedFragmentState, FragmentManagerImpl.TARGET_STATE_TAG);
                    if (f.mTarget != null) {
                        f.mTargetRequestCode = f.mSavedFragmentState.getInt(FragmentManagerImpl.TARGET_REQUEST_CODE_STATE_TAG, 0);
                    }
                    f.mUserVisibleHint = f.mSavedFragmentState.getBoolean(FragmentManagerImpl.USER_VISIBLE_HINT_TAG, true);
                    if (!f.mUserVisibleHint) {
                        f.mDeferStart = true;
                        if (newState > Fragment.STOPPED) {
                            newState = Fragment.STOPPED;
                        }
                    }
                }
                f.mActivity = mActivity;
                f.mParentFragment = mParent;
                f.mFragmentManager = mParent != null ? mParent.mChildFragmentManager : mActivity.mFragments;
                f.mCalled = false;
                f.onAttach(mActivity);
                if (!f.mCalled) {
                    throw new SuperNotCalledException("Fragment " + f + " did not call through to super.onAttach()");
                }
                if (f.mParentFragment == null) {
                    mActivity.onAttachFragment(f);
                }
                if (!f.mRetaining) {
                    f.performCreate(f.mSavedFragmentState);
                }
                f.mRetaining = false;
                if (f.mFromLayout) {
                    // For fragments that are part of the content view
                    // layout, we need to instantiate the view immediately
                    // and the inflater will take care of adding it.
                    f.mView = f.performCreateView(f.getLayoutInflater(f.mSavedFragmentState), null, f.mSavedFragmentState);
                    if (f.mView != null) {
                        f.mInnerView = f.mView;
                        f.mView = NoSaveStateFrameLayout.wrap(f.mView);
                        if (f.mHidden)
                            f.mView.setVisibility(View.GONE);
                        f.onViewCreated(f.mView, f.mSavedFragmentState);
                    } else {
                        f.mInnerView = null;
                    }
                }
            case Fragment.CREATED:
                if (newState > Fragment.CREATED) {
                    if (DEBUG)
                        Log.v(TAG, "moveto ACTIVITY_CREATED: " + f);
                    if (!f.mFromLayout) {
                        ViewGroup container = null;
                        if (f.mContainerId != 0) {
                            container = (ViewGroup) mContainer.findViewById(f.mContainerId);
                            if (container == null && !f.mRestored) {
                                throwException(new IllegalArgumentException("No view found for id 0x" + Integer.toHexString(f.mContainerId) + " (" + f.getResources().getResourceName(f.mContainerId) + ") for fragment " + f));
                            }
                        }
                        f.mContainer = container;
                        f.mView = f.performCreateView(f.getLayoutInflater(f.mSavedFragmentState), container, f.mSavedFragmentState);
                        if (f.mView != null) {
                            f.mInnerView = f.mView;
                            f.mView = NoSaveStateFrameLayout.wrap(f.mView);
                            if (container != null) {
                                Animation anim = loadAnimation(f, transit, true, transitionStyle);
                                if (anim != null) {
                                    f.mView.startAnimation(anim);
                                }
                                container.addView(f.mView);
                            }
                            if (f.mHidden)
                                f.mView.setVisibility(View.GONE);
                            f.onViewCreated(f.mView, f.mSavedFragmentState);
                        } else {
                            f.mInnerView = null;
                        }
                    }
                    f.performActivityCreated(f.mSavedFragmentState);
                    if (f.mView != null) {
                        f.restoreViewState(f.mSavedFragmentState);
                    }
                    f.mSavedFragmentState = null;
                }
            case Fragment.ACTIVITY_CREATED:
            case Fragment.STOPPED:
                if (newState > Fragment.STOPPED) {
                    if (DEBUG)
                        Log.v(TAG, "moveto STARTED: " + f);
                    f.performStart();
                }
            case Fragment.STARTED:
                if (newState > Fragment.STARTED) {
                    if (DEBUG)
                        Log.v(TAG, "moveto RESUMED: " + f);
                    f.mResumed = true;
                    f.performResume();
                    f.mSavedFragmentState = null;
                    f.mSavedViewState = null;
                }
        }
    } else if (f.mState > newState) {
        switch(f.mState) {
            case Fragment.RESUMED:
                if (newState < Fragment.RESUMED) {
                    if (DEBUG)
                        Log.v(TAG, "movefrom RESUMED: " + f);
                    f.performPause();
                    f.mResumed = false;
                }
            case Fragment.STARTED:
                if (newState < Fragment.STARTED) {
                    if (DEBUG)
                        Log.v(TAG, "movefrom STARTED: " + f);
                    f.performStop();
                }
            case Fragment.STOPPED:
                if (newState < Fragment.STOPPED) {
                    if (DEBUG)
                        Log.v(TAG, "movefrom STOPPED: " + f);
                    f.performReallyStop();
                }
            case Fragment.ACTIVITY_CREATED:
                if (newState < Fragment.ACTIVITY_CREATED) {
                    if (DEBUG)
                        Log.v(TAG, "movefrom ACTIVITY_CREATED: " + f);
                    if (f.mView != null) {
                        // done already.
                        if (!mActivity.isFinishing() && f.mSavedViewState == null) {
                            saveFragmentViewState(f);
                        }
                    }
                    f.performDestroyView();
                    if (f.mView != null && f.mContainer != null) {
                        Animation anim = null;
                        if (mCurState > Fragment.INITIALIZING && !mDestroyed) {
                            anim = loadAnimation(f, transit, false, transitionStyle);
                        }
                        if (anim != null) {
                            final Fragment fragment = f;
                            f.mAnimatingAway = f.mView;
                            f.mStateAfterAnimating = newState;
                            anim.setAnimationListener(new AnimationListener() {

                                @Override
                                public void onAnimationEnd(Animation animation) {
                                    if (fragment.mAnimatingAway != null) {
                                        fragment.mAnimatingAway = null;
                                        moveToState(fragment, fragment.mStateAfterAnimating, 0, 0, false);
                                    }
                                }

                                @Override
                                public void onAnimationRepeat(Animation animation) {
                                }

                                @Override
                                public void onAnimationStart(Animation animation) {
                                }
                            });
                            f.mView.startAnimation(anim);
                        }
                        f.mContainer.removeView(f.mView);
                    }
                    f.mContainer = null;
                    f.mView = null;
                    f.mInnerView = null;
                }
            case Fragment.CREATED:
                if (newState < Fragment.CREATED) {
                    if (mDestroyed) {
                        if (f.mAnimatingAway != null) {
                            // The fragment's containing activity is
                            // being destroyed, but this fragment is
                            // currently animating away.  Stop the
                            // animation right now -- it is not needed,
                            // and we can't wait any more on destroying
                            // the fragment.
                            View v = f.mAnimatingAway;
                            f.mAnimatingAway = null;
                            v.clearAnimation();
                        }
                    }
                    if (f.mAnimatingAway != null) {
                        // We are waiting for the fragment's view to finish
                        // animating away.  Just make a note of the state
                        // the fragment now should move to once the animation
                        // is done.
                        f.mStateAfterAnimating = newState;
                        newState = Fragment.CREATED;
                    } else {
                        if (DEBUG)
                            Log.v(TAG, "movefrom CREATED: " + f);
                        if (!f.mRetaining) {
                            f.performDestroy();
                        }
                        f.mCalled = false;
                        f.onDetach();
                        if (!f.mCalled) {
                            throw new SuperNotCalledException("Fragment " + f + " did not call through to super.onDetach()");
                        }
                        if (!keepActive) {
                            if (!f.mRetaining) {
                                makeInactive(f);
                            } else {
                                f.mActivity = null;
                                f.mFragmentManager = null;
                            }
                        }
                    }
                }
        }
    }
    f.mState = newState;
}