) getListeners()
332 | .clone();
333 | for (AnimatorListener listener : tmpListeners) {
334 | listener.onAnimationEnd(this);
335 | }
336 | }
337 | mStarted = false;
338 | }
339 | }
340 |
341 | /**
342 | * Returns true if any of the child animations of this MyAnimatorSet have been started and have
343 | * not yet ended.
344 | *
345 | * @return Whether this MyAnimatorSet has been started and has not yet ended.
346 | */
347 | @Override
348 | public boolean isRunning() {
349 | for (Node node : mNodes) {
350 | if (node.animation.isRunning()) {
351 | return true;
352 | }
353 | }
354 | return false;
355 | }
356 |
357 | @Override
358 | public boolean isStarted() {
359 | return mStarted;
360 | }
361 |
362 | /**
363 | * The amount of time, in milliseconds, to delay starting the animation after {@link #start()}
364 | * is called.
365 | *
366 | * @return the number of milliseconds to delay running the animation
367 | */
368 | @Override
369 | public long getStartDelay() {
370 | return mStartDelay;
371 | }
372 |
373 | /**
374 | * The amount of time, in milliseconds, to delay starting the animation after {@link #start()}
375 | * is called.
376 | *
377 | * @param startDelay
378 | * The amount of the delay, in milliseconds
379 | */
380 | @Override
381 | public void setStartDelay(long startDelay) {
382 | mStartDelay = startDelay;
383 | }
384 |
385 | /**
386 | * Gets the length of each of the child animations of this MyAnimatorSet. This value may
387 | * be less than 0, which indicates that no duration has been set on this MyAnimatorSet
388 | * and each of the child animations will use their own duration.
389 | *
390 | * @return The length of the animation, in milliseconds, of each of the child
391 | * animations of this MyAnimatorSet.
392 | */
393 | @Override
394 | public long getDuration() {
395 | return mDuration;
396 | }
397 |
398 | /**
399 | * Sets the length of each of the current child animations of this MyAnimatorSet. By default,
400 | * each child animation will use its own duration. If the duration is set on the MyAnimatorSet,
401 | * then each child animation inherits this duration.
402 | *
403 | * @param duration
404 | * The length of the animation, in milliseconds, of each of the child
405 | * animations of this MyAnimatorSet.
406 | */
407 | @Override
408 | public MyAnimatorSet setDuration(long duration) {
409 | if (duration < 0) {
410 | throw new IllegalArgumentException("duration must be a value of zero or greater");
411 | }
412 | // Just record the value for now - it will be used later when the MyAnimatorSet starts
413 | mDuration = duration;
414 | return this;
415 | }
416 |
417 | @Override
418 | public void setupStartValues() {
419 | for (Node node : mNodes) {
420 | node.animation.setupStartValues();
421 | }
422 | }
423 |
424 | @Override
425 | public void setupEndValues() {
426 | for (Node node : mNodes) {
427 | node.animation.setupEndValues();
428 | }
429 | }
430 |
431 | @Override
432 | public void pause() {
433 | boolean previouslyPaused = isPaused();
434 | super.pause();
435 | if (!previouslyPaused && isPaused()) {
436 | if (mDelayAnim != null) {
437 | mDelayAnim.pause();
438 | } else {
439 | for (Node node : mNodes) {
440 | node.animation.pause();
441 | }
442 | }
443 | }
444 | }
445 |
446 | @Override
447 | public void resume() {
448 | boolean previouslyPaused = isPaused();
449 | super.resume();
450 | if (previouslyPaused && !isPaused()) {
451 | if (mDelayAnim != null) {
452 | mDelayAnim.resume();
453 | } else {
454 | for (Node node : mNodes) {
455 | node.animation.resume();
456 | }
457 | }
458 | }
459 | }
460 |
461 | /**
462 | * {@inheritDoc}
463 | *
464 | * Starting this MyAnimatorSet will, in turn, start the animations for which it is
465 | * responsible. The details of when exactly those animations are started depends on the
466 | * dependency relationships that have been set up between the animations.
467 | */
468 | @SuppressWarnings("unchecked")
469 | @Override
470 | public void start() {
471 | mTerminated = false;
472 | mStarted = true;
473 | // isPaused() = false;
474 |
475 | if (mDuration >= 0) {
476 | // If the duration was set on this MyAnimatorSet, pass it along to all child animations
477 | for (Node node : mNodes) {
478 | // TODO: don't set the duration of the timing-only nodes created by MyAnimatorSet to
479 | // insert "play-after" delays
480 | node.animation.setDuration(mDuration);
481 | }
482 | }
483 | if (mInterpolator != null) {
484 | for (Node node : mNodes) {
485 | node.animation.setInterpolator(mInterpolator);
486 | }
487 | }
488 | // First, sort the nodes (if necessary). This will ensure that sortedNodes
489 | // contains the animation nodes in the correct order.
490 | sortNodes();
491 |
492 | int numSortedNodes = mSortedNodes.size();
493 | for (int i = 0; i < numSortedNodes; ++i) {
494 | Node node = mSortedNodes.get(i);
495 | // First, clear out the old listeners
496 | ArrayList oldListeners = node.animation.getListeners();
497 | if (oldListeners != null && oldListeners.size() > 0) {
498 | final ArrayList clonedListeners = new ArrayList(
499 | oldListeners);
500 |
501 | for (AnimatorListener listener : clonedListeners) {
502 | if (listener instanceof DependencyListener
503 | || listener instanceof AnimatorSetListener) {
504 | node.animation.removeListener(listener);
505 | }
506 | }
507 | }
508 | }
509 |
510 | // nodesToStart holds the list of nodes to be started immediately. We don't want to
511 | // start the animations in the loop directly because we first need to set up
512 | // dependencies on all of the nodes. For example, we don't want to start an animation
513 | // when some other animation also wants to start when the first animation begins.
514 | final ArrayList nodesToStart = new ArrayList();
515 | for (int i = 0; i < numSortedNodes; ++i) {
516 | Node node = mSortedNodes.get(i);
517 | if (mSetListener == null) {
518 | mSetListener = new AnimatorSetListener(this);
519 | }
520 | if (node.dependencies == null || node.dependencies.size() == 0) {
521 | nodesToStart.add(node);
522 | } else {
523 | int numDependencies = node.dependencies.size();
524 | for (int j = 0; j < numDependencies; ++j) {
525 | Dependency dependency = node.dependencies.get(j);
526 | dependency.node.animation.addListener(new DependencyListener(this, node,
527 | dependency.rule));
528 | }
529 | node.tmpDependencies = (ArrayList) node.dependencies.clone();
530 | }
531 | node.animation.addListener(mSetListener);
532 | }
533 | // Now that all dependencies are set up, start the animations that should be started.
534 | if (mStartDelay <= 0) {
535 | for (Node node : nodesToStart) {
536 | node.animation.start();
537 | mPlayingSet.add(node.animation);
538 | }
539 | } else {
540 | mDelayAnim = ValueAnimator.ofFloat(0f, 1f);
541 | mDelayAnim.setDuration(mStartDelay);
542 | mDelayAnim.addListener(new AnimatorListenerAdapter() {
543 | boolean canceled = false;
544 |
545 | public void onAnimationCancel(Animator anim) {
546 | canceled = true;
547 | }
548 |
549 | public void onAnimationEnd(Animator anim) {
550 | if (!canceled) {
551 | int numNodes = nodesToStart.size();
552 | for (int i = 0; i < numNodes; ++i) {
553 | Node node = nodesToStart.get(i);
554 | node.animation.start();
555 | mPlayingSet.add(node.animation);
556 | }
557 | }
558 | mDelayAnim = null;
559 | }
560 | });
561 | mDelayAnim.start();
562 | }
563 | if (getListeners() != null) {
564 | ArrayList tmpListeners = (ArrayList) getListeners()
565 | .clone();
566 | int numListeners = tmpListeners.size();
567 | for (int i = 0; i < numListeners; ++i) {
568 | tmpListeners.get(i).onAnimationStart(this);
569 | }
570 | }
571 | if (mNodes.size() == 0 && mStartDelay == 0) {
572 | // Handle unusual case where empty MyAnimatorSet is started - should send out
573 | // end event immediately since the event will not be sent out at all otherwise
574 | mStarted = false;
575 | if (getListeners() != null) {
576 | ArrayList tmpListeners = (ArrayList) getListeners()
577 | .clone();
578 | int numListeners = tmpListeners.size();
579 | for (int i = 0; i < numListeners; ++i) {
580 | tmpListeners.get(i).onAnimationEnd(this);
581 | }
582 | }
583 | }
584 | }
585 |
586 | @Override
587 | public MyAnimatorSet clone() {
588 | final MyAnimatorSet anim = (MyAnimatorSet) super.clone();
589 | /*
590 | * The basic clone() operation copies all items. This doesn't work very well for
591 | * MyAnimatorSet, because it will copy references that need to be recreated and state
592 | * that may not apply. What we need to do now is put the clone in an uninitialized
593 | * state, with fresh, empty data structures. Then we will build up the nodes list
594 | * manually, as we clone each Node (and its animation). The clone will then be sorted,
595 | * and will populate any appropriate lists, when it is started.
596 | */
597 | anim.mNeedsSort = true;
598 | anim.mTerminated = false;
599 | anim.mStarted = false;
600 | anim.mPlayingSet = new ArrayList();
601 | anim.mNodeMap = new HashMap();
602 | anim.mNodes = new ArrayList();
603 | anim.mSortedNodes = new ArrayList();
604 |
605 | // Walk through the old nodes list, cloning each node and adding it to the new nodemap.
606 | // One problem is that the old node dependencies point to nodes in the old MyAnimatorSet.
607 | // We need to track the old/new nodes in order to reconstruct the dependencies in the clone.
608 | HashMap nodeCloneMap = new HashMap(); //
609 | for (Node node : mNodes) {
610 | Node nodeClone = node.clone();
611 | nodeCloneMap.put(node, nodeClone);
612 | anim.mNodes.add(nodeClone);
613 | anim.mNodeMap.put(nodeClone.animation, nodeClone);
614 | // Clear out the dependencies in the clone; we'll set these up manually later
615 | nodeClone.dependencies = null;
616 | nodeClone.tmpDependencies = null;
617 | nodeClone.nodeDependents = null;
618 | nodeClone.nodeDependencies = null;
619 | // clear out any listeners that were set up by the MyAnimatorSet; these will
620 | // be set up when the clone's nodes are sorted
621 | ArrayList cloneListeners = nodeClone.animation.getListeners();
622 | if (cloneListeners != null) {
623 | ArrayList listenersToRemove = null;
624 | for (AnimatorListener listener : cloneListeners) {
625 | if (listener instanceof AnimatorSetListener) {
626 | if (listenersToRemove == null) {
627 | listenersToRemove = new ArrayList();
628 | }
629 | listenersToRemove.add(listener);
630 | }
631 | }
632 | if (listenersToRemove != null) {
633 | for (AnimatorListener listener : listenersToRemove) {
634 | cloneListeners.remove(listener);
635 | }
636 | }
637 | }
638 | }
639 | // Now that we've cloned all of the nodes, we're ready to walk through their
640 | // dependencies, mapping the old dependencies to the new nodes
641 | for (Node node : mNodes) {
642 | Node nodeClone = nodeCloneMap.get(node);
643 | if (node.dependencies != null) {
644 | for (Dependency dependency : node.dependencies) {
645 | Node clonedDependencyNode = nodeCloneMap.get(dependency.node);
646 | Dependency cloneDependency = new Dependency(clonedDependencyNode,
647 | dependency.rule);
648 | nodeClone.addDependency(cloneDependency);
649 | }
650 | }
651 | }
652 |
653 | return anim;
654 | }
655 |
656 | /**
657 | * This class is the mechanism by which animations are started based on events in other
658 | * animations. If an animation has multiple dependencies on other animations, then
659 | * all dependencies must be satisfied before the animation is started.
660 | */
661 | private static class DependencyListener implements AnimatorListener {
662 |
663 | private MyAnimatorSet mAnimatorSet;
664 |
665 | // The node upon which the dependency is based.
666 | private Node mNode;
667 |
668 | // The Dependency rule (WITH or AFTER) that the listener should wait for on
669 | // the node
670 | private int mRule;
671 |
672 | public DependencyListener(MyAnimatorSet animatorSet, Node node, int rule) {
673 | this.mAnimatorSet = animatorSet;
674 | this.mNode = node;
675 | this.mRule = rule;
676 | }
677 |
678 | /**
679 | * Ignore cancel events for now. We may want to handle this eventually,
680 | * to prevent follow-on animations from running when some dependency
681 | * animation is canceled.
682 | */
683 | public void onAnimationCancel(Animator animation) {
684 | }
685 |
686 | /**
687 | * An end event is received - see if this is an event we are listening for
688 | */
689 | public void onAnimationEnd(Animator animation) {
690 | if (mRule == Dependency.AFTER) {
691 | startIfReady(animation);
692 | }
693 | }
694 |
695 | /**
696 | * Ignore repeat events for now
697 | */
698 | public void onAnimationRepeat(Animator animation) {
699 | }
700 |
701 | /**
702 | * A start event is received - see if this is an event we are listening for
703 | */
704 | public void onAnimationStart(Animator animation) {
705 | if (mRule == Dependency.WITH) {
706 | startIfReady(animation);
707 | }
708 | }
709 |
710 | /**
711 | * Check whether the event received is one that the node was waiting for.
712 | * If so, mark it as complete and see whether it's time to start
713 | * the animation.
714 | *
715 | * @param dependencyAnimation
716 | * the animation that sent the event.
717 | */
718 | private void startIfReady(Animator dependencyAnimation) {
719 | if (mAnimatorSet.mTerminated) {
720 | // if the parent MyAnimatorSet was canceled, then don't start any dependent anims
721 | return;
722 | }
723 | Dependency dependencyToRemove = null;
724 | int numDependencies = mNode.tmpDependencies.size();
725 | for (int i = 0; i < numDependencies; ++i) {
726 | Dependency dependency = mNode.tmpDependencies.get(i);
727 | if (dependency.rule == mRule && dependency.node.animation == dependencyAnimation) {
728 | // rule fired - remove the dependency and listener and check to
729 | // see whether it's time to start the animation
730 | dependencyToRemove = dependency;
731 | dependencyAnimation.removeListener(this);
732 | break;
733 | }
734 | }
735 | mNode.tmpDependencies.remove(dependencyToRemove);
736 | if (mNode.tmpDependencies.size() == 0) {
737 | // all dependencies satisfied: start the animation
738 | mNode.animation.start();
739 | mAnimatorSet.mPlayingSet.add(mNode.animation);
740 | }
741 | }
742 |
743 | }
744 |
745 | private class AnimatorSetListener implements AnimatorListener {
746 |
747 | private MyAnimatorSet mAnimatorSet;
748 |
749 | AnimatorSetListener(MyAnimatorSet animatorSet) {
750 | mAnimatorSet = animatorSet;
751 | }
752 |
753 | public void onAnimationCancel(Animator animation) {
754 | if (!mTerminated) {
755 | // Listeners are already notified of the MyAnimatorSet canceling in cancel().
756 | // The logic below only kicks in when animations end normally
757 | if (mPlayingSet.size() == 0) {
758 | if (getListeners() != null) {
759 | int numListeners = getListeners().size();
760 | for (int i = 0; i < numListeners; ++i) {
761 | getListeners().get(i).onAnimationCancel(mAnimatorSet);
762 | }
763 | }
764 | }
765 | }
766 | }
767 |
768 | @SuppressWarnings("unchecked")
769 | public void onAnimationEnd(Animator animation) {
770 | animation.removeListener(this);
771 | mPlayingSet.remove(animation);
772 | Node animNode = mAnimatorSet.mNodeMap.get(animation);
773 | animNode.done = true;
774 | if (!mTerminated) {
775 | // Listeners are already notified of the MyAnimatorSet ending in cancel() or
776 | // end(); the logic below only kicks in when animations end normally
777 | ArrayList sortedNodes = mAnimatorSet.mSortedNodes;
778 | boolean allDone = true;
779 | int numSortedNodes = sortedNodes.size();
780 | for (int i = 0; i < numSortedNodes; ++i) {
781 | if (!sortedNodes.get(i).done) {
782 | allDone = false;
783 | break;
784 | }
785 | }
786 | if (allDone) {
787 | // If this was the last child animation to end, then notify listeners that this
788 | // MyAnimatorSet has ended
789 | if (getListeners() != null) {
790 | ArrayList tmpListeners = (ArrayList) getListeners()
791 | .clone();
792 | int numListeners = tmpListeners.size();
793 | for (int i = 0; i < numListeners; ++i) {
794 | tmpListeners.get(i).onAnimationEnd(mAnimatorSet);
795 | }
796 | }
797 | mAnimatorSet.mStarted = false;
798 | // mAnimatorSet.set = false;
799 | }
800 | }
801 | }
802 |
803 | // Nothing to do
804 | public void onAnimationRepeat(Animator animation) {
805 | }
806 |
807 | // Nothing to do
808 | public void onAnimationStart(Animator animation) {
809 | }
810 |
811 | }
812 |
813 | /**
814 | * This method sorts the current set of nodes, if needed. The sort is a simple
815 | * DependencyGraph sort, which goes like this:
816 | * - All nodes without dependencies become 'roots'
817 | * - while roots list is not null
818 | * - for each root r
819 | * - add r to sorted list
820 | * - remove r as a dependency from any other node
821 | * - any nodes with no dependencies are added to the roots list
822 | */
823 | private void sortNodes() {
824 | if (mNeedsSort) {
825 | mSortedNodes.clear();
826 | ArrayList roots = new ArrayList();
827 | int numNodes = mNodes.size();
828 | for (int i = 0; i < numNodes; ++i) {
829 | Node node = mNodes.get(i);
830 | if (node.dependencies == null || node.dependencies.size() == 0) {
831 | roots.add(node);
832 | }
833 | }
834 | ArrayList tmpRoots = new ArrayList();
835 | while (roots.size() > 0) {
836 | int numRoots = roots.size();
837 | for (int i = 0; i < numRoots; ++i) {
838 | Node root = roots.get(i);
839 | mSortedNodes.add(root);
840 | if (root.nodeDependents != null) {
841 | int numDependents = root.nodeDependents.size();
842 | for (int j = 0; j < numDependents; ++j) {
843 | Node node = root.nodeDependents.get(j);
844 | node.nodeDependencies.remove(root);
845 | if (node.nodeDependencies.size() == 0) {
846 | tmpRoots.add(node);
847 | }
848 | }
849 | }
850 | }
851 | roots.clear();
852 | roots.addAll(tmpRoots);
853 | tmpRoots.clear();
854 | }
855 | mNeedsSort = false;
856 | if (mSortedNodes.size() != mNodes.size()) {
857 | throw new IllegalStateException("Circular dependencies cannot exist"
858 | + " in MyAnimatorSet");
859 | }
860 | } else {
861 | // Doesn't need sorting, but still need to add in the nodeDependencies list
862 | // because these get removed as the event listeners fire and the dependencies
863 | // are satisfied
864 | int numNodes = mNodes.size();
865 | for (int i = 0; i < numNodes; ++i) {
866 | Node node = mNodes.get(i);
867 | if (node.dependencies != null && node.dependencies.size() > 0) {
868 | int numDependencies = node.dependencies.size();
869 | for (int j = 0; j < numDependencies; ++j) {
870 | Dependency dependency = node.dependencies.get(j);
871 | if (node.nodeDependencies == null) {
872 | node.nodeDependencies = new ArrayList();
873 | }
874 | if (!node.nodeDependencies.contains(dependency.node)) {
875 | node.nodeDependencies.add(dependency.node);
876 | }
877 | }
878 | }
879 | // nodes are 'done' by default; they become un-done when started, and done
880 | // again when ended
881 | node.done = false;
882 | }
883 | }
884 | }
885 |
886 | /**
887 | * Dependency holds information about the node that some other node is
888 | * dependent upon and the nature of that dependency.
889 | */
890 | private static class Dependency {
891 | static final int WITH = 0; // dependent node must start with this dependency node
892 | static final int AFTER = 1; // dependent node must start when this dependency node finishes
893 |
894 | // The node that the other node with this Dependency is dependent upon
895 | public Node node;
896 |
897 | // The nature of the dependency (WITH or AFTER)
898 | public int rule;
899 |
900 | public Dependency(Node node, int rule) {
901 | this.node = node;
902 | this.rule = rule;
903 | }
904 | }
905 |
906 | /**
907 | * A Node is an embodiment of both the Animator that it wraps as well as
908 | * any dependencies that are associated with that Animation. This includes
909 | * both dependencies upon other nodes (in the dependencies list) as
910 | * well as dependencies of other nodes upon this (in the nodeDependents list).
911 | */
912 | private static class Node implements Cloneable {
913 | public Animator animation;
914 |
915 | /**
916 | * These are the dependencies that this node's animation has on other
917 | * nodes. For example, if this node's animation should begin with some
918 | * other animation ends, then there will be an item in this node's
919 | * dependencies list for that other animation's node.
920 | */
921 | public ArrayList dependencies = null;
922 |
923 | /**
924 | * tmpDependencies is a runtime detail. We use the dependencies list for sorting.
925 | * But we also use the list to keep track of when multiple dependencies are satisfied,
926 | * but removing each dependency as it is satisfied. We do not want to remove
927 | * the dependency itself from the list, because we need to retain that information
928 | * if the MyAnimatorSet is launched in the future. So we create a copy of the dependency
929 | * list when the MyAnimatorSet starts and use this tmpDependencies list to track the
930 | * list of satisfied dependencies.
931 | */
932 | public ArrayList tmpDependencies = null;
933 |
934 | /**
935 | * nodeDependencies is just a list of the nodes that this Node is dependent upon.
936 | * This information is used in sortNodes(), to determine when a node is a root.
937 | */
938 | public ArrayList nodeDependencies = null;
939 |
940 | /**
941 | * nodeDepdendents is the list of nodes that have this node as a dependency. This
942 | * is a utility field used in sortNodes to facilitate removing this node as a
943 | * dependency when it is a root node.
944 | */
945 | public ArrayList nodeDependents = null;
946 |
947 | /**
948 | * Flag indicating whether the animation in this node is finished. This flag
949 | * is used by MyAnimatorSet to check, as each animation ends, whether all child animations
950 | * are done and it's time to send out an end event for the entire MyAnimatorSet.
951 | */
952 | public boolean done = false;
953 |
954 | /**
955 | * Constructs the Node with the animation that it encapsulates. A Node has no
956 | * dependencies by default; dependencies are added via the addDependency()
957 | * method.
958 | *
959 | * @param animation
960 | * The animation that the Node encapsulates.
961 | */
962 | public Node(Animator animation) {
963 | this.animation = animation;
964 | }
965 |
966 | /**
967 | * Add a dependency to this Node. The dependency includes information about the
968 | * node that this node is dependency upon and the nature of the dependency.
969 | *
970 | * @param dependency
971 | */
972 | public void addDependency(Dependency dependency) {
973 | if (dependencies == null) {
974 | dependencies = new ArrayList();
975 | nodeDependencies = new ArrayList();
976 | }
977 | dependencies.add(dependency);
978 | if (!nodeDependencies.contains(dependency.node)) {
979 | nodeDependencies.add(dependency.node);
980 | }
981 | Node dependencyNode = dependency.node;
982 | if (dependencyNode.nodeDependents == null) {
983 | dependencyNode.nodeDependents = new ArrayList();
984 | }
985 | dependencyNode.nodeDependents.add(this);
986 | }
987 |
988 | @Override
989 | public Node clone() {
990 | try {
991 | Node node = (Node) super.clone();
992 | node.animation = (Animator) animation.clone();
993 | return node;
994 | } catch (CloneNotSupportedException e) {
995 | throw new AssertionError();
996 | }
997 | }
998 | }
999 |
1000 | /**
1001 | * The Builder object is a utility class to facilitate adding animations to a
1002 | * MyAnimatorSet along with the relationships between the various animations. The
1003 | * intention of the Builder methods, along with the
1004 | * {@link MyAnimatorSet#play(Animator) play()} method of MyAnimatorSet is to make
1005 | * it
1006 | * possible
1007 | * to express the dependency relationships of animations in a natural way. Developers can also
1008 | * use the {@link MyAnimatorSet#playTogether(Animator[]) playTogether()} and
1009 | * {@link MyAnimatorSet#playSequentially(Animator[]) playSequentially()} methods if these suit
1010 | * the
1011 | * need,
1012 | * but it might be easier in some situations to express the MyAnimatorSet of animations in
1013 | * pairs.
1014 | *
1015 | *
1016 | * The Builder object cannot be constructed directly, but is rather constructed
1017 | * internally via a call to {@link MyAnimatorSet#play(Animator)}.
1018 | *
1019 | *
1020 | *
1021 | * For example, this sets up a MyAnimatorSet to play anim1 and anim2 at the same time, anim3 to
1022 | * play when anim2 finishes, and anim4 to play when anim3 finishes:
1023 | *
1024 | *
1025 | *
1026 | * MyAnimatorSet s = new MyAnimatorSet();
1027 | * s.play(anim1).with(anim2);
1028 | * s.play(anim2).before(anim3);
1029 | * s.play(anim4).after(anim3);
1030 | *
1031 | *
1032 | *
1033 | * Note in the example that both {@link Builder#before(Animator)} and
1034 | * {@link Builder#after(Animator)} are used. These are just different ways of expressing the
1035 | * same relationship and are provided to make it easier to say things in a way that is more
1036 | * natural, depending on the situation.
1037 | *
1038 | *
1039 | *
1040 | * It is possible to make several calls into the same Builder object to express
1041 | * multiple relationships. However, note that it is only the animation passed into the initial
1042 | * {@link MyAnimatorSet#play(Animator)} method that is the dependency in any of the successive
1043 | * calls to the Builder object. For example, the following code starts both anim2
1044 | * and anim3 when anim1 ends; there is no direct dependency relationship between anim2 and
1045 | * anim3:
1046 | *
1047 | *
1048 | * MyAnimatorSet s = new MyAnimatorSet();
1049 | * s.play(anim1).before(anim2).before(anim3);
1050 | *
1051 | *
1052 | * If the desired result is to play anim1 then anim2 then anim3, this code expresses the
1053 | * relationship correctly:
1054 | *
1055 | *
1056 | *
1057 | * MyAnimatorSet s = new MyAnimatorSet();
1058 | * s.play(anim1).before(anim2);
1059 | * s.play(anim2).before(anim3);
1060 | *
1061 | *
1062 | *
1063 | * Note that it is possible to express relationships that cannot be resolved and will not result
1064 | * in sensible results. For example, play(anim1).after(anim1) makes no sense. In
1065 | * general, circular dependencies like this one (or more indirect ones where a depends on b,
1066 | * which depends on c, which depends on a) should be avoided. Only create AnimatorSets that can
1067 | * boil down to a simple, one-way relationship of animations starting with, before, and after
1068 | * other, different, animations.
1069 | *
1070 | */
1071 | public class Builder {
1072 |
1073 | /**
1074 | * This tracks the current node being processed. It is supplied to the play() method
1075 | * of MyAnimatorSet and passed into the constructor of Builder.
1076 | */
1077 | private Node mCurrentNode;
1078 |
1079 | /**
1080 | * package-private constructor. Builders are only constructed by MyAnimatorSet, when the
1081 | * play() method is called.
1082 | *
1083 | * @param anim
1084 | * The animation that is the dependency for the other animations passed into
1085 | * the other methods of this Builder object.
1086 | */
1087 | Builder(Animator anim) {
1088 | mCurrentNode = mNodeMap.get(anim);
1089 | if (mCurrentNode == null) {
1090 | mCurrentNode = new Node(anim);
1091 | mNodeMap.put(anim, mCurrentNode);
1092 | mNodes.add(mCurrentNode);
1093 | }
1094 | }
1095 |
1096 | /**
1097 | * Sets up the given animation to play at the same time as the animation supplied in the
1098 | * {@link MyAnimatorSet#play(Animator)} call that created this Builder object.
1099 | *
1100 | * @param anim
1101 | * The animation that will play when the animation supplied to the
1102 | * {@link MyAnimatorSet#play(Animator)} method starts.
1103 | */
1104 | public Builder with(Animator anim) {
1105 | Node node = mNodeMap.get(anim);
1106 | if (node == null) {
1107 | node = new Node(anim);
1108 | mNodeMap.put(anim, node);
1109 | mNodes.add(node);
1110 | }
1111 | Dependency dependency = new Dependency(mCurrentNode, Dependency.WITH);
1112 | node.addDependency(dependency);
1113 | return this;
1114 | }
1115 |
1116 | /**
1117 | * Sets up the given animation to play when the animation supplied in the
1118 | * {@link MyAnimatorSet#play(Animator)} call that created this Builder object
1119 | * ends.
1120 | *
1121 | * @param anim
1122 | * The animation that will play when the animation supplied to the
1123 | * {@link MyAnimatorSet#play(Animator)} method ends.
1124 | */
1125 | public Builder before(Animator anim) {
1126 | Node node = mNodeMap.get(anim);
1127 | if (node == null) {
1128 | node = new Node(anim);
1129 | mNodeMap.put(anim, node);
1130 | mNodes.add(node);
1131 | }
1132 | Dependency dependency = new Dependency(mCurrentNode, Dependency.AFTER);
1133 | node.addDependency(dependency);
1134 | return this;
1135 | }
1136 |
1137 | /**
1138 | * Sets up the given animation to play when the animation supplied in the
1139 | * {@link MyAnimatorSet#play(Animator)} call that created this Builder object
1140 | * to start when the animation supplied in this method call ends.
1141 | *
1142 | * @param anim
1143 | * The animation whose end will cause the animation supplied to the
1144 | * {@link MyAnimatorSet#play(Animator)} method to play.
1145 | */
1146 | public Builder after(Animator anim) {
1147 | Node node = mNodeMap.get(anim);
1148 | if (node == null) {
1149 | node = new Node(anim);
1150 | mNodeMap.put(anim, node);
1151 | mNodes.add(node);
1152 | }
1153 | Dependency dependency = new Dependency(node, Dependency.AFTER);
1154 | mCurrentNode.addDependency(dependency);
1155 | return this;
1156 | }
1157 |
1158 | /**
1159 | * Sets up the animation supplied in the {@link MyAnimatorSet#play(Animator)} call that
1160 | * created this Builder object
1161 | * to play when the given amount of time elapses.
1162 | *
1163 | * @param delay
1164 | * The number of milliseconds that should elapse before the
1165 | * animation starts.
1166 | */
1167 | public Builder after(long delay) {
1168 | // setup dummy ValueAnimator just to run the clock
1169 | ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
1170 | anim.setDuration(delay);
1171 | after(anim);
1172 | return this;
1173 | }
1174 |
1175 | }
1176 |
1177 | public void setCurrentPlayTime(long cpt) {
1178 | int numNodes = mNodes.size();
1179 | for (int i = 0; i < numNodes; ++i) {
1180 | Node node = mNodes.get(i);
1181 | ((ValueAnimator) node.animation).setCurrentPlayTime(cpt);
1182 | }
1183 | }
1184 |
1185 | public long getMaxDuration() {
1186 | long maxDuration = 0;
1187 | int numNodes = mNodes.size();
1188 | for (int i = 0; i < numNodes; ++i) {
1189 | Node node = mNodes.get(i);
1190 | maxDuration = Math.max(node.animation.getDuration(), maxDuration);
1191 | }
1192 | return maxDuration;
1193 | }
1194 |
1195 | MyAnimatorListener listener;
1196 |
1197 | public void setCurrentPlayTimeAtRatio(float ratio) {
1198 | int numNodes = mNodes.size();
1199 | // AnimatorListener listener = getListeners().get(0);
1200 | listener.onAnimationStart(this);
1201 | for (int i = 0; i < numNodes; ++i) {
1202 | Node node = mNodes.get(i);
1203 | ValueAnimator valueAnimator = (ValueAnimator) node.animation;
1204 | // if (valueAnimator.getRepeatCount() != -1) {
1205 | long cpt = (long) (valueAnimator.getDuration() * ratio);
1206 | valueAnimator.setCurrentPlayTime(cpt);
1207 | // } else {
1208 | // valueAnimator.start();
1209 | // }
1210 | }
1211 | }
1212 |
1213 | public void reverse() {
1214 | this.listener.onAnimationReverse(this);
1215 |
1216 | mTerminated = false;
1217 | mStarted = true;
1218 |
1219 | sortNodes();
1220 |
1221 | int numSortedNodes = mSortedNodes.size();
1222 | for (int i = 0; i < numSortedNodes; ++i) {
1223 | Node node = mSortedNodes.get(i);
1224 | // First, clear out the old listeners
1225 | ArrayList oldListeners = node.animation.getListeners();
1226 | if (oldListeners != null && oldListeners.size() > 0) {
1227 | final ArrayList clonedListeners = new ArrayList(
1228 | oldListeners);
1229 |
1230 | for (AnimatorListener listener : clonedListeners) {
1231 | if (listener instanceof DependencyListener
1232 | || listener instanceof AnimatorSetListener) {
1233 | node.animation.removeListener(listener);
1234 | }
1235 | }
1236 | }
1237 | }
1238 |
1239 | int numNodes = mNodes.size();
1240 | for (int i = 0; i < numNodes; ++i) {
1241 | Node node = mNodes.get(i);
1242 |
1243 | // 不顶用
1244 | // ArrayList oldListeners = node.animation.getListeners();
1245 | // if (oldListeners != null && oldListeners.size() > 0) {
1246 | // final ArrayList clonedListeners = new ArrayList(
1247 | // oldListeners);
1248 | //
1249 | // for (AnimatorListener listener : clonedListeners) {
1250 | // if (listener instanceof DependencyListener
1251 | // || listener instanceof AnimatorSetListener) {
1252 | // node.animation.removeListener(listener);
1253 | // }
1254 | // }
1255 | // }
1256 |
1257 | ((ValueAnimator) node.animation).reverse();
1258 |
1259 | if (mSetListener == null) {
1260 | mSetListener = new AnimatorSetListener(this);
1261 | }
1262 | node.animation.addListener(mSetListener);
1263 | }
1264 | }
1265 |
1266 | // @Override
1267 | // public void addListener(AnimatorListener listener) {
1268 | // super.addListener(listener);
1269 | //
1270 | // }
1271 |
1272 | public void addMyListener(MyAnimatorListener listener) {
1273 | super.addListener(listener);
1274 | this.listener = listener;
1275 | }
1276 |
1277 | public static class MyAnimatorListener implements AnimatorListener {
1278 |
1279 | public void onAnimationReverse(Animator animation) {
1280 |
1281 | }
1282 |
1283 | @Override
1284 | public void onAnimationStart(Animator animation) {
1285 |
1286 | }
1287 |
1288 | @Override
1289 | public void onAnimationEnd(Animator animation) {
1290 |
1291 | }
1292 |
1293 | @Override
1294 | public void onAnimationCancel(Animator animation) {
1295 |
1296 | }
1297 |
1298 | @Override
1299 | public void onAnimationRepeat(Animator animation) {
1300 |
1301 | }
1302 |
1303 | }
1304 |
1305 | public ArrayList getChildAnimationsClone() {
1306 | ArrayList childList = new ArrayList();
1307 | for (Node node : mNodes) {
1308 | Node nodeClone = node.clone();
1309 | childList.add(nodeClone.animation);
1310 | }
1311 | return childList;
1312 | }
1313 | }
1314 |
--------------------------------------------------------------------------------
/src/com/kongnan/weibo/MyImageView.java:
--------------------------------------------------------------------------------
1 | package com.kongnan.weibo;
2 |
3 | import java.lang.reflect.Field;
4 |
5 | import android.content.Context;
6 | import android.util.AttributeSet;
7 | import android.util.DisplayMetrics;
8 | import android.util.Log;
9 | import android.widget.ImageView;
10 |
11 | public class MyImageView extends ImageView {
12 |
13 | private static final String TAG = MyImageView.class.getSimpleName();
14 |
15 | public MyImageView(Context context, AttributeSet attrs, int defStyle) {
16 | super(context, attrs, defStyle);
17 | init(context);
18 | }
19 |
20 | public MyImageView(Context context, AttributeSet attrs) {
21 | super(context, attrs);
22 | init(context);
23 | }
24 |
25 | public MyImageView(Context context) {
26 | super(context);
27 | init(context);
28 | }
29 |
30 | private int width, height = 0;
31 |
32 | private void init(Context context) {
33 | // 获取分辨率
34 | DisplayMetrics dm = context.getApplicationContext().getResources().getDisplayMetrics();
35 | width = dm.widthPixels;
36 | // 高度不对
37 | // 应该去掉 状态栏
38 | height = dm.heightPixels;
39 | Class c = null;
40 | Object obj = null;
41 | Field field = null;
42 | int x = 0, sbar = 0;
43 | try {
44 | c = Class.forName("com.android.internal.R$dimen");
45 | obj = c.newInstance();
46 | field = c.getField("status_bar_height");
47 | x = Integer.parseInt(field.get(obj).toString());
48 | sbar = getResources().getDimensionPixelSize(x);
49 | } catch (Exception e) {
50 | e.printStackTrace();
51 | }
52 | height = height - sbar;
53 | Log.d(TAG, "width" + width + "height" + height);
54 | }
55 |
56 | @Override
57 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
58 | // super.onMeasure(widthMeasureSpec, heightMeasureSpec);
59 | setMeasuredDimension(width, height);
60 | // Log.d(TAG, "onMeasure :" + widthMeasureSpec + "/" + heightMeasureSpec);
61 | }
62 |
63 | @Override
64 | public void layout(int l, int t, int r, int b) {
65 | super.layout(l, t, r, b);
66 |
67 | Log.d(TAG, "layout :" + l + t + r + b);
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/src/com/kongnan/weibo/MyInterpolator.java:
--------------------------------------------------------------------------------
1 | package com.kongnan.weibo;
2 |
3 | import android.view.animation.Interpolator;
4 |
5 | public class MyInterpolator implements Interpolator {
6 |
7 | @Override
8 | public float getInterpolation(float t) {
9 | t = t * 1.43f;
10 | if (t == 1.0f) {
11 | return 1.0f;
12 | }
13 | return t;
14 | }
15 |
16 | }
17 |
--------------------------------------------------------------------------------
/src/com/kongnan/weibo/MyVideoImageView.java:
--------------------------------------------------------------------------------
1 | package com.kongnan.weibo;
2 |
3 | import android.content.Context;
4 | import android.graphics.Bitmap;
5 | import android.graphics.BitmapShader;
6 | import android.graphics.Canvas;
7 | import android.graphics.Color;
8 | import android.graphics.Matrix;
9 | import android.graphics.Paint;
10 | import android.graphics.PixelFormat;
11 | import android.graphics.Rect;
12 | import android.graphics.RectF;
13 | import android.graphics.Shader;
14 | import android.graphics.drawable.Drawable;
15 | import android.util.AttributeSet;
16 | import android.util.Log;
17 | import android.widget.ImageView;
18 |
19 | public class MyVideoImageView extends ImageView {
20 |
21 | private static final String TAG = MyVideoImageView.class.getSimpleName();
22 |
23 | private Rect mDrawableRect;
24 | private Bitmap mBitmap;
25 | private BitmapShader mBitmapShader;
26 | private Paint mBitmapPaint;
27 | private Matrix mShaderMatrix;
28 | private int mBitmapWidth;
29 | private int mBitmapHeight;
30 |
31 | private int mTopRect;
32 | private int mBottomRect;
33 |
34 | private String mTime;
35 |
36 | private float mTextFontSize;
37 | private float mTextX;
38 | private float mTextY;
39 |
40 | public MyVideoImageView(Context context, AttributeSet attrs, int defStyle) {
41 | super(context, attrs, defStyle);
42 | init(context);
43 | }
44 |
45 | public MyVideoImageView(Context context, AttributeSet attrs) {
46 | super(context, attrs);
47 | init(context);
48 | }
49 |
50 | public MyVideoImageView(Context context) {
51 | super(context);
52 | init(context);
53 | }
54 |
55 | public void setTimeText(String time) {
56 | mTime = time;
57 | }
58 |
59 | private boolean isReverse = false;
60 |
61 | public void setTranslationHight(float i) {
62 | Log.d(TAG, "translationHight :" + i);
63 | Log.d(TAG, "mTopRect :" + mTopRect + "/mBottomRect" + mBottomRect);
64 | // 做个保护
65 | if (i > 1 || i < 0)
66 | return;
67 | if (i == 1) {
68 | // mTopRect = 0;
69 | // mBottomRect = getBottom();
70 | invalidate();
71 | return;
72 | }
73 | // 动画一半，不做任何改变
74 | if (i > 0.5) {
75 | // return;
76 | i = 0.5f;
77 | }
78 | // 小于 10分之2 停止裁剪
79 | if (i < 0.2) {
80 | return;
81 | }
82 | // Log.d(TAG, "setTranslationHight :" + i);
83 |
84 | mTopRect = (int) (-getHeight() * (i - 0.5));
85 | mBottomRect = getHeight() - mTopRect;
86 |
87 | invalidate();
88 | }
89 |
90 | private void init(Context context) {
91 | mTextX = Util.dp2px(getContext(), 180);
92 | mTextY = Util.dp2px(getContext(), 40);
93 | mTextFontSize = Util.sp2px(getContext(), 18);
94 | }
95 |
96 | @Override
97 | protected void onDraw(Canvas canvas) {
98 |
99 | // super.onDraw(canvas);
100 | if (getDrawable() == null) {
101 | return;
102 | }
103 | // Log.d(TAG, "onDraw()");
104 | // if (isStart) {
105 |
106 | RectF rect = new RectF(0, mTopRect, getRight(), mBottomRect);
107 |
108 | // RectF rect = new RectF(getPaddingLeft(), getPaddingTop(), getRight() - getLeft()
109 | // - getPaddingRight(), getBottom() - getTop() - getPaddingBottom());
110 |
111 | canvas.drawRect(rect, mBitmapPaint);
112 | // }
113 |
114 | Paint p = new Paint();
115 | p.setColor(Color.BLACK);
116 | p.setTextSize(mTextFontSize);
117 | canvas.drawText(mTime, mTextX, mTextY, p);// 画文本
118 | }
119 |
120 | @Override
121 | public void setImageBitmap(Bitmap bm) {
122 | super.setImageBitmap(bm);
123 | mBitmap = bm;
124 | // mBitmap = drawableToBitmap(getDrawable());
125 | setup();
126 | }
127 |
128 | public static Bitmap drawableToBitmap(Drawable drawable) {
129 | // 取 drawable 的长宽
130 | int w = drawable.getIntrinsicWidth();
131 | int h = drawable.getIntrinsicHeight();
132 |
133 | // 取 drawable 的颜色格式
134 | Bitmap.Config config = drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
135 | : Bitmap.Config.RGB_565;
136 | // 建立对应 bitmap
137 | Bitmap bitmap = Bitmap.createBitmap(w, h, config);
138 | // 建立对应 bitmap 的画布
139 | Canvas canvas = new Canvas(bitmap);
140 | drawable.setBounds(0, 0, w, h);
141 | // 把 drawable 内容画到画布中
142 | drawable.draw(canvas);
143 | return bitmap;
144 | }
145 |
146 | private void setup() {
147 | if (mBitmap == null) {
148 | return;
149 | }
150 |
151 | mTopRect = 0;
152 | mBottomRect = getBottom();
153 |
154 | mBitmapShader = new BitmapShader(mBitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
155 |
156 | mBitmapPaint = new Paint();
157 | mBitmapPaint.setAntiAlias(true);
158 | mBitmapPaint.setShader(mBitmapShader);
159 |
160 | mBitmapHeight = mBitmap.getHeight();
161 | mBitmapWidth = mBitmap.getWidth();
162 |
163 | updateShaderMatrix();
164 | invalidate();
165 | }
166 |
167 | private void updateShaderMatrix() {
168 |
169 | float scaleX;
170 | float scaleY;
171 |
172 | mShaderMatrix = new Matrix();
173 | mShaderMatrix.set(null);
174 |
175 | mDrawableRect = new Rect(0, 0, getRight() - getLeft(), getBottom() - getTop());
176 |
177 | scaleX = mDrawableRect.width() / (float) mBitmapWidth;
178 | scaleY = mDrawableRect.height() / (float) mBitmapHeight;
179 | mShaderMatrix.setScale(scaleX, scaleY);
180 |
181 | mBitmapShader.setLocalMatrix(mShaderMatrix);
182 | }
183 | }
184 |
--------------------------------------------------------------------------------
/src/com/kongnan/weibo/MyViewGroup.java:
--------------------------------------------------------------------------------
1 | package com.kongnan.weibo;
2 |
3 | import android.content.Context;
4 | import android.graphics.Rect;
5 | import android.graphics.drawable.Drawable;
6 | import android.util.AttributeSet;
7 | import android.view.View;
8 | import android.view.ViewGroup;
9 |
10 | public class MyViewGroup extends ViewGroup {
11 |
12 | public MyViewGroup(Context context, AttributeSet attrs, int defStyle) {
13 | super(context, attrs, defStyle);
14 | }
15 |
16 | public MyViewGroup(Context context, AttributeSet attrs) {
17 | super(context, attrs);
18 | }
19 |
20 | public MyViewGroup(Context context) {
21 | super(context);
22 |
23 | // AbsoluteLayout
24 | }
25 |
26 | @Override
27 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
28 | int count = getChildCount();
29 |
30 | int maxHeight = 0;
31 | int maxWidth = 0;
32 |
33 | // Find out how big everyone wants to be
34 | measureChildren(widthMeasureSpec, heightMeasureSpec);
35 |
36 | // Find rightmost and bottom-most child
37 | for (int i = 0; i < count; i++) {
38 | View child = getChildAt(i);
39 | if (child.getVisibility() != GONE) {
40 | int childRight;
41 | int childBottom;
42 |
43 | // ViewGroup.LayoutParams lp = (ViewGroup.LayoutParams) child.getLayoutParams();
44 |
45 | childRight = child.getMeasuredWidth();
46 | childBottom = child.getMeasuredHeight();
47 |
48 | // Rect mCachedBounds = new Rect();
49 | // Drawable drawable = child.getBackground();
50 | // if (i == 0 && drawable != null) {
51 | //
52 | // drawable.getPadding(mCachedBounds);
53 | // int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
54 | // int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
55 | //
56 | // // child.measure(
57 | // // MeasureSpec.makeMeasureSpec(widthSpecSize + mCachedBounds.left
58 | // // + mCachedBounds.right, MeasureSpec.EXACTLY),
59 | // // MeasureSpec.makeMeasureSpec(heightSpecSize + mCachedBounds.top
60 | // // + mCachedBounds.bottom, MeasureSpec.EXACTLY));
61 | // }
62 |
63 | maxWidth = Math.max(maxWidth, childRight);
64 | maxHeight = Math.max(maxHeight, childBottom);
65 | }
66 | }
67 |
68 | // Account for padding too
69 | maxWidth += getPaddingLeft() + getPaddingRight();
70 | maxHeight += getPaddingTop() + getPaddingBottom();
71 |
72 | // Check against minimum height and width
73 | maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
74 | maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
75 |
76 | setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, 0),
77 | resolveSizeAndState(maxHeight, heightMeasureSpec, 0));
78 | }
79 |
80 | @Override
81 | protected void onLayout(boolean changed, int l, int t, int r, int b) {
82 | int count = getChildCount();
83 |
84 | for (int i = 0; i < count; i++) {
85 | View child = getChildAt(i);
86 | if (child.getVisibility() != GONE) {
87 |
88 | Rect mCachedBounds = new Rect();
89 | Drawable drawable = child.getBackground();
90 | if (drawable != null) {
91 | // child.measure(0, 0);
92 | drawable.getPadding(mCachedBounds);
93 | }
94 |
95 | int childLeft = -mCachedBounds.left;
96 | int childTop = -mCachedBounds.top;
97 |
98 | child.layout(childLeft, childTop,
99 | child.getMeasuredWidth() + mCachedBounds.right,
100 | child.getMeasuredHeight() + mCachedBounds.bottom);
101 |
102 | // child.layout(0, 0, child.getMeasuredWidth(), child.getMeasuredHeight());
103 | }
104 | }
105 | }
106 |
107 | @Override
108 | protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
109 | return new LayoutParams(p);
110 | }
111 |
112 | @Override
113 | public boolean shouldDelayChildPressedState() {
114 | return false;
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/src/com/kongnan/weibo/MyViewPager.java:
--------------------------------------------------------------------------------
1 | package com.kongnan.weibo;
2 |
3 | import android.content.Context;
4 | import android.util.AttributeSet;
5 | import android.util.DisplayMetrics;
6 | import android.view.MotionEvent;
7 | import android.view.VelocityTracker;
8 | import android.view.View;
9 | import android.view.ViewConfiguration;
10 | import android.widget.FrameLayout;
11 |
12 | public class MyViewPager extends FrameLayout {
13 |
14 | private static final String TAG = MyViewPager.class.getSimpleName();
15 | /**
16 | * 认为是用户滑动的最小距离
17 | */
18 | private int mSlop;
19 | /**
20 | * 滑动的最小速度
21 | */
22 | private int mMinFlingVelocity;
23 | /**
24 | * 滑动的最大速度
25 | */
26 | private int mMaxFlingVelocity;
27 | /**
28 | * 执行动画的时间
29 | */
30 | protected long mAnimationTime = 150;
31 | /**
32 | * 用来标记用户是否正在滑动中
33 | */
34 | private boolean mSwiping;
35 | /**
36 | * 滑动速度检测类
37 | */
38 | private VelocityTracker mVelocityTracker;
39 | /**
40 | * 手指按下的position
41 | */
42 | private int mDownPosition;
43 | /**
44 | * 按下的item对应的View
45 | */
46 | private View mDownView;
47 | private float mDownX;
48 | private float mDownY;
49 |
50 | private int mWidth;
51 |
52 | private int mFlaggingWidth;
53 |
54 | public MyViewPager(Context context, AttributeSet attrs, int defStyle) {
55 | super(context, attrs, defStyle);
56 | init(context);
57 | }
58 |
59 | public MyViewPager(Context context, AttributeSet attrs) {
60 | super(context, attrs);
61 | init(context);
62 | }
63 |
64 | public MyViewPager(Context context) {
65 | super(context);
66 | init(context);
67 | }
68 |
69 | private void init(Context context) {
70 | ViewConfiguration vc = ViewConfiguration.get(context);
71 | mSlop = vc.getScaledTouchSlop();
72 | mMinFlingVelocity = vc.getScaledMinimumFlingVelocity() * 8; // 获取滑动的最小速度
73 | mMaxFlingVelocity = vc.getScaledMaximumFlingVelocity(); // 获取滑动的最大速度
74 |
75 | // 获取分辨率
76 | DisplayMetrics dm = context.getApplicationContext().getResources().getDisplayMetrics();
77 | mWidth = dm.widthPixels;
78 | mFlaggingWidth = mWidth / 4;
79 | }
80 |
81 | private OnPageChangeListener onPageChangeListener;
82 |
83 | public void setOnPageChangeListener(OnPageChangeListener onPageChangeListener) {
84 | this.onPageChangeListener = onPageChangeListener;
85 | }
86 |
87 | public static float clamp(float value, float max, float min) {
88 | return Math.max(Math.min(value, min), max);
89 | }
90 |
91 | @Override
92 | public boolean onTouchEvent(MotionEvent ev) {
93 | // Log.d(TAG, "onTouchEvent" + ev.getAction());
94 | switch (ev.getAction()) {
95 | case MotionEvent.ACTION_DOWN:
96 | handleActionDown(ev);
97 | break;
98 | case MotionEvent.ACTION_MOVE:
99 | handleActionMove(ev);
100 | return super.onTouchEvent(ev);
101 | case MotionEvent.ACTION_UP:
102 | handleActionUp(ev);
103 | break;
104 | }
105 | // return super.onTouchEvent(ev);
106 | return true;
107 | }
108 |
109 | /**
110 | * 按下事件处理
111 | *
112 | * @param ev
113 | * @return
114 | */
115 | private void handleActionDown(MotionEvent ev) {
116 | mSwiping = false;
117 | mIsStartRight = false;
118 | mIsStart = false;
119 | mDownX = ev.getX();
120 | mDownY = ev.getY();
121 |
122 | // mDownView = getChildAt(0);
123 |
124 | // 加入速度检测
125 | mVelocityTracker = VelocityTracker.obtain();
126 | mVelocityTracker.addMovement(ev);
127 | }
128 |
129 | private boolean mIsStart = false;
130 | private boolean mIsStartRight = false;
131 |
132 | /**
133 | * 处理手指滑动的方法
134 | *
135 | * @param ev
136 | * @return
137 | */
138 | private void handleActionMove(MotionEvent ev) {
139 |
140 | float deltaX = ev.getX() - mDownX;
141 | float deltaY = ev.getY() - mDownY;
142 |
143 | boolean dismissRight = deltaX > 0;// 是否往右边
144 | if (deltaX != 0 && !mIsStart) {
145 | mIsStart = true;
146 | mIsStartRight = dismissRight;
147 | }
148 | mSwiping = true;
149 |
150 | if (dismissRight) {
151 | float ratio = clamp(deltaX / (float) mWidth, 0.0f, 1.0f);
152 | onPageChangeListener.onRight(mDownPosition, ratio);
153 | } else {
154 | float ratio = clamp(-deltaX / (float) mWidth, 0.0f, 1.0f);
155 | onPageChangeListener.onLeft(mDownPosition, ratio);
156 | }
157 | }
158 |
159 | /**
160 | * 手指抬起的事件处理
161 | *
162 | * @param ev
163 | */
164 | private void handleActionUp(MotionEvent ev) {
165 | if (mVelocityTracker == null || !mSwiping) {
166 | return;
167 | }
168 |
169 | float deltaX = ev.getX() - mDownX;
170 |
171 | // 通过滑动的距离计算出X,Y方向的速度
172 | mVelocityTracker.computeCurrentVelocity(1000);
173 | float velocityX = Math.abs(mVelocityTracker.getXVelocity());
174 | float velocityY = Math.abs(mVelocityTracker.getYVelocity());
175 |
176 | boolean dismiss = false; // item是否要滑出屏幕
177 | boolean dismissRight = deltaX > 0;// 是否往右边
178 | // 当拖动item的距离大于item的 4/1，item滑出屏幕
179 | if (Math.abs(deltaX) > mFlaggingWidth) {
180 | dismiss = true;
181 | // 手指在屏幕滑动的速度在某个范围内，也使得item滑出屏幕
182 | } else if (mMinFlingVelocity <= velocityX && velocityX <= mMaxFlingVelocity
183 | && velocityY < velocityX) {
184 | dismiss = true;
185 | }
186 |
187 | // 动画
188 | if (mIsStartRight) {
189 | if (mDownPosition != 0) {
190 | float ratio = clamp(deltaX / (float) mWidth, 0.0f, 1.0f);
191 | onPageChangeListener.onRightEnd(mDownPosition, ratio, dismiss);
192 | }
193 | } else {
194 | float ratio = clamp(-deltaX / (float) mWidth, 0.0f, 1.0f);
195 | onPageChangeListener.onLeftEnd(mDownPosition, ratio, dismiss);
196 | }
197 | // 切换
198 | if (dismiss) {
199 | if (mIsStartRight) {
200 | mDownPosition = Math.max(mDownPosition - 1, 0);
201 | } else {
202 | mDownPosition = Math.min(mDownPosition + 1, getChildCount() - 2);
203 | }
204 | }
205 |
206 | // 移除速度检测
207 | if (mVelocityTracker != null) {
208 | mVelocityTracker.recycle();
209 | mVelocityTracker = null;
210 | }
211 | mSwiping = false;
212 | mIsStartRight = false;
213 | mIsStart = false;
214 | }
215 |
216 | public interface OnPageChangeListener {
217 | public void onLeft(int position, float ratio);
218 |
219 | public void onLeftEnd(int position, float ratio, boolean dismiss);
220 |
221 | public void onRight(int position, float ratio);
222 |
223 | public void onRightEnd(int position, float ratio, boolean dismiss);
224 | }
225 | }
226 |
--------------------------------------------------------------------------------
/src/com/kongnan/weibo/Util.java:
--------------------------------------------------------------------------------
1 | package com.kongnan.weibo;
2 |
3 | import android.content.Context;
4 | import android.util.TypedValue;
5 |
6 | public class Util {
7 | public static float dp2px(Context context, int dp) {
8 | return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, context.getResources()
9 | .getDisplayMetrics());
10 | }
11 |
12 | public static float sp2px(Context context, int sp) {
13 | // final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
14 | // return (int) (spValue * fontScale + 0.5f);
15 | return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, context.getResources()
16 | .getDisplayMetrics());
17 | }
18 | }
19 |
--------------------------------------------------------------------------------