Moving Server dependencies to frameworks/libs (285f7907) · Commits · e / os / android_frameworks_base

packages/SystemUI/monet/Android.bp

deleted100644 → 0

+0 −33

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2021 The Android Open Source Project
		//
		// 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 {
		default_team: "trendy_team_system_ui_please_use_a_more_specific_subteam_if_possible_",
		default_applicable_licenses: ["Android-Apache-2.0"],
		}

		java_library {
		name: "monet",
		platform_apis: true,
		static_libs: [
		"androidx.annotation_annotation",
		"androidx.core_core",
		"libmonet",
		],
		srcs: [
		"src/*/.java",
		"src/*/.kt",
		],
		}

packages/SystemUI/monet/AndroidManifest.xml

deleted100644 → 0

+0 −20

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<!--
		Copyright (C) 2021 The Android Open Source Project

		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.
		-->

		<manifest xmlns:android="http://schemas.android.com/apk/res/android"
		package="com.android.systemui.monet">
		</manifest>

packages/SystemUI/monet/src/com/android/systemui/monet/ColorScheme.kt

deleted100644 → 0

+0 −372

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 The Android Open Source Project
		*
		* 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.android.systemui.monet

		import android.annotation.ColorInt
		import android.app.WallpaperColors
		import android.graphics.Color
		import com.android.internal.graphics.ColorUtils
		import com.google.ux.material.libmonet.hct.Hct
		import com.google.ux.material.libmonet.scheme.DynamicScheme
		import com.google.ux.material.libmonet.scheme.SchemeContent
		import com.google.ux.material.libmonet.scheme.SchemeExpressive
		import com.google.ux.material.libmonet.scheme.SchemeFruitSalad
		import com.google.ux.material.libmonet.scheme.SchemeMonochrome
		import com.google.ux.material.libmonet.scheme.SchemeNeutral
		import com.google.ux.material.libmonet.scheme.SchemeRainbow
		import com.google.ux.material.libmonet.scheme.SchemeTonalSpot
		import com.google.ux.material.libmonet.scheme.SchemeVibrant
		import kotlin.math.absoluteValue
		import kotlin.math.roundToInt

		const val TAG = "ColorScheme"

		const val ACCENT1_CHROMA = 48.0f
		const val GOOGLE_BLUE = 0xFF1b6ef3.toInt()
		const val MIN_CHROMA = 5

		enum class Style{
		SPRITZ,
		TONAL_SPOT,
		VIBRANT,
		EXPRESSIVE,
		RAINBOW,
		FRUIT_SALAD,
		CONTENT,
		MONOCHROMATIC,
		CLOCK,
		CLOCK_VIBRANT
		}

		class TonalPalette
		internal constructor(
		private val materialTonalPalette: com.google.ux.material.libmonet.palettes.TonalPalette
		) {
		@Deprecated("Do not use. For color system only")
		val allShades: List<Int>
		val allShadesMapped: Map<Int, Int>

		init{
		allShades = SHADE_KEYS.map {key -> getAtTone(key.toFloat()) }
		allShadesMapped = SHADE_KEYS.zip(allShades).toMap()
		}

		// Dynamically computed tones across the full range from 0 to 1000
		fun getAtTone(shade: Float): Int = materialTonalPalette.tone(((1000.0f - shade) / 10f).toInt())

		// Predefined & precomputed tones
		val s0: Int
		get() = this.allShades[0]
		val s10: Int
		get() = this.allShades[1]
		val s50: Int
		get() = this.allShades[2]
		val s100: Int
		get() = this.allShades[3]
		val s200: Int
		get() = this.allShades[4]
		val s300: Int
		get() = this.allShades[5]
		val s400: Int
		get() = this.allShades[6]
		val s500: Int
		get() = this.allShades[7]
		val s600: Int
		get() = this.allShades[8]
		val s700: Int
		get() = this.allShades[9]
		val s800: Int
		get() = this.allShades[10]
		val s900: Int
		get() = this.allShades[11]
		val s1000: Int
		get() = this.allShades[12]

		companion object {
		val SHADE_KEYS = listOf(0, 10, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000)
		}
		}

		@Deprecated("Please use com.google.ux.material.libmonet.dynamiccolor.MaterialDynamicColors " +
		"instead")
		class ColorScheme(
		@ColorInt val seed: Int,
		val isDark: Boolean,
		val style: Style,
		val contrastLevel: Double
		) {
		var materialScheme: DynamicScheme

		private val proposedSeedHct: Hct = Hct.fromInt(seed)
		private val seedHct: Hct = Hct.fromInt(if (seed == Color.TRANSPARENT) {
		GOOGLE_BLUE
		} else if (style != Style.CONTENT && proposedSeedHct.chroma < 5) {
		GOOGLE_BLUE
		} else {
		seed
		})

		val accent1: TonalPalette
		val accent2: TonalPalette
		val accent3: TonalPalette
		val neutral1: TonalPalette
		val neutral2: TonalPalette

		constructor(@ColorInt seed: Int, darkTheme: Boolean) : this(seed, darkTheme, Style.TONAL_SPOT)

		@JvmOverloads
		constructor(
		@ColorInt seed: Int,
		darkTheme: Boolean,
		style: Style
		) : this(seed, darkTheme, style, 0.0)

		@JvmOverloads
		constructor(
		wallpaperColors: WallpaperColors,
		darkTheme: Boolean,
		style: Style = Style.TONAL_SPOT
		) : this(getSeedColor(wallpaperColors, style != Style.CONTENT), darkTheme, style)

		val backgroundColor
		get() = ColorUtils.setAlphaComponent(if (isDark) neutral1.s700 else neutral1.s10, 0xFF)

		val accentColor
		get() = ColorUtils.setAlphaComponent(if (isDark) accent1.s100 else accent1.s500, 0xFF)

		init {
		materialScheme = when (style) {
		Style.SPRITZ -> SchemeNeutral(seedHct, isDark, contrastLevel)
		Style.TONAL_SPOT -> SchemeTonalSpot(seedHct, isDark, contrastLevel)
		Style.VIBRANT -> SchemeVibrant(seedHct, isDark, contrastLevel)
		Style.EXPRESSIVE -> SchemeExpressive(seedHct, isDark, contrastLevel)
		Style.RAINBOW -> SchemeRainbow(seedHct, isDark, contrastLevel)
		Style.FRUIT_SALAD -> SchemeFruitSalad(seedHct, isDark, contrastLevel)
		Style.CONTENT -> SchemeContent(seedHct, isDark, contrastLevel)
		Style.MONOCHROMATIC -> SchemeMonochrome(seedHct, isDark, contrastLevel)

		// SystemUI Schemes
		Style.CLOCK -> SchemeClock(seedHct, isDark, contrastLevel)
		Style.CLOCK_VIBRANT -> SchemeClockVibrant(seedHct, isDark, contrastLevel)
		}

		accent1 = TonalPalette(materialScheme.primaryPalette)
		accent2 = TonalPalette(materialScheme.secondaryPalette)
		accent3 = TonalPalette(materialScheme.tertiaryPalette)
		neutral1 = TonalPalette(materialScheme.neutralPalette)
		neutral2 = TonalPalette(materialScheme.neutralVariantPalette)
		}

		val seedTone: Float
		get() = 1000f - proposedSeedHct.tone.toFloat() * 10f

		override fun toString(): String {
		return "ColorScheme {\n" +
		" seed color: ${stringForColor(seed)}\n" +
		" style: $style\n" +
		" palettes: \n" +
		" ${humanReadable("PRIMARY", accent1.allShades)}\n" +
		" ${humanReadable("SECONDARY", accent2.allShades)}\n" +
		" ${humanReadable("TERTIARY", accent3.allShades)}\n" +
		" ${humanReadable("NEUTRAL", neutral1.allShades)}\n" +
		" ${humanReadable("NEUTRAL VARIANT", neutral2.allShades)}\n" +
		"}"
		}

		companion object {
		/**
		* Identifies a color to create a color scheme from.
		*
		* @param wallpaperColors Colors extracted from an image via quantization.
		* @param filter If false, allow colors that have low chroma, creating grayscale themes.
		* @return ARGB int representing the color
		*/
		@JvmStatic
		@JvmOverloads
		@ColorInt
		fun getSeedColor(wallpaperColors: WallpaperColors, filter: Boolean = true): Int {
		return getSeedColors(wallpaperColors, filter).first()
		}

		/**
		* Filters and ranks colors from WallpaperColors.
		*
		* @param wallpaperColors Colors extracted from an image via quantization.
		* @param filter If false, allow colors that have low chroma, creating grayscale themes.
		* @return List of ARGB ints, ordered from highest scoring to lowest.
		*/
		@JvmStatic
		@JvmOverloads
		fun getSeedColors(wallpaperColors: WallpaperColors, filter: Boolean = true): List<Int> {
		val totalPopulation =
		wallpaperColors.allColors.values.reduce { a, b -> a + b }.toDouble()
		val totalPopulationMeaningless = (totalPopulation == 0.0)
		if (totalPopulationMeaningless) {
		// WallpaperColors with a population of 0 indicate the colors didn't come from
		// quantization. Instead of scoring, trust the ordering of the provided primary
		// secondary/tertiary colors.
		//
		// In this case, the colors are usually from a Live Wallpaper.
		val distinctColors =
		wallpaperColors.mainColors
		.map { it.toArgb() }
		.distinct()
		.filter {
		if (!filter) {
		true
		} else {
		Hct.fromInt(it).chroma >= MIN_CHROMA
		}
		}
		.toList()
		if (distinctColors.isEmpty()) {
		return listOf(GOOGLE_BLUE)
		}
		return distinctColors
		}

		val intToProportion =
		wallpaperColors.allColors.mapValues { it.value.toDouble() / totalPopulation }
		val intToHct = wallpaperColors.allColors.mapValues { Hct.fromInt(it.key) }

		// Get an array with 360 slots. A slot contains the percentage of colors with that hue.
		val hueProportions = huePopulations(intToHct, intToProportion, filter)
		// Map each color to the percentage of the image with its hue.
		val intToHueProportion =
		wallpaperColors.allColors.mapValues {
		val hct = intToHct[it.key]!!
		val hue = hct.hue.roundToInt()
		var proportion = 0.0
		for (i in hue - 15..hue + 15) {
		proportion += hueProportions[wrapDegrees(i)]
		}
		proportion
		}
		// Remove any inappropriate seed colors. For example, low chroma colors look grayscale
		// raising their chroma will turn them to a much louder color that may not have been
		// in the image.
		val filteredIntToHct =
		if (!filter) intToHct
		else
		(intToHct.filter {
		val hct = it.value
		val proportion = intToHueProportion[it.key]!!
		hct.chroma >= MIN_CHROMA &&
		(totalPopulationMeaningless \|\| proportion > 0.01)
		})
		// Sort the colors by score, from high to low.
		val intToScoreIntermediate =
		filteredIntToHct.mapValues { score(it.value, intToHueProportion[it.key]!!) }
		val intToScore = intToScoreIntermediate.entries.toMutableList()
		intToScore.sortByDescending { it.value }

		// Go through the colors, from high score to low score.
		// If the color is distinct in hue from colors picked so far, pick the color.
		// Iteratively decrease the amount of hue distinctness required, thus ensuring we
		// maximize difference between colors.
		val minimumHueDistance = 15
		val seeds = mutableListOf<Int>()
		maximizeHueDistance@ for (i in 90 downTo minimumHueDistance step 1) {
		seeds.clear()
		for (entry in intToScore) {
		val int = entry.key
		val existingSeedNearby =
		seeds.find {
		val hueA = intToHct[int]!!.hue
		val hueB = intToHct[it]!!.hue
		hueDiff(hueA, hueB) < i
		} != null
		if (existingSeedNearby) {
		continue
		}
		seeds.add(int)
		if (seeds.size >= 4) {
		break@maximizeHueDistance
		}
		}
		}

		if (seeds.isEmpty()) {
		// Use gBlue 500 if there are 0 colors
		seeds.add(GOOGLE_BLUE)
		}

		return seeds
		}

		private fun wrapDegrees(degrees: Int): Int {
		return when {
		degrees < 0 -> {
		(degrees % 360) + 360
		}
		degrees >= 360 -> {
		degrees % 360
		}
		else -> {
		degrees
		}
		}
		}

		private fun hueDiff(a: Double, b: Double): Double {
		return 180f - ((a - b).absoluteValue - 180f).absoluteValue
		}

		private fun stringForColor(color: Int): String {
		val width = 4
		val hct = Hct.fromInt(color)
		val h = "H${hct.hue.roundToInt().toString().padEnd(width)}"
		val c = "C${hct.chroma.roundToInt().toString().padEnd(width)}"
		val t = "T${hct.tone.roundToInt().toString().padEnd(width)}"
		val hex = Integer.toHexString(color and 0xffffff).padStart(6, '0').uppercase()
		return "$h$c$t = #$hex"
		}

		private fun humanReadable(paletteName: String, colors: List<Int>): String {
		return "$paletteName\n" +
		colors.map { stringForColor(it) }.joinToString(separator = "\n") { it }
		}

		private fun score(hct: Hct, proportion: Double): Double {
		val proportionScore = 0.7 * 100.0 * proportion
		val chromaScore =
		if (hct.chroma < ACCENT1_CHROMA) 0.1 * (hct.chroma - ACCENT1_CHROMA)
		else 0.3 * (hct.chroma - ACCENT1_CHROMA)
		return chromaScore + proportionScore
		}

		private fun huePopulations(
		hctByColor: Map<Int, Hct>,
		populationByColor: Map<Int, Double>,
		filter: Boolean = true
		): List<Double> {
		val huePopulation = List(size = 360, init = { 0.0 }).toMutableList()

		for (entry in populationByColor.entries) {
		val population = populationByColor[entry.key]!!
		val hct = hctByColor[entry.key]!!
		val hue = hct.hue.roundToInt() % 360
		if (filter && hct.chroma <= MIN_CHROMA) {
		continue
		}
		huePopulation[hue] = huePopulation[hue] + population
		}

		return huePopulation
		}
		}
		}

packages/SystemUI/monet/src/com/android/systemui/monet/SchemeClock.java

deleted100644 → 0

+0 −55

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 The Android Open Source Project
		*
		* 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.android.systemui.monet;

		import static com.google.ux.material.libmonet.utils.MathUtils.clampDouble;

		import static java.lang.Double.max;

		import com.google.ux.material.libmonet.hct.Hct;
		import com.google.ux.material.libmonet.palettes.TonalPalette;
		import com.google.ux.material.libmonet.scheme.DynamicScheme;
		import com.google.ux.material.libmonet.scheme.Variant;

		public class SchemeClock extends DynamicScheme {
		public SchemeClock(Hct sourceColorHct, boolean isDark, double contrastLevel) {
		super(
		sourceColorHct,
		Variant.MONOCHROME,
		isDark,
		contrastLevel,
		/primary/
		TonalPalette.fromHueAndChroma(
		/hue/ sourceColorHct.getHue(),
		/chroma/ max(sourceColorHct.getChroma(), 20)
		),
		/secondary/
		TonalPalette.fromHueAndChroma(
		/hue/ sourceColorHct.getHue() + 10.0,
		/chroma/ clampDouble(17, 40, sourceColorHct.getChroma() * 0.85)
		),
		/tertiary/
		TonalPalette.fromHueAndChroma(
		/hue/ sourceColorHct.getHue() + 20.0,
		/chroma/ max(sourceColorHct.getChroma() + 20, 50)
		),

		//not used
		TonalPalette.fromHueAndChroma(sourceColorHct.getHue(), 0.0),
		TonalPalette.fromHueAndChroma(sourceColorHct.getHue(), 0.0));
		}
		}

packages/SystemUI/monet/src/com/android/systemui/monet/SchemeClockVibrant.java

deleted100644 → 0

+0 −53

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 The Android Open Source Project
		*
		* 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.android.systemui.monet;

		import static java.lang.Double.max;

		import com.google.ux.material.libmonet.hct.Hct;
		import com.google.ux.material.libmonet.palettes.TonalPalette;
		import com.google.ux.material.libmonet.scheme.DynamicScheme;
		import com.google.ux.material.libmonet.scheme.Variant;

		public class SchemeClockVibrant extends DynamicScheme {
		public SchemeClockVibrant(Hct sourceColorHct, boolean isDark, double contrastLevel) {
		super(
		sourceColorHct,
		Variant.MONOCHROME,
		isDark,
		contrastLevel,
		/primary/
		TonalPalette.fromHueAndChroma(
		/hue/ sourceColorHct.getHue(),
		/chroma/ max(sourceColorHct.getChroma(), 70)
		),
		/secondary/
		TonalPalette.fromHueAndChroma(
		/hue/ sourceColorHct.getHue() + 20.0,
		/chroma/ max(sourceColorHct.getChroma(), 70)
		),
		/tertiary/
		TonalPalette.fromHueAndChroma(
		/hue/ sourceColorHct.getHue() + 60.0,
		/chroma/ max(sourceColorHct.getChroma(), 70)
		),

		//not used
		TonalPalette.fromHueAndChroma(sourceColorHct.getHue(), 0.0),
		TonalPalette.fromHueAndChroma(sourceColorHct.getHue(), 0.0));
		}
		}