RootUI.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using FastbootEnhance.Core.Adb;
using FastbootEnhance.Core.Fastboot;
using FastbootEnhance.Core.Images;
using FastbootEnhance.Core.Payload;

namespace FastbootEnhance
{
    /// <summary>
    /// The Root page: takes the stock boot or init_boot image (or pulls it out of an OTA),
    /// sends it to the phone for Magisk, KernelSU or APatch to patch, brings the patched image
    /// back, checks it, and flashes it to the right partition from the bootloader.
    /// </summary>
    static class RootUI
    {
        static MainWindow W => MainWindow.THIS;

        static readonly TimeSpan FastbootWait = TimeSpan.FromMinutes(2);

        // The work folder keeps the stock image (to undo the root) and the patched one.
        static string folder;
        static string stockPath;
        static BootImageAnalysis stock;
        static string partition;
        static string adbSerial;
        static DateTime sentAt;
        static string patchedPath;
        static volatile bool busy;

        static void log(string line) => LogStore.Append("root: " + line);

        static RootTool tool => W.root_tool_kernelsu.IsChecked == true ? RootTool.KernelSU
            : W.root_tool_apatch.IsChecked == true ? RootTool.APatch : RootTool.Magisk;

        public static void init()
        {
            W.root_pick.Click += delegate { pick(); };
            W.root_push.Click += delegate { push(); };
            W.root_pull.Click += delegate { pull(); };
            W.root_flash.Click += delegate { flash(); };
            W.root_boot_once.Click += delegate { bootOnce(); };
            W.root_open_folder.Click += delegate { openFolder(); };
            foreach (var radio in new[] { W.root_tool_magisk, W.root_tool_kernelsu, W.root_tool_apatch })
                radio.Checked += delegate { toolChanged(); };
            refresh();
        }

        /// <summary>A different app may patch a different image: start again from step 1.</summary>
        static void toolChanged()
        {
            if (W.root_pick == null)
                return; // still loading
            stockPath = null;
            stock = null;
            partition = null;
            patchedPath = null;
            W.root_image_text.Text = "";
            W.root_push_text.Text = "";
            W.root_pull_text.Text = "";
            W.root_flash_text.Text = "";
            refresh();
        }

        static void refresh()
        {
            string phoneName = partition != null ? RootHelper.PhoneName(partition) : "fbstudio_….img";
            W.root_step2_note.Text = string.Format(Properties.Resources.root_step2_note, phoneName);
            string how = tool == RootTool.KernelSU ? Properties.Resources.root_how_kernelsu
                : tool == RootTool.APatch ? Properties.Resources.root_how_apatch
                : Properties.Resources.root_how_magisk;
            W.root_how.Text = string.Format(how, phoneName);
            W.root_step4_note.Text = string.Format(Properties.Resources.root_step4_note, partition ?? "boot / init_boot");

            W.root_pick.IsEnabled = !busy;
            foreach (var radio in new[] { W.root_tool_magisk, W.root_tool_kernelsu, W.root_tool_apatch })
                radio.IsEnabled = !busy;
            W.root_push.IsEnabled = !busy && stockPath != null;
            W.root_pull.IsEnabled = !busy && adbSerial != null;
            W.root_flash.IsEnabled = !busy && patchedPath != null;
            W.root_boot_once.Visibility = partition == "boot" ? Visibility.Visible : Visibility.Collapsed;
            W.root_boot_once.IsEnabled = !busy && patchedPath != null && partition == "boot";
            W.root_open_folder.IsEnabled = folder != null;

            // The current step is lit, the ones done carry a tick, the ones ahead are dimmed.
            int current = patchedPath != null ? 4 : adbSerial != null ? 3 : stockPath != null ? 2 : 1;
            paintStep(W.root_step1, W.root_step1_no, W.root_step1_num, W.root_step1_tick, W.root_step1_state, 1, current);
            paintStep(W.root_step2, W.root_step2_no, W.root_step2_num, W.root_step2_tick, W.root_step2_state, 2, current);
            paintStep(W.root_step3, W.root_step3_no, W.root_step3_num, W.root_step3_tick, W.root_step3_state, 3, current);
            paintStep(W.root_step4, W.root_step4_no, W.root_step4_num, W.root_step4_tick, W.root_step4_state, 4, current);
        }

        static void paintStep(Border card, Border circle, TextBlock number, System.Windows.Shapes.Path tick, TextBlock state, int step, int current)
        {
            bool done = step < current, now = step == current;
            card.Opacity = done || now ? 1 : 0.6;
            card.BorderBrush = Palette.Get(now ? "AccentLine" : "GlassLine");
            circle.Background = Palette.Get(done ? "OkSoft" : now ? "Accent" : "Glass2");
            circle.BorderBrush = Palette.Get(done ? "OkLine" : now ? "Accent" : "GlassLine2");
            number.Foreground = Palette.Get(now ? "AccentInk" : "Dim");
            number.Visibility = done ? Visibility.Collapsed : Visibility.Visible;
            tick.Visibility = done ? Visibility.Visible : Visibility.Collapsed;
            state.Text = done ? Properties.Resources.root_step_done : now ? Properties.Resources.root_step_current : "";
            state.Foreground = Palette.Get(done ? "Ok" : "Accent");
        }

        /// <summary>
        /// Runs work in the background with the page locked, then done on the UI thread. When
        /// the work throws, done is not run: the error is shown instead, so a failed step is
        /// never reported as a finished one.
        /// </summary>
        static void run(Action work, Action done)
        {
            busy = true;
            refresh();
            Exception failure = null;
            Helper.offloadAndRun(delegate
            {
                try
                {
                    work();
                }
                catch (Exception e)
                {
                    failure = e;
                    log("failed: " + e);
                }
            }, delegate
            {
                busy = false;
                if (failure != null)
                    ThemedDialog.Show(failure.Message, Properties.Resources.error, MessageBoxButton.OK, MessageBoxImage.Error);
                else
                    done();
                refresh();
            });
        }

        // ---------------------------------------------------------------- 1. the stock image

        static void pick()
        {
            Helper.fileSelect(new Helper.PathSelectCallback(delegate (string path)
            {
                RootTool chosen = tool;
                string error = null, note = null;
                string newFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
                    "Fastboot Studio", "Root", DateTime.Now.ToString("yyyyMMdd-HHmmss"));
                string image = null, imagePartition = null;
                BootImageAnalysis analysis = null;
                W.root_image_text.Text = Properties.Resources.root_picking;

                run(delegate
                {
                    try
                    {
                        ImageInfo info = ImageProbe.Identify(path);
                        if (info.Kind == ImageKind.Payload || info.Kind == ImageKind.Zip)
                        {
                            using (PayloadFile payload = PayloadFile.Open(path))
                            {
                                bool hasInitBoot = payload.Partitions.Any(p => p.Name == "init_boot");
                                imagePartition = RootHelper.PartitionFor(chosen, hasInitBoot);
                                if (!payload.Partitions.Any(p => p.Name == imagePartition))
                                {
                                    error = Properties.Resources.root_no_image_in_ota;
                                    return;
                                }
                                if (imagePartition == "init_boot")
                                    note = string.Format(Properties.Resources.root_needs_init_boot, chosen);
                                ExtractionReport report = PayloadExtractor.ExtractAll(payload, newFolder, new[] { imagePartition });
                                PartitionResult result = report.Results.Single();
                                if (!result.Succeeded)
                                {
                                    error = result.Error;
                                    return;
                                }
                                image = result.OutputPath;
                            }
                        }
                        else
                        {
                            analysis = BootImageAnalysis.Analyze(path);
                            if (analysis.Kind != BootImageKind.Bootable && analysis.Kind != BootImageKind.NoKernel)
                            {
                                error = Properties.Resources.root_not_boot;
                                return;
                            }
                            imagePartition = analysis.Kind == BootImageKind.NoKernel ? "init_boot" : "boot";
                            if (chosen == RootTool.APatch && imagePartition != "boot")
                            {
                                error = Properties.Resources.root_apatch_kernel;
                                return;
                            }
                            Directory.CreateDirectory(newFolder);
                            image = Path.Combine(newFolder, imagePartition + ".img");
                            File.Copy(path, image, true);
                        }
                        analysis = BootImageAnalysis.Analyze(image);
                        if (analysis.Root != RootKind.None)
                            error = string.Format(Properties.Resources.root_already_rooted,
                                BootFlashCheck.RootName(analysis.Root, analysis.Kernel?.SuSFS ?? false));
                    }
                    catch (Exception e)
                    {
                        error = e.Message;
                    }
                }, delegate
                {
                    if (error != null)
                    {
                        log("image " + path + " not used: " + error);
                        W.root_image_text.Text = "";
                        ThemedDialog.Show(error, Properties.Resources.nav_root, MessageBoxButton.OK, MessageBoxImage.Warning);
                        return;
                    }
                    folder = newFolder;
                    stockPath = image;
                    stock = analysis;
                    partition = imagePartition;
                    adbSerial = null;
                    patchedPath = null;
                    W.root_push_text.Text = "";
                    W.root_pull_text.Text = "";
                    W.root_flash_text.Text = "";
                    W.root_image_text.Text = describe(partition, analysis) + (note != null ? "\n" + note : "");
                    log("stock " + partition + " ready in " + folder + " (from " + path + ")");
                });
            }), "Boot image or OTA|*.img;*.bin;*.zip|All files|*.*");
        }

        /// <summary>"init_boot.img · Android 14 · 2024-09 · android14-6.1 · stock".</summary>
        static string describe(string name, BootImageAnalysis image, bool patched = false)
        {
            List<string> parts = new List<string> { name + ".img" };
            if (image.OsVersion != null)
                parts.Add("Android " + image.OsVersion);
            if (image.PatchLevel != null)
                parts.Add(image.PatchLevel);
            if (image.Kernel?.Kmi != null)
                parts.Add(image.Kernel.Kmi);
            else if (image.Kernel?.Release != null)
                parts.Add(image.Kernel.Release);
            parts.Add(image.Root == RootKind.None ? Properties.Resources.root_image_stock
                : string.Format(patched ? Properties.Resources.root_image_patched : Properties.Resources.root_image_rooted,
                    BootFlashCheck.RootName(image.Root, image.Kernel?.SuSFS ?? false)));
            return Helper.ltr(string.Join("  ·  ", parts));
        }

        // ---------------------------------------------------------------- 2. to the phone

        /// <summary>The one phone running Android over adb, or null.</summary>
        static AdbDevice findPhone()
        {
            Adb.Result list = Adb.Run("devices -l", Adb.ShortCommand);
            return AdbDevice.ParseList(list.Output).FirstOrDefault(d => d.State == "device");
        }

        static void push()
        {
            string local = stockPath, remote = RootHelper.PhonePath(partition);
            AdbDevice phone = null;
            DateTime phoneNow = DateTime.MinValue;
            string error = null;
            run(delegate
            {
                phone = findPhone();
                if (phone == null)
                {
                    error = Properties.Resources.root_no_adb;
                    return;
                }
                // The phone's own clock: patched files are looked for from this time on.
                Adb.Result clock = Adb.Run(AdbCommand.Shell(phone.Serial, "date +%s"), Adb.ShortCommand);
                long seconds;
                phoneNow = clock.Succeeded && long.TryParse(clock.Output.Trim(), out seconds)
                    ? DateTimeOffset.FromUnixTimeSeconds(seconds).UtcDateTime
                    : DateTime.UtcNow;
                Adb.Result sent = Adb.Run(AdbCommand.Push(phone.Serial, local, remote), Fastboot.LongCommand);
                if (!sent.Succeeded)
                    error = string.Format(Properties.Resources.root_push_failed, sent.Problem);
            }, delegate
            {
                if (error != null)
                {
                    log(error);
                    W.root_push_text.Text = error;
                    return;
                }
                adbSerial = phone.Serial;
                sentAt = phoneNow.AddMinutes(-1);
                patchedPath = null;
                W.root_push_text.Text = string.Format(Properties.Resources.root_pushed, Helper.ltr(remote), phone.Model ?? phone.Serial);
                W.root_pull_text.Text = "";
                log("sent " + local + " to " + phone.Serial + ":" + remote);
            });
        }

        // ---------------------------------------------------------------- 3. back from the phone

        static void pull()
        {
            string serial = adbSerial;
            RootTool chosen = tool;
            PatchedImage found = null;
            BootImageAnalysis patched = null;
            string local = null, error = null;
            List<PatchProblem> problems = null;
            run(delegate
            {
                Adb.Result listing = Adb.Run(AdbCommand.Shell(serial, RootHelper.ListPatchedCommand), Adb.ShortCommand);
                found = RootHelper.FindNewest(listing.Output, sentAt);
                if (found == null)
                {
                    error = Properties.Resources.root_no_patched;
                    return;
                }
                local = Path.Combine(folder, found.Name);
                Adb.Result pulled = Adb.Run(AdbCommand.Pull(serial, found.Path, local), Fastboot.LongCommand);
                if (!pulled.Succeeded || !File.Exists(local))
                {
                    error = pulled.Problem;
                    return;
                }
                patched = BootImageAnalysis.Analyze(local);
                problems = RootHelper.Verify(stock, patched, chosen);
            }, delegate
            {
                if (error != null)
                {
                    log("no patched image: " + error);
                    W.root_pull_text.Text = error;
                    return;
                }
                log("got " + found.Path + " -> " + local + (problems.Count > 0 ? " (" + string.Join(", ", problems) + ")" : ""));
                if (problems.Count > 0)
                {
                    string text = Properties.Resources.root_patch_problems + "\n\n" + string.Join("\n", problems.Select(p => "• " + (
                        p == PatchProblem.NotRooted ? Properties.Resources.root_patch_not_rooted
                        : p == PatchProblem.DifferentKind ? Properties.Resources.root_patch_kind
                        : Properties.Resources.root_patch_kernel)));
                    ThemedDialog.Show(text, Properties.Resources.nav_root, MessageBoxButton.OK, MessageBoxImage.Warning);
                    W.root_pull_text.Text = text;
                    return;
                }
                patchedPath = local;
                W.root_pull_text.Text = string.Format(Properties.Resources.root_pulled, Helper.ltr(found.Name), describe(partition, patched, true));
            });
        }

        // ---------------------------------------------------------------- 4. flash

        /// <summary>
        /// Restarts this phone (and only this one) to the bootloader and waits for it there;
        /// returns its fastboot serial, or null when it does not show up or cannot be told apart
        /// from another phone. Another phone that is already in fastboot is never used.
        /// </summary>
        static string toBootloader(string serial)
        {
            if (string.IsNullOrEmpty(serial))
                return null;
            List<string> before = Fastboot.ListSerials();
            if (before.Contains(serial))
                return serial;
            Adb.Result reboot = Adb.Run(AdbCommand.Reboot(serial, "bootloader"), Adb.ShortCommand);
            log("adb -s " + serial + " reboot bootloader: " + (reboot.Succeeded ? "ok" : reboot.Problem)
                + (before.Count > 0 ? "; already in fastboot, not used: " + string.Join(", ", before) : ""));
            Stopwatch waited = Stopwatch.StartNew();
            while (waited.Elapsed < FastbootWait)
            {
                string found = RootHelper.PickFastbootSerial(serial, before, Fastboot.ListSerials());
                if (found != null)
                    return found;
                Thread.Sleep(2000);
            }
            return null;
        }

        static void flash()
        {
            string image = patchedPath, target = partition, serial = adbSerial;
            if (!ThemedDialog.ConfirmTyped(string.Format(Properties.Resources.root_confirm_flash, serial, Path.GetFileName(image), target),
                    Properties.Resources.nav_root, target))
                return;

            string fastbootSerial = null, error = null;
            W.root_flash_text.Text = Properties.Resources.root_waiting_fastboot;
            run(delegate
            {
                fastbootSerial = toBootloader(serial);
                if (fastbootSerial == null)
                {
                    error = string.Format(Properties.Resources.root_no_fastboot, Helper.ltr(image));
                    return;
                }
                W.Dispatcher.Invoke(delegate { W.root_flash_text.Text = string.Format(Properties.Resources.root_flashing, target); });
                string output;
                // No slot suffix: fastboot writes the active slot's partition.
                int? code = Fastboot.Run(fastbootSerial, "flash " + target + " " + AdbCommand.WindowsArgument(image), Fastboot.LongCommand, out output);
                log("fastboot flash " + target + " " + image + " -> " + code + "\n" + output.Trim());
                if (code != 0)
                    error = string.Format(Properties.Resources.root_flash_failed, output.Trim());
            }, delegate
            {
                if (error != null)
                {
                    W.root_flash_text.Text = error;
                    ThemedDialog.Show(error, Properties.Resources.error, MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
                if (Helper.confirm(string.Format(Properties.Resources.root_flashed, target), Properties.Resources.nav_root))
                {
                    string output;
                    Fastboot.Run(fastbootSerial, "reboot", Fastboot.ShortCommand, out output);
                }
                W.root_flash_text.Text = Properties.Resources.root_done;
            });
        }

        /// <summary>"fastboot boot": the patched boot image runs once, from memory, without being written.</summary>
        static void bootOnce()
        {
            string image = patchedPath, serial = adbSerial, error = null;
            W.root_flash_text.Text = Properties.Resources.root_waiting_fastboot;
            run(delegate
            {
                string fastbootSerial = toBootloader(serial);
                if (fastbootSerial == null)
                {
                    error = string.Format(Properties.Resources.root_no_fastboot, Helper.ltr(image));
                    return;
                }
                W.Dispatcher.Invoke(delegate { W.root_flash_text.Text = Properties.Resources.root_booting; });
                string output;
                int? code = Fastboot.Run(fastbootSerial, "boot " + AdbCommand.WindowsArgument(image), Fastboot.LongCommand, out output);
                log("fastboot boot " + image + " -> " + code + "\n" + output.Trim());
                if (code != 0)
                    error = string.Format(Properties.Resources.root_boot_failed, output.Trim());
            }, delegate
            {
                W.root_flash_text.Text = error ?? Properties.Resources.root_booted;
            });
        }

        static void openFolder()
        {
            if (folder == null)
                return;
            try
            {
                Directory.CreateDirectory(folder);
                Process.Start(new ProcessStartInfo("explorer.exe", AdbCommand.WindowsArgument(folder)) { UseShellExecute = true });
            }
            catch (Exception e)
            {
                log("cannot open " + folder + ": " + e.Message);
            }
        }
    }
}