null
139 | * if share history should not be persisted between sessions.
140 | *
141 | * Note: The history file name can be set any time, however
142 | * only the action views created by {@link #onCreateActionView()} after setting
143 | * the file name will be backed by the provided file. Therefore, if you want to
144 | * use different history files for sharing specific types of content, every time
145 | * you change the history file {@link #setShareHistoryFileName(String)} you must
146 | * call {@link android.app.Activity#invalidateOptionsMenu()} to recreate the
147 | * action view. You should not call
148 | * {@link android.app.Activity#invalidateOptionsMenu()} from
149 | * {@link android.app.Activity#onCreateOptionsMenu(Menu)}."
150 | *
151 | *
152 | * private void doShare(Intent intent) {
153 | * if (IMAGE.equals(intent.getMimeType())) {
154 | * mShareActionProvider.setHistoryFileName(SHARE_IMAGE_HISTORY_FILE_NAME);
155 | * } else if (TEXT.equals(intent.getMimeType())) {
156 | * mShareActionProvider.setHistoryFileName(SHARE_TEXT_HISTORY_FILE_NAME);
157 | * }
158 | * mShareActionProvider.setIntent(intent);
159 | * invalidateOptionsMenu();
160 | * }
161 | *
162 | *
163 | * @param shareHistoryFile The share history file name.
164 | */
165 | public void setShareHistoryFileName(String shareHistoryFile) {
166 | shareHistoryFileName = shareHistoryFile;
167 | setActivityChooserPolicyIfNeeded();
168 | }
169 |
170 | /**
171 | * Sets an intent with information about the share action. Here is a
172 | * sample for constructing a share intent:
173 | *
174 | *
175 | *
176 | * Intent shareIntent = new Intent(Intent.ACTION_SEND);
177 | * shareIntent.setType("image/*");
178 | * Uri uri = Uri.fromFile(new File(getFilesDir(), "foo.jpg"));
179 | * shareIntent.putExtra(Intent.EXTRA_STREAM, uri.toString());
180 | *
181 | *
182 | *
183 | *
184 | * @param shareIntent The share intent.
185 | * @see Intent#ACTION_SEND
186 | * @see Intent#ACTION_SEND_MULTIPLE
187 | */
188 | public void setShareIntent(Intent shareIntent) {
189 | ActivityChooserModel dataModel = ActivityChooserModel.get(context,
190 | shareHistoryFileName);
191 | dataModel.setIntent(shareIntent);
192 | }
193 |
194 | /**
195 | * Reusable listener for handling share item clicks.
196 | */
197 | private class ShareMenuItemOnMenuItemClickListener implements OnMenuItemClickListener {
198 | @Override
199 | public boolean onMenuItemClick(MenuItem item) {
200 | ActivityChooserModel dataModel = ActivityChooserModel.get(context,
201 | shareHistoryFileName);
202 | final int itemId = item.getItemId();
203 | Intent launchIntent = dataModel.chooseActivity(itemId);
204 | if (launchIntent != null) {
205 | launchIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
206 | context.startActivity(launchIntent);
207 | }
208 | return true;
209 | }
210 | }
211 |
212 | /**
213 | * Set the activity chooser policy of the model backed by the current
214 | * share history file if needed which is if there is a registered callback.
215 | */
216 | private void setActivityChooserPolicyIfNeeded() {
217 | if (onShareListener == null) {
218 | return;
219 | }
220 | if (onChooseActivityListener == null) {
221 | onChooseActivityListener = new ShareActivityChooserModelPolicy();
222 | }
223 | ActivityChooserModel dataModel = ActivityChooserModel.get(context, shareHistoryFileName);
224 | dataModel.setOnChooseActivityListener(onChooseActivityListener);
225 | }
226 |
227 | private class ShareActivityChooserModelPolicy implements ActivityChooserModel.OnChooseActivityListener {
228 | @Override
229 | public boolean onChooseActivity(ActivityChooserModel host, Intent intent) {
230 |
231 | if (onShareListener != null) {
232 | SharePackageHelper.ApplicationType applicationType = new SharePackageHelper().getApplicationType(intent);
233 |
234 | if (applicationType == SharePackageHelper.ApplicationType.Twitter) {
235 | return onShareListener.shareWithTwitter(intent);
236 | } else if (applicationType == SharePackageHelper.ApplicationType.Facebook) {
237 | return onShareListener.shareWithFacebook(intent);
238 | } else if (applicationType == SharePackageHelper.ApplicationType.GooglePlus) {
239 | return onShareListener.shareWithGooglePlus(intent);
240 | } else if (applicationType == SharePackageHelper.ApplicationType.Email) {
241 | return onShareListener.shareWithEmail(intent);
242 | } else if (applicationType == SharePackageHelper.ApplicationType.Sms) {
243 | return onShareListener.shareWithSms(intent);
244 | } else {
245 | return onShareListener.shareWithOther(intent);
246 | }
247 | }
248 | return false;
249 | }
250 | }
251 |
252 | private OnShareListener onShareListener; //also need to add getter and setter
253 |
254 | public OnShareListener getOnShareListener() {
255 | return onShareListener;
256 | }
257 |
258 | public void setOnShareListener(OnShareListener onShareListener) {
259 | this.onShareListener = onShareListener;
260 | setActivityChooserPolicyIfNeeded();
261 | }
262 |
263 | }
264 |
--------------------------------------------------------------------------------
/yeti/src/main/java/me/kentin/yeti/view/ResolverDrawerLayout.java:
--------------------------------------------------------------------------------
1 | package me.kentin.yeti.view;
2 |
3 | /*
4 | * Copyright (C) 2014 The Android Open Source Project
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | import android.annotation.TargetApi;
20 | import android.content.Context;
21 | import android.content.res.TypedArray;
22 | import android.graphics.Rect;
23 | import android.os.Build;
24 | import android.os.Parcel;
25 | import android.os.Parcelable;
26 | import android.support.v4.view.ViewCompat;
27 | import android.support.v7.widget.RecyclerView;
28 | import android.util.AttributeSet;
29 | import android.util.Log;
30 | import android.view.MotionEvent;
31 | import android.view.VelocityTracker;
32 | import android.view.View;
33 | import android.view.ViewConfiguration;
34 | import android.view.ViewGroup;
35 | import android.view.ViewParent;
36 | import android.view.ViewTreeObserver;
37 | import android.view.animation.AnimationUtils;
38 | import android.widget.AbsListView;
39 | import android.widget.OverScroller;
40 |
41 | import me.kentin.yeti.R;
42 |
43 |
44 | public class ResolverDrawerLayout extends ViewGroup {
45 |
46 | private static final String TAG = "ResolverDrawerLayout";
47 |
48 | private static final String RECYCLERVIEW_CLASS_NAME = "android.support.v7.widget.RecyclerView";
49 |
50 | /**
51 | * Max width of the whole drawer layout
52 | */
53 | private int mMaxWidth;
54 |
55 | /**
56 | * Max total visible height of views not marked always-show when in the closed/initial state
57 | */
58 | private int mMaxCollapsedHeight;
59 |
60 | /**
61 | * Max total visible height of views not marked always-show when in the closed/initial state
62 | * when a default option is present
63 | */
64 | private int mMaxCollapsedHeightSmall;
65 |
66 | private boolean mSmallCollapsed;
67 |
68 | /**
69 | * Move views down from the top by this much in px
70 | */
71 | private float mCollapseOffset;
72 |
73 | private int mCollapsibleHeight;
74 |
75 | private int mTopOffset;
76 |
77 | private boolean mIsDragging;
78 |
79 | private boolean mOpenOnClick;
80 |
81 | private boolean mOpenOnLayout;
82 |
83 | private final int mTouchSlop;
84 |
85 | private final float mMinFlingVelocity;
86 |
87 | private final OverScroller mScroller;
88 |
89 | private final VelocityTracker mVelocityTracker;
90 |
91 | private OnClickListener mClickOutsideListener;
92 |
93 | private float mInitialTouchX;
94 |
95 | private float mInitialTouchY;
96 |
97 | private float mLastTouchY;
98 |
99 | private int mActivePointerId = MotionEvent.INVALID_POINTER_ID;
100 |
101 | private View mScrollableChildView;
102 |
103 | private final Rect mTempRect = new Rect();
104 |
105 | private final ViewTreeObserver.OnTouchModeChangeListener mTouchModeChangeListener =
106 | new ViewTreeObserver.OnTouchModeChangeListener() {
107 | @Override
108 | public void onTouchModeChanged(boolean isInTouchMode) {
109 | if (!isInTouchMode && hasFocus() && isDescendantClipped(getFocusedChild())) {
110 | smoothScrollTo(0, 0);
111 | }
112 | }
113 | };
114 |
115 | private boolean mIsLaidOut;
116 |
117 | public ResolverDrawerLayout(Context context) {
118 | this(context, null);
119 | }
120 |
121 | public ResolverDrawerLayout(Context context, AttributeSet attrs) {
122 | this(context, attrs, 0);
123 | }
124 |
125 | public ResolverDrawerLayout(Context context, AttributeSet attrs, int defStyleAttr) {
126 | super(context, attrs, defStyleAttr);
127 |
128 | final TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ResolverDrawerLayout,
129 | defStyleAttr, 0);
130 | mMaxWidth = a.getDimensionPixelSize(R.styleable.ResolverDrawerLayout_android_maxWidth, -1);
131 | mMaxCollapsedHeight = a.getDimensionPixelSize(
132 | R.styleable.ResolverDrawerLayout_maxCollapsedHeight, 0);
133 | mMaxCollapsedHeightSmall = a.getDimensionPixelSize(
134 | R.styleable.ResolverDrawerLayout_maxCollapsedHeightSmall,
135 | mMaxCollapsedHeight);
136 | a.recycle();
137 |
138 | mScroller = new OverScroller(context, AnimationUtils.loadInterpolator(context,
139 | android.R.interpolator.decelerate_quint));
140 | mVelocityTracker = VelocityTracker.obtain();
141 |
142 | final ViewConfiguration vc = ViewConfiguration.get(context);
143 | mTouchSlop = vc.getScaledTouchSlop();
144 | mMinFlingVelocity = vc.getScaledMinimumFlingVelocity();
145 | }
146 |
147 | public void setSmallCollapsed(boolean smallCollapsed) {
148 | mSmallCollapsed = smallCollapsed;
149 | requestLayout();
150 | }
151 |
152 | public boolean isSmallCollapsed() {
153 | return mSmallCollapsed;
154 | }
155 |
156 | public boolean isCollapsed() {
157 | return mCollapseOffset > 0;
158 | }
159 |
160 | private boolean isMoving() {
161 | return mIsDragging || !mScroller.isFinished();
162 | }
163 |
164 | private int getMaxCollapsedHeight() {
165 | return isSmallCollapsed() ? mMaxCollapsedHeightSmall : mMaxCollapsedHeight;
166 | }
167 |
168 | public void setOnClickOutsideListener(OnClickListener listener) {
169 | mClickOutsideListener = listener;
170 | }
171 |
172 | @Override
173 | public boolean onInterceptTouchEvent(MotionEvent ev) {
174 | final int action = ev.getActionMasked();
175 |
176 | if (canChildScrollUp()) {
177 | // Fail fast if we're not in a state where a swipe is possible
178 | return super.onInterceptTouchEvent(ev);
179 | }
180 |
181 | if (action == MotionEvent.ACTION_DOWN) {
182 | mVelocityTracker.clear();
183 | }
184 |
185 | mVelocityTracker.addMovement(ev);
186 |
187 | switch (action) {
188 | case MotionEvent.ACTION_DOWN: {
189 | final float x = ev.getX();
190 | final float y = ev.getY();
191 | mInitialTouchX = x;
192 | mInitialTouchY = mLastTouchY = y;
193 | mOpenOnClick = isListChildUnderClipped(x, y) && mCollapsibleHeight > 0;
194 | }
195 | break;
196 |
197 | case MotionEvent.ACTION_MOVE: {
198 | final float x = ev.getX();
199 | final float y = ev.getY();
200 | final float dy = y - mInitialTouchY;
201 | boolean isSlidingUp = Math.abs(dy) > mTouchSlop
202 | && findChildUnder(x, y) != null
203 | && mCollapseOffset > 0;
204 | boolean isSlidingDown = mCollapseOffset == 0 && dy > mTouchSlop;
205 | if (isSlidingUp || isSlidingDown) {
206 | mActivePointerId = ev.getPointerId(0);
207 | mIsDragging = true;
208 | mLastTouchY = Math.max(mLastTouchY - mTouchSlop,
209 | Math.min(mLastTouchY + dy, mLastTouchY + mTouchSlop));
210 | }
211 | }
212 | break;
213 |
214 | case MotionEvent.ACTION_POINTER_UP: {
215 | onSecondaryPointerUp(ev);
216 | }
217 | break;
218 |
219 | case MotionEvent.ACTION_CANCEL:
220 | case MotionEvent.ACTION_UP: {
221 | resetTouch();
222 | }
223 | break;
224 | }
225 |
226 | if (mIsDragging) {
227 | mScroller.abortAnimation();
228 | }
229 | return mIsDragging || mOpenOnClick;
230 | }
231 |
232 | @Override
233 | public boolean onTouchEvent(MotionEvent ev) {
234 | final int action = ev.getActionMasked();
235 |
236 | if (canChildScrollUp()) {
237 | // Fail fast if we're not in a state where a swipe is possible
238 | return super.onTouchEvent(ev);
239 | }
240 |
241 | mVelocityTracker.addMovement(ev);
242 |
243 | boolean handled = false;
244 | switch (action) {
245 | case MotionEvent.ACTION_DOWN: {
246 | final float x = ev.getX();
247 | final float y = ev.getY();
248 | mInitialTouchX = x;
249 | mInitialTouchY = mLastTouchY = y;
250 | mActivePointerId = ev.getPointerId(0);
251 | if (findChildUnder(mInitialTouchX, mInitialTouchY) == null &&
252 | mClickOutsideListener != null) {
253 | mIsDragging = handled = true;
254 | }
255 | handled |= mCollapsibleHeight > 0;
256 | mScroller.abortAnimation();
257 | }
258 | break;
259 |
260 | case MotionEvent.ACTION_MOVE: {
261 | int index = ev.findPointerIndex(mActivePointerId);
262 | if (index < 0) {
263 | Log.e(TAG, "Bad pointer id " + mActivePointerId + ", resetting");
264 | index = 0;
265 | mActivePointerId = ev.getPointerId(0);
266 | mInitialTouchX = ev.getX();
267 | mInitialTouchY = mLastTouchY = ev.getY();
268 | }
269 | final float x = ev.getX(index);
270 | final float y = ev.getY(index);
271 | if (!mIsDragging) {
272 | final float dy = y - mInitialTouchY;
273 | if (Math.abs(dy) > mTouchSlop && findChildUnder(x, y) != null) {
274 | handled = mIsDragging = true;
275 | mLastTouchY = Math.max(mLastTouchY - mTouchSlop,
276 | Math.min(mLastTouchY + dy, mLastTouchY + mTouchSlop));
277 | }
278 | }
279 | if (mIsDragging) {
280 | final float dy = y - mLastTouchY;
281 | performDrag(dy);
282 | }
283 | mLastTouchY = y;
284 | }
285 | break;
286 |
287 | case MotionEvent.ACTION_POINTER_DOWN: {
288 | final int pointerIndex = ev.getActionIndex();
289 | final int pointerId = ev.getPointerId(pointerIndex);
290 | mActivePointerId = pointerId;
291 | mInitialTouchX = ev.getX(pointerIndex);
292 | mInitialTouchY = mLastTouchY = ev.getY(pointerIndex);
293 | }
294 | break;
295 |
296 | case MotionEvent.ACTION_POINTER_UP: {
297 | onSecondaryPointerUp(ev);
298 | }
299 | break;
300 |
301 | case MotionEvent.ACTION_UP: {
302 | mIsDragging = false;
303 | if (!mIsDragging && findChildUnder(mInitialTouchX, mInitialTouchY) == null &&
304 | findChildUnder(ev.getX(), ev.getY()) == null) {
305 | if (mClickOutsideListener != null) {
306 | mClickOutsideListener.onClick(this);
307 | resetTouch();
308 | return true;
309 | }
310 | }
311 | if (mOpenOnClick && Math.abs(ev.getX() - mInitialTouchX) < mTouchSlop &&
312 | Math.abs(ev.getY() - mInitialTouchY) < mTouchSlop) {
313 | smoothScrollTo(0, 0);
314 | return true;
315 | }
316 | mVelocityTracker.computeCurrentVelocity(1000);
317 | final float yvel = mVelocityTracker.getYVelocity(mActivePointerId);
318 | if (Math.abs(yvel) > mMinFlingVelocity) {
319 | smoothScrollTo(yvel < 0 ? 0 : mCollapsibleHeight, yvel);
320 | } else {
321 | smoothScrollTo(
322 | mCollapseOffset < mCollapsibleHeight / 2 ? 0 : mCollapsibleHeight, 0);
323 | }
324 | resetTouch();
325 | }
326 | break;
327 |
328 | case MotionEvent.ACTION_CANCEL: {
329 | if (mIsDragging) {
330 | smoothScrollTo(
331 | mCollapseOffset < mCollapsibleHeight / 2 ? 0 : mCollapsibleHeight, 0);
332 | }
333 | resetTouch();
334 | return true;
335 | }
336 | }
337 |
338 | return handled
339 | || (action == MotionEvent.ACTION_MOVE && mCollapseOffset > 0);
340 | }
341 |
342 | private void onSecondaryPointerUp(MotionEvent ev) {
343 | final int pointerIndex = ev.getActionIndex();
344 | final int pointerId = ev.getPointerId(pointerIndex);
345 | if (pointerId == mActivePointerId) {
346 | // This was our active pointer going up. Choose a new
347 | // active pointer and adjust accordingly.
348 | final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
349 | mInitialTouchX = ev.getX(newPointerIndex);
350 | mInitialTouchY = mLastTouchY = ev.getY(newPointerIndex);
351 | mActivePointerId = ev.getPointerId(newPointerIndex);
352 | }
353 | }
354 |
355 | private void resetTouch() {
356 | mActivePointerId = MotionEvent.INVALID_POINTER_ID;
357 | mIsDragging = false;
358 | mOpenOnClick = false;
359 | mInitialTouchX = mInitialTouchY = mLastTouchY = 0;
360 | mVelocityTracker.clear();
361 | }
362 |
363 | @Override
364 | public void computeScroll() {
365 | super.computeScroll();
366 | if (!mScroller.isFinished()) {
367 | final boolean keepGoing = mScroller.computeScrollOffset();
368 | performDrag(mScroller.getCurrY() - mCollapseOffset);
369 | if (keepGoing) {
370 | ViewCompat.postInvalidateOnAnimation(this);
371 | }
372 | }
373 | }
374 |
375 | private float performDrag(float dy) {
376 | final float newPos = Math.max(0, Math.min(mCollapseOffset + dy, mCollapsibleHeight));
377 | if (newPos != mCollapseOffset) {
378 | dy = newPos - mCollapseOffset;
379 | final int childCount = getChildCount();
380 | for (int i = 0; i < childCount; i++) {
381 | final View child = getChildAt(i);
382 | final LayoutParams lp = (LayoutParams) child.getLayoutParams();
383 | if (!lp.ignoreOffset) {
384 | child.offsetTopAndBottom((int) dy);
385 | }
386 | }
387 | mCollapseOffset = newPos;
388 | mTopOffset += dy;
389 | ViewCompat.postInvalidateOnAnimation(this);
390 | return dy;
391 | }
392 | return 0;
393 | }
394 |
395 | private void smoothScrollTo(int yOffset, float velocity) {
396 | if (getMaxCollapsedHeight() == 0) {
397 | return;
398 | }
399 | mScroller.abortAnimation();
400 | final int sy = (int) mCollapseOffset;
401 | int dy = yOffset - sy;
402 | if (dy == 0) {
403 | return;
404 | }
405 |
406 | final int height = getHeight();
407 | final int halfHeight = height / 2;
408 | final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dy) / height);
409 | final float distance = halfHeight + halfHeight *
410 | distanceInfluenceForSnapDuration(distanceRatio);
411 |
412 | int duration = 0;
413 | velocity = Math.abs(velocity);
414 | if (velocity > 0) {
415 | duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
416 | } else {
417 | final float pageDelta = (float) Math.abs(dy) / height;
418 | duration = (int) ((pageDelta + 1) * 100);
419 | }
420 | duration = Math.min(duration, 300);
421 |
422 | mScroller.startScroll(0, sy, 0, dy, duration);
423 | ViewCompat.postInvalidateOnAnimation(this);
424 | }
425 |
426 | private float distanceInfluenceForSnapDuration(float f) {
427 | f -= 0.5f; // center the values about 0.
428 | f *= 0.3f * Math.PI / 2.0f;
429 | return (float) Math.sin(f);
430 | }
431 |
432 | /**
433 | * Note: this method doesn't take Z into account for overlapping views
434 | * since it is only used in contexts where this doesn't affect the outcome.
435 | */
436 | private View findChildUnder(float x, float y) {
437 | return findChildUnder(this, x, y);
438 | }
439 |
440 | private static View findChildUnder(ViewGroup parent, float x, float y) {
441 | final int childCount = parent.getChildCount();
442 | for (int i = childCount - 1; i >= 0; i--) {
443 | final View child = parent.getChildAt(i);
444 | if (isChildUnder(child, x, y)) {
445 | return child;
446 | }
447 | }
448 | return null;
449 | }
450 |
451 | private View findListChildUnder(float x, float y) {
452 | View v = findChildUnder(x, y);
453 | while (v != null) {
454 | x -= v.getX();
455 | y -= v.getY();
456 | if (v instanceof AbsListView
457 | || RECYCLERVIEW_CLASS_NAME.equals(v.getClass().getName())) {
458 | // One more after this.
459 | return findChildUnder((ViewGroup) v, x, y);
460 | }
461 | v = v instanceof ViewGroup ? findChildUnder((ViewGroup) v, x, y) : null;
462 | }
463 | return v;
464 | }
465 |
466 | /**
467 | * This only checks clipping along the bottom edge.
468 | */
469 | private boolean isListChildUnderClipped(float x, float y) {
470 | final View listChild = findListChildUnder(x, y);
471 | return listChild != null && isDescendantClipped(listChild);
472 | }
473 |
474 | private boolean isDescendantClipped(View child) {
475 | mTempRect.set(0, 0, child.getWidth(), child.getHeight());
476 | offsetDescendantRectToMyCoords(child, mTempRect);
477 | View directChild;
478 | if (child.getParent() == this) {
479 | directChild = child;
480 | } else {
481 | View v = child;
482 | ViewParent p = child.getParent();
483 | while (p != this) {
484 | v = (View) p;
485 | p = v.getParent();
486 | }
487 | directChild = v;
488 | }
489 |
490 | // ResolverDrawerLayout lays out vertically in child order;
491 | // the next view and forward is what to check against.
492 | int clipEdge = getHeight() - getPaddingBottom();
493 | final int childCount = getChildCount();
494 | for (int i = indexOfChild(directChild) + 1; i < childCount; i++) {
495 | final View nextChild = getChildAt(i);
496 | if (nextChild.getVisibility() == GONE) {
497 | continue;
498 | }
499 | clipEdge = Math.min(clipEdge, nextChild.getTop());
500 | }
501 | return mTempRect.bottom > clipEdge;
502 | }
503 |
504 | private static boolean isChildUnder(View child, float x, float y) {
505 | final float left = child.getX();
506 | final float top = child.getY();
507 | final float right = left + child.getWidth();
508 | final float bottom = top + child.getHeight();
509 | return x >= left && y >= top && x < right && y < bottom;
510 | }
511 |
512 | @Override
513 | public void requestChildFocus(View child, View focused) {
514 | super.requestChildFocus(child, focused);
515 | if (!isInTouchMode() && isDescendantClipped(focused)) {
516 | smoothScrollTo(0, 0);
517 | }
518 | }
519 |
520 | @Override
521 | protected void onAttachedToWindow() {
522 | super.onAttachedToWindow();
523 | getViewTreeObserver().addOnTouchModeChangeListener(mTouchModeChangeListener);
524 | }
525 |
526 | @Override
527 | protected void onDetachedFromWindow() {
528 | super.onDetachedFromWindow();
529 | getViewTreeObserver().removeOnTouchModeChangeListener(mTouchModeChangeListener);
530 | }
531 |
532 | @Override
533 | public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
534 | return (nestedScrollAxes & View.SCROLL_AXIS_VERTICAL) != 0;
535 | }
536 |
537 | @Override
538 | @TargetApi(Build.VERSION_CODES.LOLLIPOP)
539 | public void onStopNestedScroll(View child) {
540 | super.onStopNestedScroll(child);
541 | if (mScroller.isFinished()) {
542 | smoothScrollTo(mCollapseOffset < mCollapsibleHeight / 2 ? 0 : mCollapsibleHeight, 0);
543 | }
544 | }
545 |
546 | @Override
547 | public void onNestedScroll(View target, int dxConsumed, int dyConsumed,
548 | int dxUnconsumed, int dyUnconsumed) {
549 | if (dyUnconsumed < 0) {
550 | performDrag(-dyUnconsumed);
551 | }
552 | }
553 |
554 | @Override
555 | public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
556 | if (dy > 0) {
557 | consumed[1] = (int) -performDrag(-dy);
558 | }
559 | }
560 |
561 | @Override
562 | public boolean onNestedPreFling(View target, float velocityX, float velocityY) {
563 | if (velocityY > mMinFlingVelocity && mCollapseOffset != 0) {
564 | smoothScrollTo(0, velocityY);
565 | return true;
566 | }
567 | return false;
568 | }
569 |
570 | @Override
571 | public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {
572 | if (!consumed && Math.abs(velocityY) > mMinFlingVelocity) {
573 | smoothScrollTo(velocityY > 0 ? 0 : mCollapsibleHeight, velocityY);
574 | return true;
575 | }
576 | return false;
577 | }
578 |
579 | @Override
580 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
581 | final int sourceWidth = MeasureSpec.getSize(widthMeasureSpec);
582 | int widthSize = sourceWidth;
583 | int heightSize = MeasureSpec.getSize(heightMeasureSpec);
584 |
585 | // Single-use layout; just ignore the mode and use available space.
586 | // Clamp to maxWidth.
587 | if (mMaxWidth >= 0) {
588 | widthSize = Math.min(widthSize, mMaxWidth);
589 | }
590 |
591 | final int widthSpec = MeasureSpec.makeMeasureSpec(widthSize, MeasureSpec.EXACTLY);
592 | final int heightSpec = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.EXACTLY);
593 | final int widthPadding = getPaddingLeft() + getPaddingRight();
594 | int heightUsed = getPaddingTop() + getPaddingBottom();
595 |
596 | // Measure always-show children first.
597 | final int childCount = getChildCount();
598 | for (int i = 0; i < childCount; i++) {
599 | final View child = getChildAt(i);
600 | final LayoutParams lp = (LayoutParams) child.getLayoutParams();
601 | if (lp.alwaysShow && child.getVisibility() != GONE) {
602 | measureChildWithMargins(child, widthSpec, widthPadding, heightSpec, heightUsed);
603 | heightUsed += lp.topMargin + child.getMeasuredHeight() + lp.bottomMargin;
604 | }
605 | }
606 |
607 | final int alwaysShowHeight = heightUsed;
608 |
609 | // And now the rest.
610 | for (int i = 0; i < childCount; i++) {
611 | final View child = getChildAt(i);
612 | final LayoutParams lp = (LayoutParams) child.getLayoutParams();
613 | if (!lp.alwaysShow && child.getVisibility() != GONE) {
614 | measureChildWithMargins(child, widthSpec, widthPadding, heightSpec, heightUsed);
615 | heightUsed += lp.topMargin + child.getMeasuredHeight() + lp.bottomMargin;
616 | }
617 | }
618 |
619 | mCollapsibleHeight = Math.max(0,
620 | heightUsed - alwaysShowHeight - getMaxCollapsedHeight());
621 |
622 | if (mIsLaidOut) {
623 | mCollapseOffset = Math.min(mCollapseOffset, mCollapsibleHeight);
624 | } else {
625 | // Start out collapsed at first unless we restored state for otherwise
626 | mCollapseOffset = mOpenOnLayout ? 0 : mCollapsibleHeight;
627 | }
628 |
629 | mTopOffset = Math.max(0, heightSize - heightUsed) + (int) mCollapseOffset;
630 |
631 | setMeasuredDimension(sourceWidth, heightSize);
632 | }
633 |
634 | @Override
635 | protected void onLayout(boolean changed, int l, int t, int r, int b) {
636 | final int width = getWidth();
637 |
638 | int ypos = mTopOffset;
639 | int leftEdge = getPaddingLeft();
640 | int rightEdge = width - getPaddingRight();
641 |
642 | final int childCount = getChildCount();
643 | for (int i = 0; i < childCount; i++) {
644 | final View child = getChildAt(i);
645 | final LayoutParams lp = (LayoutParams) child.getLayoutParams();
646 |
647 | if (child.getVisibility() == GONE) {
648 | continue;
649 | }
650 |
651 | int top = ypos + lp.topMargin;
652 | if (lp.ignoreOffset) {
653 | top -= mCollapseOffset;
654 | }
655 | final int bottom = top + child.getMeasuredHeight();
656 |
657 | final int childWidth = child.getMeasuredWidth();
658 | final int widthAvailable = rightEdge - leftEdge;
659 | final int left = leftEdge + (widthAvailable - childWidth) / 2;
660 | final int right = left + childWidth;
661 |
662 | child.layout(left, top, right, bottom);
663 |
664 | ypos = bottom + lp.bottomMargin;
665 | }
666 |
667 | mIsLaidOut = true;
668 | }
669 |
670 | @Override
671 | public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
672 | return new LayoutParams(getContext(), attrs);
673 | }
674 |
675 | @Override
676 | protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
677 | if (p instanceof LayoutParams) {
678 | return new LayoutParams((LayoutParams) p);
679 | } else if (p instanceof MarginLayoutParams) {
680 | return new LayoutParams((MarginLayoutParams) p);
681 | }
682 | return new LayoutParams(p);
683 | }
684 |
685 | @Override
686 | protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
687 | return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
688 | }
689 |
690 | @Override
691 | protected Parcelable onSaveInstanceState() {
692 | final SavedState ss = new SavedState(super.onSaveInstanceState());
693 | ss.open = mCollapsibleHeight > 0 && mCollapseOffset == 0;
694 | return ss;
695 | }
696 |
697 | @Override
698 | protected void onRestoreInstanceState(Parcelable state) {
699 | final SavedState ss = (SavedState) state;
700 | super.onRestoreInstanceState(ss.getSuperState());
701 | mOpenOnLayout = ss.open;
702 | }
703 |
704 | public boolean canChildScrollUp() {
705 | if (mScrollableChildView != null) {
706 | if (android.os.Build.VERSION.SDK_INT < 14) {
707 | if (mScrollableChildView instanceof AbsListView) {
708 | final AbsListView absListView = (AbsListView) mScrollableChildView;
709 | return absListView.getChildCount() > 0
710 | && (absListView.getFirstVisiblePosition() > 0
711 | || absListView.getChildAt(0)
712 | .getTop() < absListView.getPaddingTop());
713 | } else if (
714 | RECYCLERVIEW_CLASS_NAME.equals(mScrollableChildView.getClass().getName())) {
715 | final RecyclerView recyclerView = (RecyclerView) mScrollableChildView;
716 | View firstView = recyclerView.getChildAt(0);
717 | return recyclerView.getChildCount() > 0
718 | && (recyclerView.getLayoutManager().getPosition(firstView) > 0
719 | || recyclerView.getChildAt(0).getTop() < recyclerView.getPaddingTop());
720 | } else {
721 | return mScrollableChildView.getScrollY() > 0;
722 | }
723 | } else {
724 | return ViewCompat.canScrollVertically(mScrollableChildView, -1);
725 | }
726 | }
727 | return false;
728 | }
729 |
730 | public void setScrollableChildView(View scrollableChildView) {
731 | mScrollableChildView = scrollableChildView;
732 | }
733 |
734 | public static class LayoutParams extends MarginLayoutParams {
735 |
736 | public boolean alwaysShow;
737 |
738 | public boolean ignoreOffset;
739 |
740 | public LayoutParams(Context c, AttributeSet attrs) {
741 | super(c, attrs);
742 |
743 | final TypedArray a = c.obtainStyledAttributes(attrs,
744 | R.styleable.ResolverDrawerLayout_LayoutParams);
745 | alwaysShow = a.getBoolean(
746 | R.styleable.ResolverDrawerLayout_LayoutParams_layout_alwaysShow,
747 | false);
748 | ignoreOffset = a.getBoolean(
749 | R.styleable.ResolverDrawerLayout_LayoutParams_layout_ignoreOffset,
750 | false);
751 | a.recycle();
752 | }
753 |
754 | public LayoutParams(int width, int height) {
755 | super(width, height);
756 | }
757 |
758 | public LayoutParams(LayoutParams source) {
759 | super(source);
760 | this.alwaysShow = source.alwaysShow;
761 | this.ignoreOffset = source.ignoreOffset;
762 | }
763 |
764 | public LayoutParams(MarginLayoutParams source) {
765 | super(source);
766 | }
767 |
768 | public LayoutParams(ViewGroup.LayoutParams source) {
769 | super(source);
770 | }
771 | }
772 |
773 | static class SavedState extends BaseSavedState {
774 |
775 | boolean open;
776 |
777 | SavedState(Parcelable superState) {
778 | super(superState);
779 | }
780 |
781 | private SavedState(Parcel in) {
782 | super(in);
783 | open = in.readInt() != 0;
784 | }
785 |
786 | @Override
787 | public void writeToParcel(Parcel out, int flags) {
788 | super.writeToParcel(out, flags);
789 | out.writeInt(open ? 1 : 0);
790 | }
791 |
792 | public static final Parcelable.Creator CREATOR =
793 | new Parcelable.Creator() {
794 | @Override
795 | public SavedState createFromParcel(Parcel in) {
796 | return new SavedState(in);
797 | }
798 |
799 | @Override
800 | public SavedState[] newArray(int size) {
801 | return new SavedState[size];
802 | }
803 | };
804 | }
805 | }
--------------------------------------------------------------------------------