fix(region): read a bare number in the phone's own country

Region rules read every bare ten- or eleven-digit number as North American.
Android leaves a caller ID in national form when it can't validate it for
the phone's home region, so on an Italian phone a domestic number that stayed
bare never matched the user's own +39 entry and was blocked as out of region,
while ten digits shaped like a New York number counted as NY.

- RegionCallingCodes maps each ISO region to its ITU-T calling code (245
  regions, generated from libphonenumber's metadata via Python phonenumbers
  9.0.39); Android exposes no public API for it.
- regionCode() and isOutsideAllowedRegions() take the phone's home region. A
  bare number is NANP only where the home region uses +1 or is unknown (the
  old behavior); elsewhere it is read with the home calling code and never
  gets a US state or Canadian province.
- RegionBlockChecker reads the home region (PhoneIdentityCanonicalizer's
  TTL-cached value) only for a bare number.

Tests: Italian-phone cases (a bare domestic number allowed by +39 and blocked
by +44, ten NY-shaped digits not read as NY), NANP-home and unknown-region
cases keeping the old reading, and the table's NANP coverage. The home-region
branch was mutation-checked (the mutant failed exactly the Italian-phone
test). 1376 JVM tests pass; lint, ktlint and detekt are clean.

Author: SysAdminDoc

CHANGELOG.md

@@ -104,7 +104,10 @@ All notable changes to CallShield will be documented in this file.
   is Colorado, never Colombia.
 - Region rules no longer mistake a ten-digit number from outside North America
   for a North American one. A Penang landline (+60 4) counted as Vancouver's
-  604 area code, so allowing British Columbia let it ring.
+  604 area code, so allowing British Columbia let it ring. On a phone outside
+  North America, a number Android couldn't put in international form is now
+  read as a number from your own country instead of a North American one, so
+  allowing your country's code lets it ring.
 - Settings has a Telemarketing ranges card for number ranges regulators set
   aside for sales calls. It can block Spain's 400 range (required for
   commercial calls from 17 October 2026), India's 140 promotional series and

app/src/main/java/com/sysadmindoc/callshield/data/RegionCallingCodes.kt

@@ -0,0 +1,42 @@
+package com.sysadmindoc.callshield.data
+
+import java.util.Locale
+
+/**
+ * ITU-T calling code of each ISO 3166 region. Android leaves a caller ID in
+ * national form when it can't validate it for the phone's home region, and
+ * region rules read such a number in that region's numbering, so they need
+ * the region's code.
+ *
+ * Generated from libphonenumber's metadata (Python `phonenumbers` 9.0.39,
+ * `country_code_for_region` over `SUPPORTED_REGIONS`, 245 regions).
+ */
+internal object RegionCallingCodes {
+    private val codes: Map<String, String> =
+        (
+            "AC:247 AD:376 AE:971 AF:93 AG:1 AI:1 AL:355 AM:374 AO:244 AR:54 AS:1 AT:43 " +
+                "AU:61 AW:297 AX:358 AZ:994 BA:387 BB:1 BD:880 BE:32 BF:226 BG:359 BH:973 BI:257 " +
+                "BJ:229 BL:590 BM:1 BN:673 BO:591 BQ:599 BR:55 BS:1 BT:975 BW:267 BY:375 BZ:501 " +
+                "CA:1 CC:61 CD:243 CF:236 CG:242 CH:41 CI:225 CK:682 CL:56 CM:237 CN:86 CO:57 " +
+                "CR:506 CU:53 CV:238 CW:599 CX:61 CY:357 CZ:420 DE:49 DJ:253 DK:45 DM:1 DO:1 " +
+                "DZ:213 EC:593 EE:372 EG:20 EH:212 ER:291 ES:34 ET:251 FI:358 FJ:679 FK:500 FM:691 " +
+                "FO:298 FR:33 GA:241 GB:44 GD:1 GE:995 GF:594 GG:44 GH:233 GI:350 GL:299 GM:220 " +
+                "GN:224 GP:590 GQ:240 GR:30 GT:502 GU:1 GW:245 GY:592 HK:852 HN:504 HR:385 HT:509 " +
+                "HU:36 ID:62 IE:353 IL:972 IM:44 IN:91 IO:246 IQ:964 IR:98 IS:354 IT:39 JE:44 " +
+                "JM:1 JO:962 JP:81 KE:254 KG:996 KH:855 KI:686 KM:269 KN:1 KP:850 KR:82 KW:965 " +
+                "KY:1 KZ:7 LA:856 LB:961 LC:1 LI:423 LK:94 LR:231 LS:266 LT:370 LU:352 LV:371 " +
+                "LY:218 MA:212 MC:377 MD:373 ME:382 MF:590 MG:261 MH:692 MK:389 ML:223 MM:95 MN:976 " +
+                "MO:853 MP:1 MQ:596 MR:222 MS:1 MT:356 MU:230 MV:960 MW:265 MX:52 MY:60 MZ:258 " +
+                "NA:264 NC:687 NE:227 NF:672 NG:234 NI:505 NL:31 NO:47 NP:977 NR:674 NU:683 NZ:64 " +
+                "OM:968 PA:507 PE:51 PF:689 PG:675 PH:63 PK:92 PL:48 PM:508 PR:1 PS:970 PT:351 " +
+                "PW:680 PY:595 QA:974 RE:262 RO:40 RS:381 RU:7 RW:250 SA:966 SB:677 SC:248 SD:249 " +
+                "SE:46 SG:65 SH:290 SI:386 SJ:47 SK:421 SL:232 SM:378 SN:221 SO:252 SR:597 SS:211 " +
+                "ST:239 SV:503 SX:1 SY:963 SZ:268 TA:290 TC:1 TD:235 TG:228 TH:66 TJ:992 TK:690 " +
+                "TL:670 TM:993 TN:216 TO:676 TR:90 TT:1 TV:688 TW:886 TZ:255 UA:380 UG:256 US:1 " +
+                "UY:598 UZ:998 VA:39 VC:1 VE:58 VG:1 VI:1 VN:84 VU:678 WF:681 WS:685 XK:383 " +
+                "YE:967 YT:262 ZA:27 ZM:260 ZW:263"
+        ).split(' ').associate { it.substringBefore(':') to it.substringAfter(':') }
+
+    /** Calling code digits (no `+`) for [regionIso], or null for an unknown region. */
+    fun forRegion(regionIso: String?): String? = regionIso?.let { codes[it.uppercase(Locale.ROOT)] }
+}

app/src/main/java/com/sysadmindoc/callshield/data/RegionRules.kt

@@ -12,6 +12,7 @@ object RegionRules {
     const val MAX_NAME_PATTERNS = 30
     const val MAX_NAME_PATTERN_LENGTH = 60
     private const val NANP_NATIONAL_LENGTH = 10
+    private const val NANP_CALLING_CODE = "1"
 
     /** `1` plus a three-digit area code, as in `+1809`. */
     private const val NANP_AREA_CODE_ENTRY_LENGTH = 4
@@ -128,33 +129,55 @@ object RegionRules {
     /**
      * The NANP state, province or territory code of [number], or null. A `+`
      * number outside +1 is never NANP, even when it has ten digits: Penang's
-     * +60 4 would otherwise read as Vancouver's 604.
+     * +60 4 would otherwise read as Vancouver's 604. A bare number is NANP
+     * only on a phone whose home region uses +1 or is unknown.
      */
-    fun regionCode(number: String): String? = if (number.startsWith("+") && !number.startsWith("+1")) null else AreaCodeLookup.getRegionCode(number)
+    fun regionCode(
+        number: String,
+        homeRegionIso: String? = null,
+    ): String? =
+        when {
+            number.startsWith("+") && !number.startsWith("+1") -> null
+            !number.startsWith("+") && !homeUsesNanp(homeRegionIso) -> null
+            else -> AreaCodeLookup.getRegionCode(number)
+        }
 
     fun isOutsideAllowedRegions(
         number: String,
         allowedRegions: Set<String>,
+        homeRegionIso: String? = null,
     ): Boolean {
         val normalized = normalizeRegionCodes(allowedRegions)
         if (normalized.isEmpty()) return false
-        val nanpRegion = regionCode(number)
+        val nanpRegion = regionCode(number, homeRegionIso)
         if (nanpRegion != null && nanpRegion in normalized) return false
-        val international = internationalForm(number) ?: return true
+        val international = internationalForm(number, homeRegionIso) ?: return true
         return normalized.none { it.startsWith("+") && international.startsWith(it) }
     }
 
-    /** [number] as `+<digits>`, reading a bare ten- or eleven-digit number as NANP. */
-    private fun internationalForm(number: String): String? {
+    /**
+     * [number] as `+<digits>`. Android leaves a number it can't validate in
+     * national form, so a bare number is read in the phone's home region:
+     * ten or eleven digits as NANP where that region uses +1 (or is unknown),
+     * and with the home region's calling code anywhere else.
+     */
+    private fun internationalForm(
+        number: String,
+        homeRegionIso: String?,
+    ): String? {
         if (number.startsWith("+")) return number
         val digits = filterAsciiDigits(number)
+        val homeCode = RegionCallingCodes.forRegion(homeRegionIso)
+        if (homeCode != null && homeCode != NANP_CALLING_CODE) return digits.takeIf { it.isNotEmpty() }?.let { "+$homeCode$it" }
         return when {
             digits.length == NANP_NATIONAL_LENGTH -> "+1$digits"
             digits.length == NANP_NATIONAL_LENGTH + 1 && digits.startsWith("1") -> "+$digits"
             else -> null
         }
     }
 
+    private fun homeUsesNanp(homeRegionIso: String?): Boolean = RegionCallingCodes.forRegion(homeRegionIso)?.let { it == NANP_CALLING_CODE } ?: true
+
     fun matchesPresentedName(
         presentedName: String?,
         patterns: Set<String>,

app/src/main/java/com/sysadmindoc/callshield/data/checker/Checkers.kt

@@ -701,8 +701,10 @@ internal class CallerNameBlockChecker : IChecker {
     }
 }
 
-/** Blocks calls whose NANP state/province is not in the user's allowlist. */
-internal class RegionBlockChecker : IChecker {
+/** Blocks calls from outside the NANP regions and country calling codes the user allows. */
+internal class RegionBlockChecker(
+    private val homeRegion: (Context) -> String? = phoneHomeRegion,
+) : IChecker {
     override val priority = CheckerPriority.REGION_BLOCK
     override val name = "region_block"
 
@@ -722,6 +724,8 @@ internal class RegionBlockChecker : IChecker {
                     ctx.appContext.getString(R.string.block_reason_out_of_region, region)
                 }
             },
+            // Only a bare (national-form) number needs the phone's home region.
+            homeRegionIso = if (ctx.number.startsWith("+")) null else homeRegion(ctx.appContext),
         )
 
     companion object {
@@ -731,9 +735,10 @@ internal class RegionBlockChecker : IChecker {
             descriptionForRegion: (String?) -> String = { region ->
                 "Blocked — ${region ?: "international or unknown"} is outside allowed regions"
             },
+            homeRegionIso: String? = null,
         ): BlockResult? {
-            if (!RegionRules.isOutsideAllowedRegions(number, allowedRegions)) return null
-            val region = RegionRules.regionCode(number)
+            if (!RegionRules.isOutsideAllowedRegions(number, allowedRegions, homeRegionIso)) return null
+            val region = RegionRules.regionCode(number, homeRegionIso)
             return BlockResult.block(
                 matchSource = "region_block",
                 type = "out_of_region",

app/src/test/java/com/sysadmindoc/callshield/data/RegionRulesTest.kt

@@ -191,6 +191,36 @@ class RegionRulesTest {
         assertNull(RegionRules.normalizeDialingCode("+1"))
     }
 
+    @Test
+    fun `a bare number on a phone outside North America is read in that country`() {
+        // Android leaves a number it can't validate in national form.
+        assertFalse(RegionRules.isOutsideAllowedRegions("0612345678", setOf("+39"), homeRegionIso = "IT"))
+        assertTrue(RegionRules.isOutsideAllowedRegions("0612345678", setOf("+44"), homeRegionIso = "IT"))
+        // Ten digits shaped like a New York number are still an Italian number on an Italian phone.
+        assertNull(RegionRules.regionCode("2125550123", homeRegionIso = "IT"))
+        assertTrue(RegionRules.isOutsideAllowedRegions("2125550123", setOf("NY"), homeRegionIso = "IT"))
+        assertTrue(RegionBlockChecker.decidePure("0612345678", setOf("+44"), homeRegionIso = "IT")?.shouldBlock == true)
+        assertNull(RegionBlockChecker.decidePure("0612345678", setOf("+39"), homeRegionIso = "IT"))
+    }
+
+    @Test
+    fun `a bare number is NANP on a phone that uses +1 or has no known region`() {
+        assertEquals("NY", RegionRules.regionCode("2125550123", homeRegionIso = "US"))
+        assertEquals("NY", RegionRules.regionCode("2125550123", homeRegionIso = "DO"))
+        assertEquals("NY", RegionRules.regionCode("2125550123"))
+        assertFalse(RegionRules.isOutsideAllowedRegions("8095550123", setOf("+1809"), homeRegionIso = "DO"))
+        assertFalse(RegionRules.isOutsideAllowedRegions("2125550123", setOf("NY"), homeRegionIso = "ZZ"))
+    }
+
+    @Test
+    fun `calling code table covers the NANP and reads regions case-insensitively`() {
+        listOf("US", "CA", "PR", "DO", "JM").forEach { assertEquals(it, "1", RegionCallingCodes.forRegion(it)) }
+        assertEquals("39", RegionCallingCodes.forRegion("it"))
+        assertEquals("44", RegionCallingCodes.forRegion("GB"))
+        assertNull(RegionCallingCodes.forRegion("ZZ"))
+        assertNull(RegionCallingCodes.forRegion(null))
+    }
+
     @Test
     fun `ten digit international numbers are not read as NANP area codes`() {
         // Penang (+60 4) and Hamilton, New Zealand (+64 7) have ten digits after