Support ShapeAppearances in MaterialContainerTransition.

Change-Id: I397ef14fd8efd3aae5ab0749bdba21e249f4834b

Author: nickbutcher

app/build.gradle

@@ -47,7 +47,7 @@ android {
 
 dependencies {
     implementation 'androidx.appcompat:appcompat:1.1.0-rc01'
-    implementation 'androidx.fragment:fragment:1.2.0-alpha01'
+    implementation 'androidx.fragment:fragment:1.2.0-alpha02'
     implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
     implementation 'androidx.core:core-ktx:1.0.2'
     implementation 'com.google.android.material:material:1.1.0-alpha09'

app/src/main/java/com/materialstudies/owl/util/AnimationUtils.kt

@@ -87,6 +87,56 @@ fun lerp(
     return lerp(startValue, endValue, (fraction - startFraction) / (endFraction - startFraction))
 }
 
+/**
+ * Linearly interpolate between two [CornerRounding]s when the fraction is in a given range.
+ */
+fun lerp(
+    startValue: CornerRounding,
+    endValue: CornerRounding,
+    @FloatRange(
+        from = 0.0,
+        fromInclusive = true,
+        to = 1.0,
+        toInclusive = false
+    ) startFraction: Float,
+    @FloatRange(from = 0.0, fromInclusive = false, to = 1.0, toInclusive = true) endFraction: Float,
+    @FloatRange(from = 0.0, fromInclusive = true, to = 1.0, toInclusive = true) fraction: Float
+): CornerRounding {
+    if (fraction < startFraction) return startValue
+    if (fraction > endFraction) return endValue
+
+    return CornerRounding(
+        lerp(
+            startValue.topLeftRadius,
+            endValue.topLeftRadius,
+            startFraction,
+            endFraction,
+            fraction
+        ),
+        lerp(
+            startValue.topRightRadius,
+            endValue.topRightRadius,
+            startFraction,
+            endFraction,
+            fraction
+        ),
+        lerp(
+            startValue.bottomRightRadius,
+            endValue.bottomRightRadius,
+            startFraction,
+            endFraction,
+            fraction
+        ),
+        lerp(
+            startValue.bottomLeftRadius,
+            endValue.bottomLeftRadius,
+            startFraction,
+            endFraction,
+            fraction
+        )
+    )
+}
+
 /**
  * Linearly interpolate between two colors when the fraction is in a given range.
  */

app/src/main/java/com/materialstudies/owl/util/GraphicsExtensions.kt

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * 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
+ *
+ *     https://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.materialstudies.owl.util
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.Rect
+import android.graphics.RectF
+import android.graphics.Shader
+import androidx.core.graphics.toRectF
+import com.google.android.material.shape.RoundedCornerTreatment
+import com.google.android.material.shape.ShapeAppearanceModel
+
+// TODO make inline class once non-experimental
+class CornerRounding(
+    val topLeftRadius: Float = 0f,
+    val topRightRadius: Float = 0f,
+    val bottomRightRadius: Float = 0f,
+    val bottomLeftRadius: Float = 0f
+)
+
+// To FloatArray suitable for Path#addRoundRect
+fun CornerRounding.toFloatArray(): FloatArray {
+    return floatArrayOf(
+        topLeftRadius, topLeftRadius,
+        topRightRadius, topRightRadius,
+        bottomRightRadius, bottomRightRadius,
+        bottomLeftRadius, bottomLeftRadius
+    )
+}
+
+fun ShapeAppearanceModel?.toCornerRounding(): CornerRounding {
+    if (this == null) return CornerRounding()
+    // TODO handle non rounded corners?
+    return CornerRounding(
+        if (topLeftCorner is RoundedCornerTreatment) topLeftCorner.cornerSize else 0f,
+        if (topRightCorner is RoundedCornerTreatment) topRightCorner.cornerSize else 0f,
+        if (bottomRightCorner is RoundedCornerTreatment) bottomRightCorner.cornerSize else 0f,
+        if (bottomLeftCorner is RoundedCornerTreatment) bottomLeftCorner.cornerSize else 0f
+    )
+}
+
+private val path = Path()
+fun Canvas.drawRoundedRect(
+    location: RectF,
+    cornerRadii: CornerRounding,
+    paint: Paint
+) {
+    path.apply {
+        reset()
+        addRoundRect(location, cornerRadii.toFloatArray(), Path.Direction.CW)
+    }
+    drawPath(path, paint)
+}

app/src/main/java/com/materialstudies/owl/util/ViewExtensions.kt

@@ -18,6 +18,8 @@ package com.materialstudies.owl.util
 
 import android.animation.ValueAnimator
 import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Bitmap.Config.ARGB_8888
 import android.graphics.Color
 import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.ColorDrawable
@@ -30,8 +32,11 @@ import android.view.animation.AnimationUtils
 import androidx.annotation.AttrRes
 import androidx.annotation.ColorInt
 import androidx.annotation.IdRes
+import androidx.annotation.Px
 import androidx.core.animation.doOnEnd
 import androidx.core.content.res.use
+import androidx.core.graphics.applyCanvas
+import androidx.core.view.ViewCompat
 import androidx.core.view.drawToBitmap
 import androidx.core.view.forEach
 import androidx.dynamicanimation.animation.DynamicAnimation.ViewProperty
@@ -242,3 +247,18 @@ fun BottomNavigationView.hide() {
         start()
     }
 }
+
+/**
+ * A copy of the KTX method, adding the ability to add extra padding the bottom of the [Bitmap];
+ * useful when it will be used in a [android.graphics.BitmapShader][BitmapShader] with
+ * a [android.graphics.Shader.TileMode.CLAMP][CLAMP tile mode].
+ */
+fun View.drawToBitmap(@Px extraPaddingBottom: Int = 0): Bitmap {
+    if (!ViewCompat.isLaidOut(this)) {
+        throw IllegalStateException("View needs to be laid out before calling drawToBitmap()")
+    }
+    return Bitmap.createBitmap(width, height + extraPaddingBottom, ARGB_8888).applyCanvas {
+        translate(-scrollX.toFloat(), -scrollY.toFloat())
+        draw(this)
+    }
+}