First pass at Kotlin conversion

Author: zacharee

MPChartLib/src/main/java/com/github/mikephil/charting/animation/ChartAnimator.kt

@@ -1,65 +1,54 @@
-package com.github.mikephil.charting.animation;
+package com.github.mikephil.charting.animation
 
-import android.animation.ObjectAnimator;
-import android.animation.ValueAnimator.AnimatorUpdateListener;
-import androidx.annotation.RequiresApi;
-
-import com.github.mikephil.charting.animation.Easing.EasingFunction;
+import android.animation.ObjectAnimator
+import android.animation.ValueAnimator.AnimatorUpdateListener
+import com.github.mikephil.charting.animation.Easing.EasingFunction
 
 /**
  * Object responsible for all animations in the Chart. Animations require API level 11.
  *
  * @author Philipp Jahoda
  * @author Mick Ashton
  */
-public class ChartAnimator {
-
-    /** object that is updated upon animation update */
-    private AnimatorUpdateListener mListener;
+open class ChartAnimator {
+    /** object that is updated upon animation update  */
+    private var mListener: AnimatorUpdateListener? = null
 
-    /** The phase of drawn values on the y-axis. 0 - 1 */
-    @SuppressWarnings("WeakerAccess")
-    protected float mPhaseY = 1f;
+    /** The phase of drawn values on the y-axis. 0 - 1  */
+    protected var mPhaseY: Float = 1f
 
-    /** The phase of drawn values on the x-axis. 0 - 1 */
-    @SuppressWarnings("WeakerAccess")
-    protected float mPhaseX = 1f;
+    /** The phase of drawn values on the x-axis. 0 - 1  */
+    protected var mPhaseX: Float = 1f
 
-    public ChartAnimator() { }
+    constructor()
 
-    @RequiresApi(11)
-    public ChartAnimator(AnimatorUpdateListener listener) {
-        mListener = listener;
+    constructor(listener: AnimatorUpdateListener?) {
+        mListener = listener
     }
 
-    @RequiresApi(11)
-    private ObjectAnimator xAnimator(int duration, EasingFunction easing) {
+    private fun xAnimator(duration: Int, easing: EasingFunction?): ObjectAnimator {
+        val animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f)
+        animatorX.interpolator = easing
+        animatorX.setDuration(duration.toLong())
 
-        ObjectAnimator animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f);
-        animatorX.setInterpolator(easing);
-        animatorX.setDuration(duration);
-
-        return animatorX;
+        return animatorX
     }
 
-    @RequiresApi(11)
-    private ObjectAnimator yAnimator(int duration, EasingFunction easing) {
-
-        ObjectAnimator animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f);
-        animatorY.setInterpolator(easing);
-        animatorY.setDuration(duration);
+    private fun yAnimator(duration: Int, easing: EasingFunction?): ObjectAnimator {
+        val animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f)
+        animatorY.interpolator = easing
+        animatorY.setDuration(duration.toLong())
 
-        return animatorY;
+        return animatorY
     }
 
     /**
      * Animates values along the X axis, in a linear fashion.
      *
      * @param durationMillis animation duration
      */
-    @RequiresApi(11)
-    public void animateX(int durationMillis) {
-        animateX(durationMillis, Easing.Linear);
+    fun animateX(durationMillis: Int) {
+        animateX(durationMillis, Easing.Linear)
     }
 
     /**
@@ -68,12 +57,10 @@ public class ChartAnimator {
      * @param durationMillis animation duration
      * @param easing EasingFunction
      */
-    @RequiresApi(11)
-    public void animateX(int durationMillis, EasingFunction easing) {
-
-        ObjectAnimator animatorX = xAnimator(durationMillis, easing);
-        animatorX.addUpdateListener(mListener);
-        animatorX.start();
+    fun animateX(durationMillis: Int, easing: EasingFunction?) {
+        val animatorX = xAnimator(durationMillis, easing)
+        animatorX.addUpdateListener(mListener)
+        animatorX.start()
     }
 
     /**
@@ -82,9 +69,8 @@ public class ChartAnimator {
      * @param durationMillisX animation duration along the X axis
      * @param durationMillisY animation duration along the Y axis
      */
-    @RequiresApi(11)
-    public void animateXY(int durationMillisX, int durationMillisY) {
-        animateXY(durationMillisX, durationMillisY, Easing.Linear, Easing.Linear);
+    fun animateXY(durationMillisX: Int, durationMillisY: Int) {
+        animateXY(durationMillisX, durationMillisY, Easing.Linear, Easing.Linear)
     }
 
     /**
@@ -94,20 +80,18 @@ public class ChartAnimator {
      * @param durationMillisY animation duration along the Y axis
      * @param easing EasingFunction for both axes
      */
-    @RequiresApi(11)
-    public void animateXY(int durationMillisX, int durationMillisY, EasingFunction easing) {
-
-        ObjectAnimator xAnimator = xAnimator(durationMillisX, easing);
-        ObjectAnimator yAnimator = yAnimator(durationMillisY, easing);
+    fun animateXY(durationMillisX: Int, durationMillisY: Int, easing: EasingFunction?) {
+        val xAnimator = xAnimator(durationMillisX, easing)
+        val yAnimator = yAnimator(durationMillisY, easing)
 
         if (durationMillisX > durationMillisY) {
-            xAnimator.addUpdateListener(mListener);
+            xAnimator.addUpdateListener(mListener)
         } else {
-            yAnimator.addUpdateListener(mListener);
+            yAnimator.addUpdateListener(mListener)
         }
 
-        xAnimator.start();
-        yAnimator.start();
+        xAnimator.start()
+        yAnimator.start()
     }
 
     /**
@@ -118,31 +102,30 @@ public class ChartAnimator {
      * @param easingX EasingFunction for the X axis
      * @param easingY EasingFunction for the Y axis
      */
-    @RequiresApi(11)
-    public void animateXY(int durationMillisX, int durationMillisY, EasingFunction easingX,
-                          EasingFunction easingY) {
-
-        ObjectAnimator xAnimator = xAnimator(durationMillisX, easingX);
-        ObjectAnimator yAnimator = yAnimator(durationMillisY, easingY);
+    fun animateXY(
+        durationMillisX: Int, durationMillisY: Int, easingX: EasingFunction?,
+        easingY: EasingFunction?
+    ) {
+        val xAnimator = xAnimator(durationMillisX, easingX)
+        val yAnimator = yAnimator(durationMillisY, easingY)
 
         if (durationMillisX > durationMillisY) {
-            xAnimator.addUpdateListener(mListener);
+            xAnimator.addUpdateListener(mListener)
         } else {
-            yAnimator.addUpdateListener(mListener);
+            yAnimator.addUpdateListener(mListener)
         }
 
-        xAnimator.start();
-        yAnimator.start();
+        xAnimator.start()
+        yAnimator.start()
     }
 
     /**
      * Animates values along the Y axis, in a linear fashion.
      *
      * @param durationMillis animation duration
      */
-    @RequiresApi(11)
-    public void animateY(int durationMillis) {
-        animateY(durationMillis, Easing.Linear);
+    fun animateY(durationMillis: Int) {
+        animateY(durationMillis, Easing.Linear)
     }
 
     /**
@@ -151,57 +134,53 @@ public class ChartAnimator {
      * @param durationMillis animation duration
      * @param easing EasingFunction
      */
-    @RequiresApi(11)
-    public void animateY(int durationMillis, EasingFunction easing) {
-
-        ObjectAnimator animatorY = yAnimator(durationMillis, easing);
-        animatorY.addUpdateListener(mListener);
-        animatorY.start();
-    }
-
-    /**
-     * Gets the Y axis phase of the animation.
-     *
-     * @return float value of {@link #mPhaseY}
-     */
-    public float getPhaseY() {
-        return mPhaseY;
+    fun animateY(durationMillis: Int, easing: EasingFunction?) {
+        val animatorY = yAnimator(durationMillis, easing)
+        animatorY.addUpdateListener(mListener)
+        animatorY.start()
     }
 
-    /**
-     * Sets the Y axis phase of the animation.
-     *
-     * @param phase float value between 0 - 1
-     */
-    public void setPhaseY(float phase) {
-        if (phase > 1f) {
-            phase = 1f;
-        } else if (phase < 0f) {
-            phase = 0f;
+    var phaseY: Float
+        /**
+         * Gets the Y axis phase of the animation.
+         *
+         * @return float value of [.mPhaseY]
+         */
+        get() = mPhaseY
+        /**
+         * Sets the Y axis phase of the animation.
+         *
+         * @param phase float value between 0 - 1
+         */
+        set(phase) {
+            var phase = phase
+            if (phase > 1f) {
+                phase = 1f
+            } else if (phase < 0f) {
+                phase = 0f
+            }
+            mPhaseY = phase
         }
-        mPhaseY = phase;
-    }
 
-    /**
-     * Gets the X axis phase of the animation.
-     *
-     * @return float value of {@link #mPhaseX}
-     */
-    public float getPhaseX() {
-        return mPhaseX;
-    }
-
-    /**
-     * Sets the X axis phase of the animation.
-     *
-     * @param phase float value between 0 - 1
-     */
-    public void setPhaseX(float phase) {
-        if (phase > 1f) {
-            phase = 1f;
-        } else if (phase < 0f) {
-            phase = 0f;
+    var phaseX: Float
+        /**
+         * Gets the X axis phase of the animation.
+         *
+         * @return float value of [.mPhaseX]
+         */
+        get() = mPhaseX
+        /**
+         * Sets the X axis phase of the animation.
+         *
+         * @param phase float value between 0 - 1
+         */
+        set(phase) {
+            var phase = phase
+            if (phase > 1f) {
+                phase = 1f
+            } else if (phase < 0f) {
+                phase = 0f
+            }
+            mPhaseX = phase
         }
-        mPhaseX = phase;
-    }
 }