From 4fdb8272bcc1cd18c078ffc34147fcbd2f9f3fcd Mon Sep 17 00:00:00 2001 From: Shihaam Abdul Rahman Date: Thu, 1 Oct 2026 23:23:43 +0500 Subject: [PATCH] init - poc --- .build/release/.env.example | 3 + .build/release/.gitignore | 2 + .build/release/compose.yml | 9 + .gitea/workflows/auto-tag.yml | 50 +++ .gitea/workflows/build-apk.yml | 86 +++++ ...otlin-compiler-16707578751962836653.salive | 0 README.md | 46 ++- app/.gitignore | 4 +- app/build.gradle.kts | 17 +- app/src/main/AndroidManifest.xml | 5 + app/src/main/assets/bins.tsv | 22 ++ .../main/java/sh/sar/sw9000/MainActivity.kt | 126 ++++-- .../main/java/sh/sar/sw9000/nfc/BinLookup.kt | 107 ++++++ .../java/sh/sar/sw9000/nfc/CardIdentity.kt | 139 +++++++ .../java/sh/sar/sw9000/nfc/EmvCardReader.kt | 359 ++++++++++++++++++ .../main/java/sh/sar/sw9000/nfc/EmvTags.kt | 114 ++++++ .../java/sh/sar/sw9000/nfc/StatusWords.kt | 39 ++ app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt | 207 ++++++++++ .../java/sh/sar/sw9000/ui/NfcCardAnimation.kt | 291 ++++++++++++++ app/src/main/java/sh/sar/sw9000/ui/Screens.kt | 257 +++++++++++++ .../res/drawable/ic_launcher_background.xml | 163 +------- .../res/drawable/ic_launcher_foreground.xml | 70 ++-- app/src/main/res/mipmap-hdpi/ic_launcher.webp | Bin 1404 -> 0 bytes .../res/mipmap-hdpi/ic_launcher_round.webp | Bin 2898 -> 0 bytes app/src/main/res/mipmap-mdpi/ic_launcher.webp | Bin 982 -> 0 bytes .../res/mipmap-mdpi/ic_launcher_round.webp | Bin 1772 -> 0 bytes .../main/res/mipmap-xhdpi/ic_launcher.webp | Bin 1900 -> 0 bytes .../res/mipmap-xhdpi/ic_launcher_round.webp | Bin 3918 -> 0 bytes .../main/res/mipmap-xxhdpi/ic_launcher.webp | Bin 2884 -> 0 bytes .../res/mipmap-xxhdpi/ic_launcher_round.webp | Bin 5914 -> 0 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.webp | Bin 3844 -> 0 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.webp | Bin 7778 -> 0 bytes app/src/main/res/mipmap/ic_launcher.xml | 6 + app/src/main/res/mipmap/ic_launcher_round.xml | 6 + app/src/main/res/values-night/colors.xml | 5 + app/src/main/res/values-night/themes.xml | 11 + app/src/main/res/values/colors.xml | 2 + app/src/main/res/values/strings.xml | 4 +- app/src/main/res/values/themes.xml | 10 +- 39 files changed, 1944 insertions(+), 216 deletions(-) create mode 100644 .build/release/.env.example create mode 100644 .build/release/.gitignore create mode 100644 .build/release/compose.yml create mode 100644 .gitea/workflows/auto-tag.yml create mode 100644 .gitea/workflows/build-apk.yml delete mode 100644 .kotlin/sessions/kotlin-compiler-16707578751962836653.salive create mode 100644 app/src/main/assets/bins.tsv create mode 100644 app/src/main/java/sh/sar/sw9000/nfc/BinLookup.kt create mode 100644 app/src/main/java/sh/sar/sw9000/nfc/CardIdentity.kt create mode 100644 app/src/main/java/sh/sar/sw9000/nfc/EmvCardReader.kt create mode 100644 app/src/main/java/sh/sar/sw9000/nfc/EmvTags.kt create mode 100644 app/src/main/java/sh/sar/sw9000/nfc/StatusWords.kt create mode 100644 app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt create mode 100644 app/src/main/java/sh/sar/sw9000/ui/NfcCardAnimation.kt create mode 100644 app/src/main/java/sh/sar/sw9000/ui/Screens.kt delete mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.webp delete mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher_round.webp delete mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.webp delete mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher_round.webp delete mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.webp delete mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp delete mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.webp delete mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp delete mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp delete mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp create mode 100644 app/src/main/res/mipmap/ic_launcher.xml create mode 100644 app/src/main/res/mipmap/ic_launcher_round.xml create mode 100644 app/src/main/res/values-night/colors.xml create mode 100644 app/src/main/res/values-night/themes.xml diff --git a/.build/release/.env.example b/.build/release/.env.example new file mode 100644 index 0000000..f808dcb --- /dev/null +++ b/.build/release/.env.example @@ -0,0 +1,3 @@ +KEYSTORE_PASSWORD=your_keystore_password_here +KEY_ALIAS=your_key_alias_here +KEY_PASSWORD=your_key_password_here diff --git a/.build/release/.gitignore b/.build/release/.gitignore new file mode 100644 index 0000000..4f0f390 --- /dev/null +++ b/.build/release/.gitignore @@ -0,0 +1,2 @@ +.env +release/ diff --git a/.build/release/compose.yml b/.build/release/compose.yml new file mode 100644 index 0000000..32c8382 --- /dev/null +++ b/.build/release/compose.yml @@ -0,0 +1,9 @@ +services: + release: + image: git.shihaam.dev/dockerfiles/runners/gradle + network_mode: host + env_file: .env + volumes: + - ./release:/release + - ../../:/source + - /root/.cache/cache-runners/gradle:/root/.gradle diff --git a/.gitea/workflows/auto-tag.yml b/.gitea/workflows/auto-tag.yml new file mode 100644 index 0000000..e985798 --- /dev/null +++ b/.gitea/workflows/auto-tag.yml @@ -0,0 +1,50 @@ +name: Auto Tag on Version Change + +on: + push: + branches: + - main + +jobs: + check-version: + runs-on: docker-compose + + steps: + - name: Checkout source code + uses: actions/checkout@v4 + with: + fetch-depth: 0 + token: ${{ secrets.PAT_GITEA }} + + - name: Check version and prepare release + id: version + run: | + VERSION=$(grep 'versionName = ' app/build.gradle.kts | sed 's/.*versionName = "\(.*\)".*/\1/') + VERSION_CODE=$(grep 'versionCode = ' app/build.gradle.kts | sed 's/.*versionCode = \([0-9]*\).*/\1/') + echo "version=$VERSION" >> $GITHUB_OUTPUT + echo "version_code=$VERSION_CODE" >> $GITHUB_OUTPUT + + BEFORE="${{ github.event.before }}" + if [ -z "$BEFORE" ] || ! git cat-file -e "${BEFORE}^{commit}" 2>/dev/null; then + BEFORE="HEAD~1" + fi + PREV_VERSION_CODE=$(git show "${BEFORE}:app/build.gradle.kts" 2>/dev/null | grep 'versionCode = ' | sed 's/.*versionCode = \([0-9]*\).*/\1/') + + if [ "$VERSION_CODE" = "$PREV_VERSION_CODE" ]; then + echo "versionCode unchanged (${VERSION_CODE}), skipping" + echo "should_release=false" >> $GITHUB_OUTPUT + elif git tag -l | grep -q "^v${VERSION}$"; then + echo "versionCode changed (${PREV_VERSION_CODE} -> ${VERSION_CODE}) but tag v${VERSION} already exists; bump versionName" + exit 1 + else + echo "New versionCode detected: ${PREV_VERSION_CODE} -> ${VERSION_CODE} (v${VERSION})" + echo "should_release=true" >> $GITHUB_OUTPUT + fi + + - name: Create and push tag + if: steps.version.outputs.should_release == 'true' + run: | + VERSION="${{ steps.version.outputs.version }}" + git tag "v${VERSION}" + git push origin "v${VERSION}" + echo "Created and pushed tag v${VERSION}" diff --git a/.gitea/workflows/build-apk.yml b/.gitea/workflows/build-apk.yml new file mode 100644 index 0000000..6ac8b7f --- /dev/null +++ b/.gitea/workflows/build-apk.yml @@ -0,0 +1,86 @@ +name: Build and Release APK + +on: + push: + tags: + - 'v*' + +jobs: + build: + runs-on: docker-compose + + steps: + - name: Checkout source code + uses: actions/checkout@v4 + + - name: Setup keystore and environment + run: | + echo "${{ secrets.KEYSTORE_BASE64 }}" | tr -d '\n' | base64 -d > app/key.jks + echo "${{ secrets.DOTENV_BASE64 }}" | tr -d '\n' | base64 -d > .build/release/.env + + - name: Build APK + working-directory: .build/release + run: docker compose run --rm release + + - name: Rename APK + run: | + APP_NAME="${{ gitea.repository }}" + APP_NAME="${APP_NAME//\//-}" + TAG="${{ gitea.ref_name }}" + find .build/release/release/ -maxdepth 1 -name "*.apk" | head -1 | xargs -I{} mv {} ".build/release/release/${APP_NAME}-${TAG}.apk" + + - name: Extract release notes + run: | + VERSION_CODE=$(grep 'versionCode = ' app/build.gradle.kts | sed 's/.*versionCode = \([0-9]*\).*/\1/') + CHANGELOG="fastlane/metadata/android/en-US/changelogs/${VERSION_CODE}.txt" + + if [ -f "$CHANGELOG" ]; then + cp "$CHANGELOG" release_notes.md + else + echo "No changelog found at $CHANGELOG" + echo "No release notes" > release_notes.md + fi + + - name: Create Gitea Release + env: + GITEA_SERVER_URL: ${{ gitea.server_url }} + GITEA_REPOSITORY: ${{ gitea.repository }} + GITEA_TOKEN: ${{ secrets.PAT_GITEA }} + run: | + APP_NAME="${{ gitea.repository }}" + APP_NAME="${APP_NAME//\//-}" + TAG="${{ gitea.ref_name }}" + TITLE="${APP_NAME} ${TAG}" + NOTES_FILE="release_notes.md" + ASSET_PATH=".build/release/release/${APP_NAME}-${TAG}.apk" + + API_URL="${GITEA_SERVER_URL}/api/v1/repos/${GITEA_REPOSITORY}/releases" + + RELEASE_RESPONSE=$(curl -s -X POST "$API_URL" \ + -H "Authorization: token ${GITEA_TOKEN}" \ + -H "Content-Type: application/json" \ + -d "{ + \"tag_name\": \"${TAG}\", + \"name\": \"${TITLE}\", + \"body\": $(jq -Rs . < "$NOTES_FILE") + }") + + RELEASE_ID=$(echo "$RELEASE_RESPONSE" | jq -r '.id') + + if [ "$RELEASE_ID" = "null" ] || [ -z "$RELEASE_ID" ]; then + echo "Failed to create release:" + echo "$RELEASE_RESPONSE" + exit 1 + fi + + echo "Created release with ID: $RELEASE_ID" + + ASSET_NAME=$(basename "$ASSET_PATH") + UPLOAD_URL="${API_URL}/${RELEASE_ID}/assets?name=${ASSET_NAME}" + + curl -s -X POST "$UPLOAD_URL" \ + -H "Authorization: token ${GITEA_TOKEN}" \ + -H "Content-Type: application/octet-stream" \ + --data-binary "@${ASSET_PATH}" + + echo "Uploaded asset: $ASSET_NAME" diff --git a/.kotlin/sessions/kotlin-compiler-16707578751962836653.salive b/.kotlin/sessions/kotlin-compiler-16707578751962836653.salive deleted file mode 100644 index e69de29..0000000 diff --git a/README.md b/README.md index 754f424..b81860a 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,47 @@ # sw9000-android -Android app that reads NFC EMV cards and dumps everything: PPSE, AIDs, TLV tree, track2, PAN, expiry, AFL records, with raw APDUs. \ No newline at end of file +A read-only Android app that reads a contactless EMV card over NFC and shows **everything** +obtainable from it, with full APDU-level transparency. For reading your own cards. + +## What it does + +On launch it checks NFC: + +- **No NFC hardware** → an "NFC not supported" screen. +- **NFC off** → a prompt with a button to open NFC settings. +- **NFC on** → the "tap a card" animation (a card swinging onto a phone with NFC ripples, + ported from the sibling `android` app). On tap it reads the card and shows: + - **Formatted** — PAN, cardholder name, expiry, valid-from, PAN sequence, application label / + preferred name / AID, issuer country, currency, ATC, PIN-try counter, AIP, Track 2, plus the + tag's UID / technologies / ATQA / SAK / historical bytes. + - **Raw dump** — the full BER-TLV tree (every tag labelled and interpreted) for each + application, and the complete **APDU log**: every command sent, every response, and the + decoded status word. + +The read flow is: SELECT PPSE → for each advertised AID: SELECT AID → GET PROCESSING OPTIONS +(PDOL filled in) → READ RECORD across the AFL → GET DATA for the common counters. It never +writes to the card and runs no transaction (no GENERATE AC), so tapping is harmless. + +## Scheme / country / bank + +Derived with no network: + +- **Scheme** (Visa / Mastercard / Amex / UnionPay / JCB / Discover …) — from the application AID's + RID and, as a fallback, the PAN's leading digits. Reliable. +- **Issuer country** — from EMV tag `5F28` (ISO-3166 numeric), decoded to a country name. Present + on most cards. +- **Issuer bank / card type / product** — *not* stored on the card. Naming the bank needs a + **BIN/IIN database**, which you can optionally bundle at build time: drop a tab-separated dataset + at `app/src/main/assets/bins.tsv` (format documented in that file). It compiles into the APK, so + the app still makes no network calls. Without it, the app shows the raw BIN for manual lookup, + and the application label (`50` / `9F12`) often carries the issuer's branding anyway. + +## Privacy + +No network. The app declares only `android.permission.NFC` — **no `INTERNET` permission**, so +nothing read from a card can leave the device. + +## Build + +Standard Gradle / Android Studio project (AGP 9, Kotlin 2.2, Jetpack Compose). Needs a physical +NFC-capable device; the emulator can't read cards. diff --git a/app/.gitignore b/app/.gitignore index 42afabf..c7fec8b 100644 --- a/app/.gitignore +++ b/app/.gitignore @@ -1 +1,3 @@ -/build \ No newline at end of file +/build +# Signing keystore written by CI — never commit it. +key.jks diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 43bc407..019f1e0 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -6,9 +6,7 @@ plugins { android { namespace = "sh.sar.sw9000" compileSdk { - version = release(36) { - minorApiLevel = 1 - } + version = release(37) } defaultConfig { @@ -21,8 +19,21 @@ android { testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" } + signingConfigs { + create("release") { + // Supplied by CI: key.jks is written next to this module and the passwords come + // from the environment (.build/release/.env / Gitea secrets). Left unset locally, + // which is fine unless you run assembleRelease. + storeFile = file("key.jks") + storePassword = System.getenv("KEYSTORE_PASSWORD") + keyAlias = System.getenv("KEY_ALIAS") + keyPassword = System.getenv("KEY_PASSWORD") + } + } + buildTypes { release { + signingConfig = signingConfigs.getByName("release") isMinifyEnabled = false proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 8c777d4..3772eba 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -2,6 +2,11 @@ + + + + + iin_end scheme type brand bank country +# +# iin_start / iin_end : inclusive range over the first up-to-8 PAN digits. Pad a shorter prefix +# with 0s on start and 9s on end — e.g. the 6-digit prefix 457173 -> 45717300 and 45717399. +# Any trailing column may be left blank. Ranges should not overlap; the narrowest match wins. +# +# Example rows (SYNTHETIC — replace with a real dataset): +# 45717300 45717399 Visa credit Classic Example Bank United Kingdom +# 55555500 55555599 Mastercard debit Example Bank United States +# +# Where to get data (check each source's licence before shipping): +# - Commercial BIN providers (most accurate, licensed). +# - Open community lists on GitHub (quality/licensing varies). +# Convert whatever you obtain into the tab-separated format above. diff --git a/app/src/main/java/sh/sar/sw9000/MainActivity.kt b/app/src/main/java/sh/sar/sw9000/MainActivity.kt index 45f9124..30dcf74 100644 --- a/app/src/main/java/sh/sar/sw9000/MainActivity.kt +++ b/app/src/main/java/sh/sar/sw9000/MainActivity.kt @@ -1,47 +1,129 @@ package sh.sar.sw9000 +import android.content.Intent +import android.nfc.NfcAdapter import android.os.Bundle +import android.provider.Settings import androidx.activity.ComponentActivity import androidx.activity.compose.setContent import androidx.activity.enableEdgeToEdge import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.padding +import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Scaffold import androidx.compose.material3.Text -import androidx.compose.runtime.Composable +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue import androidx.compose.ui.Modifier -import androidx.compose.ui.tooling.preview.Preview +import kotlin.concurrent.thread +import sh.sar.sw9000.nfc.BinLookup +import sh.sar.sw9000.nfc.EmvCardReader +import sh.sar.sw9000.ui.NfcDisabledScreen +import sh.sar.sw9000.ui.ResultScreen import sh.sar.sw9000.ui.theme.Sw9000Theme +import sh.sar.sw9000.ui.TapState +import sh.sar.sw9000.ui.UnsupportedScreen +import sh.sar.sw9000.ui.WaitingScreen +/** Reader screen states, driven by the NFC adapter and the active read. */ +sealed interface UiState { + data object Unsupported : UiState + data object Disabled : UiState + data class Waiting(val tap: TapState) : UiState + data class Done(val result: EmvCardReader.Result) : UiState +} + +/** + * Single-activity, read-only NFC/EMV dumper. The activity owns the NFC adapter: it enables + * reader mode whenever we're on the waiting screen and tears it down otherwise. The reader-mode + * callback runs on a binder thread, so the (blocking) card read happens there and the result is + * posted back to Compose state on the main thread. + */ class MainActivity : ComponentActivity() { + + private var adapter: NfcAdapter? = null + private var uiState by mutableStateOf(UiState.Waiting(TapState.WAITING)) + + @OptIn(ExperimentalMaterial3Api::class) override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) + adapter = NfcAdapter.getDefaultAdapter(this) + // Load the optional bundled BIN database off the main thread (no-op if none is bundled). + thread { BinLookup.init(applicationContext) } enableEdgeToEdge() setContent { Sw9000Theme { - Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding -> - Greeting( - name = "Android", - modifier = Modifier.padding(innerPadding) - ) + Scaffold( + modifier = Modifier.fillMaxSize(), + topBar = { TopAppBar(title = { Text(getString(R.string.app_name)) }) }, + ) { inner -> + when (val s = uiState) { + UiState.Unsupported -> UnsupportedScreen(Modifier.padding(inner)) + UiState.Disabled -> NfcDisabledScreen( + onOpenSettings = { startActivity(Intent(Settings.ACTION_NFC_SETTINGS)) }, + modifier = Modifier.padding(inner), + ) + is UiState.Waiting -> WaitingScreen( + state = s.tap, + label = if (s.tap == TapState.READING) getString(R.string.reading) + else getString(R.string.tap_card), + modifier = Modifier.padding(inner), + ) + is UiState.Done -> ResultScreen( + result = s.result, + onReadAnother = { uiState = UiState.Waiting(TapState.WAITING) }, + modifier = Modifier.padding(inner), + ) + } } } } } -} -@Composable -fun Greeting(name: String, modifier: Modifier = Modifier) { - Text( - text = "Hello $name!", - modifier = modifier - ) -} - -@Preview(showBackground = true) -@Composable -fun GreetingPreview() { - Sw9000Theme { - Greeting("Android") + override fun onResume() { + super.onResume() + syncAdapterState() } -} \ No newline at end of file + + override fun onPause() { + super.onPause() + runCatching { adapter?.disableReaderMode(this) } + } + + /** Reconciles the current UI state with NFC availability and (re)arms reader mode. */ + private fun syncAdapterState() { + val a = adapter + when { + a == null -> uiState = UiState.Unsupported + !a.isEnabled -> uiState = UiState.Disabled + else -> { + // Coming back from Disabled/Unsupported resets us to waiting. + if (uiState is UiState.Unsupported || uiState is UiState.Disabled) { + uiState = UiState.Waiting(TapState.WAITING) + } + enableReader(a) + } + } + } + + private fun enableReader(a: NfcAdapter) { + val flags = NfcAdapter.FLAG_READER_NFC_A or NfcAdapter.FLAG_READER_NFC_B or + NfcAdapter.FLAG_READER_SKIP_NDEF_CHECK + a.enableReaderMode(this, { tag -> + // Binder thread — safe to block on card I/O here. + runOnUiThread { if (uiState is UiState.Waiting) uiState = UiState.Waiting(TapState.READING) } + thread { + val result = runCatching { EmvCardReader.read(tag) }.getOrElse { + EmvCardReader.Result( + uid = "", techList = emptyList(), historicalBytes = null, hiLayerResponse = null, + atqa = null, sak = null, apps = emptyList(), fields = emptyList(), apduLog = emptyList(), + error = "Read error: ${it.message ?: it.javaClass.simpleName}", + ) + } + runOnUiThread { uiState = UiState.Done(result) } + } + }, flags, null) + } +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/BinLookup.kt b/app/src/main/java/sh/sar/sw9000/nfc/BinLookup.kt new file mode 100644 index 0000000..ed941c8 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/BinLookup.kt @@ -0,0 +1,107 @@ +package sh.sar.sw9000.nfc + +import android.content.Context +import java.io.BufferedReader + +/** + * Optional, fully-offline issuer lookup from the card's BIN/IIN (leading PAN digits). + * + * The card itself does NOT name the issuing bank; that needs an external BIN database. This loads + * one — if you bundle it — from `assets/bins.tsv`, built into the APK at compile time, so the app + * still makes no network calls and keeps the INTERNET permission off. If the asset is missing or + * empty, [lookup] simply returns null and the UI falls back to showing the raw BIN. + * + * ## File format (`app/src/main/assets/bins.tsv`), tab-separated, `#` lines ignored: + * ``` + * iin_start iin_end scheme type brand bank country + * ``` + * `iin_start`/`iin_end` are the inclusive range of the first up-to-8 PAN digits (pad shorter + * prefixes with 0s on the start and 9s on the end — e.g. the 6-digit prefix `457173` becomes + * `45717300`–`45717399`). Any trailing column may be left blank. Ranges should not overlap; if + * they do, the narrowest match wins. + */ +object BinLookup { + + data class Issuer( + val scheme: String?, + val type: String?, // debit / credit / prepaid, if known + val brand: String?, // product name, e.g. "Platinum" + val bank: String?, + val country: String?, + ) { + val isEmpty get() = listOf(scheme, type, brand, bank, country).all { it.isNullOrBlank() } + } + + @Volatile private var loaded = false + private var starts = LongArray(0) + private var ends = LongArray(0) + private var info = emptyArray() + + /** Loads the bundled dataset once. Safe to call repeatedly; no-op after the first success. */ + @Synchronized + fun init(context: Context) { + if (loaded) return + loaded = true + runCatching { + context.assets.open("bins.tsv").bufferedReader().use { parse(it) } + }.onFailure { + // No asset bundled (or unreadable): leave the index empty — lookups just return null. + starts = LongArray(0); ends = LongArray(0); info = emptyArray() + } + } + + /** Returns issuer details for [pan], or null if no dataset is bundled or nothing matches. */ + fun lookup(pan: String?): Issuer? { + if (starts.isEmpty() || pan == null) return null + val digits = pan.filter { it.isDigit() } + if (digits.length < 6) return null + val key = digits.take(8).padEnd(8, '0').toLongOrNull() ?: return null + + // Rightmost range whose start <= key, then widen the search backward for a container, + // keeping the narrowest (most specific) match. + var lo = 0; var hi = starts.size - 1; var idx = -1 + while (lo <= hi) { + val mid = (lo + hi) ushr 1 + if (starts[mid] <= key) { idx = mid; lo = mid + 1 } else hi = mid - 1 + } + if (idx < 0) return null + var best = -1 + var i = idx + var scanned = 0 + while (i >= 0 && scanned < 64) { + if (ends[i] >= key) { + if (best < 0 || (ends[i] - starts[i]) < (ends[best] - starts[best])) best = i + } + i--; scanned++ + } + return if (best >= 0) info[best] else null + } + + private fun parse(reader: BufferedReader) { + val s = ArrayList(1 shl 16) + val e = ArrayList(1 shl 16) + val list = ArrayList(1 shl 16) + reader.forEachLine { raw -> + val line = raw.trim() + if (line.isEmpty() || line.startsWith("#")) return@forEachLine + val c = line.split('\t') + val start = c.getOrNull(0)?.trim()?.padEnd(8, '0')?.toLongOrNull() ?: return@forEachLine + val end = c.getOrNull(1)?.trim()?.padEnd(8, '9')?.toLongOrNull() ?: start + s.add(start); e.add(end) + list.add( + Issuer( + scheme = c.getOrNull(2)?.trim()?.ifBlank { null }, + type = c.getOrNull(3)?.trim()?.ifBlank { null }, + brand = c.getOrNull(4)?.trim()?.ifBlank { null }, + bank = c.getOrNull(5)?.trim()?.ifBlank { null }, + country = c.getOrNull(6)?.trim()?.ifBlank { null }, + ) + ) + } + // Sort all three arrays together by range start. + val order = (0 until s.size).sortedBy { s[it] } + starts = LongArray(order.size) { s[order[it]] } + ends = LongArray(order.size) { e[order[it]] } + info = Array(order.size) { list[order[it]] } + } +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/CardIdentity.kt b/app/src/main/java/sh/sar/sw9000/nfc/CardIdentity.kt new file mode 100644 index 0000000..1df2e77 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/CardIdentity.kt @@ -0,0 +1,139 @@ +package sh.sar.sw9000.nfc + +/** + * Derives what a card reveals about itself without any network lookup: the payment **scheme** + * (Visa / Mastercard / Amex …) from the application AID and the PAN, and the **issuer country** + * from EMV tag 5F28. + * + * The specific issuing **bank** is deliberately not guessed: that needs a BIN/IIN database, which + * isn't on the card. The BIN (leading PAN digits) is exposed instead so it can be looked up + * elsewhere, and the application label often carries the issuer's own branding. + */ +object CardIdentity { + + /** Scheme name from the AID's RID (first 5 bytes / 10 hex chars), or null if unrecognised. */ + fun schemeFromAid(aidHex: String): String? { + val rid = aidHex.uppercase().take(10) + return RID[rid] + } + + /** Scheme name inferred from the PAN's leading digits (IIN), or null. */ + fun schemeFromPan(pan: String): String? { + val d = pan.filter { it.isDigit() } + if (d.length < 2) return null + fun p(n: Int) = d.take(n).toIntOrNull() ?: -1 + return when { + d[0] == '4' -> "Visa" + p(2) in 34..34 || p(2) == 37 -> "American Express" + p(2) in 51..55 || p(4) in 2221..2720 -> "Mastercard" + p(4) == 6011 || p(2) == 65 || p(3) in 644..649 -> "Discover" + p(2) == 35 -> "JCB" + p(2) == 62 || p(2) == 81 -> "UnionPay" + p(2) == 36 || p(2) == 38 || p(3) in 300..305 -> "Diners Club" + p(2) == 50 || p(2) in 56..69 -> "Maestro" + p(4) in 6521..6522 -> "RuPay" + else -> null + } + } + + /** Best-effort scheme: AID first (authoritative), PAN as fallback. */ + fun scheme(aidHex: String?, pan: String?): String? = + aidHex?.let { schemeFromAid(it) } ?: pan?.let { schemeFromPan(it) } + + /** Country name for an ISO-3166-1 numeric code (as a 3-digit string), or the code itself. */ + fun country(numeric: String): String { + val code = numeric.filter { it.isDigit() }.trimStart('0').padStart(3, '0') + return COUNTRIES[code]?.let { "$it ($code)" } ?: numeric + } + + // Registered Application Provider Identifiers (RID) → scheme. + private val RID = mapOf( + "A000000003" to "Visa", + "A000000004" to "Mastercard", + "A000000005" to "Mastercard", + "A000000025" to "American Express", + "A000000065" to "JCB", + "A000000152" to "Discover", + "A000000324" to "Discover", + "A000000333" to "UnionPay", + "A000000277" to "Interac", + "A000000042" to "Cartes Bancaires", + "A000000524" to "RuPay", + "A000000658" to "Mir", + "A000000371" to "Verve", + "A000000228" to "SPAN (Saudi)", + "A000000098" to "Visa (Debit)", + "A000000620" to "Interac", + ) + + // ISO 3166-1 numeric → country / territory name. Full assigned list. + private val COUNTRIES = mapOf( + "004" to "Afghanistan", "008" to "Albania", "010" to "Antarctica", "012" to "Algeria", + "016" to "American Samoa", "020" to "Andorra", "024" to "Angola", "028" to "Antigua and Barbuda", + "031" to "Azerbaijan", "032" to "Argentina", "036" to "Australia", "040" to "Austria", + "044" to "Bahamas", "048" to "Bahrain", "050" to "Bangladesh", "051" to "Armenia", + "052" to "Barbados", "056" to "Belgium", "060" to "Bermuda", "064" to "Bhutan", + "068" to "Bolivia", "070" to "Bosnia and Herzegovina", "072" to "Botswana", "074" to "Bouvet Island", + "076" to "Brazil", "084" to "Belize", "086" to "British Indian Ocean Territory", + "090" to "Solomon Islands", "092" to "British Virgin Islands", "096" to "Brunei", + "100" to "Bulgaria", "104" to "Myanmar", "108" to "Burundi", "112" to "Belarus", + "116" to "Cambodia", "120" to "Cameroon", "124" to "Canada", "132" to "Cape Verde", + "136" to "Cayman Islands", "140" to "Central African Republic", "144" to "Sri Lanka", + "148" to "Chad", "152" to "Chile", "156" to "China", "158" to "Taiwan", + "162" to "Christmas Island", "166" to "Cocos (Keeling) Islands", "170" to "Colombia", + "174" to "Comoros", "175" to "Mayotte", "178" to "Congo", "180" to "DR Congo", + "184" to "Cook Islands", "188" to "Costa Rica", "191" to "Croatia", "192" to "Cuba", + "196" to "Cyprus", "203" to "Czechia", "204" to "Benin", "208" to "Denmark", + "212" to "Dominica", "214" to "Dominican Republic", "218" to "Ecuador", "222" to "El Salvador", + "226" to "Equatorial Guinea", "231" to "Ethiopia", "232" to "Eritrea", "233" to "Estonia", + "234" to "Faroe Islands", "238" to "Falkland Islands", + "239" to "South Georgia and the South Sandwich Islands", "242" to "Fiji", "246" to "Finland", + "248" to "Åland Islands", "250" to "France", "254" to "French Guiana", "258" to "French Polynesia", + "260" to "French Southern Territories", "262" to "Djibouti", "266" to "Gabon", "268" to "Georgia", + "270" to "Gambia", "275" to "Palestine", "276" to "Germany", "288" to "Ghana", + "292" to "Gibraltar", "296" to "Kiribati", "300" to "Greece", "304" to "Greenland", + "308" to "Grenada", "312" to "Guadeloupe", "316" to "Guam", "320" to "Guatemala", + "324" to "Guinea", "328" to "Guyana", "332" to "Haiti", + "334" to "Heard Island and McDonald Islands", "336" to "Vatican City", "340" to "Honduras", + "344" to "Hong Kong", "348" to "Hungary", "352" to "Iceland", "356" to "India", + "360" to "Indonesia", "364" to "Iran", "368" to "Iraq", "372" to "Ireland", + "376" to "Israel", "380" to "Italy", "384" to "Côte d'Ivoire", "388" to "Jamaica", + "392" to "Japan", "398" to "Kazakhstan", "400" to "Jordan", "404" to "Kenya", + "408" to "North Korea", "410" to "South Korea", "414" to "Kuwait", "417" to "Kyrgyzstan", + "418" to "Laos", "422" to "Lebanon", "426" to "Lesotho", "428" to "Latvia", + "430" to "Liberia", "434" to "Libya", "438" to "Liechtenstein", "440" to "Lithuania", + "442" to "Luxembourg", "446" to "Macau", "450" to "Madagascar", "454" to "Malawi", + "458" to "Malaysia", "462" to "Maldives", "466" to "Mali", "470" to "Malta", + "474" to "Martinique", "478" to "Mauritania", "480" to "Mauritius", "484" to "Mexico", + "492" to "Monaco", "496" to "Mongolia", "498" to "Moldova", "499" to "Montenegro", + "500" to "Montserrat", "504" to "Morocco", "508" to "Mozambique", "512" to "Oman", + "516" to "Namibia", "520" to "Nauru", "524" to "Nepal", "528" to "Netherlands", + "531" to "Curaçao", "533" to "Aruba", "534" to "Sint Maarten", + "535" to "Bonaire, Sint Eustatius and Saba", "540" to "New Caledonia", "548" to "Vanuatu", + "554" to "New Zealand", "558" to "Nicaragua", "562" to "Niger", "566" to "Nigeria", + "570" to "Niue", "574" to "Norfolk Island", "578" to "Norway", + "580" to "Northern Mariana Islands", "581" to "U.S. Minor Outlying Islands", + "583" to "Micronesia", "584" to "Marshall Islands", "585" to "Palau", "586" to "Pakistan", + "591" to "Panama", "598" to "Papua New Guinea", "600" to "Paraguay", "604" to "Peru", + "608" to "Philippines", "612" to "Pitcairn", "616" to "Poland", "620" to "Portugal", + "624" to "Guinea-Bissau", "626" to "Timor-Leste", "630" to "Puerto Rico", "634" to "Qatar", + "638" to "Réunion", "642" to "Romania", "643" to "Russia", "646" to "Rwanda", + "652" to "Saint Barthélemy", "654" to "Saint Helena", "659" to "Saint Kitts and Nevis", + "660" to "Anguilla", "662" to "Saint Lucia", "663" to "Saint Martin", "666" to "Saint Pierre and Miquelon", + "670" to "Saint Vincent and the Grenadines", "674" to "San Marino", "678" to "São Tomé and Príncipe", + "682" to "Saudi Arabia", "686" to "Senegal", "688" to "Serbia", "690" to "Seychelles", + "694" to "Sierra Leone", "702" to "Singapore", "703" to "Slovakia", "704" to "Vietnam", + "705" to "Slovenia", "706" to "Somalia", "710" to "South Africa", "716" to "Zimbabwe", + "724" to "Spain", "728" to "South Sudan", "729" to "Sudan", "732" to "Western Sahara", + "740" to "Suriname", "744" to "Svalbard and Jan Mayen", "748" to "Eswatini", "752" to "Sweden", + "756" to "Switzerland", "760" to "Syria", "762" to "Tajikistan", "764" to "Thailand", + "768" to "Togo", "772" to "Tokelau", "776" to "Tonga", "780" to "Trinidad and Tobago", + "784" to "UAE", "788" to "Tunisia", "792" to "Turkey", "795" to "Turkmenistan", + "796" to "Turks and Caicos Islands", "798" to "Tuvalu", "800" to "Uganda", "804" to "Ukraine", + "807" to "North Macedonia", "818" to "Egypt", "826" to "United Kingdom", "831" to "Guernsey", + "832" to "Jersey", "833" to "Isle of Man", "834" to "Tanzania", "840" to "United States", + "850" to "U.S. Virgin Islands", "854" to "Burkina Faso", "858" to "Uruguay", "860" to "Uzbekistan", + "862" to "Venezuela", "876" to "Wallis and Futuna", "882" to "Samoa", "887" to "Yemen", + "894" to "Zambia", + ) +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/EmvCardReader.kt b/app/src/main/java/sh/sar/sw9000/nfc/EmvCardReader.kt new file mode 100644 index 0000000..206b3c2 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/EmvCardReader.kt @@ -0,0 +1,359 @@ +package sh.sar.sw9000.nfc + +import android.nfc.Tag +import android.nfc.tech.IsoDep +import android.nfc.tech.NfcA + +/** + * Read-only contactless EMV reader that dumps everything obtainable from a card: + * the PPSE directory, every advertised application (SELECT → GPO → AFL records), a merged + * BER-TLV tree per application, a flat list of notable fields, and — for full transparency — + * the complete command/response APDU log of the whole session. + * + * It never writes to the card and runs no transaction (no GENERATE AC), so tapping is harmless + * to your own cards. [read] blocks on NFC I/O and must be called off the main thread. + */ +object EmvCardReader { + + /** One command→response round-trip, kept verbatim so the UI can show the raw dump. */ + data class Apdu( + val label: String, + val command: ByteArray, + val response: ByteArray, + val sw1: Int, + val sw2: Int, + ) { + val sw: String get() = "%02X%02X".format(sw1, sw2) + val ok: Boolean get() = sw1 == 0x90 && sw2 == 0x00 + val swMeaning: String get() = StatusWords.describe(sw1, sw2) + } + + /** Everything learned about a single application (AID). */ + data class AppResult( + val aid: String, + val label: String?, + val preferredName: String?, + val tlv: List, + ) + + /** A single labelled value for the "formatted" view. */ + data class Field(val name: String, val value: String) + + /** The full outcome of a tap. [error] is set only when nothing usable could be read. */ + data class Result( + val uid: String, + val techList: List, + val historicalBytes: String?, + val hiLayerResponse: String?, + val atqa: String?, + val sak: String?, + val apps: List, + val fields: List, + val apduLog: List, + val error: String?, + ) { + val hasData: Boolean get() = apps.isNotEmpty() || fields.isNotEmpty() + } + + // Fallback AID list if the PPSE directory is empty or absent. + private val KNOWN_AIDS = listOf( + "A0000000031010" to "Visa", + "A0000000032010" to "Visa Electron", + "A0000000041010" to "Mastercard", + "A0000000043060" to "Maestro", + "A00000002501" to "American Express", + "A0000003330101" to "UnionPay", + "A0000001523010" to "Discover", + "A0000000651010" to "JCB", + "A0000006200620" to "Interac", + ) + + fun read(tag: Tag): Result { + val log = ArrayList() + val iso = IsoDep.get(tag) + ?: return Result( + uid = Hex.encode(tag.id), + techList = tag.techList.toList(), + historicalBytes = null, hiLayerResponse = null, + atqa = nfcA(tag)?.let { Hex.encode(it.atqa) }, + sak = nfcA(tag)?.let { "%02X".format(it.sak) }, + apps = emptyList(), fields = emptyList(), apduLog = emptyList(), + error = "Card does not support ISO-DEP (IsoDep). It may not be an EMV payment card.", + ) + + val apps = ArrayList() + var error: String? = null + try { + iso.connect() + iso.timeout = 5000 + + // 1) PPSE — the payment application directory. + val ppse = exchange(iso, selectName("2PAY.SYS.DDF01"), "SELECT PPSE (2PAY.SYS.DDF01)", log) + val aidsFromPpse = ppse?.let { Tlv.parse(it) }?.let { collectAids(it) } ?: emptyList() + val candidates = if (aidsFromPpse.isNotEmpty()) aidsFromPpse else KNOWN_AIDS + + // 2) Walk each candidate application. + for ((aidHex, hint) in candidates) { + val aid = Hex.decode(aidHex) + val fci = exchange(iso, selectAid(aid), "SELECT AID $aidHex${hint?.let { " ($it)" } ?: ""}", log) + ?: continue + val fciTlv = Tlv.parse(fci) + val merged = ArrayList().apply { addAll(fciTlv) } + + // 3) GET PROCESSING OPTIONS with the card's PDOL filled in. + val pdol = Tlv.find(fciTlv, "9F38") + val gpo = exchange(iso, gpoApdu(pdol), "GET PROCESSING OPTIONS", log) + if (gpo != null) { + val gpoTlv = Tlv.parse(gpo) + merged.addAll(gpoTlv) + + // 4) Read every record named by the AFL. + val afl = aflFrom(gpoTlv) + var i = 0 + while (i + 3 < afl.size) { + val sfi = (afl[i].toInt() and 0xFF) shr 3 + val first = afl[i + 1].toInt() and 0xFF + val last = afl[i + 2].toInt() and 0xFF + for (rec in first..last) { + val data = exchange(iso, readRecord(sfi, rec), "READ RECORD SFI $sfi rec $rec", log) + if (data != null) merged.addAll(Tlv.parse(data)) + } + i += 4 + } + } + + // 5) GET DATA for the common counters (harmless, read-only). + for ((t, name) in listOf("9F36" to "ATC", "9F13" to "Last Online ATC", "9F17" to "PIN Try Counter")) { + val d = exchange(iso, getData(t), "GET DATA $t ($name)", log) + if (d != null) merged.addAll(Tlv.parse(d)) + } + + apps.add( + AppResult( + aid = aidHex, + label = Tlv.find(merged, "50")?.let { asciiOrNull(it) } ?: hint, + preferredName = Tlv.find(merged, "9F12")?.let { asciiOrNull(it) }, + tlv = dedupe(merged), + ) + ) + } + if (apps.isEmpty() && ppse == null) { + error = "No EMV payment application responded. The card may use a scheme this tool " + + "doesn't probe, or it isn't a contactless payment card." + } + } catch (e: Exception) { + error = "Read error: ${e.message ?: e.javaClass.simpleName}" + } finally { + runCatching { iso.close() } + } + + val fields = buildFields(apps) + return Result( + uid = Hex.encode(tag.id), + techList = tag.techList.toList(), + historicalBytes = iso.historicalBytes?.takeIf { it.isNotEmpty() }?.let { Hex.encode(it) }, + hiLayerResponse = iso.hiLayerResponse?.takeIf { it.isNotEmpty() }?.let { Hex.encode(it) }, + atqa = nfcA(tag)?.let { Hex.encode(it.atqa) }, + sak = nfcA(tag)?.let { "%02X".format(it.sak) }, + apps = apps, + fields = fields, + apduLog = log, + error = if (apps.isEmpty()) (error ?: "Couldn't read any card data.") else null, + ) + } + + // ── Field extraction for the formatted view ──────────────────────────────── + + private fun buildFields(apps: List): List { + val out = LinkedHashMap() + fun put(name: String, value: String?) { if (!value.isNullOrBlank() && !out.containsKey(name)) out[name] = value } + + for (app in apps) { + val t = app.tlv + // PAN: prefer 5A, fall back to Track 2. + val pan = Tlv.find(t, "5A")?.let { Hex.encode(it).trimEnd('F') } + ?: Tlv.find(t, "57")?.let { trackPan(it) } + put("Card Number (PAN)", pan?.chunked(4)?.joinToString(" ")) + put("Card Scheme", CardIdentity.scheme(app.aid, pan)) + pan?.filter { it.isDigit() }?.takeIf { it.length >= 6 } + ?.let { put("BIN (IIN) — look up issuer", it.take(8)) } + // Issuer bank/type/brand come only from a bundled BIN database (if present); the + // card itself doesn't carry them. These fill gaps without overriding card-read values. + BinLookup.lookup(pan)?.let { iss -> + put("Card Scheme", iss.scheme) + put("Issuer Bank", iss.bank) + put("Card Type", iss.type) + put("Card Product", iss.brand) + } + put("Cardholder Name", Tlv.find(t, "5F20")?.let { asciiOrNull(it) }) + Tlv.find(t, "5F24")?.let { put("Expiry Date", expiry(it)) } + ?: Tlv.find(t, "57")?.let { put("Expiry Date", trackExpiry(it)) } + put("Valid From", Tlv.find(t, "5F25")?.let { effective(it) }) + put("PAN Sequence Number", Tlv.find(t, "5F34")?.let { Hex.encode(it) }) + put("Application Label", app.label) + put("Preferred Name", app.preferredName) + put("AID", app.aid) + put("Issuer Country", Tlv.find(t, "5F28")?.let { CardIdentity.country(Hex.encode(it)) } + ?: BinLookup.lookup(pan)?.country) + put("Application Currency", Tlv.find(t, "9F42")?.let { TlvInterpreter.interpret("9F42", it) }) + put("Language Preference", Tlv.find(t, "5F2D")?.let { asciiOrNull(it) }) + put("Application Version", Tlv.find(t, "9F08")?.let { Hex.encode(it) }) + put("ATC (Transaction Counter)", Tlv.find(t, "9F36")?.let { beInt(it).toString() }) + put("Last Online ATC", Tlv.find(t, "9F13")?.let { beInt(it).toString() }) + put("PIN Try Counter", Tlv.find(t, "9F17")?.let { beInt(it).toString() }) + put("Application Interchange Profile", Tlv.find(t, "82")?.let { TlvInterpreter.interpret("82", it) }) + put("Track 2 Equivalent", Tlv.find(t, "57")?.let { Hex.encode(it) }) + } + return out.map { Field(it.key, it.value) } + } + + // ── APDU builders ────────────────────────────────────────────────────────── + + private fun selectName(name: String): ByteArray = selectAid(name.toByteArray(Charsets.US_ASCII)) + + private fun selectAid(aid: ByteArray): ByteArray = + byteArrayOf(0x00, 0xA4.toByte(), 0x04, 0x00, aid.size.toByte()) + aid + byteArrayOf(0x00) + + private fun readRecord(sfi: Int, rec: Int): ByteArray = + byteArrayOf(0x00, 0xB2.toByte(), rec.toByte(), ((sfi shl 3) or 0x04).toByte(), 0x00) + + private fun getData(tag: String): ByteArray { + val t = Hex.decode(tag) + return byteArrayOf(0x80.toByte(), 0xCA.toByte(), t[0], t.getOrElse(1) { 0 }, 0x00) + } + + /** Builds GPO, filling the PDOL with sensible terminal values (zeros where unknown). */ + private fun gpoApdu(pdol: ByteArray?): ByteArray { + val data = ArrayList() + if (pdol != null) { + var i = 0 + while (i < pdol.size) { + var tag = pdol[i].toInt() and 0xFF + i++ + if (tag and 0x1F == 0x1F) { + while (i < pdol.size) { + val b = pdol[i++].toInt() and 0xFF + tag = (tag shl 8) or b + if (b and 0x80 == 0) break + } + } + if (i >= pdol.size) break + val len = pdol[i++].toInt() and 0xFF + val value = pdolValue(tag, len) + data.addAll(value.copyOf(len).toList()) + } + } + val pdolData = data.toByteArray() + val body = byteArrayOf(0x83.toByte(), pdolData.size.toByte()) + pdolData + return byteArrayOf(0x80.toByte(), 0xA8.toByte(), 0x00, 0x00, body.size.toByte()) + body + byteArrayOf(0x00) + } + + private fun pdolValue(tag: Int, len: Int): ByteArray = when (tag) { + 0x9F66 -> Hex.decode("B6204000") // TTQ: qVSDC, online-capable, no CVM required + 0x9F1A -> Hex.decode("0462") // Terminal country: Maldives + 0x5F2A -> Hex.decode("0462") // Transaction currency: MVR + 0x9A -> Hex.decode("260101") // Transaction date (YYMMDD) + 0x9C -> Hex.decode("00") // Transaction type: purchase + 0x9F37 -> Hex.decode("12345678") // Unpredictable number + 0x9F35 -> Hex.decode("22") // Terminal type + 0x9F33 -> Hex.decode("6008C8") // Terminal capabilities + 0x9F40 -> Hex.decode("F000F0A001") // Additional terminal capabilities + 0x9F02 -> Hex.decode("000000000100") // Amount authorised: 1 minor unit + 0x9F03 -> Hex.decode("000000000000") // Amount other + 0x95 -> Hex.decode("0000000000") // TVR + else -> ByteArray(len) + } + + // ── Transceive with 61xx / 6Cxx handling ─────────────────────────────────── + + private fun exchange(iso: IsoDep, apdu: ByteArray, label: String, log: MutableList): ByteArray? { + var cmd = apdu + var resp = iso.transceive(cmd) + if (resp.size < 2) { log.add(Apdu(label, cmd, resp, 0, 0)); return null } + + var sw1 = resp[resp.size - 2].toInt() and 0xFF + var sw2 = resp[resp.size - 1].toInt() and 0xFF + + if (sw1 == 0x6C) { // wrong Le; retry with the length the card wants + cmd = apdu.copyOf() + cmd[cmd.size - 1] = resp[resp.size - 1] + resp = iso.transceive(cmd) + sw1 = resp[resp.size - 2].toInt() and 0xFF + sw2 = resp[resp.size - 1].toInt() and 0xFF + } + // Accumulate any GET RESPONSE (61xx) continuations. + var payload = resp.copyOf(resp.size - 2) + while (sw1 == 0x61) { + val getResp = byteArrayOf(0x00, 0xC0.toByte(), 0x00, 0x00, resp[resp.size - 1]) + resp = iso.transceive(getResp) + if (resp.size < 2) break + payload += resp.copyOf(resp.size - 2) + sw1 = resp[resp.size - 2].toInt() and 0xFF + sw2 = resp[resp.size - 1].toInt() and 0xFF + } + + log.add(Apdu(label, cmd, payload + byteArrayOf(sw1.toByte(), sw2.toByte()), sw1, sw2)) + return if (sw1 == 0x90 && sw2 == 0x00) payload else null + } + + // ── Small helpers ────────────────────────────────────────────────────────── + + private fun nfcA(tag: Tag): NfcA? = runCatching { NfcA.get(tag) }.getOrNull() + + private fun collectAids(nodes: List): List> { + val out = ArrayList>() + fun walk(ns: List) { + for (n in ns) { + if (n.tag == "4F") out.add(Hex.encode(n.value) to null) + walk(n.children) + } + } + walk(nodes) + return out + } + + private fun aflFrom(gpoTlv: List): ByteArray = + Tlv.find(gpoTlv, "94") + ?: Tlv.find(gpoTlv, "80")?.let { if (it.size > 2) it.copyOfRange(2, it.size) else null } + ?: ByteArray(0) + + /** Removes duplicate leaf tags (same tag+value) that appear across records. */ + private fun dedupe(nodes: List): List { + val seen = HashSet() + val out = ArrayList() + for (n in nodes) { + val key = n.tag + ":" + if (n.constructed) "C" else Hex.encode(n.value) + if (seen.add(key)) out.add(n) + } + return out + } + + private fun asciiOrNull(v: ByteArray): String? = + String(v, Charsets.US_ASCII).trim().filter { it.code in 32..126 }.ifBlank { null } + + private fun beInt(v: ByteArray): Int = v.fold(0) { a, b -> (a shl 8) or (b.toInt() and 0xFF) } + + private fun trackPan(track2: ByteArray): String { + val h = Hex.encode(track2).uppercase() + val sep = h.indexOfFirst { it == 'D' || it == '=' } + return if (sep > 0) h.substring(0, sep) else h + } + + private fun trackExpiry(track2: ByteArray): String { + val h = Hex.encode(track2).uppercase() + val sep = h.indexOfFirst { it == 'D' || it == '=' } + if (sep < 0) return "" + val yymm = h.substring(sep + 1).take(4) + return if (yymm.length == 4) "${yymm.substring(2, 4)}/${yymm.substring(0, 2)}" else "" + } + + private fun expiry(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 4) "${h.substring(2, 4)}/${h.substring(0, 2)}" else h + } + + private fun effective(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 4) "${h.substring(2, 4)}/${h.substring(0, 2)}" else h + } +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/EmvTags.kt b/app/src/main/java/sh/sar/sw9000/nfc/EmvTags.kt new file mode 100644 index 0000000..577005a --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/EmvTags.kt @@ -0,0 +1,114 @@ +package sh.sar.sw9000.nfc + +/** + * Dictionary of EMV / ISO 7816 BER-TLV tags, used to label every object pulled off the card. + * Names follow the EMV 4.x specification and common issuer usage. Unknown tags fall back to + * "Unknown ()" so nothing read from the card is ever silently dropped. + */ +object EmvTags { + + private val names: Map = mapOf( + // ── Templates / FCI ────────────────────────────────────────────────── + "6F" to "FCI Template", + "84" to "Dedicated File (DF) Name / AID", + "A5" to "FCI Proprietary Template", + "87" to "Application Priority Indicator", + "88" to "Short File Identifier (SFI)", + "5F2D" to "Language Preference", + "9F11" to "Issuer Code Table Index", + "9F12" to "Application Preferred Name", + "50" to "Application Label", + "9F38" to "Processing Options Data Object List (PDOL)", + "BF0C" to "FCI Issuer Discretionary Data", + "61" to "Application Template", + "4F" to "Application Identifier (AID)", + "73" to "Directory Discretionary Template", + // ── PPSE ───────────────────────────────────────────────────────────── + "DF60" to "Kernel Identifier (proprietary)", + "9F2A" to "Kernel Identifier", + "9F0A" to "Application Selection Registered Proprietary Data", + // ── GPO / processing ───────────────────────────────────────────────── + "80" to "Response Message Template Format 1", + "77" to "Response Message Template Format 2", + "82" to "Application Interchange Profile (AIP)", + "94" to "Application File Locator (AFL)", + "83" to "Command Template", + "9F66" to "Terminal Transaction Qualifiers (TTQ)", + // ── Cardholder / account ───────────────────────────────────────────── + "5A" to "Application Primary Account Number (PAN)", + "5F34" to "PAN Sequence Number", + "5F20" to "Cardholder Name", + "5F24" to "Application Expiration Date", + "5F25" to "Application Effective Date", + "5F28" to "Issuer Country Code", + "5F2A" to "Transaction Currency Code", + "9F42" to "Application Currency Code", + "9F44" to "Application Currency Exponent", + "5F30" to "Service Code", + "5F36" to "Transaction Currency Exponent", + "57" to "Track 2 Equivalent Data", + "9F6B" to "Track 2 Data", + "56" to "Track 1 Equivalent Data", + "9F1F" to "Track 1 Discretionary Data", + "9F20" to "Track 2 Discretionary Data", + "9F5B" to "Issuer Script Results", + // ── Application control / counters ─────────────────────────────────── + "8C" to "Card Risk Management Data Object List 1 (CDOL1)", + "8D" to "Card Risk Management Data Object List 2 (CDOL2)", + "8E" to "Cardholder Verification Method (CVM) List", + "8F" to "Certification Authority Public Key Index", + "90" to "Issuer Public Key Certificate", + "92" to "Issuer Public Key Remainder", + "93" to "Signed Static Application Data", + "9F32" to "Issuer Public Key Exponent", + "9F46" to "ICC Public Key Certificate", + "9F47" to "ICC Public Key Exponent", + "9F48" to "ICC Public Key Remainder", + "9F49" to "Dynamic Data Authentication Data Object List (DDOL)", + "9F4A" to "Static Data Authentication Tag List", + "9F4B" to "Signed Dynamic Application Data", + "9F4C" to "ICC Dynamic Number", + "9F62" to "Track 1 bit map for PCII (PAN/Seq)", + "9F63" to "Track 2 bit map for PCII", + "9F64" to "Track 1 Number of ATC Digits", + "9F65" to "Track 2 bit map for CVC3", + "9F67" to "Track 2 Number of ATC Digits / NATC", + "9F68" to "Mag-stripe CVM List", + "9F69" to "Card Authentication Related Data (UDOL)", + "9F6C" to "Card Transaction Qualifiers (CTQ)", + "9F6E" to "Form Factor Indicator / 3rd Party Data", + // ── Counters read via GET DATA ─────────────────────────────────────── + "9F36" to "Application Transaction Counter (ATC)", + "9F13" to "Last Online ATC Register", + "9F17" to "PIN Try Counter", + "9F4F" to "Log Format", + "9F4D" to "Log Entry", + // ── Issuer / misc ──────────────────────────────────────────────────── + "9F07" to "Application Usage Control (AUC)", + "9F08" to "Application Version Number", + "9F0D" to "Issuer Action Code - Default", + "9F0E" to "Issuer Action Code - Denial", + "9F0F" to "Issuer Action Code - Online", + "9F5A" to "Application Program Identifier", + "9F10" to "Issuer Application Data", + "9F26" to "Application Cryptogram", + "9F27" to "Cryptogram Information Data", + "9F34" to "Cardholder Verification Method (CVM) Results", + "9F37" to "Unpredictable Number", + "9F35" to "Terminal Type", + "9F33" to "Terminal Capabilities", + "9F1A" to "Terminal Country Code", + "9F40" to "Additional Terminal Capabilities", + "95" to "Terminal Verification Results (TVR)", + "9A" to "Transaction Date", + "9C" to "Transaction Type", + "9F02" to "Amount, Authorised (Numeric)", + "9F03" to "Amount, Other (Numeric)", + "9F21" to "Transaction Time", + "9F7C" to "Customer Exclusive Data", + "BF50" to "Issuer Discretionary Data", + "DF810C" to "Kernel Identifier", + ) + + fun name(tag: String): String = names[tag.uppercase()] ?: "Unknown (0x$tag)" +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/StatusWords.kt b/app/src/main/java/sh/sar/sw9000/nfc/StatusWords.kt new file mode 100644 index 0000000..d196593 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/StatusWords.kt @@ -0,0 +1,39 @@ +package sh.sar.sw9000.nfc + +/** Human-readable meaning of ISO 7816 / EMV status words (SW1 SW2), for the raw APDU dump. */ +object StatusWords { + fun describe(sw1: Int, sw2: Int): String { + val sw = (sw1 shl 8) or sw2 + exact[sw]?.let { return it } + return when (sw1) { + 0x61 -> "$sw2 bytes available (GET RESPONSE)" + 0x6C -> "Wrong Le; $sw2 bytes expected" + 0x63 -> if (sw2 in 0xC0..0xCF) "Verification failed, ${sw2 and 0x0F} tries left" else "Warning" + 0x62 -> "Warning: state unchanged" + 0x64 -> "Error: state unchanged" + 0x65 -> "Error: state changed (memory)" + 0x67 -> "Wrong length" + 0x6A -> "Wrong parameters P1-P2" + else -> "Unknown status" + } + } + + private val exact = mapOf( + 0x9000 to "Success", + 0x6700 to "Wrong length", + 0x6283 to "Selected file invalidated", + 0x6982 to "Security status not satisfied", + 0x6983 to "Authentication method blocked", + 0x6985 to "Conditions of use not satisfied", + 0x6A80 to "Incorrect data in command", + 0x6A81 to "Function not supported", + 0x6A82 to "File or application not found", + 0x6A83 to "Record not found", + 0x6A84 to "Not enough memory space", + 0x6A86 to "Incorrect P1-P2", + 0x6A88 to "Referenced data not found", + 0x6D00 to "Instruction not supported", + 0x6E00 to "Class not supported", + 0x6F00 to "No precise diagnosis", + ) +} diff --git a/app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt b/app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt new file mode 100644 index 0000000..00ba581 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/nfc/Tlv.kt @@ -0,0 +1,207 @@ +package sh.sar.sw9000.nfc + +/** + * BER-TLV parsing for EMV responses, plus best-effort human interpretation of each value. + * The parser is tolerant: it stops cleanly at padding (00 / FF) and never throws on a truncated + * object, so a partial read still yields whatever objects were decodable. + */ + +/** One decoded TLV object. [children] is non-empty only for constructed tags. */ +data class TlvNode( + val tag: String, // uppercase hex, e.g. "5F24" + val length: Int, + val value: ByteArray, // raw value bytes (empty for constructed tags we recursed into) + val constructed: Boolean, + val children: List, +) { + val name: String get() = EmvTags.name(tag) + val valueHex: String get() = Hex.encode(value) + + /** A friendly rendering of the value where the tag's meaning is known; null if hex is best. */ + val interpreted: String? get() = TlvInterpreter.interpret(tag, value) +} + +object Tlv { + + /** Parses [data] as a sequence of BER-TLV objects, recursing into constructed templates. */ + fun parse(data: ByteArray): List = parse(data, 0, data.size) + + private fun parse(data: ByteArray, start: Int, end: Int): List { + val out = ArrayList() + var i = start + while (i < end) { + val b0 = data[i].toInt() and 0xFF + if (b0 == 0x00 || b0 == 0xFF) { i++; continue } // inter-object padding + val tagStart = i + val constructed = b0 and 0x20 != 0 + i++ + if (b0 and 0x1F == 0x1F) { // multi-byte tag + while (i < end) { + val b = data[i++].toInt() and 0xFF + if (b and 0x80 == 0) break + } + } + if (i >= end) break + val tag = Hex.encode(data.copyOfRange(tagStart, i)) + + var len = data[i++].toInt() and 0xFF + if (len and 0x80 != 0) { // multi-byte length + val n = len and 0x7F + if (n == 0 || i + n > end) break + len = 0 + repeat(n) { len = (len shl 8) or (data[i++].toInt() and 0xFF) } + } + if (len < 0 || i + len > end) break + val value = data.copyOfRange(i, i + len) + val children = if (constructed) parse(value, 0, value.size) else emptyList() + out.add(TlvNode(tag, len, if (constructed) ByteArray(0) else value, constructed, children)) + i += len + } + return out + } + + /** Finds the first value for [tag] anywhere in the tree (depth-first). */ + fun find(nodes: List, tag: String): ByteArray? { + val t = tag.uppercase() + for (n in nodes) { + if (n.tag == t && !n.constructed) return n.value + val c = find(n.children, t) + if (c != null) return c + } + return null + } +} + +/** Turns known EMV values into readable text. Returns null when raw hex is the clearest form. */ +object TlvInterpreter { + + fun interpret(tag: String, v: ByteArray): String? = when (tag.uppercase()) { + "5A" -> "PAN " + digitsBcd(v).trimEnd('F').chunked(4).joinToString(" ") + "5F34" -> "Sequence #" + digitsBcd(v) + "5F20" -> ascii(v) + "50", "9F12" -> ascii(v) + "5F2D" -> ascii(v) + "5F24" -> expiryDate(v) + "5F25" -> effectiveDate(v) + "5F28" -> "Country " + countryName(digitsBcd(v)) + "9F1A" -> "Country " + countryName(digitsBcd(v)) + "5F2A", "9F42" -> "Currency " + currencyName(digitsBcd(v)) + "57" -> track2(v) + "9F6B" -> track2(v) + "56" -> ascii(v) + "82" -> "AIP " + Hex.encode(v) + aipBits(v) + "94" -> "AFL " + aflText(v) + "87" -> "Priority " + (v.firstOrNull()?.toInt()?.and(0x0F) ?: 0) + "88" -> "SFI " + (v.firstOrNull()?.toInt()?.and(0xFF) ?: 0) + "9F36", "9F13", "9F17" -> (v.fold(0) { a, b -> (a shl 8) or (b.toInt() and 0xFF) }).toString() + "9F08", "9F09" -> "v" + Hex.encode(v) + "9A" -> "Date " + bcdDate(v) + "9F21" -> "Time " + bcdTime(v) + "9C" -> transactionType(v) + "5F30" -> "Service code " + digitsBcd(v) + else -> null + }?.takeIf { it.isNotBlank() } + + private fun ascii(v: ByteArray): String = + String(v, Charsets.US_ASCII).trim().filter { it.code in 32..126 } + + private fun digitsBcd(v: ByteArray): String = Hex.encode(v) + + private fun expiryDate(v: ByteArray): String { + val h = Hex.encode(v) + if (h.length < 4) return h + return "Expires ${h.substring(2, 4)}/${h.substring(0, 2)}" // MM/YY from YYMMDD + } + + private fun effectiveDate(v: ByteArray): String { + val h = Hex.encode(v) + if (h.length < 4) return h + return "Valid from ${h.substring(2, 4)}/${h.substring(0, 2)}" + } + + private fun bcdDate(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 6) "20${h.substring(0, 2)}-${h.substring(2, 4)}-${h.substring(4, 6)}" else h + } + + private fun bcdTime(v: ByteArray): String { + val h = Hex.encode(v) + return if (h.length >= 6) "${h.substring(0, 2)}:${h.substring(2, 4)}:${h.substring(4, 6)}" else h + } + + private fun track2(v: ByteArray): String { + val h = Hex.encode(v).uppercase() + val sep = h.indexOfFirst { it == 'D' || it == '=' } + if (sep <= 0) return h + val pan = h.substring(0, sep) + val rest = h.substring(sep + 1) + val exp = rest.take(4) + val svc = rest.drop(4).take(3) + val expShown = if (exp.length == 4) "exp ${exp.substring(2, 4)}/${exp.substring(0, 2)}" else "" + return "PAN ${pan.chunked(4).joinToString(" ")} $expShown svc $svc" + } + + private fun aipBits(v: ByteArray): String { + if (v.isEmpty()) return "" + val b1 = v[0].toInt() and 0xFF + val flags = buildList { + if (b1 and 0x40 != 0) add("SDA") + if (b1 and 0x20 != 0) add("DDA") + if (b1 and 0x10 != 0) add("Cardholder verification") + if (b1 and 0x08 != 0) add("Terminal risk mgmt") + if (b1 and 0x04 != 0) add("Issuer auth") + if (b1 and 0x01 != 0) add("CDA") + } + return if (flags.isEmpty()) "" else " (" + flags.joinToString(", ") + ")" + } + + private fun aflText(v: ByteArray): String { + val sb = StringBuilder() + var i = 0 + while (i + 3 < v.size) { + val sfi = (v[i].toInt() and 0xFF) shr 3 + val first = v[i + 1].toInt() and 0xFF + val last = v[i + 2].toInt() and 0xFF + if (sb.isNotEmpty()) sb.append("; ") + sb.append("SFI $sfi rec $first-$last") + i += 4 + } + return sb.toString() + } + + private fun transactionType(v: ByteArray): String = when (Hex.encode(v)) { + "00" -> "Purchase" + "01" -> "Cash" + "09" -> "Purchase with cashback" + "20" -> "Refund" + else -> Hex.encode(v) + } + + private fun countryName(code: String): String = CardIdentity.country(code) + private fun currencyName(code: String): String = CURRENCY[code.trimStart('0').padStart(3, '0')] ?: code + + private val CURRENCY = mapOf( + "462" to "MVR (462)", "840" to "USD (840)", "978" to "EUR (978)", + "826" to "GBP (826)", "356" to "INR (356)", "702" to "SGD (702)", + "784" to "AED (784)", "036" to "AUD (036)", "124" to "CAD (124)", + ) +} + +/** Hex helpers shared across the NFC layer. */ +object Hex { + fun encode(b: ByteArray): String { + val sb = StringBuilder(b.size * 2) + for (x in b) sb.append(HEX[(x.toInt() ushr 4) and 0xF]).append(HEX[x.toInt() and 0xF]) + return sb.toString() + } + + fun decode(s: String): ByteArray { + val clean = s.filter { !it.isWhitespace() } + return ByteArray(clean.length / 2) { clean.substring(it * 2, it * 2 + 2).toInt(16).toByte() } + } + + /** Space-grouped hex for readable dumps, e.g. "00 A4 04 00". */ + fun pretty(b: ByteArray): String = b.joinToString(" ") { "%02X".format(it) } + + private const val HEX = "0123456789ABCDEF" +} diff --git a/app/src/main/java/sh/sar/sw9000/ui/NfcCardAnimation.kt b/app/src/main/java/sh/sar/sw9000/ui/NfcCardAnimation.kt new file mode 100644 index 0000000..cecb704 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/ui/NfcCardAnimation.kt @@ -0,0 +1,291 @@ +package sh.sar.sw9000.ui + +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.rotate +import androidx.compose.ui.graphics.drawscope.scale +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.withFrameMillis +import androidx.compose.runtime.LaunchedEffect +import kotlin.math.PI +import kotlin.math.min +import kotlin.math.sin + +/** What the reader is doing; the animation reflects it. */ +enum class TapState { WAITING, READING, SUCCESS, ERROR } + +/** + * "Tap your card" animation: a bank card swings onto the back of a phone, NFC waves ripple out + * from the antenna, then it lifts away and repeats. In READING the waves pulse continuously; + * SUCCESS pops a check badge; ERROR shakes the card. Faithful to the reference app's artwork. + */ +@Composable +fun NfcCardAnimation( + state: TapState, + label: String, + modifier: Modifier = Modifier, +) { + val cs = MaterialTheme.colorScheme + var now by remember { mutableLongStateOf(0L) } + var stateStart by remember { mutableLongStateOf(0L) } + + // Drives redraws every frame. + LaunchedEffect(Unit) { + while (true) withFrameMillis { now = it } + } + // Resets the animation clock each time the state changes (and on first show). + LaunchedEffect(state) { + withFrameMillis { stateStart = it; now = it } + } + val elapsed = (now - stateStart).coerceAtLeast(0L) + + Column( + modifier = modifier, + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center, + ) { + Canvas( + modifier = Modifier + .fillMaxWidth() + .height(220.dp) + ) { + drawScene(state, elapsed, cs.primary, cs.onSurface, cs.surfaceVariant, cs.error, cs.onPrimary) + } + Text( + text = label, + modifier = Modifier + .fillMaxWidth() + .padding(top = 12.dp, start = 24.dp, end = 24.dp), + textAlign = TextAlign.Center, + style = TextStyle( + fontSize = 16.sp, + fontWeight = FontWeight.Medium, + color = if (state == TapState.ERROR) cs.error else cs.onSurface, + ), + ) + } +} + +private const val DESIGN_W = 240f +private const val DESIGN_H = 170f +private const val CYCLE_MS = 2600f + +private fun DrawScope.drawScene( + state: TapState, + elapsed: Long, + primary: Color, + onSurface: Color, + surfaceVariant: Color, + error: Color, + onPrimary: Color, +) { + val w = size.width + val h = size.height + if (w <= 0f || h <= 0f) return + + val scale = min(min(w / DESIGN_W, h / DESIGN_H), density * 1.1f).coerceAtLeast(0.6f) + val u = scale + val cx = w / 2f + val top = (h - DESIGN_H * u) / 2f + + // Card contact: 0 = away, 1 = held on phone. + val contact = when (state) { + TapState.WAITING -> { + val p = (elapsed % CYCLE_MS.toLong()) / CYCLE_MS + when { + p < 0.35f -> easeInOut(p / 0.35f) + p < 0.70f -> 1f + p < 1.00f -> 1f - easeInOut((p - 0.70f) / 0.30f) + else -> 0f + } + } + else -> 1f + } + val shake = if (state == TapState.ERROR && elapsed < 500) + (sin(elapsed / 500f * 6 * PI).toFloat() * (1f - elapsed / 500f) * 8 * u) else 0f + + // ── Phone (back view) ── + val phoneW = 64 * u; val phoneH = 112 * u + val phoneL = cx - phoneW / 2f; val phoneT = top + 44 * u + drawRoundRect( + color = surfaceVariant, + topLeft = Offset(phoneL, phoneT), + size = Size(phoneW, phoneH), + cornerRadius = corner(10 * u), + ) + drawRoundRect( + color = onSurface, + topLeft = Offset(phoneL, phoneT), + size = Size(phoneW, phoneH), + cornerRadius = corner(10 * u), + style = Stroke(width = 2.5f * u), + ) + drawRoundRect( + color = onSurface.copy(alpha = 0.24f), + topLeft = Offset(phoneL + 8 * u, phoneT + 8 * u), + size = Size(18 * u, 22 * u), + cornerRadius = corner(5 * u), + ) + + val touchX = cx + val touchY = phoneT + phoneH * 0.42f + + // ── NFC waves ── + val waveStrength = when (state) { + TapState.WAITING -> ((contact - 0.85f) / 0.15f).coerceIn(0f, 1f) + TapState.READING -> 1f + else -> 0f + } + if (waveStrength > 0f) { + val period = if (state == TapState.READING) 700f else 1100f + val base = (elapsed % period.toLong()) / period + for (i in 0..2) { + val p = (base + i / 3f) % 1f + val r = 58 * u + p * 46 * u + drawArcOval( + center = Offset(touchX, touchY), + rx = r, ry = r * 0.72f, + color = primary.copy(alpha = (1f - p) * 0.85f * waveStrength), + stroke = 3 * u, + ) + } + } + + // ── Card ── + val cardW = 104 * u; val cardH = 66 * u + val restX = cx + 58 * u; val restY = top + 48 * u + val cardCx = restX + (touchX - restX) * contact + shake + val cardCy = restY + (touchY - restY) * contact + val rotation = 18f * (1f - contact) + val lift = 1f + 0.08f * (1f - contact) + + translate(cardCx, cardCy) { + rotate(rotation, pivot = Offset.Zero) { + scale(lift, lift, pivot = Offset.Zero) { + val outline = if (state == TapState.ERROR) error else onSurface + val left = -cardW / 2; val tp = -cardH / 2 + drawRoundRect( + color = surfaceVariant, + topLeft = Offset(left, tp), + size = Size(cardW, cardH), + cornerRadius = corner(8 * u), + ) + drawRoundRect( + color = outline, + topLeft = Offset(left, tp), + size = Size(cardW, cardH), + cornerRadius = corner(8 * u), + style = Stroke(width = 2.5f * u), + ) + // Chip + drawRoundRect( + color = primary.copy(alpha = 0.28f), + topLeft = Offset(left + 12 * u, -9 * u), + size = Size(18 * u, 14 * u), + cornerRadius = corner(3 * u), + ) + drawRoundRect( + color = outline, + topLeft = Offset(left + 12 * u, -9 * u), + size = Size(18 * u, 14 * u), + cornerRadius = corner(3 * u), + style = Stroke(width = 1.5f * u), + ) + // Contactless arcs on the card + for (i in 0..2) { + val r = (5 + i * 4.5f) * u + val arcCx = cardW / 2 - 28 * u + drawArc( + color = outline, + startAngle = -45f, + sweepAngle = 90f, + useCenter = false, + topLeft = Offset(arcCx - r, -14 * u - r), + size = Size(r * 2, r * 2), + style = Stroke(width = 1.8f * u, cap = StrokeCap.Round), + ) + } + // Number + name placeholders + for (g in 0..3) { + val x = left + 12 * u + g * 21 * u + drawLine(outline.copy(alpha = 0.6f), Offset(x, 16 * u), Offset(x + 15 * u, 16 * u), 3f * u) + } + drawLine(outline.copy(alpha = 0.4f), Offset(left + 12 * u, 26 * u), Offset(left + 48 * u, 26 * u), 2.5f * u) + } + } + } + + // ── Success badge ── + if (state == TapState.SUCCESS) { + val t = (elapsed / 450f).coerceIn(0f, 1f) + val badgeR = 22 * u * overshoot(t) + val bx = touchX + cardW / 2 - 6 * u; val by = touchY - cardH / 2 + 4 * u + drawCircle(primary, badgeR, Offset(bx, by)) + val checkT = ((elapsed - 200) / 350f).coerceIn(0f, 1f) + if (checkT > 0f) { + val x0 = bx - 9 * u; val y0 = by + val x1 = bx - 3 * u; val y1 = by + 7 * u + val x2 = bx + 10 * u; val y2 = by - 7 * u + val path = Path().apply { + moveTo(x0, y0) + if (checkT < 0.4f) { + val k = checkT / 0.4f + lineTo(x0 + (x1 - x0) * k, y0 + (y1 - y0) * k) + } else { + val k = (checkT - 0.4f) / 0.6f + lineTo(x1, y1); lineTo(x1 + (x2 - x1) * k, y1 + (y2 - y1) * k) + } + } + drawPath(path, onPrimary, style = Stroke(width = 3.5f * u, cap = StrokeCap.Round)) + } + } +} + +private fun DrawScope.drawArcOval(center: Offset, rx: Float, ry: Float, color: Color, stroke: Float) { + drawArc( + color = color, + startAngle = 0f, + sweepAngle = 360f, + useCenter = false, + topLeft = Offset(center.x - rx, center.y - ry), + size = Size(rx * 2, ry * 2), + style = Stroke(width = stroke), + ) +} + +private fun DrawScope.corner(r: Float) = androidx.compose.ui.geometry.CornerRadius(r, r) + +private fun easeInOut(x: Float): Float { + val c = x.coerceIn(0f, 1f) + return -(kotlin.math.cos(PI * c).toFloat() - 1f) / 2f +} + +private fun overshoot(x: Float, tension: Float = 2.2f): Float { + val t = x.coerceIn(0f, 1f) - 1f + return t * t * ((tension + 1) * t + tension) + 1f +} diff --git a/app/src/main/java/sh/sar/sw9000/ui/Screens.kt b/app/src/main/java/sh/sar/sw9000/ui/Screens.kt new file mode 100644 index 0000000..6dc5eb2 --- /dev/null +++ b/app/src/main/java/sh/sar/sw9000/ui/Screens.kt @@ -0,0 +1,257 @@ +package sh.sar.sw9000.ui + +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.Button +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.SecondaryTabRow +import androidx.compose.material3.Tab +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import sh.sar.sw9000.nfc.EmvCardReader +import sh.sar.sw9000.nfc.Hex +import sh.sar.sw9000.nfc.TlvNode + +/** NFC hardware isn't present on this device. */ +@Composable +fun UnsupportedScreen(modifier: Modifier = Modifier) { + CenteredMessage( + modifier = modifier, + title = "NFC not supported", + body = "This device has no NFC hardware, so it can't read contactless cards. " + + "Run sw9000 on a phone with NFC.", + ) +} + +/** NFC exists but is turned off — offer to open settings. */ +@Composable +fun NfcDisabledScreen(onOpenSettings: () -> Unit, modifier: Modifier = Modifier) { + Column( + modifier = modifier + .fillMaxSize() + .padding(32.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center, + ) { + Text("NFC is off", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold) + Spacer(Modifier.height(12.dp)) + Text( + "Turn on NFC to read a card.", + style = MaterialTheme.typography.bodyLarge, + textAlign = TextAlign.Center, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(Modifier.height(24.dp)) + Button(onClick = onOpenSettings) { Text("Open NFC settings") } + } +} + +/** Waiting for a tap (or actively reading). */ +@Composable +fun WaitingScreen(state: TapState, label: String, modifier: Modifier = Modifier) { + Box(modifier = modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + NfcCardAnimation(state = state, label = label, modifier = Modifier.fillMaxWidth()) + } +} + +/** Full dump of a card read: a success/error animation, formatted fields, and raw data. */ +@Composable +fun ResultScreen( + result: EmvCardReader.Result, + onReadAnother: () -> Unit, + modifier: Modifier = Modifier, +) { + var tab by remember { mutableIntStateOf(0) } + Column(modifier = modifier.fillMaxSize()) { + NfcCardAnimation( + state = if (result.hasData) TapState.SUCCESS else TapState.ERROR, + label = if (result.hasData) "Card read" else "Couldn't read card", + modifier = Modifier.fillMaxWidth().padding(top = 8.dp), + ) + + if (result.error != null && !result.hasData) { + Text( + result.error, + modifier = Modifier.fillMaxWidth().padding(24.dp), + textAlign = TextAlign.Center, + color = MaterialTheme.colorScheme.error, + ) + } + + SecondaryTabRow(selectedTabIndex = tab) { + Tab(selected = tab == 0, onClick = { tab = 0 }, text = { Text("Formatted") }) + Tab(selected = tab == 1, onClick = { tab = 1 }, text = { Text("Raw dump") }) + } + + Column( + Modifier + .weight(1f) + .verticalScroll(rememberScrollState()) + .padding(16.dp), + ) { + if (tab == 0) FormattedView(result) else RawDumpView(result) + Spacer(Modifier.height(16.dp)) + Button(onClick = onReadAnother, modifier = Modifier.fillMaxWidth()) { Text("Read another card") } + Spacer(Modifier.height(32.dp)) + } + } +} + +@Composable +private fun FormattedView(result: EmvCardReader.Result) { + if (result.fields.isNotEmpty()) { + SectionCard("Card data") { + result.fields.forEachIndexed { i, f -> + if (i > 0) HorizontalDivider(Modifier.padding(vertical = 8.dp)) + FieldRow(f.name, f.value) + } + } + Spacer(Modifier.height(12.dp)) + } + + result.apps.forEach { app -> + SectionCard("Application ${app.label ?: app.aid}") { + FieldRow("AID", app.aid) + app.label?.let { FieldRow("Label", it) } + app.preferredName?.let { FieldRow("Preferred name", it) } + } + Spacer(Modifier.height(12.dp)) + } + + SectionCard("Tag / NFC") { + FieldRow("UID", result.uid) + FieldRow("Technologies", result.techList.joinToString(", ") { it.substringAfterLast('.') }) + result.atqa?.let { FieldRow("ATQA", it) } + result.sak?.let { FieldRow("SAK", it) } + result.historicalBytes?.let { FieldRow("Historical bytes", it) } + result.hiLayerResponse?.let { FieldRow("Higher-layer response", it) } + } +} + +@Composable +private fun RawDumpView(result: EmvCardReader.Result) { + result.apps.forEach { app -> + SectionCard("TLV tree — ${app.label ?: app.aid}") { + app.tlv.forEach { TlvRow(it, 0) } + } + Spacer(Modifier.height(12.dp)) + } + + SectionCard("APDU log (${result.apduLog.size})") { + result.apduLog.forEachIndexed { i, a -> + if (i > 0) HorizontalDivider(Modifier.padding(vertical = 10.dp)) + Text( + a.label, + style = MaterialTheme.typography.labelLarge, + fontWeight = FontWeight.SemiBold, + ) + Spacer(Modifier.height(4.dp)) + MonoLabeled(">>", Hex.pretty(a.command), MaterialTheme.colorScheme.primary) + MonoLabeled("<<", Hex.pretty(a.response), MaterialTheme.colorScheme.onSurface) + Text( + "SW ${a.sw} — ${a.swMeaning}", + fontSize = 12.sp, + color = if (a.ok) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error, + modifier = Modifier.padding(top = 2.dp), + ) + } + } +} + +@Composable +private fun TlvRow(node: TlvNode, depth: Int) { + Column(Modifier.padding(start = (depth * 12).dp, top = 4.dp, bottom = 4.dp)) { + Row { + Text( + node.tag, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Bold, + fontSize = 13.sp, + color = MaterialTheme.colorScheme.primary, + ) + Spacer(Modifier.width(8.dp)) + Text(node.name, fontSize = 13.sp, fontWeight = FontWeight.Medium) + } + if (node.constructed) { + node.children.forEach { TlvRow(it, depth + 1) } + } else { + MonoLabeled("", node.valueHex, MaterialTheme.colorScheme.onSurfaceVariant) + node.interpreted?.let { + Text(it, fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(top = 1.dp)) + } + } + } +} + +@Composable +private fun MonoLabeled(prefix: String, text: String, color: androidx.compose.ui.graphics.Color) { + Row(Modifier.fillMaxWidth().horizontalScroll(rememberScrollState())) { + if (prefix.isNotEmpty()) { + Text(prefix, fontFamily = FontFamily.Monospace, fontSize = 12.sp, color = color) + Spacer(Modifier.width(6.dp)) + } + Text(text.ifBlank { "(empty)" }, fontFamily = FontFamily.Monospace, fontSize = 12.sp, color = color) + } +} + +@Composable +private fun FieldRow(name: String, value: String) { + Column(Modifier.fillMaxWidth()) { + Text(name, fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) + Text(value, fontSize = 15.sp, fontWeight = FontWeight.Medium) + } +} + +@Composable +private fun SectionCard(title: String, content: @Composable () -> Unit) { + Card( + modifier = Modifier.fillMaxWidth(), + shape = RoundedCornerShape(16.dp), + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.35f)), + ) { + Column(Modifier.padding(16.dp)) { + Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold) + Spacer(Modifier.height(12.dp)) + content() + } + } +} + +@Composable +private fun CenteredMessage(title: String, body: String, modifier: Modifier = Modifier) { + Column( + modifier = modifier.fillMaxSize().padding(32.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center, + ) { + Text(title, style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold, textAlign = TextAlign.Center) + Spacer(Modifier.height(12.dp)) + Text(body, style = MaterialTheme.typography.bodyLarge, textAlign = TextAlign.Center, color = MaterialTheme.colorScheme.onSurfaceVariant) + } +} diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml index 07d5da9..58f9128 100644 --- a/app/src/main/res/drawable/ic_launcher_background.xml +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -1,170 +1,11 @@ + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml index 2b068d1..e79b9fa 100644 --- a/app/src/main/res/drawable/ic_launcher_foreground.xml +++ b/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -1,30 +1,50 @@ + + - - - - - - - - - - \ No newline at end of file + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/app/src/main/res/mipmap-hdpi/ic_launcher.webp deleted file mode 100644 index c209e78ecd372343283f4157dcfd918ec5165bb3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1404 zcmV-?1%vuhNk&F=1pok7MM6+kP&il$0000G0000-002h-06|PpNX!5L00Dqw+t%{r zzW2vH!KF=w&cMnnN@{whkTw+#mAh0SV?YL=)3MimFYCWp#fpdtz~8$hD5VPuQgtcN zXl<@<#Cme5f5yr2h%@8TWh?)bSK`O z^Z@d={gn7J{iyxL_y_%J|L>ep{dUxUP8a{byupH&!UNR*OutO~0{*T4q5R6@ApLF! z5{w?Z150gC7#>(VHFJZ-^6O@PYp{t!jH(_Z*nzTK4 zkc{fLE4Q3|mA2`CWQ3{8;gxGizgM!zccbdQoOLZc8hThi-IhN90RFT|zlxh3Ty&VG z?Fe{#9RrRnxzsu|Lg2ddugg7k%>0JeD+{XZ7>Z~{=|M+sh1MF7~ zz>To~`~LVQe1nNoR-gEzkpe{Ak^7{{ZBk2i_<+`Bq<^GB!RYG+z)h;Y3+<{zlMUYd zrd*W4w&jZ0%kBuDZ1EW&KLpyR7r2=}fF2%0VwHM4pUs}ZI2egi#DRMYZPek*^H9YK zay4Iy3WXFG(F14xYsoDA|KXgGc5%2DhmQ1gFCkrgHBm!lXG8I5h*uf{rn48Z!_@ z4Bk6TJAB2CKYqPjiX&mWoW>OPFGd$wqroa($ne7EUK;#3VYkXaew%Kh^3OrMhtjYN?XEoY`tRPQsAkH-DSL^QqyN0>^ zmC>{#F14jz4GeW{pJoRpLFa_*GI{?T93^rX7SPQgT@LbLqpNA}<@2wH;q493)G=1Y z#-sCiRNX~qf3KgiFzB3I>4Z%AfS(3$`-aMIBU+6?gbgDb!)L~A)je+;fR0jWLL-Fu z4)P{c7{B4Hp91&%??2$v9iRSFnuckHUm}or9seH6 z>%NbT+5*@L5(I9j@06@(!{ZI?U0=pKn8uwIg&L{JV14+8s2hnvbRrU|hZCd}IJu7*;;ECgO%8_*W Kmw_-CKmY()leWbG diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp deleted file mode 100644 index b2dfe3d1ba5cf3ee31b3ecc1ced89044a1f3b7a9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2898 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 diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/app/src/main/res/mipmap-mdpi/ic_launcher.webp deleted file mode 100644 index 4f0f1d64e58ba64d180ce43ee13bf9a17835fbca..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 982 zcmV;{11bDcNk&G_0{{S5MM6+kP&il$0000G0000l001ul06|PpNU8t;00Dqo+t#w^ z^1csucXz7-Qrhzl9HuHB%l>&>1tG2^vb*E&k^T3$FG1eQZ51g$uv4V+kI`0<^1Z@N zk?Jjh$olyC%l>)Xq;7!>{iBj&BjJ`P&$fsCfpve_epJOBkTF?nu-B7D!hO=2ZR}

C%4 zc_9eOXvPbC4kzU8YowIA8cW~Uv|eB&yYwAObSwL2vY~UYI7NXPvf3b+c^?wcs~_t{ ze_m66-0)^{JdOMKPwjpQ@Sna!*?$wTZ~su*tNv7o!gXT!GRgivP}ec?5>l1!7<(rT zds|8x(qGc673zrvYIz;J23FG{9nHMnAuP}NpAED^laz3mAN1sy+NXK)!6v1FxQ;lh zOBLA>$~P3r4b*NcqR;y6pwyhZ3_PiDb|%n1gGjl3ZU}ujInlP{eks-#oA6>rh&g+!f`hv#_%JrgYPu z(U^&XLW^QX7F9Z*SRPpQl{B%x)_AMp^}_v~?j7 zapvHMKxSf*Mtyx8I}-<*UGn3)oHd(nn=)BZ`d$lDBwq_GL($_TPaS{UeevT(AJ`p0 z9%+hQb6z)U9qjbuXjg|dExCLjpS8$VKQ55VsIC%@{N5t{NsW)=hNGI`J=x97_kbz@ E0Of=7!TQj4N+cqN`nQhxvX7dAV-`K|Ub$-q+H-5I?Tx0g9jWxd@A|?POE8`3b8fO$T))xP* z(X?&brZw({`)WU&rdAs1iTa0x6F@PIxJ&&L|dpySV!ID|iUhjCcKz(@mE z!x@~W#3H<)4Ae(4eQJRk`Iz3<1)6^m)0b_4_TRZ+cz#eD3f8V;2r-1fE!F}W zEi0MEkTTx}8i1{`l_6vo0(Vuh0HD$I4SjZ=?^?k82R51bC)2D_{y8mi_?X^=U?2|F{Vr7s!k(AZC$O#ZMyavHhlQ7 zUR~QXuH~#o#>(b$u4?s~HLF*3IcF7023AlwAYudn0FV~|odGH^05AYPEfR)8p`i{n zwg3zPVp{+wOsxKc>)(pMupKF!Y2HoUqQ3|Yu|8lwR=?5zZuhG6J?H`bSNk_wPoM{u zSL{c@pY7+c2kck>`^q1^^gR0QB7Y?KUD{vz-uVX~;V-rW)PDcI)$_UjgVV?S?=oLR zf4}zz{#*R_{LkiJ#0RdQLNC^2Vp%JPEUvG9ra2BVZ92(p9h7Ka@!yf9(lj#}>+|u* z;^_?KWdzkM`6gqPo9;;r6&JEa)}R3X{(CWv?NvgLeOTq$cZXqf7|sPImi-7cS8DCN zGf;DVt3Am`>hH3{4-WzH43Ftx)SofNe^-#|0HdCo<+8Qs!}TZP{HH8~z5n`ExcHuT zDL1m&|DVpIy=xsLO>8k92HcmfSKhflQ0H~9=^-{#!I1g(;+44xw~=* zxvNz35vfsQE)@)Zsp*6_GjYD};Squ83<_?^SbALb{a`j<0Gn%6JY!zhp=Fg}Ga2|8 z52e1WU%^L1}15Ex0fF$e@eCT(()_P zvV?CA%#Sy08_U6VPt4EtmVQraWJX` zh=N|WQ>LgrvF~R&qOfB$!%D3cGv?;Xh_z$z7k&s4N)$WYf*k=|*jCEkO19{h_(%W4 zPuOqbCw`SeAX*R}UUsbVsgtuG?xs(#Ikx9`JZoQFz0n*7ZG@Fv@kZk`gzO$HoA9kN z8U5{-yY zvV{`&WKU2$mZeoBmiJrEdzUZAv1sRxpePdg1)F*X^Y)zp^Y*R;;z~vOv-z&)&G)JQ{m!C9cmziu1^nHA z`#`0c>@PnQ9CJKgC5NjJD8HM3|KC(g5nnCq$n0Gsu_DXk36@ql%npEye|?%RmG)

FJ$wK}0tWNB{uH;AM~i diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp deleted file mode 100644 index 948a3070fe34c611c42c0d3ad3013a0dce358be0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1900 zcmV-y2b1_xNk&Fw2LJ$9MM6+kP&il$0000G0001A003VA06|PpNH75a00DqwTbm-~ zullQTcXxO9ki!OCRx^i?oR|n!<8G0=kI^!JSjFi-LL*`V;ET0H2IXfU0*i>o6o6Gy zRq6Ap5(_{XLdXcL-MzlN`ugSdZY_`jXhcENAu)N_0?GhF))9R;E`!bo9p?g?SRgw_ zEXHhFG$0{qYOqhdX<(wE4N@es3VIo$%il%6xP9gjiBri+2pI6aY4 zJbgh-Ud|V%3O!IcHKQx1FQH(_*TK;1>FQWbt^$K1zNn^cczkBs=QHCYZ8b&l!UV{K z{L0$KCf_&KR^}&2Fe|L&?1I7~pBENnCtCuH3sjcx6$c zwqkNkru);ie``q+_QI;IYLD9OV0ZxkuyBz|5<$1BH|vtey$> z5oto4=l-R-Aaq`Dk0}o9N0VrkqW_#;!u{!bJLDq%0092{Ghe=F;(kn} z+sQ@1=UlX30+2nWjkL$B^b!H2^QYO@iFc0{(-~yXj2TWz?VG{v`Jg zg}WyYnwGgn>{HFaG7E~pt=)sOO}*yd(UU-D(E&x{xKEl6OcU?pl)K%#U$dn1mDF19 zSw@l8G!GNFB3c3VVK0?uyqN&utT-D5%NM4g-3@Sii9tSXKtwce~uF zS&Jn746EW^wV~8zdQ1XC28~kXu8+Yo9p!<8h&(Q({J*4DBglPdpe4M_mD8AguZFn~ ztiuO~{6Bx?SfO~_ZV(GIboeR9~hAym{{fV|VM=77MxDrbW6`ujX z<3HF(>Zr;#*uCvC*bpoSr~C$h?_%nXps@A)=l_;({Fo#6Y1+Zv`!T5HB+)#^-Ud_; zBwftPN=d8Vx)*O1Mj+0oO=mZ+NVH*ptNDC-&zZ7Hwho6UQ#l-yNvc0Cm+2$$6YUk2D2t#vdZX-u3>-Be1u9gtTBiMB^xwWQ_rgvGpZ6(C@e23c!^K=>ai-Rqu zhqT`ZQof;9Bu!AD(i^PCbYV%yha9zuoKMp`U^z;3!+&d@Hud&_iy!O-$b9ZLcSRh? z)R|826w}TU!J#X6P%@Zh=La$I6zXa#h!B;{qfug}O%z@K{EZECu6zl)7CiNi%xti0 zB{OKfAj83~iJvmpTU|&q1^?^cIMn2RQ?jeSB95l}{DrEPTW{_gmU_pqTc)h@4T>~& zluq3)GM=xa(#^VU5}@FNqpc$?#SbVsX!~RH*5p0p@w z;~v{QMX0^bFT1!cXGM8K9FP+=9~-d~#TK#ZE{4umGT=;dfvWi?rYj;^l_Zxywze`W z^Cr{55U@*BalS}K%Czii_80e0#0#Zkhlij4-~I@}`-JFJ7$5{>LnoJSs??J8kWVl6|8A}RCGAu9^rAsfCE=2}tHwl93t0C?#+jMpvr7O3`2=tr{Hg$=HlnjVG^ewm|Js0J*kfPa6*GhtB>`fN!m#9J(sU!?(OSfzY*zS(FJ<-Vb zfAIg+`U)YaXv#sY(c--|X zEB+TVyZ%Ie4L$gi#Fc++`h6%vzsS$pjz9aLt+ZL(g;n$Dzy5=m=_TV(3H8^C{r0xd zp#a%}ht55dOq?yhwYPrtp-m1xXp;4X;)NhxxUpgP%XTLmO zcjaFva^}dP3$&sfFTIR_jC=2pHh9kpI@2(6V*GQo7Ws)`j)hd+tr@P~gR*2gO@+1? zG<`_tB+LJuF|SZ9tIec;h%}}6WClT`L>HSW?E{Hp1h^+mlbf_$9zA>!ug>NALJsO{ mU%z=YwVD?}XMya)Bp;vlyE5&E_6!fzx9pwrdz474!~g(M6R?N? diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp deleted file mode 100644 index 1b9a6956b3acdc11f40ce2bb3f6efbd845cc243f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3918 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�(p-{x$&=IACIfoAR!za)F-^da-t3#0Dycnp zwO~NVXwXCl;jE<}>%@xz|=8fIJAB?>+E{7)|4l${4ngA3G|=r z2Dyv;VVWSgZx9Wj>qUjleGl3Ei9K4>h!(lPS%8VOG>Xu0%6VDz^O=bjJmuP7>DeUv zrbI}MlHB^^d?{zv6d=@_ZD2lg1&G7UjnVN{1}9WkaM3H~btX0GtSzB+tZ^qRgWo4m z!GmimlG$=wgXCnr6j@m<1gAL46#T~5Bnm=2{^@>|t&`9mkEPddj zAvG~@Tv~TAm2i%VW}R-g(Z0)z-Y|szHr@rk>4MAyG*Ma*7Yh#H7(!-5>DZ@8r;_dx z{prSe<>~099F8vsYd2xff7uAS%7{S)f(|@me3t2$iy&NEc7OUEchp@9A|X;;IA>8!oX+y(BKJ$EzV* znR$z;!L$s7uy@{OT~nG#B!NRraT8(X##Ho!0r_o@gg0CA-9H^;-uE&?$2$nHv_00o z%cbuUc-tCx$Uh&EZ4Nf4Zgqv)Y6>usG3>GeQnxx_Z6+PcbX-+ysbt1hQ`K1LDpOE? zrAhIZhSN9yVIAOa22gn577tbc&i3|3V8NWy&!tw##`}9*x}gtI^h1DzZRA>UuaJG) zaZ7j)dq!O}{?#8Y7~7i6fHh4{`pL?>-18|p!S75Y#^DM>-S3)vuZG+Q7l@ek zQP~#cBpWgg#mApc_sPYjpw8odQuRokmTkzcNl`^CcKB7e&;zViV;{Y{o^Y$%7i0m# z62%#1Lq!RC?}lK>%mp}T!3Xv;L*0v*>USLm``N%>w>@fwC+#T&Tx2bN4w(20JB}oU zuSa6v^kXi0xPs?pbaOHnyiqq6By1EZY9OZ^^QA>{q-Hsd&m`pbQ%8121aWG-F5xf zlZ%;B{;C>X19|`^_?dVyCq>n+41w7|!tUS!{9rHlbhX=SZO5CQ^;!Du_E7*`GiR^Q w)2!4MKjfSAeNo!9>IaV6aUZ*?W>} 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

UmY2RIYtNPVDpE$%vda+HD#3m z&VuXJ{BK&Qe+rBa7eq}Q(bq|tn(RrJAk|ztj2(i{d>nmQnM?;HF2k&9sA6up5tmjl z7lySlzMbifH17-m-Lwa_F&e7nOH?ESi3#ckR3tsM+jsck3`oG!uMS}|eAwVXv>}qxwq?QY%QJ0}r@^;fhuUA9W z*BVl>TGo&N004@xSiwDUXUvp51sVmqO3m)=B55aPwf@0=e}cN+$-BdKxY`YrT_4)0 z_d10#i44Q*rFr8MC>*)v$EJvz``(pb{e&*6k+b zsMz%($|1+8hn8c2?P(l@;Rb&CsZeYoCI3?2!LqjbwPXW3z4G$Qfj=cT5Yb%vY0(AX oeb?AaKtwrnc|$|zzw9vfvn^aJJ!zd)XFXqqy0000001=f@-~a#s diff --git a/app/src/main/res/mipmap/ic_launcher.xml b/app/src/main/res/mipmap/ic_launcher.xml new file mode 100644 index 0000000..95437fa --- /dev/null +++ b/app/src/main/res/mipmap/ic_launcher.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/app/src/main/res/mipmap/ic_launcher_round.xml b/app/src/main/res/mipmap/ic_launcher_round.xml new file mode 100644 index 0000000..ba29788 --- /dev/null +++ b/app/src/main/res/mipmap/ic_launcher_round.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/app/src/main/res/values-night/colors.xml b/app/src/main/res/values-night/colors.xml new file mode 100644 index 0000000..00a6443 --- /dev/null +++ b/app/src/main/res/values-night/colors.xml @@ -0,0 +1,5 @@ + + + + #FF1C1B1F + diff --git a/app/src/main/res/values-night/themes.xml b/app/src/main/res/values-night/themes.xml new file mode 100644 index 0000000..bdb6a08 --- /dev/null +++ b/app/src/main/res/values-night/themes.xml @@ -0,0 +1,11 @@ + + + + + + diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml index f8c6127..0d3841a 100644 --- a/app/src/main/res/values/colors.xml +++ b/app/src/main/res/values/colors.xml @@ -7,4 +7,6 @@ #FF018786 #FF000000 #FFFFFFFF + + #FFFFFBFE \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index bdff66b..20f70be 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1,3 +1,5 @@ sw9000 - \ No newline at end of file + Tap a card to read it + Reading card… hold still + diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml index 9a98ff2..787fe3c 100644 --- a/app/src/main/res/values/themes.xml +++ b/app/src/main/res/values/themes.xml @@ -1,5 +1,11 @@ - +