Feature/androidx

build.gradle

@@ -2,23 +2,21 @@
 
 buildscript {
     repositories {
+        google()
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.0.0-alpha4'
-
-        // For Bintray publishing
-        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.2'
-        classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5'
+        classpath 'com.android.tools.build:gradle:3.2.1'
     }
 }
 
+plugins {
+    id "com.jfrog.bintray" version "1.8.0"
+}
+
 allprojects {
     repositories {
+        google()
         jcenter()
     }
 }
-
-task clean(type: Delete) {
-    delete rootProject.buildDir
-}

gradle.properties

@@ -17,6 +17,5 @@
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
 compileSdkVersion = 26
-targetSdkVersion = 25
-buildToolsVersion = 25.0.3
-supportLibVersion = 24.2.0
+targetSdkVersion = 26
+supportLibVersion = 26.1.0

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Sat Jun 24 21:38:23 PDT 2017
+#Tue Nov 13 00:07:04 KST 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.0-rc-1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-all.zip

hover/build.gradle

@@ -1,11 +1,11 @@
 apply plugin: 'com.android.library'
 apply plugin: 'checkstyle'
 
-version = '0.9.8'
+project.group = 'com.buzzvil'
+project.version = '1.0.1'
 
 android {
     compileSdkVersion project.compileSdkVersion.toInteger()
-    buildToolsVersion project.buildToolsVersion
 
     defaultConfig {
         minSdkVersion 15
@@ -21,52 +21,13 @@ android {
 }
 
 dependencies {
-    compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile "com.android.support:appcompat-v7:${supportLibVersion}"
-    compile "com.android.support:recyclerview-v7:${supportLibVersion}" // Used to get DiffUtil
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    api ("androidx.appcompat:appcompat:$androidXAppcompatVersion")
+    api ("androidx.recyclerview:recyclerview:$androidXRecyclerviewVersion")
 
-    testCompile 'junit:junit:4.12'
+    testImplementation "junit:junit:$junitVersion"
 }
 
-// For Bintray publishing
-ext {
-    bintrayRepo = 'maven'
-    bintrayName = 'hover'
-
-    publishedGroupId = 'io.mattcarroll.hover'
-    artifact = 'hover'
-    libraryName = 'Hover'
-
-    libraryDescription = 'An Android implementation of a floating menu.'
-
-    siteUrl = 'http://google.github.io/hover/'
-    gitUrl = 'https://github.com/google/hover.git'
-
-    libraryVersion = version
-
-    developerId = 'matthew-carroll'
-    developerName = 'Matt Carroll'
-    developerEmail = 'me@mattcarroll.io'
-
-    licenseName = 'The Apache Software License, Version 2.0'
-    licenseUrl = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-    allLicenses = ["Apache-2.0"]
-}
-
-apply from: 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/installv1.gradle'
-apply from: 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/bintrayv1.gradle'
-
-// The following is used to add our dependencies to the classpath for Javadoc linking.
-afterEvaluate {
-    javadoc.classpath += files(android.libraryVariants.collect { variant ->
-        variant.javaCompile.classpath.files
-    })
-}
-
-// This disabled Javadoc tasks because its breaking the release build.  Since Javadocs are
-// not mission critical, they will remain disabled until the issue can be debugged.
-tasks.withType(Javadoc).all { enabled = false }
-
 //------ Checkstyle -------
 task checkstyle(type: Checkstyle) {
     showViolations = true
@@ -86,4 +47,14 @@ project.afterEvaluate {
     preBuild.dependsOn('checkstyle')
     assemble.dependsOn('lint')
     check.dependsOn('checkstyle')
-}
+}
+
+ext {
+    pName = 'hover'
+    pDescription = 'Buzzvil hover Android SDK'
+    pPublisherVcsUrl = 'https://github.com/Buzzvil/hover.git'
+    pGroup = project.group
+    pVersion = project.version
+}
+
+apply from: "$rootDir/gradle/publish.gradle"

hover/src/main/java/io/mattcarroll/hover/BaseHoverViewState.java

@@ -15,64 +15,43 @@
  */
 package io.mattcarroll.hover;
 
-import android.support.annotation.NonNull;
-import android.view.WindowManager;
+import androidx.annotation.CallSuper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 /**
  * {@link HoverViewState} that includes behavior common to all implementations.
  */
 abstract class BaseHoverViewState implements HoverViewState {
 
-    private HoverView mHoverView;
+    private boolean mHasControl = false;
+    protected HoverView mHoverView;
 
+    @CallSuper
     @Override
-    public void takeControl(@NonNull HoverView hoverView) {
-        mHoverView = hoverView;
-    }
-
-    // Only call this if using HoverMenuView directly in a window.
-    @Override
-    public void addToWindow() {
-        if (!mHoverView.mIsAddedToWindow) {
-            mHoverView.mWindowViewController.addView(
-                    WindowManager.LayoutParams.MATCH_PARENT,
-                    WindowManager.LayoutParams.MATCH_PARENT,
-                    false,
-                    mHoverView
-            );
-
-            mHoverView.mIsAddedToWindow = true;
-
-            if (mHoverView.mIsTouchableInWindow) {
-                mHoverView.makeTouchableInWindow();
-            } else {
-                mHoverView.makeUntouchableInWindow();
-            }
+    public void takeControl(@NonNull HoverView hoverView, Runnable onStateChanged) {
+        if (mHasControl) {
+            throw new RuntimeException("Cannot take control of a FloatingTab when we already control one.");
         }
+        mHasControl = true;
+        mHoverView = hoverView;
     }
 
-    // Only call this if using HoverMenuView directly in a window.
+    @CallSuper
     @Override
-    public void removeFromWindow() {
-        if (mHoverView.mIsAddedToWindow) {
-            mHoverView.mWindowViewController.removeView(mHoverView);
-            mHoverView.mIsAddedToWindow = false;
+    public void giveUpControl(@NonNull HoverViewState nextState) {
+        if (!mHasControl) {
+            throw new RuntimeException("Cannot give up control of a FloatingTab when we don't have the control");
         }
+        mHasControl = false;
+        mHoverView = null;
     }
 
-    @Override
-    public void makeTouchableInWindow() {
-        mHoverView.mIsTouchableInWindow = true;
-        if (mHoverView.mIsAddedToWindow) {
-            mHoverView.mWindowViewController.makeTouchable(mHoverView);
-        }
+    protected final boolean hasControl() {
+        return mHasControl;
     }
 
     @Override
-    public void makeUntouchableInWindow() {
-        mHoverView.mIsTouchableInWindow = false;
-        if (mHoverView.mIsAddedToWindow) {
-            mHoverView.mWindowViewController.makeUntouchable(mHoverView);
-        }
+    public void setMenu(@Nullable HoverMenu menu) {
     }
 }

hover/src/main/java/io/mattcarroll/hover/BaseTouchController.java

@@ -0,0 +1,166 @@
+package io.mattcarroll.hover;
+
+import android.graphics.PointF;
+import android.graphics.Rect;
+import androidx.annotation.NonNull;
+import androidx.core.util.Pair;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public abstract class BaseTouchController {
+    private static final String TAG = "BaseTouchController";
+
+    protected Map<String, TouchViewItem> mTouchViewMap = new HashMap<>();
+    protected boolean mIsActivated;
+    private boolean mIsDebugMode;
+
+    private final HoverFrameLayout.OnPositionChangeListener mOnPositionChangeListener = new HoverFrameLayout.OnPositionChangeListener() {
+        @Override
+        public void onPositionChange(@NonNull View view) {
+            moveTouchViewTo(mTouchViewMap.get(view.getTag()).mTouchView, new PointF(view.getX(), view.getY()));
+        }
+    };
+
+    public abstract View createTouchView(@NonNull Rect rect);
+
+    public abstract void destroyTouchView(@NonNull View touchView);
+
+    public abstract void moveTouchViewTo(@NonNull View touchView, @NonNull PointF position);
+
+    public void activate(final List<Pair<? extends HoverFrameLayout, ? extends TouchListener>> viewList) {
+        if (!mIsActivated) {
+            Log.d(TAG, "Activating.");
+            mIsActivated = true;
+
+            clearTouchViewMap();
+            for (int i = 0; i < viewList.size(); i++) {
+                final Pair<? extends HoverFrameLayout, ? extends TouchListener> viewItem = viewList.get(i);
+                final String tag = "view" + i;
+                final TouchViewItem touchViewItem = createTouchViewItem(viewItem.first, viewItem.second, tag);
+                mTouchViewMap.put(tag, touchViewItem);
+            }
+            updateTouchControlViewAppearance();
+        }
+    }
+
+    public void deactivate() {
+        if (mIsActivated) {
+            Log.d(TAG, "Deactivating.");
+            clearTouchViewMap();
+            mIsActivated = false;
+        }
+    }
+
+    public void enableDebugMode(boolean isDebugMode) {
+        mIsDebugMode = isDebugMode;
+        updateTouchControlViewAppearance();
+    }
+
+    private <T extends TouchListener<V>, V extends HoverFrameLayout> TouchViewItem createTouchViewItem(final V originalView, final T listener, final String tag) {
+        return new TouchViewItem<>(originalView, createTouchViewFrom(originalView), listener, tag);
+    }
+
+    protected <T extends TouchListener<V>, V extends View> TouchDetector createTouchDetector(final V originalView, final T touchListener) {
+        return new TouchDetector<>(originalView, touchListener);
+    }
+
+    private void clearTouchViewMap() {
+        for (final TouchViewItem touchViewItem : mTouchViewMap.values()) {
+            touchViewItem.destroy();
+        }
+        mTouchViewMap.clear();
+    }
+
+    private void updateTouchControlViewAppearance() {
+        for (final TouchViewItem touchViewItemItem : mTouchViewMap.values()) {
+            final View touchView = touchViewItemItem.mTouchView;
+            if (null != touchView) {
+                if (mIsDebugMode) {
+                    touchView.setBackgroundColor(0x44FF0000);
+                } else {
+                    touchView.setBackgroundColor(0x00000000);
+                }
+            }
+        }
+    }
+
+    private Rect getRectFrom(final View view) {
+        final Rect rect = new Rect();
+        view.getDrawingRect(rect);
+        return rect;
+
+    }
+
+    private View createTouchViewFrom(final View originalView) {
+        final View touchView = createTouchView(getRectFrom(originalView));
+        moveTouchViewTo(touchView, new PointF(originalView.getX(), originalView.getY()));
+        return touchView;
+    }
+
+    public interface TouchListener <V extends View> {
+        void onTap(V view);
+
+        void onTouchDown(V view);
+
+        void onTouchUp(V view);
+    }
+
+    protected class TouchDetector<T extends TouchListener<V>, V extends View> implements View.OnTouchListener {
+
+        @NonNull
+        protected final V mOriginalView;
+        @NonNull
+        protected final T mEventListener;
+
+        TouchDetector(@NonNull final V originalView, @NonNull final T touchListener) {
+            this.mOriginalView = originalView;
+            this.mEventListener = touchListener;
+        }
+
+        @Override
+        public boolean onTouch(View view, MotionEvent motionEvent) {
+            switch (motionEvent.getAction()) {
+                case MotionEvent.ACTION_DOWN:
+                    Log.d(TAG, "ACTION_DOWN");
+                    mEventListener.onTouchDown(mOriginalView);
+                    return true;
+                case MotionEvent.ACTION_UP:
+                    Log.d(TAG, "ACTION_UP");
+                    mEventListener.onTouchUp(mOriginalView);
+                    mEventListener.onTap(mOriginalView);
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+
+    protected class TouchViewItem<V extends HoverFrameLayout, T extends TouchListener<V>> {
+        final V mOriginalView;
+        final View mTouchView;
+        final T mTouchListener;
+
+        TouchViewItem(final V originalView, final View touchView, final T touchListener, final String tag) {
+            this.mOriginalView = originalView;
+            this.mTouchView = touchView;
+            this.mTouchListener = touchListener;
+
+            mOriginalView.setTag(tag);
+            mTouchView.setTag(tag);
+
+            mTouchView.setOnTouchListener(createTouchDetector(mOriginalView, mTouchListener));
+            mOriginalView.addOnPositionChangeListener(mOnPositionChangeListener);
+        }
+
+        void destroy() {
+            mTouchView.setOnTouchListener(null);
+            mOriginalView.removeOnPositionChangeListener(mOnPositionChangeListener);
+            destroyTouchView(mTouchView);
+        }
+    }
+}