calculatorApp

Kalkulator Sederhana adalah aplikasi Android yang dirancang untuk melakukan operasi matematika dasar seperti penjumlahan, pengurangan, perkalian, dan pembagian. Aplikasi ini memanfaatkan Jetpack Compose untuk membuat antarmuka pengguna yang modern dan responsif. Dengan tampilan yang bersih dan intuitif, pengguna dapat dengan mudah memasukkan angka dan operator untuk menghitung hasil ekspresi matematika.

Fitur Utama:

1. Input Ekspresi: Pengguna dapat memasukkan angka dan operator matematika secara langsung pada bidang teks yang disediakan.
2. Tampilan Hasil: Hasil dari ekspresi yang dimasukkan akan ditampilkan secara real-time setelah pengguna menekan tombol "=".
3. Operasi Matematika: Mendukung operasi penjumlahan (+), pengurangan (-), perkalian (*), dan pembagian (/).
4. Tombol C: Tombol ini digunakan untuk menghapus semua input yang telah dimasukkan, memungkinkan pengguna untuk memulai perhitungan baru.
5. Desain Responsif: Antarmuka pengguna yang dirancang menggunakan Jetpack Compose memastikan aplikasi tetap responsif dan mudah digunakan pada berbagai ukuran layar.

Teknologi yang Digunakan:

• Jetpack Compose: Digunakan untuk membangun antarmuka pengguna modern dan deklaratif.
• Kotlin: Bahasa pemrograman utama untuk pengembangan aplikasi Android.
• Android Studio: Lingkungan pengembangan terintegrasi (IDE) yang digunakan untuk mengembangkan dan menguji aplikasi.

Cara Menggunakan:

1. Memasukkan Angka dan Operator: Gunakan tombol angka dan operator untuk membentuk ekspresi matematika.
2. Menghitung Hasil: Tekan tombol "=" untuk menghitung dan menampilkan hasil dari ekspresi yang dimasukkan.
3. Menghapus Input: Tekan tombol "C" untuk menghapus semua input dan memulai perhitungan baru.
   
   Source Code sebagai berikut:
   

   package com.example.calculatorapp
   
   import android.os.Bundle
   import androidx.activity.ComponentActivity
   import androidx.activity.compose.setContent
   import androidx.compose.foundation.background
   import androidx.compose.foundation.layout.*
   import androidx.compose.foundation.text.BasicTextField
   import androidx.compose.material3.*
   import androidx.compose.runtime.*
   import androidx.compose.ui.Alignment
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.graphics.Color
   import androidx.compose.ui.text.TextStyle
   import androidx.compose.ui.unit.dp
   import androidx.compose.ui.unit.sp
   import androidx.compose.ui.tooling.preview.Preview
   import com.example.calculatorapp.ui.theme.CalculatorAppTheme
   
   class MainActivity : ComponentActivity() {
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
           setContent {
               CalculatorAppTheme {
                   CalculatorScreen()
               }
           }
       }
   }
   
   @Composable
   fun CalculatorScreen() {
       var input by remember { mutableStateOf("") }
       var result by remember { mutableStateOf("") }
   
       Column(
           modifier = Modifier
               .fillMaxSize()
               .padding(16.dp),
           verticalArrangement = Arrangement.Center,
           horizontalAlignment = Alignment.CenterHorizontally
       ) {
           BasicTextField(
               value = input,
               onValueChange = { input = it },
               textStyle = TextStyle(fontSize = 32.sp, color = Color.Black),
               modifier = Modifier
                   .fillMaxWidth()
                   .background(Color.White)
                   .padding(16.dp)
           )
           Spacer(modifier = Modifier.height(16.dp))
           BasicTextField(
               value = result,
               onValueChange = { },
               textStyle = TextStyle(fontSize = 32.sp, color = Color.Black),
               modifier = Modifier
                   .fillMaxWidth()
                   .background(Color.LightGray)
                   .padding(16.dp)
           )
           Spacer(modifier = Modifier.height(16.dp))
           Row(
               modifier = Modifier.fillMaxWidth(),
               horizontalArrangement = Arrangement.SpaceEvenly
           ) {
               CalculatorButton(text = "1", onClick = { input += "1" })
               CalculatorButton(text = "2", onClick = { input += "2" })
               CalculatorButton(text = "3", onClick = { input += "3" })
               CalculatorButton(text = "+", onClick = { input += "+" })
           }
           Row(
               modifier = Modifier.fillMaxWidth(),
               horizontalArrangement = Arrangement.SpaceEvenly
           ) {
               CalculatorButton(text = "4", onClick = { input += "4" })
               CalculatorButton(text = "5", onClick = { input += "5" })
               CalculatorButton(text = "6", onClick = { input += "6" })
               CalculatorButton(text = "-", onClick = { input += "-" })
           }
           Row(
               modifier = Modifier.fillMaxWidth(),
               horizontalArrangement = Arrangement.SpaceEvenly
           ) {
               CalculatorButton(text = "7", onClick = { input += "7" })
               CalculatorButton(text = "8", onClick = { input += "8" })
               CalculatorButton(text = "9", onClick = { input += "9" })
               CalculatorButton(text = "*", onClick = { input += "*" })
           }
           Row(
               modifier = Modifier.fillMaxWidth(),
               horizontalArrangement = Arrangement.SpaceEvenly
           ) {
               CalculatorButton(text = "0", onClick = { input += "0" })
               CalculatorButton(text = "C", onClick = { input = ""; result = "" })
               CalculatorButton(text = "=", onClick = { result = evaluateExpression(input) })
               CalculatorButton(text = "/", onClick = { input += "/" })
           }
       }
   }
   
   @Composable
   fun CalculatorButton(text: String, onClick: () -> Unit) {
       Button(
           onClick = onClick,
           modifier = Modifier
               .size(64.dp)
               .padding(4.dp)
       ) {
           Text(text = text, style = TextStyle(fontSize = 24.sp))
       }
   }
   
   fun evaluateExpression(expression: String): String {
       return try {
           val result = expressionEvaluator(expression)
           result.toString()
       } catch (e: Exception) {
           "Error"
       }
   }
   
   fun expressionEvaluator(expression: String): Double {
       val tokens = expression.replace(" ", "").toList()
       val values = mutableListOf<Double>()
       val ops = mutableListOf<Char>()
   
       var i = 0
       while (i < tokens.size) {
           if (tokens[i].isDigit() || tokens[i] == '.') {
               val sbuf = StringBuffer()
               while (i < tokens.size && (tokens[i].isDigit() || tokens[i] == '.')) {
                   sbuf.append(tokens[i++])
               }
               values.add(sbuf.toString().toDouble())
               i--
           } else if (tokens[i] == '(') {
               ops.add(tokens[i])
           } else if (tokens[i] == ')') {
               while (ops.isNotEmpty() && ops.last() != '(') {
                   values.add(applyOp(ops.removeAt(ops.size - 1), values.removeAt(values.size - 1), values.removeAt(values.size - 1)))
               }
               ops.removeAt(ops.size - 1)
           } else if (tokens[i] in listOf('+', '-', '*', '/')) {
               while (ops.isNotEmpty() && hasPrecedence(tokens[i], ops.last())) {
                   values.add(applyOp(ops.removeAt(ops.size - 1), values.removeAt(values.size - 1), values.removeAt(values.size - 1)))
               }
               ops.add(tokens[i])
           }
           i++
       }
   
       while (ops.isNotEmpty()) {
           values.add(applyOp(ops.removeAt(ops.size - 1), values.removeAt(values.size - 1), values.removeAt(values.size - 1)))
       }
   
       return values.last()
   }
   
   fun hasPrecedence(op1: Char, op2: Char): Boolean {
       if (op2 == '(' || op2 == ')') return false
       if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')) return false
       return true
   }
   
   fun applyOp(op: Char, b: Double, a: Double): Double {
       return when (op) {
           '+' -> a + b
           '-' -> a - b
           '*' -> a * b
           '/' -> {
               if (b == 0.0) throw UnsupportedOperationException("Cannot divide by zero")
               a / b
           }
           else -> throw UnsupportedOperationException("Unknown operator: $op")
       }
   }
   
   @Preview(showBackground = true)
   @Composable
   fun CalculatorScreenPreview() {
       CalculatorAppTheme {
           CalculatorScreen()
       }
   }
   

4. Tampilan seperti berikut: