iphone2android 0.1.0__tar.gz → 0.2.0__tar.gz

iphone2android-0.2.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: iphone2android
+Version: 0.2.0
+Summary: Move from an iPhone to an Android phone: messages, contacts, photos, apps and the home screen, from an encrypted iPhone backup
+Author: Konstantinos Georgiou
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/drkostas/iphone2android
+Keywords: iphone,ios,android,migration,backup,adb,sms,launcher
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: iOSbackup>=0.9.9
+Requires-Dist: pycryptodome>=3.18
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# iphone2android
+
+iphone2android is a toolkit for moving from an iPhone to an Android phone without leaving anything behind. It is built for Claude Code to run the move, and every command also works by hand.
+
+The official transfer (the setup wizard's "Copy apps and data", Samsung Smart Switch, OPPO Clone Phone) moves a lot, but it misses apps without an obvious match, app data, iMessage attachments, photo edits, widgets and the home screen itself. iphone2android starts from there. It reads an encrypted iPhone backup on your computer, finds what the official transfer missed, and fills the gaps on the phone over `adb`, checking each step.
+
+What it covers:
+
+- Finding the Android version of every iPhone app (Apple's app lookup, then the Play Store search) and installing the free ones
+- Messages, call history, contacts, calendars and Safari bookmarks, converted for Android and Google
+- Photos, iMessage attachments and photo edits, copied to the phone
+- The data iPhone apps keep locally, found, copied, and the account names in their settings
+- The home screen with its folders, order and widgets, and the iPhone wallpaper
+- An audit of what the iPhone had against what the phone has, before and after
+
+## With Claude Code
+
+```bash
+pip install iphone2android
+iphone2android skill          # installs the skill into ~/.claude/skills/iphone2android
+```
+
+Then ask Claude to move you from your iPhone. The skill walks the whole move in order, starting with what has to happen before the iPhone is wiped, and Claude runs each command with `--json`, reads the result, and checks the phone with screenshots. You only do what needs your hands or your consent (the backup password, accepting terms, choosing a default SMS app).
+
+## By hand
+
+You need `adb` (`brew install android-platform-tools` on macOS) with USB debugging on in the phone's developer options, and an encrypted backup (Finder, select the iPhone, tick "Encrypt local backup", Back Up Now).
+
+```bash
+iphone2android backups                        # the backups on this computer
+iphone2android extract --inventory            # asks for the backup password
+iphone2android audit --photos                 # what the official transfer missed
+
+iphone2android suggest                        # mapping.json, and mapping.draft.json for apps to review
+iphone2android find-app "App name"            # search the Play Store by hand
+iphone2android verify mapping.json
+iphone2android install --mapping mapping.json
+
+iphone2android convert --out android-import
+iphone2android media message-attachments photo-edits
+iphone2android appdata survey
+
+iphone2android layout extracted/IconState.plist --mapping mapping.json > layout.json
+iphone2android wallpaper extract
+iphone2android build layout.json --state build.json --autofill
+iphone2android wallpaper set wallpaper/<image>
+```
+
+| File from `convert` | Import it with |
+|---|---|
+| `sms_backup.xml`, `calls_backup.xml` | the SMS Backup & Restore app |
+| `contacts.vcf` | Google Contacts (Import) |
+| `calendar.ics` | Google Calendar on the web (Settings, Import & export) |
+| `safari_bookmarks.html` | Chrome on a computer (Bookmarks, Import) |
+
+`iphone2android screenshot` and `iphone2android screen` show what is on the phone, and `iphone2android debloat` removes preinstalled apps you do not want (reversibly).
+
+## What cannot move
+
+- Passwords in the iCloud Keychain. Every item is sealed with a key that never leaves the iPhone, so no backup can open them. Export them with a password manager first.
+- Authenticator codes. Transfer them from the authenticator app while the iPhone still works.
+- Most app data. Android apps cannot read their iPhone version's files, so app data is copied out for an app's own import, a dedicated migrator (WhatsApp chats need one) or safekeeping. Apps that keep their data in an account only need signing in.
+- Paid apps are not installed automatically.
+
+## How the home screen is rebuilt
+
+Many launchers do not let `adb` change the layout (on ColorOS the launcher database and shortcut pinning are closed without root), so the builder moves icons through the screen the way a person does. It adds each app from the drawer search, reads the screen again after every drop, saves its progress so an interrupted build continues, puts each page in order one swap at a time, and turns on icon autofill at the end to close the gaps. Widgets are listed for placing through the launcher's widget picker. The builder is tested on ColorOS 16 (OPPO Find X9 Pro). Other launchers name their menus differently and may need changes in `android/launcher.py`.
+
+Wallpapers come from the backup as images (iOS 16 and later) or Apple's `.cpbitmap` format (older versions), converted to PNG. `wallpaper set` copies the image to the phone and opens its "Set as" screen.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e '.[test]'
+.venv/bin/pytest
+```
+
+The tests use synthetic databases, a fake decryptor, fake web pages for the app stores, a fake `adb` and a simulated home screen, so they need no iPhone and no Android phone.
+
+## License
+
+MIT. Backup decryption uses [iOSbackup](https://github.com/avibrazil/iOSbackup) (LGPL). The cpbitmap layout follows [cpbitmap-to-png](https://github.com/hthetiot/cpbitmap-to-png) (MIT).

iphone2android-0.2.0/README.md

@@ -0,0 +1,82 @@
+# iphone2android
+
+iphone2android is a toolkit for moving from an iPhone to an Android phone without leaving anything behind. It is built for Claude Code to run the move, and every command also works by hand.
+
+The official transfer (the setup wizard's "Copy apps and data", Samsung Smart Switch, OPPO Clone Phone) moves a lot, but it misses apps without an obvious match, app data, iMessage attachments, photo edits, widgets and the home screen itself. iphone2android starts from there. It reads an encrypted iPhone backup on your computer, finds what the official transfer missed, and fills the gaps on the phone over `adb`, checking each step.
+
+What it covers:
+
+- Finding the Android version of every iPhone app (Apple's app lookup, then the Play Store search) and installing the free ones
+- Messages, call history, contacts, calendars and Safari bookmarks, converted for Android and Google
+- Photos, iMessage attachments and photo edits, copied to the phone
+- The data iPhone apps keep locally, found, copied, and the account names in their settings
+- The home screen with its folders, order and widgets, and the iPhone wallpaper
+- An audit of what the iPhone had against what the phone has, before and after
+
+## With Claude Code
+
+```bash
+pip install iphone2android
+iphone2android skill          # installs the skill into ~/.claude/skills/iphone2android
+```
+
+Then ask Claude to move you from your iPhone. The skill walks the whole move in order, starting with what has to happen before the iPhone is wiped, and Claude runs each command with `--json`, reads the result, and checks the phone with screenshots. You only do what needs your hands or your consent (the backup password, accepting terms, choosing a default SMS app).
+
+## By hand
+
+You need `adb` (`brew install android-platform-tools` on macOS) with USB debugging on in the phone's developer options, and an encrypted backup (Finder, select the iPhone, tick "Encrypt local backup", Back Up Now).
+
+```bash
+iphone2android backups                        # the backups on this computer
+iphone2android extract --inventory            # asks for the backup password
+iphone2android audit --photos                 # what the official transfer missed
+
+iphone2android suggest                        # mapping.json, and mapping.draft.json for apps to review
+iphone2android find-app "App name"            # search the Play Store by hand
+iphone2android verify mapping.json
+iphone2android install --mapping mapping.json
+
+iphone2android convert --out android-import
+iphone2android media message-attachments photo-edits
+iphone2android appdata survey
+
+iphone2android layout extracted/IconState.plist --mapping mapping.json > layout.json
+iphone2android wallpaper extract
+iphone2android build layout.json --state build.json --autofill
+iphone2android wallpaper set wallpaper/<image>
+```
+
+| File from `convert` | Import it with |
+|---|---|
+| `sms_backup.xml`, `calls_backup.xml` | the SMS Backup & Restore app |
+| `contacts.vcf` | Google Contacts (Import) |
+| `calendar.ics` | Google Calendar on the web (Settings, Import & export) |
+| `safari_bookmarks.html` | Chrome on a computer (Bookmarks, Import) |
+
+`iphone2android screenshot` and `iphone2android screen` show what is on the phone, and `iphone2android debloat` removes preinstalled apps you do not want (reversibly).
+
+## What cannot move
+
+- Passwords in the iCloud Keychain. Every item is sealed with a key that never leaves the iPhone, so no backup can open them. Export them with a password manager first.
+- Authenticator codes. Transfer them from the authenticator app while the iPhone still works.
+- Most app data. Android apps cannot read their iPhone version's files, so app data is copied out for an app's own import, a dedicated migrator (WhatsApp chats need one) or safekeeping. Apps that keep their data in an account only need signing in.
+- Paid apps are not installed automatically.
+
+## How the home screen is rebuilt
+
+Many launchers do not let `adb` change the layout (on ColorOS the launcher database and shortcut pinning are closed without root), so the builder moves icons through the screen the way a person does. It adds each app from the drawer search, reads the screen again after every drop, saves its progress so an interrupted build continues, puts each page in order one swap at a time, and turns on icon autofill at the end to close the gaps. Widgets are listed for placing through the launcher's widget picker. The builder is tested on ColorOS 16 (OPPO Find X9 Pro). Other launchers name their menus differently and may need changes in `android/launcher.py`.
+
+Wallpapers come from the backup as images (iOS 16 and later) or Apple's `.cpbitmap` format (older versions), converted to PNG. `wallpaper set` copies the image to the phone and opens its "Set as" screen.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e '.[test]'
+.venv/bin/pytest
+```
+
+The tests use synthetic databases, a fake decryptor, fake web pages for the app stores, a fake `adb` and a simulated home screen, so they need no iPhone and no Android phone.
+
+## License
+
+MIT. Backup decryption uses [iOSbackup](https://github.com/avibrazil/iOSbackup) (LGPL). The cpbitmap layout follows [cpbitmap-to-png](https://github.com/hthetiot/cpbitmap-to-png) (MIT).

{iphone2android-0.1.0 → iphone2android-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iphone2android"
-version = "0.1.0"
+version = "0.2.0"
 description = "Move from an iPhone to an Android phone: messages, contacts, photos, apps and the home screen, from an encrypted iPhone backup"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -25,3 +25,6 @@ test = ["pytest>=8"]
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.setuptools.package-data]
+iphone2android = ["skill/SKILL.md"]

{iphone2android-0.1.0 → iphone2android-0.2.0}/src/iphone2android/__init__.py

@@ -1,3 +1,3 @@
 """Move from an iPhone to an Android phone: messages, contacts, photos, apps and the home screen."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{iphone2android-0.1.0 → iphone2android-0.2.0}/src/iphone2android/android/adb.py

@@ -23,6 +23,14 @@ class Adb:
         cmd = [self.binary] + (["-s", self.serial] if self.serial else []) + list(args)
         return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, stdin=subprocess.DEVNULL)
 
+    def screenshot(self, timeout: float = 30) -> bytes:
+        """The screen as PNG bytes (binary output, so not through run's text decoding)."""
+        cmd = [self.binary] + (["-s", self.serial] if self.serial else []) + ["exec-out", "screencap", "-p"]
+        r = subprocess.run(cmd, capture_output=True, timeout=timeout, stdin=subprocess.DEVNULL)
+        if r.returncode != 0 or not r.stdout.startswith(b"\x89PNG"):
+            raise DeviceUnavailable((r.stderr or b"").decode("utf-8", "replace").strip()[:200] or "no screenshot returned")
+        return r.stdout
+
     def shell(self, cmd: str, timeout: float = 90) -> str:
         try:
             r = self.run("shell", cmd, timeout=timeout)

{iphone2android-0.1.0 → iphone2android-0.2.0}/src/iphone2android/android/build.py

@@ -18,15 +18,22 @@ from pathlib import Path
 
 
 def _label(entry) -> str:
+    if isinstance(entry, dict) and "widget" in entry:
+        return f"Widget:{'/'.join(entry['widget'])}"
     return f"Folder:{entry['folder']}" if isinstance(entry, dict) else entry
 
 
+def _is_widget(entry) -> bool:
+    return isinstance(entry, dict) and "widget" in entry
+
+
 class Builder:
     def __init__(self, launcher, state_file: Path | None = None, log=print):
         self.l = launcher
         self.state_file = state_file
         self.log = log
         self.done: list[str] = []
+        self.todo: list[dict] = []
         if state_file and state_file.exists():
             self.done = json.loads(state_file.read_text()).get("done", [])
 
@@ -51,6 +58,12 @@ class Builder:
             key = f"p{page}:{_label(e)}"
             if key in self.done:
                 continue
+            if _is_widget(e):
+                # Widget pickers differ between launchers, so a widget is placed through the screen
+                # (see the skill), and the builder records it as still to do.
+                self.todo.append({"page": page + 1, "widget": e["widget"], "size": e.get("size")})
+                self.log(f"  widget {'/'.join(e['widget'])} ({e.get('size')}): to place by hand")
+                continue
             if isinstance(e, str):
                 r = self.add(e, page)
                 self.log(f"  {e}: {'placed' if r else 'FAILED'}")
@@ -112,5 +125,5 @@ class Builder:
     def order_all(self, layout: dict) -> bool:
         ok = True
         for page, entries in enumerate(layout.get("pages", [])):
-            ok = self.order(page, [_label(e) for e in entries]) and ok
+            ok = self.order(page, [_label(e) for e in entries if not _is_widget(e)]) and ok
         return ok

iphone2android-0.2.0/src/iphone2android/appdata.py

@@ -0,0 +1,106 @@
+"""The data iPhone apps keep on the phone itself: databases, documents and settings.
+
+An app's data is in AppDomain-<bundle id> and AppDomainGroup-group.<bundle id> in the backup. The
+Android version of an app cannot read it directly (different formats, and Android keeps each app's
+data private without root), so this finds which apps hold real data and copies it out, for an app
+that has its own import, for a dedicated migrator (WhatsApp), or just to keep.
+
+Settings files often contain account names and email addresses. `settings_summary` reads those keys
+to help set each app up again, skips anything that looks like a secret, and is meant to stay on your
+computer.
+"""
+from __future__ import annotations
+
+import plistlib
+import re
+import tempfile
+from pathlib import Path
+
+SKIP = ("Caches/", "/Cache", "tmp/", "Crashlytics", "Logs/", "GoogleAnalytics", "Firebase",
+        "com.crashlytics", "AppCenter", ".log", ".ttf", ".car", ".nib")
+DB_EXT = (".sqlite", ".db", ".sqlite3", ".realm")
+SECRET = ("password", "passwd", "secret", "token", "refresh", "private", "pin", "cvv", "apikey", "api_key", "cookie", "session")
+INTEREST = ("account", "user", "email", "login", "server", "host", "device", "pair", "region", "locale", "profile")
+EMAIL = re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")
+
+
+def _domains(bundle: str) -> tuple[str, str]:
+    return f"AppDomain-{bundle}", f"AppDomainGroup-group.{bundle}"
+
+
+def _size(row: dict) -> int:
+    from iOSbackup import iOSbackup
+
+    try:
+        return int(iOSbackup.getFileInfo(row["file"]).get("size") or 0)
+    except Exception:  # noqa: BLE001
+        return 0
+
+
+def survey(backup, bundles: list[str], size=_size) -> list[dict]:
+    """Which apps hold real local data, biggest first."""
+    out = []
+    for b in bundles:
+        rows = backup.rows("flags=1 AND (domain=? OR domain=?)", _domains(b))
+        dbs, doc_files, doc_bytes = [], 0, 0
+        for r in rows:
+            rel = r["relativePath"] or ""
+            if any(s in rel for s in SKIP):
+                continue
+            n = size(r)
+            if rel.lower().endswith(DB_EXT) and n > 20_000:
+                dbs.append({"path": rel, "bytes": n})
+            if rel.startswith("Documents/") and n > 0:
+                doc_files += 1
+                doc_bytes += n
+        if dbs or doc_bytes > 200_000:
+            out.append({"bundle": b, "databases": sorted(dbs, key=lambda d: -d["bytes"])[:5],
+                        "documents": doc_files, "document_bytes": doc_bytes,
+                        "total_bytes": sum(d["bytes"] for d in dbs) + doc_bytes})
+    return sorted(out, key=lambda x: -x["total_bytes"])
+
+
+def extract(backup, bundle: str, out: Path) -> dict:
+    """Copy one app's whole container, keeping its folder structure."""
+    base = out / bundle
+    copied, failed = 0, 0
+    for r in backup.rows("flags=1 AND (domain=? OR domain=?)", _domains(bundle)):
+        rel = r["relativePath"] or "root"
+        folder = base / Path(rel).parent
+        try:
+            backup.copy_entry(r, folder, Path(rel).name or "root")
+            copied += 1
+        except Exception:  # noqa: BLE001
+            failed += 1
+    return {"bundle": bundle, "folder": str(base), "files": copied, "failed": failed}
+
+
+def push(adb, folder: Path, dest_root: str = "/sdcard/iPhoneMigration/AppData") -> bool:
+    adb.run("shell", "mkdir", "-p", dest_root)
+    return adb.run("push", str(folder), dest_root + "/", timeout=3600).returncode == 0
+
+
+def settings_summary(backup, bundle: str, limit: int = 40) -> dict:
+    """Account names, emails and non-secret settings from an app's plist files."""
+    emails: set[str] = set()
+    keys: dict[str, str] = {}
+    rows = [r for r in backup.rows("flags=1 AND (domain=? OR domain=?)", _domains(bundle))
+            if (r["relativePath"] or "").endswith(".plist")][:limit]
+    with tempfile.TemporaryDirectory() as tmp:
+        for r in rows:
+            try:
+                p = backup.copy_entry(r, Path(tmp), "t.plist")
+                d = plistlib.loads(p.read_bytes())
+            except Exception:  # noqa: BLE001
+                continue
+            if not isinstance(d, dict):
+                continue
+            for k, v in d.items():
+                kl = str(k).lower()
+                if any(s in kl for s in SECRET) or not isinstance(v, (str, int, float)):
+                    continue
+                s = str(v)
+                emails.update(EMAIL.findall(s))
+                if any(t in kl for t in INTEREST) and len(s) < 90:
+                    keys[str(k)] = s
+    return {"bundle": bundle, "emails": sorted(emails)[:10], "settings": dict(list(keys.items())[:20])}

iphone2android-0.2.0/src/iphone2android/apps.py

@@ -0,0 +1,146 @@
+"""Find the Android app for each iPhone app.
+
+The iPhone side gives bundle ids (com.spotify.client). Apple's public lookup turns a bundle id into
+the app's name and developer. The Play Store's own search page then gives candidate packages for that
+name. A candidate is picked automatically only when its Play Store title matches the iPhone name;
+everything else is left for a person (or Claude) to choose from the candidates.
+"""
+from __future__ import annotations
+
+import json
+import re
+import time
+import urllib.parse
+import urllib.request
+
+UA = {
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36",
+    "Accept-Language": "en-US,en;q=0.9",
+}
+ITUNES_LOOKUP = "https://itunes.apple.com/lookup?bundleId={bundle}&country={country}"
+PLAY_SEARCH = "https://play.google.com/store/search?{query}"
+PLAY_DETAILS = "https://play.google.com/store/apps/details?id={package}&hl=en"
+
+# Apple's own apps are not in the App Store lookup, and most have a Google or system equivalent.
+APPLE_BUILTINS = {
+    "com.apple.mobilephone": ("Phone", "com.google.android.dialer"),
+    "com.apple.MobileSMS": ("Messages", "com.google.android.apps.messaging"),
+    "com.apple.mobilesafari": ("Safari", "com.android.chrome"),
+    "com.apple.mobilemail": ("Mail", "com.google.android.gm"),
+    "com.apple.mobilecal": ("Calendar", "com.google.android.calendar"),
+    "com.apple.camera": ("Camera", None),
+    "com.apple.mobileslideshow": ("Photos", "com.google.android.apps.photos"),
+    "com.apple.Maps": ("Maps", "com.google.android.apps.maps"),
+    "com.apple.MobileAddressBook": ("Contacts", "com.google.android.contacts"),
+    "com.apple.mobilenotes": ("Notes", "com.google.android.keep"),
+    "com.apple.reminders": ("Reminders", "com.google.android.apps.tasks"),
+    "com.apple.Preferences": ("Settings", None),
+    "com.apple.AppStore": ("App Store", "com.android.vending"),
+    "com.apple.weather": ("Weather", None),
+    "com.apple.mobiletimer": ("Clock", "com.google.android.deskclock"),
+    "com.apple.calculator": ("Calculator", "com.google.android.calculator"),
+    "com.apple.Music": ("Music", None),
+    "com.apple.Health": ("Health", "com.google.android.apps.healthdata"),
+    "com.apple.DocumentsApp": ("Files", "com.google.android.apps.nbu.files"),
+    "com.apple.findmy": ("Find My", "com.google.android.apps.adm"),
+    "com.apple.Passbook": ("Wallet", "com.google.android.apps.walletnfcrel"),
+    "com.apple.VoiceMemos": ("Voice Memos", None),
+    "com.apple.compass": ("Compass", None),
+    "com.apple.tv": ("TV", None),
+    "com.apple.podcasts": ("Podcasts", None),
+    "com.apple.shortcuts": ("Shortcuts", None),
+    "com.apple.Translate": ("Translate", "com.google.android.apps.translate"),
+}
+
+
+def _get(url: str, timeout: float = 20.0, tries: int = 3) -> str | None:
+    for attempt in range(tries):
+        try:
+            with urllib.request.urlopen(urllib.request.Request(url, headers=UA), timeout=timeout) as r:
+                return r.read().decode("utf-8", "replace")
+        except urllib.error.HTTPError as e:
+            if e.code == 404:
+                return None
+        except (urllib.error.URLError, TimeoutError):
+            pass
+        time.sleep(2 + attempt * 3)
+    return None
+
+
+def ios_info(bundle: str, country: str = "us", lookup_url: str = ITUNES_LOOKUP) -> dict | None:
+    """Name, developer and store link for a bundle id, from Apple's public lookup."""
+    if bundle in APPLE_BUILTINS:
+        name, _ = APPLE_BUILTINS[bundle]
+        return {"name": name, "developer": "Apple", "builtin": True}
+    body = _get(lookup_url.format(bundle=urllib.parse.quote(bundle), country=country))
+    if not body:
+        return None
+    results = (json.loads(body) or {}).get("results") or []
+    if not results:
+        return None
+    r = results[0]
+    return {"name": r.get("trackName"), "developer": r.get("sellerName") or r.get("artistName"),
+            "genre": r.get("primaryGenreName"), "builtin": False}
+
+
+def play_search(query: str, country: str = "us", search_url: str = PLAY_SEARCH, limit: int = 6) -> list[str]:
+    """Package ids the Play Store search page lists for a query, in order."""
+    body = _get(search_url.format(query=urllib.parse.urlencode({"q": query, "c": "apps", "gl": country.upper(), "hl": "en"})))
+    if not body:
+        return []
+    out: list[str] = []
+    for m in re.finditer(r"/store/apps/details\?id=([A-Za-z0-9_.]+)", body):
+        if m.group(1) not in out:
+            out.append(m.group(1))
+    return out[:limit]
+
+
+def play_title(package: str, details_url: str = PLAY_DETAILS) -> str | None:
+    body = _get(details_url.format(package=package))
+    if not body:
+        return None
+    m = re.search(r"<title[^>]*>(.*?)</title>", body, re.S)
+    if not m:
+        return None
+    return re.sub(r"\s*-\s*Apps on Google Play\s*$", "", m.group(1).strip())
+
+
+def _norm(s: str) -> str:
+    s = (s or "").lower()
+    s = re.split(r"[:\-–|(]", s)[0]  # "Spotify: Music and Podcasts" -> "spotify"
+    return re.sub(r"[^a-z0-9]+", "", s)
+
+
+def suggest(bundle: str, country: str = "us", **urls) -> dict:
+    """One mapping suggestion: the iPhone app, the candidates, and a pick when the titles agree."""
+    out = {"bundle": bundle, "name": None, "developer": None, "candidates": [], "package": None, "label": None, "confident": False}
+    if bundle in APPLE_BUILTINS:
+        name, pkg = APPLE_BUILTINS[bundle]
+        out.update(name=name, developer="Apple", package=pkg, label=name, confident=True)
+        return out
+    info = ios_info(bundle, country, urls.get("lookup_url", ITUNES_LOOKUP))
+    if not info or not info.get("name"):
+        return out
+    out.update(name=info["name"], developer=info.get("developer"))
+    want = _norm(info["name"])
+    for pkg in play_search(info["name"], country, urls.get("search_url", PLAY_SEARCH)):
+        title = play_title(pkg, urls.get("details_url", PLAY_DETAILS))
+        out["candidates"].append({"package": pkg, "title": title})
+        if title and not out["package"] and _norm(title) == want:
+            out.update(package=pkg, label=title.split(":")[0].strip(), confident=True)
+    return out
+
+
+def suggest_all(bundles: list[str], country: str = "us", log=print, **urls) -> dict:
+    """A draft mapping for every bundle id. Entries without a confident pick keep their candidates."""
+    draft = {}
+    for i, b in enumerate(bundles, 1):
+        s = suggest(b, country, **urls)
+        draft[b] = s
+        log(f"[{i}/{len(bundles)}] {b}: " + (f"{s['package']} ({s['label']})" if s["confident"] else f"{len(s['candidates'])} candidates, pick one"))
+    return draft
+
+
+def to_mapping(draft: dict) -> dict:
+    """The confident part of a draft, in the mapping format the other commands read."""
+    return {b: {"package": s["package"], "label": s["label"]} for b, s in draft.items() if s.get("confident") and s.get("label")}

iphone2android-0.2.0/src/iphone2android/audit.py

@@ -0,0 +1,91 @@
+"""What is on the iPhone (from the backup) and what reached the Android phone.
+
+Run it after the official transfer to see what that missed, and again at the end to check the
+migration. Every number on the phone side comes from the phone itself over adb. A count the phone
+refuses to give (some vendors block the content providers to adb) is reported as null, not as 0.
+"""
+from __future__ import annotations
+
+import os
+import sqlite3
+from pathlib import Path
+
+from .android.adb import Adb, DeviceUnavailable
+
+
+def _count(db: Path, sql: str) -> int | None:
+    if not db.exists():
+        return None
+    try:
+        con = sqlite3.connect(f"file:{db}?mode=ro", uri=True)
+        n = con.execute(sql).fetchone()[0]
+        con.close()
+        return n
+    except sqlite3.DatabaseError:
+        return None
+
+
+def iphone_counts(extracted: Path) -> dict:
+    sms = extracted / "sms_recovered.db"
+    if not sms.exists():
+        sms = extracted / "sms.db"
+    return {
+        "messages": _count(sms, "SELECT count(*) FROM message WHERE text IS NOT NULL AND text != ''"),
+        "calls": _count(extracted / "CallHistory.storedata", "SELECT count(*) FROM ZCALLRECORD"),
+        "contacts": _count(extracted / "AddressBook.sqlitedb", "SELECT count(*) FROM ABPerson"),
+        "calendar_events": _count(extracted / "Calendar.sqlitedb", "SELECT count(*) FROM CalendarItem"),
+    }
+
+
+def _provider_count(adb: Adb, uri: str) -> int | None:
+    out = adb.shell(f"content query --uri {uri} --projection _id 2>&1 | grep -c '^Row:'")
+    if "Permission Denial" in out or "SecurityException" in out:
+        return None
+    try:
+        return int(out.strip().splitlines()[-1])
+    except (ValueError, IndexError):
+        return None
+
+
+def phone_counts(adb: Adb) -> dict:
+    return {
+        "messages": _provider_count(adb, "content://sms"),
+        "calls": _provider_count(adb, "content://call_log/calls"),
+        "contacts": _provider_count(adb, "content://com.android.contacts/contacts"),
+        "calendar_events": _provider_count(adb, "content://com.android.calendar/events"),
+    }
+
+
+def phone_media_names(adb: Adb, roots=("/sdcard/DCIM", "/sdcard/Pictures", "/sdcard/Movies")) -> set[str]:
+    names: set[str] = set()
+    for root in roots:
+        out = adb.shell(f"find {root} -type f 2>/dev/null")
+        names.update(os.path.basename(line.strip()) for line in out.splitlines() if line.strip())
+    return names
+
+
+def camera_roll_names(backup) -> list[str]:
+    from .media import media_rows
+
+    return sorted({os.path.basename(r["relativePath"]) for r in media_rows(backup, "CameraRollDomain", "Media/DCIM/")})
+
+
+def run(adb: Adb, extracted: Path, mapping: dict | None = None, backup=None) -> dict:
+    report: dict = {"iphone": iphone_counts(extracted)}
+    try:
+        report["phone"] = phone_counts(adb)
+        packages = {m["package"] for m in (mapping or {}).values() if m.get("package")}
+        if packages:
+            installed = {line.split(":", 1)[1].strip() for line in adb.shell("pm list packages").splitlines() if ":" in line}
+            report["apps"] = {"mapped": len(packages), "missing": sorted(packages - installed)}
+        if backup is not None:
+            want = camera_roll_names(backup)
+            have = phone_media_names(adb)
+            missing = [n for n in want if n not in have]
+            report["photos"] = {"camera_roll": len(want), "missing_by_name": len(missing), "examples": missing[:20]}
+    except DeviceUnavailable as e:
+        report["phone"] = {"error": str(e)}
+    report["gaps"] = {k: (report["iphone"][k] or 0) - (report["phone"].get(k) or 0)
+                      for k in report["iphone"]
+                      if isinstance(report.get("phone"), dict) and report["phone"].get(k) is not None and report["iphone"][k] is not None}
+    return report

{iphone2android-0.1.0 → iphone2android-0.2.0}/src/iphone2android/backup.py

@@ -32,6 +32,11 @@ KNOWN = [
     ("HomeDomain", "Library/SpringBoard/IconState.plist", "IconState.plist", "Home screen layout", "iphone2android layout"),
 ]
 
+# Files that have lived in more than one place across iOS versions: (domain, other path, name).
+ALTERNATES = {
+    "IconState.plist": [("HomeDomain", "Library/Preferences/IconState.plist")],
+}
+
 
 def backups(root: Path = DEFAULT_ROOT) -> list[dict]:
     """Every backup under root, with what its Info.plist says (no password needed)."""
@@ -135,9 +140,13 @@ def extract_known(b: Backup, out: Path) -> list[tuple[str, str, Path | None]]:
     """Copy every known database out. Returns (label, destination format, path or None)."""
     got = []
     for domain, rel, name, label, dest in KNOWN:
-        try:
-            p = b.copy(domain, rel, out, name)
-        except Exception:  # noqa: BLE001 - a file that fails to decrypt is reported as missing
-            p = None
+        p = None
+        for d, r in [(domain, rel)] + ALTERNATES.get(name, []):
+            try:
+                p = b.copy(d, r, out, name)
+            except Exception:  # noqa: BLE001 - a file that fails to decrypt is reported as missing
+                p = None
+            if p:
+                break
         got.append((label, dest, p))
     return got