SlideStackViewまたはAndroidでのViewGroupの拡張（パート2）

最近、Android用のMail.RuモバイルメールでSlideStackViewを開発した経験について話しました。 その後、近い将来、第2部を準備し、ビジュアルコンポーネントのプログラミングの観点から最も興味深い部分を実装する方法について説明することを約束しました。 当然、アプリケーションにインタラクティブ機能を追加するもの、つまりアニメーションについて説明します。 モバイルアプリケーションはユーザーの操作に応答する必要があるという事実に、誰もが長い間慣れ親しんでいます。 明らかに、アプリケーションと対話する主な方法は、タッチスクリーンを使用することです。

Navigation Stack-SlideStackView-を作成しているため、アプリケーションの主要部分間のアニメーション化されたトランジションにインタラクティブ機能を追加します。 Mail.Ruモバイルメールでは、これらは3つのフラグメントです。アプリケーションに追加されたアカウントのリスト、選択したメールボックス内のフォルダーのリスト、1つのフォルダーの内容を示す文字のリストです。

最初の部分で書いたように、それはすべて、静的スライドの配置と描画の方法を学ぶことから始まります。 次のステップは、これらのスライドをアニメーション化する方法を学ぶことです。

ほとんどの開発者は、彼らが解決しようとしていたタスクのフレームワークで、これに出くわし、AndroidフレームワークでMotionEventがどのように処理されるかをある程度理解していると思いますが、それでも最初から始めます。

そのため、基本クラスのViewは、MotionEventの潜在的な処理を暗示するような方法で設計されています。 そして、対応するアクションに応じて、ウィジェットはこのMotionEventを受け取ります。このMotionEventには、ユーザーがTouchScreenと対話する方法に関するすべての必要な情報が格納されます。

この例では、スライドスタック内のスライドをスクロールするのに役立つイベントのみに関心があります。

しかし、コードを書き始める前に、何が起こっているかの最も正確なモデルを自分のために構築するために、最初に利用可能なすべてのデータ、要件、および希望をヒープに収集することを常に好みます。 当然のことながら、ささいなことを一度に考えることは不可能です。コードを書くときは、アーキテクチャの単純さを支持するために、または開発時間を短縮するために、アイデアを捨てる必要があります。 しかし、私がずっと前に気づいたように、これは最小限の損失で行われます。座って、おおよそのフロー図、相互作用表を描き、1つのかさばるクラスを相互作用するコンポーネントに分割すると、システムの独立した部分に影響を与えずに動作を簡単に変更できます さまざまなウィジェットを作成する際、この理解は直感レベルで自然に行われます。必要な変更を行うには先月に書かれたすべてのコードをシャベルでシャベルする必要があるという考えに頭をつかむことはありません。 ここでは、すべてのプログラマーにとって非常にシンプルで馴染みのあるルールが前面に出てきます。

• 不要な機能でクラスをオーバーロードしないでください
• この部分が後で役立つと思われる場合は、常にコードをリファクタリングしてください
• 事前に最適化しないでください
• 各フィールドまたはメソッドは、コンポーネント自体から分離して見たときに困惑させてはなりません

最後の段落では、おそらく最も難しいでしょう。なぜなら、多くの場合、目的の結果を達成するために急いで、すべてのプログラマーが妥協し、しばしば「すぐに変更します」というメモを付けて「すぐに動作する」ようにする傾向があるためです 私はこれが絶対に間違っていると言っているのではありません。何かを変更するには遅すぎるか、さらに悪いことに、これを後で覚えている可能性が高いことを警告したいだけです。

そして、注意する必要があると私が考える最後のポイントは、わずかに物議を醸す魅力です。 狂信なしに上記のすべてを行います。 つまり、アプリケーションの画面間を移動するためのコントロールとして使用されるウィジェットを作成するタスクに直面しており、要件の主なタスクがタッチスクリーンを介した操作の容易さである場合、これを達成する前にこれに注意を払う必要はありませんタッチコントロールなどの瞬間。 もちろん、単に電話を回したり移動したりしてナビゲートすることは非常にクールで便利ですらありますが、それでもこれは主要なタスクではなく、いわば「より良い時代まで」延期できます。

それでは、ラムに戻りましょう。

一見、すべてが非常に単純ですが、一見しただけです。 以前にスクロールを処理する必要があった場合、すべての種類のMotionEventの中で、ユーザーの真の意図を判断するのはそれほど簡単ではないことをご存じでしょう。 彼はスライドを単に横に移動することを決めましたか、またはリスト内にある要素をクリックしますか？ このロジックはすべて、スライドスタックとは別に実装できるため、スクロール処理アルゴリズム全体を個別のSlideStackScrollerコンポーネントに分離すると便利です。

public static class SlideScroller extends Scroller implements OnTouchListener{ private final ScrollingListener mListener; private final GestureDetector mGestureDetector; public SlideScroller(Context context, ScrollingListener listener, OnGestureListener gestureListener) { super(context); this.mListener = listener; this.mGestureDetector = new GestureDetector(context, gestureListener); mGestureDetector.setIsLongpressEnabled(false); } } 

スクロールは革新的なタスクではないため、もちろん、役立つクラスが用意されています。 つまり、ScrollerとGestureDetectorです。 1つ目はスクロールを計算するための便利なインターフェイスを提供し、2つ目は標準タイプのジェスチャを決定するのに役立ちます。この場合、最も重要なのはフリングジェスチャです。 既製のソリューションを使用する主な利点に加えて（怠lazなプログラマーは私を理解します）-このロジックを自分で記述する必要はありません-プラットフォームが提供するソリューションを使用すると、いわゆる一貫したユーザーエクスペリエンス、またはユーザーに馴染み、他のコンポーネントの中で目立たない動作を簡単に達成できますプラットフォーム。 また、システムのインタラクティブな部分を開発している場合、これを考慮することは特に重要です。

スクローラーは、スライドスタックの観点から、重要なイベント、つまり次のものをレポートするインターフェイスをスライドスタックに提供する必要があります。

  public interface ScrollingListener { void onScroll(int distance); void onStarted(); void onFinished(); void onJustify(); } 

スクロールが開始されたとき、スライドが一定数のピクセルを移動したとき、そのスクロールは終了し、スライドの位置を揃える必要があり、スクロールは完全に完了しました。

スライドスタックの観点から見ると、これ以上簡単なものはありません。すべてのタッチイベントの処理をスクローラーに委任するだけで、実際に何が起こったのかがわかり、必要なコールバックが発生します。

お気づきのとおり、すべての委任は、android.view.View.OnTouchListenerインターフェイスのonTouch（View v、MotionEventイベント）メソッドを介して行われます。

  @Override public boolean onTouch(View v, MotionEvent event) { switch (event.getAction()) { case MotionEvent.ACTION_DOWN:{ int pointerId = MotionEventCompat.findPointerIndex(event, mActivePointerId); if (pointerId == INVALID_POINTER_ID){ break; } mLastTouchX = MotionEventCompat.getX(event, pointerId); mJustifying = false; forceFinished(true); clearMessages(); break; } case MotionEvent.ACTION_MOVE:{ int pointerId = MotionEventCompat.findPointerIndex(event, mActivePointerId); if (pointerId == INVALID_POINTER_ID){ break; } // perform scrolling float x = MotionEventCompat.getX(event, pointerId); int distanceX = (int)(x - mLastTouchX); if (distanceX != 0) { mTouchScrolling = true; startScrolling(); mListener.onScroll(-distanceX); mLastTouchX = x; } break; } case MotionEvent.ACTION_UP: mTouchScrolling = false; mActivePointerId = INVALID_POINTER_ID; break; } if ((!mGestureDetector.onTouchEvent(event) || ((SlideStackView)v).isOverScrolled()) && (event.getAction() == MotionEvent.ACTION_UP || event.getAction() == MotionEvent.ACTION_CANCEL)){ justify(); } return true; } 

順番に行きましょう：

• ACTION_DOWNは、ユーザーが特定の座標で特定の領域の画面に触れたことを示します。 この場合、そのような場合には完全に標準的な手順を実行する必要があります。つまり、地面を準備し、画面上の後続のユーザーの動きに備えて、それに応じてスライドスタックをスクロールします。 この場合、この手順には、初期位置の保存、すべてのフラグおよび現在のスクロールのリセットが含まれます（実行された場合）。
• ACTION_MOVEは、移動自体、つまりユーザータッチが新しい座標に移動したことを示します。 座標の差を計算し、ユーザーがスクロールしたことをスライドスタックに通知する必要があることを推測することは難しくありません。 SlideStackScrollerなどのコンポーネントを強調表示することで、モーションイベントの処理とスライドスタックの内部ロジックとの過剰な結合を回避しました。 言い換えれば、スライドスタックの現在の状態、つまり一方向にスクロールできるかどうかは心配していません。 ユーザーが何をしたか、そしてこれに応答するかどうか、そしてどのように反応するかを彼に伝えるだけで、スライドスタックが決定します
• ACTION_UP そのため、多くの場合、ユーザーは画面との対話を終了します。 しかし、これはリラックスできるという意味ではありません。 おそらく、作業の最も単純な部分だけがここで終わります。 私は誰もが慣れているジェスチャーを意味し、通常は投げ飛ばしと呼ばれます。 リテラル翻訳（「スロー」）では、これが何を意味するのか理解できません。 これに関連して、ジェスチャとは、ユーザーが画面上で指を動かし、あたかも要素を加速し、触れないように実際の身体と同じように要素が動くことを期待するという意味です。 つまり、慣性によるものです。 たとえば、電話をテーブルの上で他の人にプッシュした場合、どのようにスライドするか。
• 最後に、スライドの位置を調整できるようにジェスチャが終了したかどうか、またはユーザーによって行われたジェスチャがフリングとして解釈できるかどうかを判断する必要があります。その後、適切なアクションを実行し、完了するまで待ってからスライドを調整する必要があります

すぐに言いたいのは、一見すると追加的で重要ではないように思われるフリングが、スライドスクロールの最も頻繁な完了であるということです。 問題は、ほとんどのユーザーがプラットフォーム自体と多くのアプリケーションの両方で水平スワイプに慣れているため、このジェスチャーを直感的かつ迅速に実行することです。

  if ((!mGestureDetector.onTouchEvent(event) || ((SlideStackView)v).isOverScrolled()) && (event.getAction() == MotionEvent.ACTION_UP || event.getAction() == MotionEvent.ACTION_CANCEL)){ justify(); } 

この状態をもう一度見てみましょう。 ここでは、GestureDetectorがジェスチャにどのように応答したかを確認するのではなく、すべてのジェスチャがどれだけ通過するかを確認することが非常に重要です。 この場合、ユーザーの単一の動きを見逃していないことを確認し、発生したときに必要なジェスチャーを正確に判断できるようにします。 この状態で検証の順序を並べ替えると、ほとんどのMotionEventがジェスチャー検出器に到達しないため、スライドスタックがスワイプに応答しなくなります。

その結果、フリングが完了すると、onFlingメソッド（MotionEvent e1、MotionEvent e2、float velocityX、float velocityY）を呼び出すことですべてが終了します（または、必要に応じて開始します）。

  @Override public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { if (mScroller.isTouchScrolling()){ LOG.w("mTouchScrolling in fling"); } SlideInfo slide = getSlideInfo(mSelected); int dx = getAdjustedTargetX(velocityX) - slide.mOffset; mScroller.fling(-(int)getVelocity(dx)); return true; } 

この方法では、最終的な座標が考慮されます。これは、フリングが完了した後に到達する必要があります。次に、スライドの現在位置の修正が行われ、移動の初期速度が計算され、フリング自体が開始されます。

すでに与えられているのに、なぜ速度を取るのですか？ 問題は、速度が異なる可能性があることですが、この場合、特定のポイントでフリングが終了することが重要であり、このポイントはgetAdjustedTargetX（）メソッドで計算されます。

  /** * Defines target x coordinate of the slide. * It depends on fling direction * <p> * In case right fling it is calculated like this * <pre> * * getLeftEdge() getRightEdge() targetX * _|___________________________|______________________|__ * | | |rightOverScrollInFling| | * | _ _ _ _ _ _ _ _ _ _ _ _ _ _ <--------------------> | * | | | | | * | | * | | | | | * | mSelectedSlide | * | | | | | * | | * | |_ _ _ _ _ _ _ _ _ _ _ _ _ _| | | * | SlideStackView | * |_|___________________________|______________________|__| * </pre> * <p> * In case left fling it is calculated like this * <pre> * 0 * ________________________|_____________________________ * | |leftOverScrollInFling | | * | <--------------------> _ _ _ _ _ _ _ _ _ _ _ _ _ _ | * | | | | | * | | * | | | | | * | mSelectedSlide | * | | | | | * | | * | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _| | * | SlideStackView | * |_|______________________|_____________________________| * </pre> * * @param velocityX velocity that defines direction of the fling * @return delta x in pixels that slide needs to scolled by * @see SlideStackView#getLeftEdge(int) * @see SlideStackView#getRightEdge(int) * @see SlideStackView#mRightOverScrollInFling * @see SlideStackView#mLeftOverScrollInFling */ private int getAdjustedTargetX(float velocityX) { int result = 0; if (velocityX > 0){ result = getRightEdge(mSelected) - getLeftEdge(mSelected) + mRightOverScrollInFling; // LOG.v("onFling " + targetX); } else { // relative to layout position of the slide result = 0 - mLeftOverScrollInFling; } return result; } 

メソッドの本体からわかるように、このポイントの計算はフリングの方向に依存しますが、最終的な位置は変わりません。 右への飛びの場合、これはスライドの右端の位置+スライドが右端の位置よりも遠くに飛ぶピクセル数による「ドリフト」です。 フリングが左にある場合、これは左端の位置-スキッドです。 そして、これは動きの最初の速度です。 このような制限は人為的に行われました。ユーザーエクスペリエンスの分析により、このコントロールでは特にこの動作がより自然に見えることが示されたためです。

Androidプラットフォームでは、スクロール中に要素の運動学を計算するのにスクローラーが関与します。 モデルとして、Googleの開発者は、学校で知られている均一に加速されたモーションの公式を採用しました：S = V ₀ * t-（g * t ² ）/ 2。 移動の初期速度はわかっています。移動の開始から時間を測定できます。スライドが停止する加速度を選択するだけです。

開発者は、自由落下の加速を推測せず、基礎として採用しました。

  mDefaultDeceleration = SensorManager.GRAVITY_EARTH // g (m/s^2) * 39.37f // inch/meter * ppi // pixels per inch * ViewConfiguration.getScrollFriction() * 10.0f; 

停止した実装から注意をそらすと、異なる初期速度でフリング中に発生する可能性のある4つのシナリオを区別できます。

次のように、開いたスライドと閉じたスライドの位置を取ります。





開始位置からフリングを行うと仮定します。 上記の4つの可能なオプションは、左端（1スクリーンショット）と右端（2スクリーンショット）のスライド位置を基準に移動距離をソートすることにより得られます。 これらの位置間の距離S _n



S <S _n / 2

この状況は、ユーザーが飛んで、要素に初期速度を与えていることを示しています。これは、要素が終了位置までの距離の半分を超えるには不十分です。 この場合、自然な振る舞いをエミュレートするために、ユーザーが要素に与えた速度で投げ飛ばし、要素が停止するのを待ってから、元の状態に戻すことができます。 左端の位置。



S _n / 2 <S <S _n

ここでは、要素の初期速度はターゲットまでの距離の半分を克服するには十分でしたが、終点に到達するには不十分でした。 したがって、このシナリオを決定したら、要素にもう少し速度を与えることができます-目的地に到達するには十分です。 このために、均一に加速された動きの物理学を思い出して、加速と結果の距離を知って、投げる初期速度を計算する価値があります。

S _n <S <S _n +オーバースクロール

この結果は、ユーザーが要素に十分な速度を与えていることを示しています。この時点で、ユーザーはすでに右端を超えて移動を終了しますが、最大許容スキッドには達しません。 この場合、すべてが意図したとおりに正確に行われます。つまり、ユーザーは要素が海外に移動したように見え、その後、要素は整列して右端の位置に戻ります。

S> S _n +オーバースクロール

この状況は少し悪いです。 要素の初期速度は非常に高いため、右端の位置を超えて移動し、そのドリフトは最大許容値を超えます。 理論的には、差は大幅に大きくなる可能性があり、自然ではあるが見苦しい視覚効果を生み出します。 肯定的な点は、非常に鋭い動きでは、ユーザーが速度を調整する方法に気付くのがより難しいことです-主なことは、すべてが迅速に行われ、要素が画面の境界をはるかに超えないことです。

フリングを他の方向に分解すると、参照距離が少し異なる方法で計算されることを除いて、すべて同じケースが表示されます。

それで、私たちは、フリングをどのように処理するかを考え出しました。 次に、このような動きの中でアニメーションを作成する方法を決定する必要があります。 これを行うには、次の方法を検討してください。

  public void fling(int velocity){ mLastX = 0; final int maxX = 0x7FFFFFFF; final int minX = -maxX; fling(mLastX, 0, velocity, 0, minX, maxX, 0, 0); setNextMessage(MSG_SCROLL); } 

この方法は、水平フリング専用に必要であり、開始位置と終了位置を考慮しません。 したがって、初期位置を覚えて、可能な最大境界を設定し、相続人クラスでフリング自体を開始し、スクロールを処理する必要があるというメッセージを自分で送信します。

このメソッドは非常に簡単です。以前にそこに置かれたすべてのメッセージをクリアし、現在必要なメッセージを1つだけハンドラーに送信します。

  private final Handler mAnimationHandler = new AnimationHandler(); private void setNextMessage(int message) { clearMessages(); mAnimationHandler.sendEmptyMessage(message); } private void clearMessages() { mAnimationHandler.removeMessages(MSG_SCROLL); mAnimationHandler.removeMessages(MSG_JUSTIFY); } 

mAnimationHandlerは、通常の補助的な内部クラスであり、ユーザーがTouchScreenにアクセスした後に実行される、何らかのスクロールを行っているというメッセージを受け取ります。

  private final class AnimationHandler extends Handler { @Override public void handleMessage(Message msg) { computeScrollOffset(); int currX = getCurrX(); int delta = mLastX - currX; mLastX = currX; if (delta != 0) { mListener.onScroll(-delta); } … } } 

すべてが非常に単純です。最初に、このメッセージを受け取った時点で、スクローラーにアニメーションの現在位置を計算するように依頼します。 次に、新しい位置と最後に認識された位置の差を計算します。 最後に、スクロールスタックにスクロールが完了したことを通知します。 onTouchEvent（）メソッドの本体から行ったように。

さて、これは小さなことです-これらのメッセージに応じて、画面上のスライドの位置を変更する必要があります。 出発点は、onScroll（）メソッドの実装です。

  @Override public void onScroll(int distance) { if (distance == 0){ return; } // LOG.d("onScroll " + distance); doScroll(distance); } 

すぐに安心したいです。メソッド内では、doScrollInternal（）メソッドの呼び出しの後に単一行が続きません。その中には、実際にはDoScroll（）メソッドの呼び出しなどがあります。 この場合、スクロールスタックだけでなく、たとえばAPIを介してプログラムでスライドスタックにスクロールできるように、アルゴリズムを分割することにしました。 しかし、それについては後で。

  /** * Performs actual scrolling. Moves the views according * to the current selected slide number and distance * passed to the method. After the scrolling has been * performed method {@link #onScrollPerformed()} will be * called where you can apply some visual effects. * @param distance scroll distance */ private void doScroll(int distance) { adjustScrollDistance(distance); // LOG.d("scroll delta " + mScrollDelta); View selected = getChild(getSelectedViewIndex()); scrollChildBy(selected, mScrollDelta); notifyScrollPerformed(); onScrollPerformed(); fillViewsIn(); if (!mDirty.isEmpty()){ invalidate(mDirty.left, mDirty.top, mDirty.right, mDirty.bottom); mDirty.setEmpty(); } } 

ここでは、adjustScrollDistance（）メソッドの詳細には触れません。 ユーザーがスライドを通常の位置を超えて引っ張ろうとした場合に、スライドの位置に応じて距離の値が変化し、弾力のある効果を生み出すと言えます。
次に、現在のスライドを見つけます。ユーザーがその動きを実行しようとすると、このメソッドが呼び出されます。 このスライドを相対的なピクセル数に移動します。 スライドが特定の位置に移動されたことをスライドスタックリスナーに通知します。
主な部分はほぼ完成しているため、新しい位置を考慮してスライドを追加または削除するだけであり、自分が見つけた新しい位置に応じて、表示または非表示を変更します。 これがどのように行われるかについての詳細は、記事の最初の部分で読むことができます。 さて、そして今最も重要なこと-移動のために変更された画面の領域を再描画する必要があります。

リストされたメソッドについてもう少し説明します。

  /** * Moves the specified child by some amount of pixels * @param child child to move * @param scrollDelta scrolling delta */ private void scrollChildBy(View child, int scrollDelta) { SlideInfo info = getSlideInfo(child); // LOG.d("apply scroll " + info.mPosition + " delta " + scrollDelta); Rect childDirty = getChildRectWithShadow(child); info.mOffset -= scrollDelta; child.offsetLeftAndRight(-scrollDelta); childDirty.union(getChildRectWithShadow(child)); mDirty.union(childDirty); // LOG.d("apply scroll " + info.mPosition + " newoff " + info.mOffset); } 

記事の前半で既に述べたように、この場合のmDirtyは、多くの一時オブジェクトを作成せず、1つだけを使用することを保証するのに役立ちます。 メモリの合理的な使用に加えて、1つのオブジェクト、その変更、およびそのオブジェクトへのアクセスを監視するだけで十分であるため、デバッグが簡素化されます。 これにより、エラーが気付かれない可能性が大幅に減少します。

  /** * Notifies scroll listeners about selected slide has been scrolled. * Do nothing if there is no scroll listener was set earlier. */ private void notifyScrollPerformed() { if (mScrollListener != null){ final float p = getSlidePositionInBounds(mSelected); // LOG.v("notifyScrollPerformed " + mSelected + ", " + p); mScrollListener.onSlideScrolled(mSelected, p); } } /** * Calculates position for the specified slide relative to it's * scrollable bounds. * <p> * <b>Note:</b> Slide position coulld be <code>< 0.0f</code> and * <code> > 1.0f * @param slidePosition * @return */ private float getSlidePositionInBounds(int slidePosition) { SlideInfo info = getSlideInfo(slidePosition); int offset = info.mOffset; int scrollBounds = getWidth() - getRightEdgeDelta(info.mPosition) - getLeftEdge(info.mPosition); float p = ((float) offset) / scrollBounds; return p; } 

多くの場合、再利用が必要なコンポーネントを設計するとき、一部のユーザーがコンポーネント内で発生するイベントについて知ることがどのように役立つかを考える必要があります。 このことを忘れないでください。可能であれば、クラスのユーザーに何らかのインターフェイスを提供します。これを使用して、内部で何が起こっているかについての高レベルの情報を受け取ることができます。 私の場合、これらはスライドスタックのスクロールに関連する2つの主なイベントです。 イベントは非常に明白です、すなわち：
現在のスライドがスライドスタック内で変更されたことをユーザーに通知するイベント。このイベントは、スライドが視覚的に実際にアクティブになった瞬間ではなく、スクロールが完全に完了した瞬間にのみ発生することに注意してください。
スライドの位置が元の境界に対して変更されたことをユーザーに通知するイベント。 私の場合、相対的な位置は境界[0、1]を超える可能性があり、これはまさに「ドリフト」を意味します。これについてはさらに詳しく説明します。

  /** * Listener interface that informs about slide scrolling * related events such as current selected slide has changed, * or current selected slide scroll position has changed. * @author k.kharkov */ public interface OnSlideScrollListener{ /** * Called when the current selected position for slide * has changed. Usually it happen after scrolling finished. * @param selectedSlide */ void onSlideChanged(int selectedSlide); /** * Informs about changing scroll position of the slide. * @param position current selected slide position * @param p position of the slide inside it's scroll * bounds. 0.0f at left edge, 1.0f at right edge. If * <code>p < 0.0f || p > 1.0f</code> the slide is over * scrolled to left or to the right. */ void onSlideScrolled(int position, float p); } 

最後に、すでに頻繁に満たされている3つの方法があり、それらは2回以上満たされます。 それらの目的は明確かつ真実ですが、コードがそれについてより多くのコメントを話す人にとっては：

  /** * Retrieves slide's left edge coordinate in opened state * relative to parent. * @param position slide number in adapter's data set * @return coordinate of the slide's left in opened state */ private int getLeftEdge(int position){ return mAdapter == null ? 0 :mAdapter.getSlideOffset(position); } 

非常に簡単な方法。 開いているスライドの左の境界線を構成できるようにするためにのみ必要です。 アダプターからスライドを取得するため、新しいアダプターを設定することで、ユーザーがスライドスタック内でスライドを希望の位置に配置できるように、この情報もそこから取得することにしました。

@Mail.Ru , , . - , , - :

  /** * Retrieves coordinate of the slide's left edge in closed state * relative to parent. * @param position slide number in adapter's data set * @return coordinate of slide's left in closed state. */ private int getRightEdge(int position) { int rightEdge = getRight() - getRightEdgeDelta(position); return rightEdge; } /** * Just calculates delta between child's right edge and * parent's right edge * @param position position of the child (in adapter's * data set indexes) * @return delta in pixels */ private int getRightEdgeDelta(int position){ if (position < 0){ return 0; } int delta = mSlideInvisibleOffsetFirst + mSlideInvisibleOffset * position; return delta; } 

, , . , . . , - , , .

2 : onScrollPerformed(), adjustScrollDistance().

, - . , , , - . , -, . , , , . , . , - .

bouncing effect. , -, . , , Android- , iOS. , . look&feel. , , , iOS , . , . , , ,
, , - , .

, : , . -. adjustScrollDistance():

  /** * Processes scroll distance according to the current scroll * state of the slide stack view. Takes into account * over scrolling, justifying. * @param distance desired distance to scroll. */ private void adjustScrollDistance(int distance) { mScrollDelta = distance; if (mScroller.isJustifying()){ processNonOverScroll(distance); } else if (mScrollDelta < 0 && isRightOverScrolled()){ processOverScroll(distance); } else if (mScrollDelta > 0 && isLeftOverScrolled()){ processOverScroll(distance); } else { processNonOverScroll(distance); } } 

SlideStackView, , , , , , . , , .

. , :

  /** * @return <code>true</code> if slide stack over scrolled * to the right. <code>false</code> otherwise */ private boolean isRightOverScrolled(){ /** * info.mOffset - it is * the latest position of the slide's left side * so if it is over scrolled - return true * _________________ * | _____________|_ * | |lastSlide | | * |<->| | | * | | | | * | |_____________|_| * |_________________| * SlideStack */ SlideInfo info = getSlideInfo(getSelectedViewIndex()); if (mSelected == mFirst + getChildCount() - 1){ if (info.mOffset > getLeftEdge(info.mPosition)){ return true; } } /** * getRightEdge() - it is left bound of the slide * when it is hidden * ___________|______ * | | __|____________ * | | | |anySlide | * | |<->| | | * | | | | | * | | |__|____________| * |___________|______| * SlideStack */ int left = info.mOffset + getLeftEdge(mSelected); if (left > getRightEdge(mSelected)){ return true; } return false; } 

, , :

• , .
  .
• , . — .

  /** * @return <code>true</code> if the slide stack view is * over scrolled to the left. <code>false</code> otherwise. */ private boolean isLeftOverScrolled(){ View selected = getChild(getSelectedViewIndex()); SlideInfo info = getSlideInfo(selected); return selected.getRight() + info.mOffset < getRightEdge(mSelected - 1); } 

, . , , , () . , , (. getRightEdge()).

, , :

  /** * Changes actual scroll delta in case over scroll. * Depends on whether we in fling mode or not. * @param distance */ private void processOverScroll(int distance) { // LOG.d("process overscroll " + distance); //process over scroll while in fling mode; if (!mScroller.isTouchScrolling()){ mScroller.setDecelerationFactor(mDecelerationFactor); } else{ // or just slow down while touch scrolling mOverScrollOffset += distance; int nOffsetAbsolute = (int) (mOverScrollOffset / mOverScrollFactor); int oldOffsetAbsolute = mLastOverScrollOffset; int scrollDelta = nOffsetAbsolute - oldOffsetAbsolute; mLastOverScrollOffset += scrollDelta; mScrollDelta = scrollDelta; } } 

, touchScrolling, , - . , : - , . , . , mOverscrollFactor . . , , . , overscroll factor = 5, , distance = 1. . . , , . , . , 5 , , , 1 . , , .
mOverScrollOffset — , . mLastOverScrollOffset — , . , , .

: , , mOverScrollOffset mLastOverScrollOffset. , ( ), . , . :

  /** * We need assume that actual scroll delta is distance parameter, * we need adjust {@link #mLastOverScroll} if we will not go out * from over scroll mode and over scroll again. * @param distance raw distance passed from the scroller. */ private void processNonOverScroll(int distance) { mScrollDelta = distance; if (isOverScrolled()){ mLastOverScrollOffset += distance; mOverScrollOffset = (int) (mLastOverScrollOffset * mOverScrollFactor); } else { mLastOverScrollOffset = 0; mOverScrollOffset = 0; } } 

: mOverScrollOffset mLastOverScrollOffset , , , , . — .

: , .

, . , ( ) . , , , , Scroller. , :

S=V ₀ *t-(g*t ² )/2 ( )

, , . 3 :

S=V ₀ *t-(g*t ² )/2

,

S2=V _k *t2- ((g*p)*〖t2〗 ² )/2

, , p .

S3=V _k2 *t3- ((g*p*p)*〖t3〗 ² )/2

: , .
, .

mScroller.setDecelerationFactor(mDecelerationFactor);

, . , , :

  /** * Adjusts the current deceleration to slow down more or less. * @param factor if > 1.0 the scroller will slow down more. * if factor < 1.0 the scroller will slow down less. */ public void setDecelerationFactor(float factor){ mVelocity = mVelocity - mDeceleration * mPassed / 1000.0f; float velocity = mVelocity; mDeceleration *= factor; mDuration = (int) (1000.0f * mVelocity / mDeceleration); int startX = mStartX = mCurrX; int startY = mStartY = mCurrY; int totalDistance = (int) ((velocity * velocity) / (2.0f * mDeceleration)); mFinalX = startX + Math.round(totalDistance * mCoeffX); // Pin to mMinX <= mFinalX <= mMaxX mFinalX = Math.min(mFinalX, mMaxX); mFinalX = Math.max(mFinalX, mMinX); mFinalY = startY + Math.round(totalDistance * mCoeffY); // Pin to mMinY <= mFinalY <= mMaxY mFinalY = Math.min(mFinalY, mMaxY); mFinalY = Math.max(mFinalY, mMinY); mStartTime += mPassed; } 

, , , , hide :

  /** * @hide * Returns the current velocity. * * @return The original velocity less the deceleration. Result may be * negative. */ public float getCurrVelocity() { return mVelocity - mDeceleration * timePassed() / 2000.0f; } 

, v(t)=v ₀ +at (1000 — ). - , , .

, event' , . , . , , , . Android Framework , . , . , ViewGroup.dispatchTouchEvent().

. , , . , , :

• child, touchEvent.
• child , event, . , event ViewGroup.
• MotionEvent'a ViewGroup . MotionEvent ViewGroup, child'.

, , View .

, , . , . , event' , : .

. :

  /** * Determines whether the user tries to scroll the slide stack view * or just tries to scroll some scrollable content inside the slide. * <p> * {@inheritDoc} */ @Override public boolean onInterceptTouchEvent(MotionEvent ev) { 

, , , \\ .
, :

  final int action = MotionEventCompat.getActionMasked(ev); if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP){ /* * That means we need to abort all scrolling and return to nearest * stable position in the slide stack. So justify position. */ mBeingDrag = false; mUnableToDrag = false; mScroller.justify(); // LOG.v("OnInterceptTouchEvent: action cancel | up"); return false; } /* * In case we have already determined whether we need this * touch event or not - just return immediately */ if (action != MotionEvent.ACTION_DOWN){ if (mBeingDrag){ // LOG.v("OnInterceptTouchEvent: already dragging"); return true; } if (mUnableToDrag){ // LOG.v("OnInterceptTouchEvent: already unable to drag"); return false; } } 

(, MotionEvent), event' , .

, , , event .

  switch (action){ case MotionEvent.ACTION_DOWN:{ /* * remember the start coordinates for the motion event * in order to determine drag event length */ mInitialX = ev.getX(); mInitialY = ev.getY(); mActivePointerId = MotionEventCompat.getPointerId(ev, 0); /* * pass down event to the scroller after we have decided to intercept, * not here. It helps to start calculation motion event in case we * decide to intercept it. */ mScroller.setActivePointer(mActivePointerId); if (mScroller.isScrolling() || isHiddenSlideMove(false)){ /* * in case the user start the touch while we didn't * accomplish scrolling - intercept touch event. * */ mBeingDrag = true; mUnableToDrag = false; } else { /* * Otherwise let's start the process of detecting * who the touch event belongs to. */ mBeingDrag = false; mUnableToDrag = false; } // LOG.v("OnInterceptTouchEvent: DOWN being drag " + mBeingDrag + // ", unable to drag " + mUnableToDrag); return mBeingDrag; } 

event , . . , MotionEvent.ACTION_DOWN. event' , . , , event' child' . , isHiddenSlideMove(). , event' «», , , . , .

, :

  /** * Defines whether motion events has been started on the closed slide or not * * @param extend * if <code>true</code> it will take into account * {@link #mTouchExtension}. Otherwise this method will only take * into account {@link #mInitialX} and {@link #mInitialY} * @return <code>true</code> in case the motion event has been started to * the right of the last closed slide, <code>false</code> otherwise. */ private boolean isHiddenSlideMove(boolean extend) { int x = (int) mInitialX; int y = (int) mInitialY; Rect rightSide = new Rect(); boolean right = false; for (int i = getLastHiddenSlideIndex(); i >= 0 && !right; i--) { View view = getChild(i); Rect rect = new Rect(); view.getHitRect(rect); rightSide.union(rect); if (rightSide.contains(x, y) || (extend && rightSide.contains(x + mTouchExtension, y))) { right = true; } } return right; } 

— :

  case MotionEvent.ACTION_MOVE:{ final int activePointerId = mActivePointerId; if (activePointerId == INVALID_POINTER_ID) { // If we don't have a valid id, the touch down wasn't on content. break; } final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId); final float x = MotionEventCompat.getX(ev, pointerIndex); final float dx = x - mInitialX; final float xDiff = Math.abs(dx); final float y = MotionEventCompat.getY(ev, pointerIndex); final float dy = y - mInitialY; final float yDiff = Math.abs(dy); if (dx != 0 && canScroll(this, false, (int) dx, (int) x, (int) y)) { // Nested view has scrollable area under this point. Let it be handled there. if(!isHiddenSlideMove(false)) { mUnableToDrag = true; return false; } } // if it seems to be horizontal scroll if (xDiff > mTouchSlop && xDiff * 0.5f > yDiff){ // LOG.v("OnInterceptTouchEvent: MOVE start drag"); ev.setAction(MotionEvent.ACTION_DOWN); adjustSelectedSlide(); mScroller.onTouch(this, ev); mBeingDrag = true; } else if (yDiff > mTouchSlop){ // LOG.v("OnInterceptTouchEvent: MOVE unable to drag"); mUnableToDrag = true; } break; } 

. . -, , , , , ( ). , , . ,
. , . . , , 22,5 , .



, , — . . , .

. , , , ( ), , . , Google (. ViewPager):

  if (dx != 0 && canScroll(this, false, (int) dx, (int) x, (int) y)) { // Nested view has scrollable area under this point. Let it be handled there. if(!isHiddenSlideMove(false)) { mUnableToDrag = true; return false; } } 

  /** * Tests scrollability within child views of v given a delta of dx. * * @param v View to test for horizontal scrollability * @param checkV Whether the view v passed should itself be checked for scrollability (true), * or just its children (false). * @param dx Delta scrolled in pixels * @param x X coordinate of the active touch point * @param y Y coordinate of the active touch point * @return true if child views of v can be scrolled by delta of dx. */ protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) { if (v instanceof ViewGroup) { final ViewGroup group = (ViewGroup) v; final int scrollX = v.getScrollX(); final int scrollY = v.getScrollY(); final int count = group.getChildCount(); // Count backwards - let topmost views consume scroll distance first. for (int i = count - 1; i >= 0; i--) { final View child = group.getChildAt(i); if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() && y + scrollY >= child.getTop() && y + scrollY < child.getBottom() && canScroll(child, true, dx, x + scrollX - child.getLeft(), y + scrollY - child.getTop())) { return true; } } } return (checkV && ViewCompat.canScrollHorizontally(v, -dx)); } 

View, «», , , ViewCompat.canScrollHorizontally(). , , . ViewCompat, .

 public class ViewCompat { public static boolean canScrollHorizontally(View v, int direction){ if (v instanceof QuickActionView){ return ((QuickActionView)v).canScrollHorizontally(direction); } else { return android.support.v4.view.ViewCompat.canScrollHorizontally(v, direction); } } } } 

. .

  /** * {@inheritDoc} */ @Override public boolean onTouchEvent(MotionEvent event) { LOG.i("onTouchEvent: " + event); if (event.getAction() == MotionEvent.ACTION_DOWN && event.getEdgeFlags() != 0) { // Don't handle edge touches immediately -- they may actually belong to one of our // descendants. return false; } if ((event.getAction() & MotionEventCompat.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP){ continueWithSecondPointer(event); return true; } // adjust selected slide in case we didn't it in #onInterceptTouchEvent() method // if we have no touchable child under the touch event for instance if (!mScroller.isScrolling() && event.getAction() == MotionEvent.ACTION_DOWN){ adjustSelectedSlide(); } return mScroller.onTouch(this, event); } 

event' , . , , , View.

  @Override public boolean dispatchTouchEvent(MotionEvent ev) { // LOG.v("dispatchTouchEvent: " + ev); if (getChildCount() == 0){ return false; } return super.dispatchTouchEvent(ev); } 

. - , .

, , , MotionEvent'.

— . dispatchTouchEvent(), onInterceptTouchEvent() onTouchEvent(), , event. , , . developer.android.com , event'.

, . , , .

:)