Java tutorial
/* * Copyright 2015. Appsi Mobile * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.appsimobile.appsii; import android.content.Context; import android.content.SharedPreferences; import android.database.ContentObserver; import android.database.Cursor; import android.graphics.drawable.Drawable; import android.net.Uri; import android.os.AsyncTask; import android.os.Handler; import android.os.Message; import android.os.Vibrator; import android.support.v4.util.CircularArray; import android.util.AttributeSet; import android.util.Log; import android.view.GestureDetector; import android.view.MotionEvent; import android.view.VelocityTracker; import android.view.View; import com.appsimobile.appsii.dagger.AppInjector; import com.appsimobile.appsii.module.home.provider.HomeContract; import com.appsimobile.util.ArrayUtils; import java.lang.ref.WeakReference; import javax.inject.Inject; public class SidebarHotspot extends View { public static final int VIBRATE_DURATION = 20; static final int STATE_AWAITING_RELEASE = 3; private static final int STATE_WAITING = 0; private static final int STATE_GESTURE_IN_PROGRESS = 2; private static final int SIDEBAR_MINIMUM_MOVE = 0; final CircularArray<HotspotPageEntry> mHotspotPageEntries = new CircularArray<>(8); final Handler mHandler = new Handler(); int mState = STATE_WAITING; boolean mSwipeInProgress; SidebarGestureCallback mCallback; boolean mIsDragOpening; float mStartX; float mStartY; float mRawStartY; SwipeListener mSwipeListener; ContentObserver mHotspotsPagesObserver; AsyncTask<Void, Void, CircularArray<HotspotPageEntry>> mLoadDataTask; /** * A shared preferences listener */ SharedPreferencesListener mSharedPreferencesListener; @Inject Vibrator mVibrator; @Inject SharedPreferences mPreferences; private float mMinimumMove; private boolean mVibrate; private boolean mLeft; private int mTop; private int mLeftPos; private boolean mVisibleHotspots; /** * The hotspot-item this hotspot is bound to. * This contains the properties of the hotspot. */ private HotspotItem mHotspotItem; /** * A velocity tracked given to the listeners so they can determine the speed if needed */ private VelocityTracker mVelocityTracker; /** * The current background drawable */ private Drawable mBackground; public SidebarHotspot(Context context) { super(context); } public SidebarHotspot(Context context, AttributeSet attrs) { super(context, attrs); } public SidebarHotspot(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public static Gesture detectAction(float deltaX, float deltaY, float minDistance) { Gesture swipeAction = null; if (deltaX >= minDistance) { swipeAction = Gesture.TO_CENTER; } else if (deltaY > minDistance) { swipeAction = Gesture.DOWN; } else if (deltaY < -minDistance) { swipeAction = Gesture.UP; } return swipeAction; } @Override public boolean onTouchEvent(MotionEvent e) { switch (e.getAction()) { case MotionEvent.ACTION_DOWN: { mVelocityTracker = VelocityTracker.obtain(); mVelocityTracker.addMovement(e); // remove the background to make sure it does not overlap // the sidebar mIsDragOpening = true; setBackgroundResource(0); float x = e.getX(); float y = e.getY(); if (mCallback != null) { mSwipeListener = mCallback.open(this, Gesture.TO_CENTER, (int) x, (int) y); mSwipeInProgress = mSwipeListener != null; mState = STATE_AWAITING_RELEASE; if (mVibrate) { vibrate(); } return true; } return false; } case MotionEvent.ACTION_MOVE: mVelocityTracker.addMovement(e); float x = e.getX(); float y = e.getY(); return detectSwipe(x, y, e); case MotionEvent.ACTION_UP: case MotionEvent.ACTION_CANCEL: cancelMotionHandling(e, false); return false; } return super.onTouchEvent(e); } private void vibrate() { mVibrator.vibrate(VIBRATE_DURATION); } private boolean detectSwipe(float x, float y, MotionEvent e) { if (mState == STATE_AWAITING_RELEASE && mSwipeInProgress) { if (mCallback != null) { mSwipeListener.setSwipeLocation(this, (int) e.getX(), (int) e.getY(), (int) e.getRawX(), (int) e.getRawY()); } return true; } if (mState != STATE_GESTURE_IN_PROGRESS) return false; float deltaX = Math.abs(x - mStartX); float deltaY = y - mStartY; Gesture action = detectAction(deltaX, deltaY, mMinimumMove); if (action != null) { mSwipeListener = mCallback.open(this, action, (int) x, (int) y); mSwipeInProgress = mSwipeListener != null; mState = STATE_AWAITING_RELEASE; return true; } return true; } private void cancelMotionHandling(MotionEvent e, boolean cancelled) { mState = STATE_WAITING; if (mSwipeListener != null) { if (e == null) { mSwipeListener.onSwipeEnd(this, 0, 0, cancelled, mVelocityTracker); } else { mSwipeListener.onSwipeEnd(this, (int) e.getRawX(), (int) e.getRawY(), cancelled, mVelocityTracker); } } if (mCallback != null) { mCallback.cancelVisualHints(this); } mSwipeInProgress = false; mSwipeListener = null; // restore the background setBackground(mBackground); mIsDragOpening = false; if (mCallback != null) { mCallback.removeIfNeeded(this); } invalidate(); mVelocityTracker.addMovement(e); mVelocityTracker.recycle(); mVelocityTracker = null; } @Override protected void onAttachedToWindow() { super.onAttachedToWindow(); mSwipeInProgress = false; if (mHotspotsPagesObserver == null) { mHotspotsPagesObserver = new ContentObserver(mHandler) { @Override public void onChange(boolean selfChange) { onChange(selfChange, null); } @Override public void onChange(boolean selfChange, Uri uri) { reloadHotspotData(); } }; getContext().getContentResolver().registerContentObserver(HomeContract.HotspotPages.CONTENT_URI, true, mHotspotsPagesObserver); } setupBackground(); } void reloadHotspotData() { Log.d("SidebarHotspot", "reloading hotspots"); if (mHotspotItem == null) return; final long hotspotId = mHotspotItem.mId; final Context context = getContext(); if (mLoadDataTask != null) mLoadDataTask.cancel(true); mLoadDataTask = new AsyncTask<Void, Void, CircularArray<HotspotPageEntry>>() { @Override protected CircularArray<HotspotPageEntry> doInBackground(Void... params) { Cursor c = context.getContentResolver().query(HotspotPagesQuery.createUri(hotspotId), HotspotPagesQuery.PROJECTION, null, null, HomeContract.HotspotDetails.POSITION + " ASC"); CircularArray<HotspotPageEntry> result = new CircularArray<>(c.getCount()); while (c.moveToNext()) { HotspotPageEntry entry = new HotspotPageEntry(); entry.mEnabled = c.getInt(HotspotPagesQuery.ENABLED) == 1; entry.mPageId = c.getLong(HotspotPagesQuery.PAGE_ID); entry.mHotspotId = c.getLong(HotspotPagesQuery.HOTSPOT_ID); entry.mPageName = c.getString(HotspotPagesQuery.PAGE_NAME); entry.mHotspotName = c.getString(HotspotPagesQuery.HOTSPOT_NAME); entry.mPosition = c.getInt(HotspotPagesQuery.POSITION); entry.mPageType = c.getInt(HotspotPagesQuery.PAGE_TYPE); result.addLast(entry); } c.close(); return result; } @Override protected void onPostExecute(CircularArray<HotspotPageEntry> hotspotPageEntries) { onHotspotEntriesLoaded(hotspotPageEntries); } }; mLoadDataTask.execute(); } private void setupBackground() { Drawable bg; if (mHotspotItem == null || !mVisibleHotspots) { mBackground = null; setBackground(null); return; } if (mHotspotItem.mLeft) { bg = getResources().getDrawable(R.drawable.floating_navigation_drawer_handle).mutate(); } else { bg = getResources().getDrawable(R.drawable.floating_navigation_drawer_handle_right).mutate(); } mBackground = bg; setBackground(bg); } void onHotspotEntriesLoaded(CircularArray<HotspotPageEntry> hotspotPageEntries) { mHotspotPageEntries.clear(); ArrayUtils.addAll(mHotspotPageEntries, hotspotPageEntries); } @Override protected void onDetachedFromWindow() { super.onDetachedFromWindow(); if (mHotspotsPagesObserver != null) { getContext().getContentResolver().unregisterContentObserver(mHotspotsPagesObserver); mHotspotsPagesObserver = null; } if (mLoadDataTask != null) { mLoadDataTask.cancel(true); } } @Override protected void onFinishInflate() { super.onFinishInflate(); init(getContext()); } void init(Context context) { AppInjector.inject(this); float scale = AppsiApplication.getDensity(context); mMinimumMove = scale * SIDEBAR_MINIMUM_MOVE; SharedPreferences sharedPreferences = mPreferences; mVisibleHotspots = !sharedPreferences.getBoolean("pref_hide_hotspots", false); mSharedPreferencesListener = new SharedPreferencesListener(this); sharedPreferences.registerOnSharedPreferenceChangeListener(mSharedPreferencesListener); setClickable(true); setupBackground(); } public CircularArray<HotspotPageEntry> getHotspotPageEntries() { return mHotspotPageEntries; } public void setVibrateOnTouch(boolean vibrate) { mVibrate = vibrate; } public void setCallback(SidebarGestureCallback callback) { mCallback = callback; } public void setPosition(boolean left, int x, int y) { mLeft = left; mTop = y; mLeftPos = x; } public boolean isLeft() { return mLeft; } public int getHPos() { return mLeftPos; } public int getVPos() { return mTop; } void setVisibleHotspotsEnabled(boolean visibleHotspotsEnabled) { mVisibleHotspots = visibleHotspotsEnabled; setupBackground(); invalidate(); } void bind(HotspotItem hotspotItem) { mHotspotItem = hotspotItem; setupBackground(); reloadHotspotData(); } long getHotspotId() { return mHotspotItem.mId; } public HotspotItem getConfiguration() { return mHotspotItem; } public enum Gesture { UP, DOWN, TO_CENTER, TAP, DOUBLE_TAP, LONG_PRESS, } public interface SidebarGestureCallback { /** * Show the swyper * * @return true if the swyper was added and the gesture must be tracked to it's end */ SwipeListener open(SidebarHotspot hotspot, Gesture action, int x, int y); void cancelVisualHints(SidebarHotspot sidebarHotspot); SwipeListener longPressGesturePerformed(SidebarHotspot hotspot, int localX, int localY, int rawStartY); void removeIfNeeded(SidebarHotspot hotspot); } public interface SwipeListener { /** * Update the location of the swype with the raw x and y coordinates */ void setSwipeLocation(SidebarHotspot hotspot, int localX, int localY, int screenX, int screenY); /** * @param hotspot * @param screenX * @param screenY */ void onSwipeEnd(SidebarHotspot hotspot, int screenX, int screenY, boolean cancelled, VelocityTracker velocityTracker); } static class TapGestureDetector implements Handler.Callback { static final int mMinMovePx = 40; static final int WHAT_TAP_EVENT = 1; final int mMinMoveDip; final GestureDetector.OnDoubleTapListener mOnDoubleTapListener; final Handler mHandler; boolean mCouldBeTap; int mStartX; int mStartY; long mLastTapMillis = -1; int mLastTapX = -1; int mLastTapY = -1; TapGestureDetector(Context context, GestureDetector.OnDoubleTapListener doubleTapListener) { mMinMoveDip = (int) (mMinMovePx * context.getResources().getDisplayMetrics().density); mOnDoubleTapListener = doubleTapListener; mHandler = new Handler(this); } public boolean onTouchEvent(MotionEvent e) { switch (e.getAction()) { case MotionEvent.ACTION_DOWN: mCouldBeTap = true; mStartX = (int) e.getX(); mStartY = (int) e.getY(); break; case MotionEvent.ACTION_MOVE: if (!mCouldBeTap) break; int x = (int) e.getX(); int y = (int) e.getY(); int deltaX = Math.abs(x - mStartX); int deltaY = Math.abs(y - mStartY); if (deltaX > mMinMoveDip || deltaY > mMinMoveDip) { mCouldBeTap = false; } break; case MotionEvent.ACTION_CANCEL: mCouldBeTap = false; mLastTapMillis = -1; break; case MotionEvent.ACTION_UP: if (mCouldBeTap) { int tapX = (int) e.getX(); int tapY = (int) e.getY(); return onTapEvent(tapX, tapY, e); } break; } return false; } private boolean onTapEvent(int x, int y, MotionEvent event) { cancelWatchForSigleTap(); long time = System.currentTimeMillis(); long tapDelta = Math.abs(mLastTapMillis - time); if (tapDelta > 50 && tapDelta < 300) { int deltaX = Math.abs(x - mLastTapX); int deltaY = Math.abs(y - mLastTapY); if (deltaX <= mMinMoveDip && deltaY <= mMinMoveDip) { mOnDoubleTapListener.onDoubleTap(event); mLastTapMillis = -1; return true; } } startWatchForSingleTap(x, y, event); mLastTapMillis = time; mLastTapX = x; mLastTapY = y; return false; } private void cancelWatchForSigleTap() { mHandler.removeMessages(WHAT_TAP_EVENT); } private void startWatchForSingleTap(int x, int y, MotionEvent event) { Message message = mHandler.obtainMessage(WHAT_TAP_EVENT, x, y, event); mHandler.sendMessageDelayed(message, 100); } @Override public boolean handleMessage(Message msg) { switch (msg.what) { case WHAT_TAP_EVENT: int x = msg.arg1; int y = msg.arg2; MotionEvent event = (MotionEvent) msg.obj; handleSigleTap(x, y, event); break; } return false; } private void handleSigleTap(int x, int y, MotionEvent event) { mOnDoubleTapListener.onSingleTapConfirmed(event); } } static class SharedPreferencesListener implements SharedPreferences.OnSharedPreferenceChangeListener { private final WeakReference<SidebarHotspot> mSidebarHotspot; SharedPreferencesListener(SidebarHotspot sidebarHotspot) { mSidebarHotspot = new WeakReference<>(sidebarHotspot); } @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { SidebarHotspot hotspot = mSidebarHotspot.get(); if (hotspot == null) { sharedPreferences.unregisterOnSharedPreferenceChangeListener(this); return; } if (key.equals("pref_hide_hotspots")) { boolean prefHideHotspots = sharedPreferences.getBoolean("pref_hide_hotspots", false); hotspot.setVisibleHotspotsEnabled(!prefHideHotspots); } } } }