ViewPager z problemem TabLayout z AnimatedVectorDrawable

Question

Próbuję zaimplementować prosty ViewPager z niektórymi animacjami na VectorDrawable.
Zgodnie z this very good example rozwiązanie dla ładnego przewijania kart z przełączaniem kropek.

Jedyna różnica polega na tym, że używam animacji wektorowych. Jako działanie działa jak zaklęcie, z dodanym ViewPager, animacje są niezmiennie uruchamiane , a nie.

compileSdkVersion 25 
buildToolsVersion "26.0.2" 
targetSdkVersion 25 

jestem debugowanie na urządzeniu (SG7), ustawić break-point na animation.start()

• na ekranie środkowym, break-point nie zawsze jest wywoływana
• częściej na ekranie 1 & 3, animacje nie są wyzwalane
• podczas skoków za pomocą kropek, między 1 & 3 animacje są zawsze wyzwalane! ale nie podczas 1-2 lub 2-3 !!

Wszystko to działa na jednym dużym VectorDrawable z 3 grupami, które są animowane.
2 napisy wsuwające się na początku, a następnie obracające się w nieskończoność, spin zawsze działa.

aktywny

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main_activity); 

    mSectionsPagerAdapter = new SectionsPagerAdapter(getSupportFragmentManager()); 

    // Set up the ViewPager with the sections adapter. 
    mViewPager = (ViewPager) findViewById(R.id.pager); 
    mHideHandler.post(mHidePart2Runnable); 
    mViewPager.setAdapter(mSectionsPagerAdapter); 

    TabLayout tabLayout = (TabLayout) findViewById(R.id.tabDots); 
    tabLayout.setupWithViewPager(mViewPager, true); 

    }; 

Fragment:

public class SectionsPagerAdapter extends FragmentPagerAdapter { 

    public SectionsPagerAdapter(FragmentManager fm) { 
     super(fm); 
    } 

    @Override 
    public Fragment getItem(int position) { 
     // getItem is called to instantiate the fragment for the given page. 
     // Return a PlaceholderFragment (defined as a static inner class below). 
     return PlaceholderFragment.newInstance(position + 1); 
    } 

    @Override 
    public int getCount() { 
     // Show 3 total pages. 
     return 3; 
    } 

Static Fragment

 public static class PlaceholderFragment extends Fragment { 
    /** 
    * The fragment argument representing the section number for this 
    * fragment. 
    */ 
    private static final String ARG_SECTION_NUMBER = "section_number"; 

    public PlaceholderFragment() { 
    } 

    /** 
    * Returns a new instance of this fragment for the given section 
    * number. 
    */ 
    public static PlaceholderFragment newInstance(int sectionNumber) { 
     PlaceholderFragment fragment = new PlaceholderFragment(); 
     Bundle args = new Bundle(); 
     args.putInt(ARG_SECTION_NUMBER, sectionNumber); 
     fragment.setArguments(args); 
     return fragment; 
    } 

    @Override 
    public View onCreateView(LayoutInflater inflater, ViewGroup container, 
          Bundle savedInstanceState) { 
     View rootView = inflater.inflate(R.layout.activity_fullscreen, container, false); 
     View imgView = rootView.findViewById(R.id.vec_anim); 

     Drawable drawable = ((ImageView)imgView).getDrawable(); 
     if (drawable instanceof Animatable) { 
      ((Animatable) drawable).start(); 
     }; 
     return rootView; 
    } 

Jestem nowy w tym wszystkim, chciał profil wpływu wielkości SVG (na wydajność myślenie o buforowaniu svg i wyzwalaniu animacji przy tworzeniu widoku może ...) i staram się zoptymalizować to wszystko i sprawiają, że jest gładka. Ale przede wszystkim nie działa poprawnie.

Dlaczego punkt przerwania nie zawsze jest trafiony podczas zamiany stron?
Czy istnieje lepszy sposób to zrobić?

Answer 1

spróbować,

1. Dodaj bibliotekę compile com.mcxiaoke.viewpagerindicator:library:2.4.1@aar'.

2. Twój plik główny układ,

<RelativeLayout 
     android:id="@+id/pager_layout" 
     android:layout_width="fill_parent" 
     android:layout_height="wrap_content" 
     android:gravity="right"> 
     <android.support.v4.view.ViewPager 
      android:id="@+id/pager_profile" 
      android:layout_width="fill_parent" 
      android:layout_height="match_parent" 
      app:layout_behavior="@string/appbar_scrolling_view_behavior"> 
     </android.support.v4.view.ViewPager> 

     <yourpackagename.utils.CirclePageIndicator 
      android:id="@+id/cover_photo_indicator" 
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content" 
      android:foregroundGravity="right" 
      android:layout_alignParentBottom="true" 
      android:layout_alignParentEnd="true" 
      android:padding="10dip" /> 
</RelativeLayout> 

3. Tworzenie niestandardowej klasy CirclePageIndicator

/** 
* Draws circles (one for each view). The current view position is filled and 
* others are only stroked. 
*/ 
public class CirclePageIndicator extends View implements PageIndicator { 
    private static final int INVALID_POINTER = -1; 

    private float mRadius; 
    private final Paint mPaintPageFill = new Paint(ANTI_ALIAS_FLAG); 
    private final Paint mPaintStroke = new Paint(ANTI_ALIAS_FLAG); 
    private final Paint mPaintFill = new Paint(ANTI_ALIAS_FLAG); 
    private ViewPager mViewPager; 
    private ViewPager.OnPageChangeListener mListener; 
    private int mCurrentPage; 
    private int mSnapPage; 
    private float mPageOffset; 
    private int mScrollState; 
    private int mOrientation; 
    private boolean mCentered; 
    private boolean mSnap; 

    private int mTouchSlop; 
    private float mLastMotionX = -1; 
    private int mActivePointerId = INVALID_POINTER; 
    private boolean mIsDragging; 


    public CirclePageIndicator(Context context) { 
     this(context, null); 
    } 

    public CirclePageIndicator(Context context, AttributeSet attrs) { 
     this(context, attrs, R.attr.vpiCirclePageIndicatorStyle); 
    } 

    public CirclePageIndicator(Context context, AttributeSet attrs, int defStyle) { 
     super(context, attrs, defStyle); 
     if (isInEditMode()) return; 

     //Load defaults from resources 
     final Resources res = getResources(); 
     final int defaultPageColor = res.getColor(R.color.default_circle_indicator_page_color); 
     //default_circle_indicator_fill_color 
     final int defaultFillColor = res.getColor(R.color.holo_blue_dark); 
     final int defaultOrientation = res.getInteger(R.integer.default_circle_indicator_orientation); 
     final int defaultStrokeColor = res.getColor(R.color.default_circle_indicator_stroke_color); 
     final float defaultStrokeWidth = res.getDimension(R.dimen.default_circle_indicator_stroke_width); 
     final float defaultRadius = res.getDimension(R.dimen.default_circle_indicator_radius); 
     final boolean defaultCentered = res.getBoolean(R.bool.default_circle_indicator_centered); 
     final boolean defaultSnap = res.getBoolean(R.bool.default_circle_indicator_snap); 

     //Retrieve styles attributes 
     TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CirclePageIndicator, defStyle, 0); 

     mCentered = a.getBoolean(R.styleable.CirclePageIndicator_centered, defaultCentered); 
     mOrientation = a.getInt(R.styleable.CirclePageIndicator_android_orientation, defaultOrientation); 
     mPaintPageFill.setStyle(Style.FILL); 
     mPaintPageFill.setColor(a.getColor(R.styleable.CirclePageIndicator_pageColor, defaultPageColor)); 
     mPaintStroke.setStyle(Style.STROKE); 
     mPaintStroke.setColor(a.getColor(R.styleable.CirclePageIndicator_strokeColor, defaultStrokeColor)); 
     mPaintStroke.setStrokeWidth(a.getDimension(R.styleable.CirclePageIndicator_strokeWidth, defaultStrokeWidth)); 
     mPaintFill.setStyle(Style.FILL); 
     mPaintFill.setColor(a.getColor(R.styleable.CirclePageIndicator_fillColor, defaultFillColor)); 
     mRadius = a.getDimension(R.styleable.CirclePageIndicator_radius, defaultRadius); 
     mSnap = a.getBoolean(R.styleable.CirclePageIndicator_snap, defaultSnap); 

     Drawable background = a.getDrawable(R.styleable.CirclePageIndicator_android_background); 
     if (background != null) { 
      setBackgroundDrawable(background); 
     } 

     a.recycle(); 

     final ViewConfiguration configuration = ViewConfiguration.get(context); 
     mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration); 
    } 


    public void setCentered(boolean centered) { 
     mCentered = centered; 
     invalidate(); 
    } 

    public boolean isCentered() { 
     return mCentered; 
    } 

    public void setPageColor(int pageColor) { 
     mPaintPageFill.setColor(pageColor); 
     invalidate(); 
    } 

    public int getPageColor() { 
     return mPaintPageFill.getColor(); 
    } 

    public void setFillColor(int fillColor) { 
     mPaintFill.setColor(fillColor); 
     invalidate(); 
    } 

    public int getFillColor() { 
     return mPaintFill.getColor(); 
    } 

    public void setOrientation(int orientation) { 
     switch (orientation) { 
      case HORIZONTAL: 
      case VERTICAL: 
       mOrientation = orientation; 
       requestLayout(); 
       break; 

      default: 
       throw new IllegalArgumentException("Orientation must be either HORIZONTAL or VERTICAL."); 
     } 
    } 

    public int getOrientation() { 
     return mOrientation; 
    } 

    public void setStrokeColor(int strokeColor) { 
     mPaintStroke.setColor(strokeColor); 
     invalidate(); 
    } 

    public int getStrokeColor() { 
     return mPaintStroke.getColor(); 
    } 

    public void setStrokeWidth(float strokeWidth) { 
     mPaintStroke.setStrokeWidth(strokeWidth); 
     invalidate(); 
    } 

    public float getStrokeWidth() { 
     return mPaintStroke.getStrokeWidth(); 
    } 

    public void setRadius(float radius) { 
     mRadius = radius; 
     invalidate(); 
    } 

    public float getRadius() { 
     return mRadius; 
    } 

    public void setSnap(boolean snap) { 
     mSnap = snap; 
     invalidate(); 
    } 

    public boolean isSnap() { 
     return mSnap; 
    } 

    @Override 
    protected void onDraw(Canvas canvas) { 
     super.onDraw(canvas); 

     if (mViewPager == null) { 
      return; 
     } 
     final int count = mViewPager.getAdapter().getCount(); 
     if (count == 0) { 
      return; 
     } 

     if (mCurrentPage >= count) { 
      setCurrentItem(count - 1); 
      return; 
     } 

     int longSize; 
     int longPaddingBefore; 
     int longPaddingAfter; 
     int shortPaddingBefore; 
     if (mOrientation == HORIZONTAL) { 
      longSize = getWidth(); 
      longPaddingBefore = getPaddingLeft(); 
      longPaddingAfter = getPaddingRight(); 
      shortPaddingBefore = getPaddingTop(); 
     } else { 
      longSize = getHeight(); 
      longPaddingBefore = getPaddingTop(); 
      longPaddingAfter = getPaddingBottom(); 
      shortPaddingBefore = getPaddingLeft(); 
     } 

     final float threeRadius = mRadius * 3; 
     final float shortOffset = shortPaddingBefore + mRadius; 
     float longOffset = longPaddingBefore + mRadius; 
     if (mCentered) { 
      longOffset += ((longSize - longPaddingBefore - longPaddingAfter)/2.0f) - ((count * threeRadius)/2.0f); 
     } 

     float dX; 
     float dY; 

     float pageFillRadius = mRadius; 
     if (mPaintStroke.getStrokeWidth() > 0) { 
      pageFillRadius -= mPaintStroke.getStrokeWidth()/2.0f; 
     } 

     //Draw stroked circles 
     for (int iLoop = 0; iLoop < count; iLoop++) { 
      float drawLong = longOffset + (iLoop * threeRadius); 
      if (mOrientation == HORIZONTAL) { 
       dX = drawLong; 
       dY = shortOffset; 
      } else { 
       dX = shortOffset; 
       dY = drawLong; 
      } 
      // Only paint fill if not completely transparent 
      if (mPaintPageFill.getAlpha() > 0) { 
       canvas.drawCircle(dX, dY, pageFillRadius, mPaintPageFill); 
      } 

      // Only paint stroke if a stroke width was non-zero 
      if (pageFillRadius != mRadius) { 
       canvas.drawCircle(dX, dY, mRadius, mPaintStroke); 
      } 
     } 

     //Draw the filled circle according to the current scroll 
     float cx = (mSnap ? mSnapPage : mCurrentPage) * threeRadius; 
     if (!mSnap) { 
      cx += mPageOffset * threeRadius; 
     } 
     if (mOrientation == HORIZONTAL) { 
      dX = longOffset + cx; 
      dY = shortOffset; 
     } else { 
      dX = shortOffset; 
      dY = longOffset + cx; 
     } 
     canvas.drawCircle(dX, dY, mRadius, mPaintFill); 
    } 

    public boolean onTouchEvent(android.view.MotionEvent ev) { 
     if (super.onTouchEvent(ev)) { 
      return true; 
     } 
     if ((mViewPager == null) || (mViewPager.getAdapter().getCount() == 0)) { 
      return false; 
     } 

     final int action = ev.getAction() & MotionEventCompat.ACTION_MASK; 
     switch (action) { 
      case MotionEvent.ACTION_DOWN: 
       mActivePointerId = MotionEventCompat.getPointerId(ev, 0); 
       mLastMotionX = ev.getX(); 
       break; 

      case MotionEvent.ACTION_MOVE: { 
       final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId); 
       final float x = MotionEventCompat.getX(ev, activePointerIndex); 
       final float deltaX = x - mLastMotionX; 

       if (!mIsDragging) { 
        if (Math.abs(deltaX) > mTouchSlop) { 
         mIsDragging = true; 
        } 
       } 

       if (mIsDragging) { 
        mLastMotionX = x; 
        if (mViewPager.isFakeDragging() || mViewPager.beginFakeDrag()) { 
         mViewPager.fakeDragBy(deltaX); 
        } 
       } 

       break; 
      } 

      case MotionEvent.ACTION_CANCEL: 
      case MotionEvent.ACTION_UP: 
       if (!mIsDragging) { 
        final int count = mViewPager.getAdapter().getCount(); 
        final int width = getWidth(); 
        final float halfWidth = width/2f; 
        final float sixthWidth = width/6f; 

        if ((mCurrentPage > 0) && (ev.getX() < halfWidth - sixthWidth)) { 
         if (action != MotionEvent.ACTION_CANCEL) { 
          mViewPager.setCurrentItem(mCurrentPage - 1); 
         } 
         return true; 
        } else if ((mCurrentPage < count - 1) && (ev.getX() > halfWidth + sixthWidth)) { 
         if (action != MotionEvent.ACTION_CANCEL) { 
          mViewPager.setCurrentItem(mCurrentPage + 1); 
         } 
         return true; 
        } 
       } 

       mIsDragging = false; 
       mActivePointerId = INVALID_POINTER; 
       if (mViewPager.isFakeDragging()) mViewPager.endFakeDrag(); 
       break; 

      case MotionEventCompat.ACTION_POINTER_DOWN: { 
       final int index = MotionEventCompat.getActionIndex(ev); 
       mLastMotionX = MotionEventCompat.getX(ev, index); 
       mActivePointerId = MotionEventCompat.getPointerId(ev, index); 
       break; 
      } 

      case MotionEventCompat.ACTION_POINTER_UP: 
       final int pointerIndex = MotionEventCompat.getActionIndex(ev); 
       final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex); 
       if (pointerId == mActivePointerId) { 
        final int newPointerIndex = pointerIndex == 0 ? 1 : 0; 
        mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex); 
       } 
       mLastMotionX = MotionEventCompat.getX(ev, MotionEventCompat.findPointerIndex(ev, mActivePointerId)); 
       break; 
     } 

     return true; 
    } 

    @Override 
    public void setViewPager(ViewPager view) { 
     if (mViewPager == view) { 
      return; 
     } 
     if (mViewPager != null) { 
      mViewPager.setOnPageChangeListener(null); 
     } 
     if (view.getAdapter() == null) { 
      throw new IllegalStateException("ViewPager does not have adapter instance."); 
     } 
     mViewPager = view; 
     mViewPager.setOnPageChangeListener(this); 
     invalidate(); 
    } 

    @Override 
    public void setViewPager(ViewPager view, int initialPosition) { 
     setViewPager(view); 
     setCurrentItem(initialPosition); 
    } 

    @Override 
    public void setCurrentItem(int item) { 
     if (mViewPager == null) { 
      throw new IllegalStateException("ViewPager has not been bound."); 
     } 
     mViewPager.setCurrentItem(item); 
     mCurrentPage = item; 
     invalidate(); 
    } 

    @Override 
    public void notifyDataSetChanged() { 
     invalidate(); 
    } 

    @Override 
    public void onPageScrollStateChanged(int state) { 
     mScrollState = state; 

     if (mListener != null) { 
      mListener.onPageScrollStateChanged(state); 
     } 
    } 

    @Override 
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 
     mCurrentPage = position; 
     mPageOffset = positionOffset; 
     invalidate(); 

     if (mListener != null) { 
      mListener.onPageScrolled(position, positionOffset, positionOffsetPixels); 
     } 
    } 

    @Override 
    public void onPageSelected(int position) { 
     if (mSnap || mScrollState == ViewPager.SCROLL_STATE_IDLE) { 
      mCurrentPage = position; 
      mSnapPage = position; 
      invalidate(); 
     } 

     if (mListener != null) { 
      mListener.onPageSelected(position); 
     } 
    } 

    @Override 
    public void setOnPageChangeListener(ViewPager.OnPageChangeListener listener) { 
     mListener = listener; 
    } 

    /* 
    * (non-Javadoc) 
    * 
    * @see android.view.View#onMeasure(int, int) 
    */ 
    @Override 
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
     if (mOrientation == HORIZONTAL) { 
      setMeasuredDimension(measureLong(widthMeasureSpec), measureShort(heightMeasureSpec)); 
     } else { 
      setMeasuredDimension(measureShort(widthMeasureSpec), measureLong(heightMeasureSpec)); 
     } 
    } 

    /** 
    * Determines the width of this view 
    * 
    * @param measureSpec 
    *   A measureSpec packed into an int 
    * @return The width of the view, honoring constraints from measureSpec 
    */ 
    private int measureLong(int measureSpec) { 
     int result; 
     int specMode = MeasureSpec.getMode(measureSpec); 
     int specSize = MeasureSpec.getSize(measureSpec); 

     if ((specMode == MeasureSpec.EXACTLY) || (mViewPager == null)) { 
      //We were told how big to be 
      result = specSize; 
     } else { 
      //Calculate the width according the views count 
      final int count = mViewPager.getAdapter().getCount(); 
      result = (int)(getPaddingLeft() + getPaddingRight() 
        + (count * 2 * mRadius) + (count - 1) * mRadius + 1); 
      //Respect AT_MOST value if that was what is called for by measureSpec 
      if (specMode == MeasureSpec.AT_MOST) { 
       result = Math.min(result, specSize); 
      } 
     } 
     return result; 
    } 

    /** 
    * Determines the height of this view 
    * 
    * @param measureSpec 
    *   A measureSpec packed into an int 
    * @return The height of the view, honoring constraints from measureSpec 
    */ 
    private int measureShort(int measureSpec) { 
     int result; 
     int specMode = MeasureSpec.getMode(measureSpec); 
     int specSize = MeasureSpec.getSize(measureSpec); 

     if (specMode == MeasureSpec.EXACTLY) { 
      //We were told how big to be 
      result = specSize; 
     } else { 
      //Measure the height 
      result = (int)(2 * mRadius + getPaddingTop() + getPaddingBottom() + 1); 
      //Respect AT_MOST value if that was what is called for by measureSpec 
      if (specMode == MeasureSpec.AT_MOST) { 
       result = Math.min(result, specSize); 
      } 
     } 
     return result; 
    } 

    @Override 
    public void onRestoreInstanceState(Parcelable state) { 
     SavedState savedState = (SavedState)state; 
     super.onRestoreInstanceState(savedState.getSuperState()); 
     mCurrentPage = savedState.currentPage; 
     mSnapPage = savedState.currentPage; 
     requestLayout(); 
    } 

    @Override 
    public Parcelable onSaveInstanceState() { 
     Parcelable superState = super.onSaveInstanceState(); 
     SavedState savedState = new SavedState(superState); 
     savedState.currentPage = mCurrentPage; 
     return savedState; 
    } 

    static class SavedState extends BaseSavedState { 
     int currentPage; 

     public SavedState(Parcelable superState) { 
      super(superState); 
     } 

     private SavedState(Parcel in) { 
      super(in); 
      currentPage = in.readInt(); 
     } 

     @Override 
     public void writeToParcel(Parcel dest, int flags) { 
      super.writeToParcel(dest, flags); 
      dest.writeInt(currentPage); 
     } 

     @SuppressWarnings("UnusedDeclaration") 
     public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() { 
      @Override 
      public SavedState createFromParcel(Parcel in) { 
       return new SavedState(in); 
      } 

      @Override 
      public SavedState[] newArray(int size) { 
       return new SavedState[size]; 
      } 
     }; 
    } 
} 

4. Tworzenie indicator_tags.xml wewnątrz res -> values

---

<resources> 

    <bool name="default_circle_indicator_centered">true</bool> 

    <color name="default_circle_indicator_fill_color">#FFFF0000</color> 
    <color name="default_circle_indicator_page_color">#00000000</color> 

    <integer name="default_circle_indicator_orientation">0</integer> 

    <dimen name="default_circle_indicator_radius">4dp</dimen> 

    <bool name="default_circle_indicator_snap">false</bool> 

    <color name="default_circle_indicator_stroke_color">#FFDDDDDD</color> 

    <dimen name="default_circle_indicator_stroke_width">1dp</dimen> 

    <declare-styleable name="ViewPagerIndicator"> 

     <!-- Style of the circle indicator. --> 
     <attr name="vpiCirclePageIndicatorStyle" format="reference" /> 
     <!-- Style of the icon indicator's views. --> 
     <attr name="vpiIconPageIndicatorStyle" format="reference" /> 
     <!-- Style of the line indicator. --> 
     <attr name="vpiLinePageIndicatorStyle" format="reference" /> 
     <!-- Style of the title indicator. --> 
     <attr name="vpiTitlePageIndicatorStyle" format="reference" /> 
     <!-- Style of the tab indicator's tabs. --> 
     <attr name="vpiTabPageIndicatorStyle" format="reference" /> 
     <!-- Style of the underline indicator. --> 
     <attr name="vpiUnderlinePageIndicatorStyle" format="reference" /> 
    </declare-styleable> 

    <attr name="centered" format="boolean" /> 
    <attr name="selectedColor" format="color" /> 
    <attr name="strokeWidth" format="dimension" /> 
    <attr name="unselectedColor" format="color" /> 

    <declare-styleable name="CirclePageIndicator"> 

     <!-- Whether or not the indicators should be centered. --> 
     <attr name="centered" /> 
     <!-- Color of the filled circle that represents the current page. --> 
     <attr name="fillColor" format="color" /> 
     <!-- Color of the filled circles that represents pages. --> 
     <attr name="pageColor" format="color" /> 
     <!-- Orientation of the indicator. --> 
     <attr name="android:orientation" /> 
     <!-- Radius of the circles. This is also the spacing between circles. --> 
     <attr name="radius" format="dimension" /> 
     <!-- Whether or not the selected indicator snaps to the circles. --> 
     <attr name="snap" format="boolean" /> 
     <!-- Color of the open circles. --> 
     <attr name="strokeColor" format="color" /> 
     <!-- Width of the stroke used to draw the circles. --> 
     <attr name="strokeWidth" /> 
     <!-- View background --> 
     <attr name="android:background" /> 
    </declare-styleable> 
    <declare-styleable name="LinePageIndicator"> 

     <!-- Whether or not the indicators should be centered. --> 
     <attr name="centered" /> 
     <!-- Color of the unselected lines that represent the pages. --> 
     <attr name="unselectedColor" /> 
     <!-- Color of the selected line that represents the current page. --> 
     <attr name="selectedColor" /> 
     <!-- Width of each indicator line. --> 
     <attr name="lineWidth" format="dimension" /> 
     <!-- Width of each indicator line's stroke. --> 
     <attr name="strokeWidth" /> 
     <!-- Width of the gap between each indicator line. --> 
     <attr name="gapWidth" format="dimension" /> 
     <!-- View background --> 
     <attr name="android:background" /> 
    </declare-styleable> 
    <declare-styleable name="TitlePageIndicator"> 

     <!-- Screen edge padding. --> 
     <attr name="clipPadding" format="dimension" /> 
     <!-- Color of the footer line and indicator. --> 
     <attr name="footerColor" format="color" /> 
     <!-- Height of the footer line. --> 
     <attr name="footerLineHeight" format="dimension" /> 
     <!-- Style of the indicator. Default is triangle. --> 
     <attr name="footerIndicatorStyle"> 
      <enum name="none" value="0" /> 
      <enum name="triangle" value="1" /> 
      <enum name="underline" value="2" /> 
     </attr> 
     <!-- Height of the indicator above the footer line. --> 
     <attr name="footerIndicatorHeight" format="dimension" /> 
     <!-- Left and right padding of the underline indicator. --> 
     <attr name="footerIndicatorUnderlinePadding" format="dimension" /> 
     <!-- Padding between the bottom of the title and the footer. --> 
     <attr name="footerPadding" format="dimension" /> 
     <!-- Position of the line. --> 
     <attr name="linePosition"> 
      <enum name="bottom" value="0" /> 
      <enum name="top" value="1" /> 
     </attr> 
     <!-- Color of the selected title. --> 
     <attr name="selectedColor" /> 
     <!-- Whether or not the selected item is displayed as bold. --> 
     <attr name="selectedBold" format="boolean" /> 
     <!-- Color of regular titles. --> 
     <attr name="android:textColor" /> 
     <!-- Size of title text. --> 
     <attr name="android:textSize" /> 
     <!-- Padding between titles when bumping into each other. --> 
     <attr name="titlePadding" format="dimension" /> 
     <!-- Padding between titles and the top of the View. --> 
     <attr name="topPadding" format="dimension" /> 
     <!-- View background --> 
     <attr name="android:background" /> 
    </declare-styleable> 
    <declare-styleable name="UnderlinePageIndicator"> 

     <!-- Whether or not the selected indicator fades. --> 
     <attr name="fades" format="boolean" /> 
     <!-- Length of the delay to fade the indicator. --> 
     <attr name="fadeDelay" format="integer" /> 
     <!-- Length of the indicator fade to transparent. --> 
     <attr name="fadeLength" format="integer" /> 
     <!-- Color of the selected line that represents the current page. --> 
     <attr name="selectedColor" /> 
     <!-- View background --> 
     <attr name="android:background" /> 
    </declare-styleable> 

</resources> 

5. nazywają to od MainActivity jak

// setup the view pager with its adapter 
    vpagerProfile.setAdapter(objProfilePageTopListAdapter); 

    // initialize circular indicator class 
    mCirclePageIndicator = (CirclePageIndicator)findViewById(R.id.cover_photo_indicator); 

    mCirclePageIndicator.setPageColor(android.R.color.transparent); 

    // set viewpager to indicator so it can indicate when you change the page 
    mCirclePageIndicator.setViewPager(vpagerProfile); 

Answer 2

Punkt przerwania nie jest wywoływany w drugim fragmencie, ponieważ jest tworzony razem z pierwszym lub trzecim. Android zawsze tworzy co najmniej 2 fragmenty w tym samym czasie - ten, na którym jest fokus i następny, który może się skupić (do przodu lub do tyłu). Właśnie dlatego przekonasz się, że w twoim przypadku środkowy fragment jest zawsze w pamięci podręcznej, a zatem "onCreate" nigdy nie zostanie wykonane osobno, ale w połączeniu z 1 lub 3.

Próba synchronizacji animacji z Viewpager to koszmar. Jednakże, jeśli naprawdę musisz wtedy moją sugestią byłoby wdrożyć ViewPager.OnPageChangeListener i napisać kod, aby wykryć getCurrentItem() z viewpager. Gdy już wiesz, na którym fragmencie jesteś, możesz zainicjować animację tak, jak chcesz.

Powinno to zapewnić o wiele większą kontrolę nad zachowaniem bez nadmiernych linii kodu.

Daj mi znać, jeśli potrzebujesz mnie do opracowania pewnego punktu.