Call Blocker, from an empty directory

[versions]
kotlin = "2.2.20"
agp = "8.13.2"

[plugins]
kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
android-application = { id = "com.android.application", version.ref = "agp" }
android-library = { id = "com.android.library", version.ref = "agp" }

rootProject.name = "CallBlocker"

pluginManagement {
    repositories { google(); gradlePluginPortal(); mavenCentral() }
}

dependencyResolutionManagement {
    repositories { google(); mavenCentral() }
}

include(":shared")
include(":androidApp")

plugins {
    alias(libs.plugins.kotlin.multiplatform) apply false
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.android.library) apply false
}

plugins {
    alias(libs.plugins.kotlin.multiplatform)
    alias(libs.plugins.android.library)
}

kotlin {
    jvmToolchain(17)
    androidTarget()
}

android {
    namespace = "dev.example.callblocker.shared"
    compileSdk = 36
    defaultConfig { minSdk = 26 }
}

package dev.example.callblocker

fun greeting(): String = "Call blocker, shared module"

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation(compose.runtime)
            implementation(compose.foundation)
            implementation(compose.material3)
            implementation(compose.ui)
        }
    }
}

package dev.example.callblocker

import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable

@Composable
fun App() {
    MaterialTheme {
        Surface {
            Text("Call blocker — nothing blocked yet")
        }
    }
}

plugins {
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.android.application)
    alias(libs.plugins.compose.multiplatform)
    alias(libs.plugins.compose.compiler)
}

android {
    namespace = "dev.example.callblocker"
    compileSdk = 36
    defaultConfig {
        applicationId = "dev.example.callblocker"
        minSdk = 26
        targetSdk = 36
        versionCode = 1
        versionName = "0.1.0"
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
    sourceSets["main"].java.srcDirs("src/main/kotlin")
}

kotlin { jvmToolchain(17) }

dependencies {
    implementation(project(":shared"))
    implementation(compose.runtime)
    implementation(libs.androidx.activity.compose)
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent { App() }
    }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application
        android:label="Call Blocker"
        android:theme="@android:style/Theme.Material.Light.NoActionBar">
        <activity android:name=".MainActivity" android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

org.gradle.jvmargs=-Xmx4g -Dfile.encoding=UTF-8
kotlin.code.style=official
android.useAndroidX=true
android.nonTransitiveRClass=true

<activity android:name=".MainActivity" android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
    <intent-filter>
        <action android:name="android.intent.action.DIAL" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
    <intent-filter>
        <action android:name="android.intent.action.DIAL" />
        <category android:name="android.intent.category.DEFAULT" />
        <data android:scheme="tel" />
    </intent-filter>
</activity>

<service
    android:name=".ScreeningInCallService"
    android:permission="android.permission.BIND_INCALL_SERVICE"
    android:exported="true">
    <meta-data android:name="android.telecom.IN_CALL_SERVICE_UI" android:value="true" />
    <intent-filter>
        <action android:name="android.telecom.InCallService" />
    </intent-filter>
</service>

class ScreeningInCallService : InCallService() {
    override fun onCallAdded(call: Call) {
        super.onCallAdded(call)
        val number = call.details?.handle?.schemeSpecificPart.orEmpty()
        Log.i(TAG, "onCallAdded number=$number state=${call.state}")
    }

    override fun onCallRemoved(call: Call) {
        super.onCallRemoved(call)
        Log.i(TAG, "onCallRemoved")
    }

    private companion object { const val TAG = "CallBlocker" }
}

plugins {
    alias(libs.plugins.kotlin.multiplatform)
    alias(libs.plugins.android.library)
    alias(libs.plugins.compose.multiplatform)
    alias(libs.plugins.compose.compiler)
    alias(libs.plugins.sqldelight)
}

kotlin {
    jvmToolchain(17)
    androidTarget()

    sourceSets {
        commonMain.dependencies {
            implementation(compose.runtime)
            implementation(compose.foundation)
            implementation(compose.material3)
            implementation(compose.ui)
            implementation(libs.sqldelight.runtime)
            implementation(libs.kotlinx.coroutines.core)
        }
        androidMain.dependencies {
            implementation(libs.sqldelight.android.driver)
        }
    }
}

android {
    namespace = "dev.example.callblocker.shared"
    compileSdk = 36
    defaultConfig { minSdk = 26 }
}

sqldelight {
    databases {
        create("AppDatabase") {
            packageName.set("dev.example.callblocker.db")
        }
    }
}

CREATE TABLE BlockedNumber (
    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    number TEXT NOT NULL,
    label TEXT,
    created_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s', 'now') AS INTEGER)),
    UNIQUE(number)
);

CREATE TABLE CallLogEntry (
    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    number TEXT NOT NULL,
    timestamp INTEGER NOT NULL,
    action TEXT NOT NULL CHECK (action IN ('ALLOWED', 'BLOCKED'))
);

selectAllBlockedNumbers:
SELECT * FROM BlockedNumber ORDER BY created_at DESC;

insertBlockedNumber:
INSERT OR IGNORE INTO BlockedNumber(number, label) VALUES (?, ?);

deleteBlockedNumber:
DELETE FROM BlockedNumber WHERE id = ?;

insertCallLogEntry:
INSERT INTO CallLogEntry(number, timestamp, action) VALUES (?, ?, ?);

selectAllCallLogEntries:
SELECT * FROM CallLogEntry ORDER BY timestamp DESC LIMIT 100;

package dev.example.callblocker.db

import app.cash.sqldelight.db.SqlDriver

expect class DriverFactory {
    fun createDriver(): SqlDriver
}

package dev.example.callblocker.db

import android.content.Context
import app.cash.sqldelight.db.SqlDriver
import app.cash.sqldelight.driver.android.AndroidSqliteDriver

actual class DriverFactory(
    private val context: Context,
) {
    actual fun createDriver(): SqlDriver =
        AndroidSqliteDriver(AppDatabase.Schema, context, "callblocker.db")
}

package dev.example.callblocker.rules

/** What the engine decided, and why — the reason is what the call log stores. */
sealed interface Decision {
    val isBlocked: Boolean

    data object Allowed : Decision {
        override val isBlocked = false
    }

    data class Blocked(val reason: String) : Decision {
        override val isBlocked = true
    }
}

/**
 * Pure: everything it needs is passed in, so it is testable without a database or a phone.
 *
 * Precedence is expressed here rather than in SQL for that reason — see step 5.
 */
object RuleEngine {
    fun evaluate(
        number: String,
        blockedNumbers: List<String>,
        contactNumbers: Set<String> = emptySet(),
    ): Decision {
        if (normalizedIsEmpty(number)) return Decision.Allowed

        // 1. Contacts bypass everything below. Compared with sameNumber, never with ==, and
        //    against the numbers AS SAVED — normalising them first is what broke this in the
        //    real app, because it strips the '+' sameNumber reads.
        if (contactNumbers.any { PhoneNumberParser.sameNumber(it, number) }) return Decision.Allowed

        // 2. Manual block list.
        if (blockedNumbers.any { PhoneNumberParser.sameNumber(it, number) }) {
            return Decision.Blocked("MANUAL")
        }

        return Decision.Allowed
    }

    private fun normalizedIsEmpty(number: String) = PhoneNumberParser.normalizeForComparison(number).isEmpty()
}

package dev.example.callblocker

import android.telecom.Call
import android.telecom.InCallService
import android.util.Log
import dev.example.callblocker.db.AppDatabase
import dev.example.callblocker.db.DriverFactory
import dev.example.callblocker.rules.RuleEngine
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

class ScreeningInCallService : InCallService() {
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)

    private val ringer by lazy { CallRinger(this) }

    private val database by lazy { AppDatabase(DriverFactory(applicationContext).createDriver()) }

    override fun onCallAdded(call: Call) {
        super.onCallAdded(call)
        val number = call.handleNumber()
        Log.i(TAG, "onCallAdded number=$number state=${call.state}")
        // Ring first, decide second: evaluation touches a database, and a caller must
        // never be dropped into silence because that was slow.
        if (call.state == Call.STATE_RINGING) ringer.start()

        scope.launch {
            try {
                val decision =
                    withContext(Dispatchers.IO) {
                        val blocked =
                            database.appDatabaseQueries
                                .selectAllBlockedNumbers()
                                .executeAsList()
                                .map { it.number }
                        val d = RuleEngine.evaluate(number, blocked)
                        database.appDatabaseQueries.insertCallLogEntry(
                            number = number,
                            timestamp = System.currentTimeMillis(),
                            action = if (d.isBlocked) "BLOCKED" else "ALLOWED",
                        )
                        d
                    }
                Log.i(TAG, "decision=$decision for $number")
                if (decision.isBlocked) {
                    ringer.stop()
                    call.reject(false, null)
                }
            } catch (e: CancellationException) {
                throw e
            } catch (e: Exception) {
                // Fail open: an unblocked nuisance beats a silently dropped emergency.
                Log.e(TAG, "evaluation failed, failing open", e)
            }
        }
    }

    override fun onCallRemoved(call: Call) {
        super.onCallRemoved(call)
        ringer.stop()
        Log.i(TAG, "onCallRemoved")
    }

    override fun onDestroy() {
        super.onDestroy()
        scope.cancel()
    }

    private fun Call.handleNumber(): String = details?.handle?.schemeSpecificPart.orEmpty()

    private companion object {
        const val TAG = "CallBlocker"
    }
}

package dev.example.callblocker

import android.content.Context
import android.media.AudioAttributes
import android.media.AudioManager
import android.media.MediaPlayer
import android.media.RingtoneManager
import android.util.Log

/**
 * Plays the ringtone, because declaring IN_CALL_SERVICE_RINGING means Telecom will not.
 *
 * Honours the system ringer mode exactly as the platform dialer does: silent rings not at all.
 * Getting that wrong means ringing in a meeting after the user silenced their phone.
 */
class CallRinger(
    private val context: Context,
) {
    private var player: MediaPlayer? = null

    fun start() {
        val audio = context.getSystemService(AudioManager::class.java)
        if (audio?.ringerMode != AudioManager.RINGER_MODE_NORMAL) {
            Log.i(TAG, "ringer mode ${audio?.ringerMode}; not playing a ringtone")
            return
        }
        if (player != null) return

        val uri = RingtoneManager.getActualDefaultRingtoneUri(context, RingtoneManager.TYPE_RINGTONE) ?: return
        player =
            MediaPlayer().apply {
                setAudioAttributes(
                    AudioAttributes
                        .Builder()
                        .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
                        .build(),
                )
                setDataSource(context, uri)
                isLooping = true
                setOnPreparedListener { start() }
                prepareAsync()
            }
    }

    fun stop() {
        player?.runCatching {
            stop()
            release()
        }
        player = null
    }

    private companion object {
        const val TAG = "CallBlocker"
    }
}

package dev.example.callblocker.rules

/**
 * Comparing phone numbers without guessing a region.
 *
 * The country-code list is deliberately short here; a real app needs the full ITU list. What
 * matters is the shape: a code is only ever read off a number that actually wrote itself in
 * international form.
 */
object PhoneNumberParser {
    private val knownCodes = listOf("1", "34", "39", "44", "51", "52", "55").sortedByDescending { it.length }

    private const val MAX_E164_DIGITS = 15

    fun normalizeForComparison(number: String): String = number.filter { it.isDigit() }

    /** Canonical `+<digits>`, or null when [number] was not written in international form. */
    fun toE164OrNull(number: String): String? {
        val trimmed = number.trim()
        val digits =
            when {
                trimmed.startsWith("+") -> normalizeForComparison(trimmed)
                trimmed.startsWith("00") -> normalizeForComparison(trimmed).drop(2)
                else -> return null
            }
        if (digits.isEmpty() || digits.length > MAX_E164_DIGITS) return null
        return "+$digits"
    }

    /** Every string this number may legitimately be recognised by. */
    fun comparisonKeys(number: String): Set<String> {
        val digits = normalizeForComparison(number)
        if (digits.isEmpty()) return emptySet()
        val keys = mutableSetOf(digits)
        nationalSignificantOrNull(number)?.let { keys += it }
        return keys
    }

    private fun nationalSignificantOrNull(number: String): String? {
        val e164 = toE164OrNull(number)?.removePrefix("+")
        if (e164 != null) {
            val code = knownCodes.firstOrNull { e164.startsWith(it) && e164.length >= it.length + 4 }
            return code?.let { e164.drop(it.length) }
        }
        val digits = normalizeForComparison(number)
        return if (digits.length > 1 && digits.startsWith("0")) digits.drop(1) else null
    }

    /**
     * True when [a] and [b] can be the same subscriber.
     *
     * The national form may bridge them only when at least one side does not state its country.
     * When both are international those codes are facts, and +34611998877 is not +51611998877.
     */
    fun sameNumber(a: String, b: String): Boolean {
        val da = normalizeForComparison(a)
        val db = normalizeForComparison(b)
        if (da.isEmpty() || db.isEmpty()) return false
        if (da == db) return true

        val aIntl = toE164OrNull(a) != null
        val bIntl = toE164OrNull(b) != null
        if (aIntl && bIntl) return toE164OrNull(a) == toE164OrNull(b)

        val keysA = comparisonKeys(a)
        return comparisonKeys(b).any { it in keysA }
    }
}