Myzel394/NumberHub
1
0
Fork 0
mirror of https://github.com/Myzel394/NumberHub.git synced 2025-06-19 16:55:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Introduce Token object

Browse Source
This commit is contained in:
Sad Ellie 2023-02-27 01:23:55 +04:00
parent 878d96c386
commit 61aff9c3ae
12 changed files with 322 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
core/base/src/main/java/com/sadellie/unitto/core/base/KeypadSymbols.kt
View File

@ -1,101 +0,0 @@
/*
* Unitto is a unit converter for Android
* Copyright (c) 2022-2023 Elshan Agaev
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.sadellie.unitto.core.base
const val KEY_1 = "1"
const val KEY_2 = "2"
const val KEY_3 = "3"
const val KEY_4 = "4"
const val KEY_5 = "5"
const val KEY_6 = "6"
const val KEY_7 = "7"
const val KEY_8 = "8"
const val KEY_9 = "9"
const val KEY_0 = "0"
const val KEY_BASE_A = "A"
const val KEY_BASE_B = "B"
const val KEY_BASE_C = "C"
const val KEY_BASE_D = "D"
const val KEY_BASE_E = "E"
const val KEY_BASE_F = "F"
const val KEY_DOT = "."
const val KEY_COMMA = ","
const val KEY_E = "E"
const val KEY_PLUS = "+"
const val KEY_MINUS = "-"
const val KEY_MINUS_DISPLAY = "–"
const val KEY_DIVIDE = "/"
const val KEY_DIVIDE_DISPLAY = "÷"
const val KEY_MULTIPLY = "*"
const val KEY_MULTIPLY_DISPLAY = "×"
const val KEY_LEFT_BRACKET = "("
const val KEY_RIGHT_BRACKET = ")"
const val KEY_EXPONENT = "^"
const val KEY_SQRT = "√"
const val KEY_PI = "π"
const val KEY_FACTORIAL = "!"
const val KEY_SIN = "sin("
const val KEY_COS = "cos("
const val KEY_TAN = "tan("
const val KEY_E_SMALL = "e"
const val KEY_MODULO = "#"
const val KEY_LN = "ln("
const val KEY_LOG = "log("
const val KEY_PERCENT = "%"
val OPERATORS by lazy {
listOf(
KEY_PLUS,
KEY_MINUS,
KEY_MINUS_DISPLAY,
KEY_MULTIPLY,
KEY_MULTIPLY_DISPLAY,
KEY_DIVIDE,
KEY_DIVIDE_DISPLAY,
KEY_SQRT,
KEY_EXPONENT,
)
}
val DIGITS by lazy {
listOf(
KEY_1,
KEY_2,
KEY_3,
KEY_4,
KEY_5,
KEY_6,
KEY_7,
KEY_8,
KEY_9,
KEY_0,
)
}
val INTERNAL_DISPLAY: Map<String, String> = hashMapOf(
KEY_MINUS to KEY_MINUS_DISPLAY,
KEY_MULTIPLY to KEY_MULTIPLY_DISPLAY,
KEY_DIVIDE to KEY_DIVIDE_DISPLAY
)

117
core/base/src/main/java/com/sadellie/unitto/core/base/Token.kt Normal file
View File

@ -0,0 +1,117 @@
/*
* Unitto is a unit converter for Android
* Copyright (c) 2022-2023 Elshan Agaev
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.sadellie.unitto.core.base
object Token {
const val _1 = "1"
const val _2 = "2"
const val _3 = "3"
const val _4 = "4"
const val _5 = "5"
const val _6 = "6"
const val _7 = "7"
const val _8 = "8"
const val _9 = "9"
const val _0 = "0"
const val baseA = "A"
const val baseB = "B"
const val baseC = "C"
const val baseD = "D"
const val baseE = "E"
const val baseF = "F"
const val dot = "."
const val comma = ","
const val E = "E"
const val plus = "+"
const val minus = "-"
const val minusDisplay = "–"
const val divide = "/"
const val divideDisplay = "÷"
const val multiply = "*"
const val multiplyDisplay = "×"
const val leftBracket = "("
const val rightBracket = ")"
const val exponent = "^"
const val sqrt = "√"
const val pi = "π"
const val factorial = "!"
const val sin = "sin("
const val cos = "cos("
const val tan = "tan("
const val e = "e"
const val modulo = "#"
const val ln = "ln("
const val log = "log("
const val percent = "%"
val operators by lazy {
listOf(
plus,
minus,
minusDisplay,
multiply,
multiplyDisplay,
divide,
divideDisplay,
sqrt,
exponent,
)
}
val digits by lazy {
listOf(
_1,
_2,
_3,
_4,
_5,
_6,
_7,
_8,
_9,
_0,
)
}
val internalToDisplay: Map<String, String> = hashMapOf(
minus to minusDisplay,
multiply to multiplyDisplay,
divide to divideDisplay
)
val knownSymbols: List<String> by lazy {
listOf(
sin, cos, tan, ln, log,
leftBracket, rightBracket,
exponent, sqrt, factorial,
modulo, e, percent, pi,
multiply, multiplyDisplay,
plus, minus, minusDisplay, divide, divideDisplay,
baseA, baseB, baseC, baseD, baseE, baseF,
_1, _2, _3, _4, _5, _6, _7, _8, _9, _0,
dot
)
}
}

29
core/ui/src/main/java/com/sadellie/unitto/core/ui/Formatter.kt
View File

@ -20,12 +20,7 @@ package com.sadellie.unitto.core.ui
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.ui.res.stringResource import androidx.compose.ui.res.stringResource
import com.sadellie.unitto.core.base.INTERNAL_DISPLAY import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_COMMA
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_E
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.Separator import com.sadellie.unitto.core.base.Separator
import java.math.BigDecimal import java.math.BigDecimal
import java.math.RoundingMode import java.math.RoundingMode
@ -51,7 +46,7 @@ open class UnittoFormatter {
/** /**
* Fractional part separator. * Fractional part separator.
*/ */
var fractional = KEY_COMMA var fractional = Token.comma
private val timeDivisions by lazy { private val timeDivisions by lazy {
mapOf( mapOf(
@ -77,7 +72,7 @@ open class UnittoFormatter {
Separator.COMMA -> COMMA Separator.COMMA -> COMMA
else -> SPACE else -> SPACE
} }
fractional = if (separator == Separator.PERIOD) KEY_COMMA else KEY_DOT fractional = if (separator == Separator.PERIOD) Token.comma else Token.dot
} }
/** /**
@ -92,7 +87,7 @@ open class UnittoFormatter {
*/ */
fun format(input: String): String { fun format(input: String): String {
// Don't do anything to engineering string. // Don't do anything to engineering string.
if (input.contains(KEY_E)) return input.replace(KEY_DOT, fractional) if (input.contains(Token.E)) return input.replace(Token.dot, fractional)
var output = input var output = input
@ -103,7 +98,7 @@ open class UnittoFormatter {
output = output.replace(it, formatNumber(it)) output = output.replace(it, formatNumber(it))
} }
INTERNAL_DISPLAY.forEach { Token.internalToDisplay.forEach {
output = output.replace(it.key, it.value) output = output.replace(it.key, it.value)
} }
@ -134,7 +129,7 @@ open class UnittoFormatter {
Separator.COMMA -> COMMA Separator.COMMA -> COMMA
else -> SPACE else -> SPACE
} }
val sFractional = if (separator == Separator.PERIOD) KEY_COMMA else KEY_DOT val sFractional = if (separator == Separator.PERIOD) Token.comma else Token.dot
return input return input
.replace(sGrouping, grouping) .replace(sGrouping, grouping)
@ -144,7 +139,7 @@ open class UnittoFormatter {
fun removeFormat(input: String): String { fun removeFormat(input: String): String {
return input return input
.replace(grouping, "") .replace(grouping, "")
.replace(fractional, KEY_DOT) .replace(fractional, Token.dot)
} }
/** /**
@ -182,25 +177,25 @@ open class UnittoFormatter {
*/ */
@Composable @Composable
fun formatTime(input: String, basicUnit: BigDecimal?): String { fun formatTime(input: String, basicUnit: BigDecimal?): String {
if (basicUnit == null) return KEY_0 if (basicUnit == null) return Token._0
try { try {
// Don't need magic if the input is zero // Don't need magic if the input is zero
if (BigDecimal(input).compareTo(BigDecimal.ZERO) == 0) return KEY_0 if (BigDecimal(input).compareTo(BigDecimal.ZERO) == 0) return Token._0
} catch (e: NumberFormatException) { } catch (e: NumberFormatException) {
// For case such as "10-" and "(" // For case such as "10-" and "("
return KEY_0 return Token._0
} }
// Attoseconds don't need "magic" // Attoseconds don't need "magic"
if (basicUnit.compareTo(BigDecimal.ONE) == 0) return formatNumber(input) if (basicUnit.compareTo(BigDecimal.ONE) == 0) return formatNumber(input)
var result = if (input.startsWith(KEY_MINUS)) KEY_MINUS else "" var result = if (input.startsWith(Token.minus)) Token.minus else ""
var remainingSeconds = BigDecimal(input) var remainingSeconds = BigDecimal(input)
.abs() .abs()
.multiply(basicUnit) .multiply(basicUnit)
.setScale(0, RoundingMode.HALF_EVEN) .setScale(0, RoundingMode.HALF_EVEN)
if (remainingSeconds.compareTo(BigDecimal.ZERO) == 0) return KEY_0 if (remainingSeconds.compareTo(BigDecimal.ZERO) == 0) return Token._0
timeDivisions.forEach { (timeStr, divider) -> timeDivisions.forEach { (timeStr, divider) ->
val division = remainingSeconds.divideAndRemainder(divider) val division = remainingSeconds.divideAndRemainder(divider)

15
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/CalculatorViewModel.kt
View File

@ -20,10 +20,7 @@ package com.sadellie.unitto.feature.calculator
import androidx.lifecycle.ViewModel import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope import androidx.lifecycle.viewModelScope
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.data.calculator.CalculatorHistoryRepository import com.sadellie.unitto.data.calculator.CalculatorHistoryRepository
import com.sadellie.unitto.data.common.setMinimumRequiredScale import com.sadellie.unitto.data.common.setMinimumRequiredScale
import com.sadellie.unitto.data.common.toStringWith import com.sadellie.unitto.data.common.toStringWith
@ -44,8 +41,8 @@ import kotlinx.coroutines.launch
import org.mariuszgromada.math.mxparser.Expression import org.mariuszgromada.math.mxparser.Expression
import java.math.BigDecimal import java.math.BigDecimal
import javax.inject.Inject import javax.inject.Inject
import org.mariuszgromada.math.mxparser.mXparser as MathParser
import org.mariuszgromada.math.mxparser.License as MathParserLicense import org.mariuszgromada.math.mxparser.License as MathParserLicense
import org.mariuszgromada.math.mxparser.mXparser as MathParser
@HiltViewModel @HiltViewModel
internal class CalculatorViewModel @Inject constructor( internal class CalculatorViewModel @Inject constructor(
@ -169,11 +166,11 @@ internal class CalculatorViewModel @Inject constructor(
*/ */
private val String.clean: String private val String.clean: String
get() { get() {
val leftBrackets = count { it.toString() == KEY_LEFT_BRACKET } val leftBrackets = count { it.toString() == Token.leftBracket }
val rightBrackets = count { it.toString() == KEY_RIGHT_BRACKET } val rightBrackets = count { it.toString() == Token.rightBracket }
val neededBrackets = leftBrackets - rightBrackets val neededBrackets = leftBrackets - rightBrackets
return replace(KEY_MINUS_DISPLAY, KEY_MINUS) return replace(Token.minusDisplay, Token.minus)
.plus(KEY_RIGHT_BRACKET.repeat(neededBrackets.coerceAtLeast(0))) .plus(Token.rightBracket.repeat(neededBrackets.coerceAtLeast(0)))
} }
init { init {

71
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/TextFieldController.kt
View File

@ -20,44 +20,7 @@ package com.sadellie.unitto.feature.calculator
import androidx.compose.ui.text.TextRange import androidx.compose.ui.text.TextRange
import androidx.compose.ui.text.input.TextFieldValue import androidx.compose.ui.text.input.TextFieldValue
import com.sadellie.unitto.core.base.KEY_0 import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_BASE_A
import com.sadellie.unitto.core.base.KEY_BASE_B
import com.sadellie.unitto.core.base.KEY_BASE_C
import com.sadellie.unitto.core.base.KEY_BASE_D
import com.sadellie.unitto.core.base.KEY_BASE_E
import com.sadellie.unitto.core.base.KEY_BASE_F
import com.sadellie.unitto.core.base.KEY_COS
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DIVIDE_DISPLAY
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_E_SMALL
import com.sadellie.unitto.core.base.KEY_FACTORIAL
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_LN
import com.sadellie.unitto.core.base.KEY_LOG
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
import com.sadellie.unitto.core.base.KEY_MODULO
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_MULTIPLY_DISPLAY
import com.sadellie.unitto.core.base.KEY_PERCENT
import com.sadellie.unitto.core.base.KEY_PI
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SIN
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.base.KEY_TAN
import com.sadellie.unitto.core.base.Separator import com.sadellie.unitto.core.base.Separator
import com.sadellie.unitto.core.ui.UnittoFormatter import com.sadellie.unitto.core.ui.UnittoFormatter
import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.MutableStateFlow
@ -80,20 +43,6 @@ class TextFieldController @Inject constructor() {
private val cursorFixer by lazy { CursorFixer() } private val cursorFixer by lazy { CursorFixer() }
private val knownSymbols: List<String> by lazy {
listOf(
KEY_SIN, KEY_COS, KEY_TAN, KEY_LN, KEY_LOG,
KEY_LEFT_BRACKET, KEY_RIGHT_BRACKET,
KEY_EXPONENT, KEY_SQRT, KEY_FACTORIAL,
KEY_MODULO, KEY_E_SMALL, KEY_PERCENT, KEY_PI,
KEY_MULTIPLY, KEY_MULTIPLY_DISPLAY,
KEY_PLUS, KEY_MINUS, KEY_MINUS_DISPLAY, KEY_DIVIDE, KEY_DIVIDE_DISPLAY,
KEY_BASE_A, KEY_BASE_B, KEY_BASE_C, KEY_BASE_D, KEY_BASE_E, KEY_BASE_F,
KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
KEY_DOT,
)
}
fun addToInput(symbols: String) { fun addToInput(symbols: String) {
val text = input.value.text val text = input.value.text
@ -175,7 +124,7 @@ class TextFieldController @Inject constructor() {
fun inputTextWithoutFormatting() = input.value.text fun inputTextWithoutFormatting() = input.value.text
.replace(localFormatter.grouping, "") .replace(localFormatter.grouping, "")
.replace(localFormatter.fractional, KEY_DOT) .replace(localFormatter.fractional, Token.dot)
private fun String.fixFormat(): String = localFormatter.reFormat(this) private fun String.fixFormat(): String = localFormatter.reFormat(this)
@ -184,7 +133,7 @@ class TextFieldController @Inject constructor() {
var garbage = clearStr var garbage = clearStr
// String with unknown symbols // String with unknown symbols
knownSymbols.forEach { Token.knownSymbols.forEach {
garbage = garbage.replace(it, " ") garbage = garbage.replace(it, " ")
} }
@ -194,17 +143,21 @@ class TextFieldController @Inject constructor() {
} }
clearStr = clearStr clearStr = clearStr
.replace(KEY_DIVIDE, KEY_DIVIDE_DISPLAY) .replace(Token.divide, Token.divideDisplay)
.replace(KEY_MULTIPLY, KEY_MULTIPLY_DISPLAY) .replace(Token.multiply, Token.multiplyDisplay)
.replace(KEY_MINUS, KEY_MINUS_DISPLAY) .replace(Token.minus, Token.minusDisplay)
return clearStr return clearStr
} }
inner class CursorFixer { inner class CursorFixer {
val illegalTokens by lazy { private val illegalTokens by lazy {
listOf( listOf(
KEY_COS, KEY_SIN, KEY_LN, KEY_LOG, KEY_TAN Token.cos,
Token.sin,
Token.ln,
Token.log,
Token.tan
) )
} }

150
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/CalculatorKeyboard.kt
View File

@ -46,35 +46,7 @@ import androidx.compose.ui.draw.rotate
import androidx.compose.ui.platform.LocalConfiguration import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import com.sadellie.unitto.core.base.KEY_0 import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_COS
import com.sadellie.unitto.core.base.KEY_DIVIDE_DISPLAY
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_E_SMALL
import com.sadellie.unitto.core.base.KEY_FACTORIAL
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_LN
import com.sadellie.unitto.core.base.KEY_LOG
import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
import com.sadellie.unitto.core.base.KEY_MODULO
import com.sadellie.unitto.core.base.KEY_MULTIPLY_DISPLAY
import com.sadellie.unitto.core.base.KEY_PERCENT
import com.sadellie.unitto.core.base.KEY_PI
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SIN
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.base.KEY_TAN
import com.sadellie.unitto.core.ui.Formatter import com.sadellie.unitto.core.ui.Formatter
import com.sadellie.unitto.core.ui.common.KeyboardButtonAdditional import com.sadellie.unitto.core.ui.common.KeyboardButtonAdditional
import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled
@ -163,7 +135,7 @@ private fun PortraitKeyboard(
clearSymbols: () -> Unit, clearSymbols: () -> Unit,
evaluate: () -> Unit evaluate: () -> Unit
) { ) {
val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma } val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
var showAdditional: Boolean by remember { mutableStateOf(false) } var showAdditional: Boolean by remember { mutableStateOf(false) }
val expandRotation: Float by animateFloatAsState( val expandRotation: Float by animateFloatAsState(
targetValue = if (showAdditional) 0f else 180f, targetValue = if (showAdditional) 0f else 180f,
@ -190,24 +162,24 @@ private fun PortraitKeyboard(
// Additional buttons // Additional buttons
Column(modifier = weightModifier) { Column(modifier = weightModifier) {
Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) { Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(KEY_SQRT) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(Token.sqrt) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(KEY_PI) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(Token.pi) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(KEY_EXPONENT) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(Token.exponent) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(KEY_FACTORIAL) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(Token.factorial) }
} }
AnimatedVisibility(visible = showAdditional) { AnimatedVisibility(visible = showAdditional) {
Column { Column {
Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) { Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
KeyboardButtonAdditional(additionalButtonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() } KeyboardButtonAdditional(additionalButtonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(KEY_SIN) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(Token.sin) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(KEY_COS) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(Token.cos) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(KEY_TAN) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(Token.tan) }
} }
Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) { Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(KEY_MODULO) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(Token.modulo) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.E, allowVibration) { addSymbol(KEY_E_SMALL) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.E, allowVibration) { addSymbol(Token.e) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(KEY_LN) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(Token.ln) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Log, allowVibration) { addSymbol(KEY_LOG) } KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Log, allowVibration) { addSymbol(Token.log) }
} }
} }
} }
@ -222,33 +194,33 @@ private fun PortraitKeyboard(
} }
Row(weightModifier) { Row(weightModifier) {
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(KEY_LEFT_BRACKET) } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(Token.leftBracket) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(KEY_RIGHT_BRACKET) } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(Token.rightBracket) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(KEY_PERCENT) } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(Token.percent) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(KEY_DIVIDE_DISPLAY) } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(Token.divideDisplay) }
} }
Row(weightModifier) { Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(KEY_7) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(Token._7) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(KEY_8) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(Token._8) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(KEY_9) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(Token._9) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(KEY_MULTIPLY_DISPLAY) } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(Token.multiplyDisplay) }
} }
Row(weightModifier) { Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(KEY_4) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(Token._4) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(KEY_5) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(Token._5) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(KEY_6) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(Token._6) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(KEY_MINUS_DISPLAY) } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(Token.minusDisplay) }
} }
Row(weightModifier) { Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(KEY_1) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(Token._1) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(KEY_2) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(Token._2) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(KEY_3) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(Token._3) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(KEY_PLUS) } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(Token.plus) }
} }
Row(weightModifier) { Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(KEY_0) } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(Token._0) }
KeyboardButtonLight(mainButtonModifier, fractionalIcon, allowVibration) { addSymbol(KEY_DOT) } KeyboardButtonLight(mainButtonModifier, fractionalIcon, allowVibration) { addSymbol(Token.dot) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() } KeyboardButtonLight(mainButtonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Equal, allowVibration) { evaluate() } KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Equal, allowVibration) { evaluate() }
} }
@ -266,52 +238,52 @@ private fun LandscapeKeyboard(
clearSymbols: () -> Unit, clearSymbols: () -> Unit,
evaluate: () -> Unit evaluate: () -> Unit
) { ) {
val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma } val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
Column(modifier = modifier) { Column(modifier = modifier) {
val buttonModifier = Modifier.weight(1f).padding(2.dp) val buttonModifier = Modifier.weight(1f).padding(2.dp)
Row(Modifier.weight(1f)) { Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() } KeyboardButtonAdditional(buttonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(KEY_SQRT) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(Token.sqrt) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(KEY_PI) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(Token.pi) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(KEY_7) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(Token._7) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(KEY_8) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(Token._8) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(KEY_9) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(Token._9) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(KEY_LEFT_BRACKET) } KeyboardButtonFilled(buttonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(Token.leftBracket) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(KEY_RIGHT_BRACKET) } KeyboardButtonFilled(buttonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(Token.rightBracket) }
} }
Row(Modifier.weight(1f)) { Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(KEY_MODULO) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(Token.modulo) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(KEY_EXPONENT) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(Token.exponent) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(KEY_FACTORIAL) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(Token.factorial) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(KEY_4) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(Token._4) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(KEY_5) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(Token._5) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(KEY_6) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(Token._6) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(KEY_MULTIPLY_DISPLAY) } KeyboardButtonFilled(buttonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(Token.multiplyDisplay) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(KEY_DIVIDE_DISPLAY) } KeyboardButtonFilled(buttonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(Token.divideDisplay) }
} }
Row(Modifier.weight(1f)) { Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(KEY_SIN) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(Token.sin) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(KEY_COS) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(Token.cos) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(KEY_TAN) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(Token.tan) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(KEY_1) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(Token._1) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(KEY_2) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(Token._2) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(KEY_3) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(Token._3) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(KEY_MINUS_DISPLAY) } KeyboardButtonFilled(buttonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(Token.minusDisplay) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(KEY_PERCENT) } KeyboardButtonFilled(buttonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(Token.percent) }
} }
Row(Modifier.weight(1f)) { Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, UnittoIcons.E, allowVibration) { addSymbol(KEY_E_SMALL) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.E, allowVibration) { addSymbol(Token.e) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(KEY_LN) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(Token.ln) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Log, allowVibration) { addSymbol(KEY_LOG) } KeyboardButtonAdditional(buttonModifier, UnittoIcons.Log, allowVibration) { addSymbol(Token.log) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(KEY_0) } KeyboardButtonLight(buttonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(Token._0) }
KeyboardButtonLight(buttonModifier, fractionalIcon, allowVibration) { addSymbol(KEY_DOT) } KeyboardButtonLight(buttonModifier, fractionalIcon, allowVibration) { addSymbol(Token.dot) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() } KeyboardButtonLight(buttonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(KEY_PLUS) } KeyboardButtonFilled(buttonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(Token.plus) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Equal, allowVibration) { evaluate() } KeyboardButtonFilled(buttonModifier, UnittoIcons.Equal, allowVibration) { evaluate() }
} }
} }

2
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/InputTextField.kt
View File

@ -50,7 +50,7 @@ internal fun InputTextField(
derivedStateOf { derivedStateOf {
value.copy( value.copy(
// We replace this because internally input value is already formatted, but uses // We replace this because internally input value is already formatted, but uses
// COMMA as separator. // comma as separator.
Formatter.fromSeparator(value.text, Separator.COMMA) Formatter.fromSeparator(value.text, Separator.COMMA)
) )
} }

6
feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterUIState.kt
View File

@ -18,7 +18,7 @@
package com.sadellie.unitto.feature.converter package com.sadellie.unitto.feature.converter
import com.sadellie.unitto.core.base.KEY_0 import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.data.model.AbstractUnit import com.sadellie.unitto.data.model.AbstractUnit
/** /**
@ -37,9 +37,9 @@ import com.sadellie.unitto.data.model.AbstractUnit
* @property allowVibration When true will vibrate on button clicks. * @property allowVibration When true will vibrate on button clicks.
*/ */
data class ConverterUIState( data class ConverterUIState(
val inputValue: String = KEY_0, val inputValue: String = Token._0,
val calculatedValue: String? = null, val calculatedValue: String? = null,
val resultValue: String = KEY_0, val resultValue: String = Token._0,
val showLoading: Boolean = true, val showLoading: Boolean = true,
val showError: Boolean = false, val showError: Boolean = false,
val unitFrom: AbstractUnit? = null, val unitFrom: AbstractUnit? = null,

115
feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterViewModel.kt
View File

@ -22,27 +22,7 @@ import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope import androidx.lifecycle.viewModelScope
import com.github.keelar.exprk.ExpressionException import com.github.keelar.exprk.ExpressionException
import com.github.keelar.exprk.Expressions import com.github.keelar.exprk.Expressions
import com.sadellie.unitto.core.base.DIGITS import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.base.OPERATORS
import com.sadellie.unitto.data.common.setMinimumRequiredScale import com.sadellie.unitto.data.common.setMinimumRequiredScale
import com.sadellie.unitto.data.common.toStringWith import com.sadellie.unitto.data.common.toStringWith
import com.sadellie.unitto.data.common.trimZeros import com.sadellie.unitto.data.common.trimZeros
@ -103,7 +83,7 @@ class ConverterViewModel @Inject constructor(
/** /**
* Current input. Used when converting units. * Current input. Used when converting units.
*/ */
private val _input: MutableStateFlow<String> = MutableStateFlow(KEY_0) private val _input: MutableStateFlow<String> = MutableStateFlow(Token._0)
/** /**
* Calculation result. Null when [_input] is not an expression. * Calculation result. Null when [_input] is not an expression.
@ -118,7 +98,7 @@ class ConverterViewModel @Inject constructor(
/** /**
* Conversion result. * Conversion result.
*/ */
private val _result: MutableStateFlow<String> = MutableStateFlow(KEY_0) private val _result: MutableStateFlow<String> = MutableStateFlow(Token._0)
/** /**
* True when loading something from network. * True when loading something from network.
@ -180,23 +160,23 @@ class ConverterViewModel @Inject constructor(
val lastSecondSymbol: String? = lastTwoSymbols.getOrNull(0) val lastSecondSymbol: String? = lastTwoSymbols.getOrNull(0)
when (symbolToAdd) { when (symbolToAdd) {
KEY_PLUS, KEY_DIVIDE, KEY_MULTIPLY, KEY_EXPONENT -> { Token.plus, Token.divide, Token.multiply, Token.exponent -> {
when { when {
// Don't need expressions that start with zero // Don't need expressions that start with zero
(_input.value == KEY_0) -> {} (_input.value == Token._0) -> {}
(_input.value == KEY_MINUS) -> {} (_input.value == Token.minus) -> {}
(lastSymbol == KEY_LEFT_BRACKET) -> {} (lastSymbol == Token.leftBracket) -> {}
(lastSymbol == KEY_SQRT) -> {} (lastSymbol == Token.sqrt) -> {}
/** /**
* For situations like "50+-", when user clicks "/" we delete "-" so it becomes * For situations like "50+-", when user clicks "/" we delete "-" so it becomes
* "50+". We don't add "/' here. User will click "/" second time and the input * "50+". We don't add "/' here. User will click "/" second time and the input
* will be "50/". * will be "50/".
*/ */
(lastSecondSymbol in OPERATORS) and (lastSymbol == KEY_MINUS) -> { (lastSecondSymbol in Token.operators) and (lastSymbol == Token.minus) -> {
deleteDigit() deleteDigit()
} }
// Don't allow multiple operators near each other // Don't allow multiple operators near each other
(lastSymbol in OPERATORS) -> { (lastSymbol in Token.operators) -> {
deleteDigit() deleteDigit()
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
@ -205,29 +185,30 @@ class ConverterViewModel @Inject constructor(
} }
} }
} }
KEY_0 -> { Token._0 -> {
when { when {
// Don't add zero if the input is already a zero // Don't add zero if the input is already a zero
(_input.value == KEY_0) -> {} (_input.value == Token._0) -> {}
(lastSymbol == KEY_RIGHT_BRACKET) -> { (lastSymbol == Token.rightBracket) -> {
processInput(KEY_MULTIPLY) processInput(Token.multiply)
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
// Prevents things like "-00" and "4+000" // Prevents things like "-00" and "4+000"
((lastSecondSymbol in OPERATORS + KEY_LEFT_BRACKET) and (lastSymbol == KEY_0)) -> {} ((lastSecondSymbol in Token.operators + Token.leftBracket) and (lastSymbol == Token._0)) -> {}
else -> { else -> {
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
} }
} }
KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9 -> { Token._1, Token._2, Token._3, Token._4, Token._5,
Token._6, Token._7, Token._8, Token._9 -> {
// Replace single zero (default input) if it's here // Replace single zero (default input) if it's here
when { when {
(_input.value == KEY_0) -> { (_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false) setInputSymbols(symbolToAdd, false)
} }
(lastSymbol == KEY_RIGHT_BRACKET) -> { (lastSymbol == Token.rightBracket) -> {
processInput(KEY_MULTIPLY) processInput(Token.multiply)
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
else -> { else -> {
@ -235,16 +216,16 @@ class ConverterViewModel @Inject constructor(
} }
} }
} }
KEY_MINUS -> { Token.minus -> {
when { when {
// Replace single zero with minus (to support negative numbers) // Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> { (_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false) setInputSymbols(symbolToAdd, false)
} }
// Don't allow multiple minuses near each other // Don't allow multiple minuses near each other
(lastSymbol.compareTo(KEY_MINUS) == 0) -> {} (lastSymbol.compareTo(Token.minus) == 0) -> {}
// Don't allow plus and minus be near each other // Don't allow plus and minus be near each other
(lastSymbol == KEY_PLUS) -> { (lastSymbol == Token.plus) -> {
deleteDigit() deleteDigit()
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
@ -253,22 +234,22 @@ class ConverterViewModel @Inject constructor(
} }
} }
} }
KEY_DOT -> { Token.dot -> {
if (!_input.value if (!_input.value
.takeLastWhile { it.toString() !in OPERATORS.minus(KEY_DOT) } .takeLastWhile { it.toString() !in Token.operators.minus(Token.dot) }
.contains(KEY_DOT) .contains(Token.dot)
) { ) {
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
} }
KEY_LEFT_BRACKET -> { Token.leftBracket -> {
when { when {
// Replace single zero with minus (to support negative numbers) // Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> { (_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false) setInputSymbols(symbolToAdd, false)
} }
(lastSymbol == KEY_RIGHT_BRACKET) || (lastSymbol in DIGITS) || (lastSymbol == KEY_DOT) -> { (lastSymbol == Token.rightBracket) || (lastSymbol in Token.digits) || (lastSymbol == Token.dot) -> {
processInput(KEY_MULTIPLY) processInput(Token.multiply)
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
else -> { else -> {
@ -276,14 +257,14 @@ class ConverterViewModel @Inject constructor(
} }
} }
} }
KEY_RIGHT_BRACKET -> { Token.rightBracket -> {
when { when {
// Replace single zero with minus (to support negative numbers) // Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> {} (_input.value == Token._0) -> {}
(lastSymbol == KEY_LEFT_BRACKET) -> {} (lastSymbol == Token.leftBracket) -> {}
( (
_latestInputStack.filter { it == KEY_LEFT_BRACKET }.size == _latestInputStack.filter { it == Token.leftBracket }.size ==
_latestInputStack.filter { it == KEY_RIGHT_BRACKET }.size _latestInputStack.filter { it == Token.rightBracket }.size
) -> { ) -> {
} }
else -> { else -> {
@ -291,14 +272,14 @@ class ConverterViewModel @Inject constructor(
} }
} }
} }
KEY_SQRT -> { Token.sqrt -> {
when { when {
// Replace single zero with minus (to support negative numbers) // Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> { (_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false) setInputSymbols(symbolToAdd, false)
} }
(lastSymbol == KEY_RIGHT_BRACKET) || (lastSymbol in DIGITS) || (lastSymbol == KEY_DOT) -> { (lastSymbol == Token.rightBracket) || (lastSymbol in Token.digits) || (lastSymbol == Token.dot) -> {
processInput(KEY_MULTIPLY) processInput(Token.multiply)
setInputSymbols(symbolToAdd) setInputSymbols(symbolToAdd)
} }
else -> { else -> {
@ -309,7 +290,7 @@ class ConverterViewModel @Inject constructor(
else -> { else -> {
when { when {
// Replace single zero with minus (to support negative numbers) // Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> { (_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false) setInputSymbols(symbolToAdd, false)
} }
else -> { else -> {
@ -373,13 +354,13 @@ class ConverterViewModel @Inject constructor(
*/ */
fun deleteDigit() { fun deleteDigit() {
// Default input, don't delete // Default input, don't delete
if (_input.value == KEY_0) return if (_input.value == Token._0) return
val lastSymbol = _latestInputStack.removeLast() val lastSymbol = _latestInputStack.removeLast()
// If this value are same, it means that after deleting there will be no symbols left, set to default // If this value are same, it means that after deleting there will be no symbols left, set to default
if (lastSymbol == _input.value) { if (lastSymbol == _input.value) {
setInputSymbols(KEY_0, false) setInputSymbols(Token._0, false)
} else { } else {
_input.update { it.removeSuffix(lastSymbol) } _input.update { it.removeSuffix(lastSymbol) }
} }
@ -389,7 +370,7 @@ class ConverterViewModel @Inject constructor(
* Clear [_input]. * Clear [_input].
*/ */
fun clearInput() { fun clearInput() {
setInputSymbols(KEY_0, false) setInputSymbols(Token._0, false)
} }
fun toggleFormatTime() { fun toggleFormatTime() {
@ -438,10 +419,10 @@ class ConverterViewModel @Inject constructor(
// Now we close open brackets that user didn't close // Now we close open brackets that user didn't close
// AUTOCLOSE ALL BRACKETS // AUTOCLOSE ALL BRACKETS
val leftBrackets = _input.value.count { it.toString() == KEY_LEFT_BRACKET } val leftBrackets = _input.value.count { it.toString() == Token.leftBracket }
val rightBrackets = _input.value.count { it.toString() == KEY_RIGHT_BRACKET } val rightBrackets = _input.value.count { it.toString() == Token.rightBracket }
val neededBrackets = leftBrackets - rightBrackets val neededBrackets = leftBrackets - rightBrackets
if (neededBrackets > 0) cleanInput += KEY_RIGHT_BRACKET.repeat(neededBrackets) if (neededBrackets > 0) cleanInput += Token.rightBracket.repeat(neededBrackets)
// Now we evaluate expression in input // Now we evaluate expression in input
val evaluationResult: BigDecimal = try { val evaluationResult: BigDecimal = try {
@ -466,7 +447,7 @@ class ConverterViewModel @Inject constructor(
// 123.456 will be true // 123.456 will be true
// -123.456 will be true // -123.456 will be true
// -123.456-123 will be false (first minus gets removed, ending with 123.456) // -123.456-123 will be false (first minus gets removed, ending with 123.456)
if (_input.value.removePrefix(KEY_MINUS).all { it.toString() !in OPERATORS }) { if (_input.value.removePrefix(Token.minus).all { it.toString() !in Token.operators }) {
// No operators // No operators
_calculated.update { null } _calculated.update { null }
} else { } else {

98
feature/converter/src/main/java/com/sadellie/unitto/feature/converter/components/Keyboard.kt
View File

@ -27,31 +27,7 @@ import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import com.sadellie.unitto.core.base.KEY_0 import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_BASE_A
import com.sadellie.unitto.core.base.KEY_BASE_B
import com.sadellie.unitto.core.base.KEY_BASE_C
import com.sadellie.unitto.core.base.KEY_BASE_D
import com.sadellie.unitto.core.base.KEY_BASE_E
import com.sadellie.unitto.core.base.KEY_BASE_F
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.ui.Formatter import com.sadellie.unitto.core.ui.Formatter
import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled
import com.sadellie.unitto.core.ui.common.KeyboardButtonLight import com.sadellie.unitto.core.ui.common.KeyboardButtonLight
@ -119,7 +95,7 @@ private fun DefaultKeyboard(
deleteDigit: () -> Unit, deleteDigit: () -> Unit,
allowVibration: Boolean allowVibration: Boolean
) { ) {
val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma } val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
Column { Column {
// Button modifier // Button modifier
val bModifier = Modifier val bModifier = Modifier
@ -129,34 +105,34 @@ private fun DefaultKeyboard(
// Column modifier // Column modifier
val cModifier = Modifier.weight(1f) val cModifier = Modifier.weight(1f)
Row(cModifier) { Row(cModifier) {
KeyboardButtonFilled(bModifier, UnittoIcons.LeftBracket, allowVibration) { addDigit(KEY_LEFT_BRACKET) } KeyboardButtonFilled(bModifier, UnittoIcons.LeftBracket, allowVibration) { addDigit(Token.leftBracket) }
KeyboardButtonFilled(bModifier, UnittoIcons.RightBracket, allowVibration) { addDigit(KEY_RIGHT_BRACKET) } KeyboardButtonFilled(bModifier, UnittoIcons.RightBracket, allowVibration) { addDigit(Token.rightBracket) }
KeyboardButtonFilled(bModifier, UnittoIcons.Exponent, allowVibration) { addDigit(KEY_EXPONENT) } KeyboardButtonFilled(bModifier, UnittoIcons.Exponent, allowVibration) { addDigit(Token.exponent) }
KeyboardButtonFilled(bModifier, UnittoIcons.SquareRoot, allowVibration) { addDigit(KEY_SQRT) } KeyboardButtonFilled(bModifier, UnittoIcons.SquareRoot, allowVibration) { addDigit(Token.sqrt) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(KEY_7) } KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(Token._7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(KEY_8) } KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(Token._8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(KEY_9) } KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(Token._9) }
KeyboardButtonFilled(bModifier, UnittoIcons.Divide, allowVibration) { addDigit(KEY_DIVIDE) } KeyboardButtonFilled(bModifier, UnittoIcons.Divide, allowVibration) { addDigit(Token.divide) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(KEY_4) } KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(Token._4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(KEY_5) } KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(Token._5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(KEY_6) } KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(Token._6) }
KeyboardButtonFilled(bModifier, UnittoIcons.Multiply, allowVibration) { addDigit(KEY_MULTIPLY) } KeyboardButtonFilled(bModifier, UnittoIcons.Multiply, allowVibration) { addDigit(Token.multiply) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(KEY_1) } KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(Token._1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(KEY_2) } KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(Token._2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(KEY_3) } KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(Token._3) }
KeyboardButtonFilled(bModifier, UnittoIcons.Minus, allowVibration) { addDigit(KEY_MINUS) } KeyboardButtonFilled(bModifier, UnittoIcons.Minus, allowVibration) { addDigit(Token.minus) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(KEY_0) } KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(Token._0) }
KeyboardButtonLight(bModifier, fractionalIcon, allowVibration) { addDigit(KEY_DOT) } KeyboardButtonLight(bModifier, fractionalIcon, allowVibration) { addDigit(Token.dot) }
KeyboardButtonLight(bModifier, UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() } KeyboardButtonLight(bModifier, UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() }
KeyboardButtonFilled(bModifier, UnittoIcons.Plus, allowVibration) { addDigit(KEY_PLUS) } KeyboardButtonFilled(bModifier, UnittoIcons.Plus, allowVibration) { addDigit(Token.plus) }
} }
} }
} }
@ -178,32 +154,32 @@ private fun BaseKeyboard(
val cModifier = Modifier.weight(1f) val cModifier = Modifier.weight(1f)
Row(cModifier) { Row(cModifier) {
KeyboardButtonFilled(bModifier, UnittoIcons.KeyA, allowVibration) { addDigit(KEY_BASE_A) } KeyboardButtonFilled(bModifier, UnittoIcons.KeyA, allowVibration) { addDigit(Token.baseA) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyB, allowVibration) { addDigit(KEY_BASE_B) } KeyboardButtonFilled(bModifier, UnittoIcons.KeyB, allowVibration) { addDigit(Token.baseB) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyC, allowVibration) { addDigit(KEY_BASE_C) } KeyboardButtonFilled(bModifier, UnittoIcons.KeyC, allowVibration) { addDigit(Token.baseC) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonFilled(bModifier, UnittoIcons.KeyD, allowVibration) { addDigit(KEY_BASE_D) } KeyboardButtonFilled(bModifier, UnittoIcons.KeyD, allowVibration) { addDigit(Token.baseD) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyE, allowVibration) { addDigit(KEY_BASE_E) } KeyboardButtonFilled(bModifier, UnittoIcons.KeyE, allowVibration) { addDigit(Token.baseE) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyF, allowVibration) { addDigit(KEY_BASE_F) } KeyboardButtonFilled(bModifier, UnittoIcons.KeyF, allowVibration) { addDigit(Token.baseF) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(KEY_7) } KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(Token._7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(KEY_8) } KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(Token._8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(KEY_9) } KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(Token._9) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(KEY_4) } KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(Token._4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(KEY_5) } KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(Token._5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(KEY_6) } KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(Token._6) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(KEY_1) } KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(Token._1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(KEY_2) } KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(Token._2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(KEY_3) } KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(Token._3) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(KEY_0) } KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(Token._0) }
KeyboardButtonLight(Modifier.fillMaxSize().weight(2f).padding(4.dp), UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() } KeyboardButtonLight(Modifier.fillMaxSize().weight(2f).padding(4.dp), UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() }
} }
} }

45
feature/converter/src/test/java/com/sadellie/unitto/feature/converter/ConverterViewModelTest.kt
View File

@ -19,29 +19,10 @@
package com.sadellie.unitto.feature.converter package com.sadellie.unitto.feature.converter
import androidx.room.Room import androidx.room.Room
import com.sadellie.unitto.core.base.KEY_0 import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_COMMA
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.data.units.AllUnitsRepository
import com.sadellie.unitto.data.database.UnittoDatabase
import com.sadellie.unitto.data.database.UnitsRepository import com.sadellie.unitto.data.database.UnitsRepository
import com.sadellie.unitto.data.database.UnittoDatabase
import com.sadellie.unitto.data.units.AllUnitsRepository
import com.sadellie.unitto.data.userprefs.DataStoreModule import com.sadellie.unitto.data.userprefs.DataStoreModule
import com.sadellie.unitto.data.userprefs.UserPreferencesRepository import com.sadellie.unitto.data.userprefs.UserPreferencesRepository
import junit.framework.TestCase.assertEquals import junit.framework.TestCase.assertEquals
@ -201,9 +182,11 @@ class ConverterViewModelTest {
} }
listOf( listOf(
KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0, Token._1, Token._2, Token._3, Token._4, Token._5,
KEY_DOT, KEY_COMMA, KEY_LEFT_BRACKET, KEY_RIGHT_BRACKET, Token._6, Token._7, Token._8, Token._9, Token._0,
KEY_PLUS, KEY_MINUS, KEY_DIVIDE, KEY_MULTIPLY, KEY_EXPONENT, KEY_SQRT Token.dot, Token.comma, Token.leftBracket, Token.rightBracket,
Token.plus, Token.minus, Token.divide, Token.multiply,
Token.exponent, Token.sqrt
).forEach { ).forEach {
// We enter one symbol and delete it, should be default as a result // We enter one symbol and delete it, should be default as a result
viewModel.processInput(it) viewModel.processInput(it)
@ -216,9 +199,9 @@ class ConverterViewModelTest {
viewModel.deleteDigit() viewModel.deleteDigit()
// Now we check that we can delete multiple values // Now we check that we can delete multiple values
viewModel.processInput(KEY_3) viewModel.processInput(Token._3)
viewModel.processInput(KEY_SQRT) viewModel.processInput(Token.sqrt)
viewModel.processInput(KEY_9) viewModel.processInput(Token._9)
viewModel.deleteDigit() viewModel.deleteDigit()
assertEquals("3*√", viewModel.uiStateFlow.value.inputValue) assertEquals("3*√", viewModel.uiStateFlow.value.inputValue)
@ -231,12 +214,12 @@ class ConverterViewModelTest {
viewModel.uiStateFlow.collect() viewModel.uiStateFlow.collect()
} }
viewModel.processInput(KEY_3) viewModel.processInput(Token._3)
viewModel.clearInput() viewModel.clearInput()
assertEquals(null, viewModel.uiStateFlow.value.calculatedValue) assertEquals(null, viewModel.uiStateFlow.value.calculatedValue)
viewModel.processInput(KEY_3) viewModel.processInput(Token._3)
viewModel.processInput(KEY_MULTIPLY) viewModel.processInput(Token.multiply)
viewModel.clearInput() viewModel.clearInput()
assertEquals(null, viewModel.uiStateFlow.value.calculatedValue) assertEquals(null, viewModel.uiStateFlow.value.calculatedValue)

31
feature/epoch/src/main/java/com/sadellie/unitto/feature/epoch/component/EpochKeyboard.kt
View File

@ -25,16 +25,7 @@ import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import com.sadellie.unitto.core.base.KEY_0 import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.ui.common.KeyboardButtonLight import com.sadellie.unitto.core.ui.common.KeyboardButtonLight
import com.sadellie.unitto.core.ui.common.key.UnittoIcons import com.sadellie.unitto.core.ui.common.key.UnittoIcons
import com.sadellie.unitto.core.ui.common.key.unittoicons.Delete import com.sadellie.unitto.core.ui.common.key.unittoicons.Delete
@ -71,22 +62,22 @@ internal fun EpochKeyboard(
.weight(2f) .weight(2f)
.padding(4.dp) .padding(4.dp)
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key7, false) { addSymbol(KEY_7) } KeyboardButtonLight(bModifier, UnittoIcons.Key7, false) { addSymbol(Token._7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, false) { addSymbol(KEY_8) } KeyboardButtonLight(bModifier, UnittoIcons.Key8, false) { addSymbol(Token._8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, false) { addSymbol(KEY_9) } KeyboardButtonLight(bModifier, UnittoIcons.Key9, false) { addSymbol(Token._9) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key4, false) { addSymbol(KEY_4) } KeyboardButtonLight(bModifier, UnittoIcons.Key4, false) { addSymbol(Token._4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, false) { addSymbol(KEY_5) } KeyboardButtonLight(bModifier, UnittoIcons.Key5, false) { addSymbol(Token._5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, false) { addSymbol(KEY_6) } KeyboardButtonLight(bModifier, UnittoIcons.Key6, false) { addSymbol(Token._6) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key1, false) { addSymbol(KEY_1) } KeyboardButtonLight(bModifier, UnittoIcons.Key1, false) { addSymbol(Token._1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, false) { addSymbol(KEY_2) } KeyboardButtonLight(bModifier, UnittoIcons.Key2, false) { addSymbol(Token._2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, false) { addSymbol(KEY_3) } KeyboardButtonLight(bModifier, UnittoIcons.Key3, false) { addSymbol(Token._3) }
} }
Row(cModifier) { Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key0, false) { addSymbol(KEY_0) } KeyboardButtonLight(bModifier, UnittoIcons.Key0, false) { addSymbol(Token._0) }
KeyboardButtonLight(dModifier, UnittoIcons.Delete, false, clearSymbols) { deleteSymbol() } KeyboardButtonLight(dModifier, UnittoIcons.Delete, false, clearSymbols) { deleteSymbol() }
} }
} }