consolemanager.cpp

#include "consolemanager.h"
#include "adbutils.h"
#include "getlocaladb.h"
#include "logfile.h"

#include <QCoreApplication>
#include <QDir>
#include <QFile>
#include <QFileDevice>
#include <QFileInfo>
#include <QJsonDocument>
#include <QJsonObject>
#include <QMessageBox>
#include <QProcess>
#include <QStandardPaths>
#include <QTextStream>

#include "scpdialog.h"

ConsoleManager::ConsoleManager(QObject *parent)
    : QObject(parent)
    , m_os(detectOs())
{
}

ConsoleManager::OSType ConsoleManager::detectOs()
{
#ifdef Q_OS_LINUX
    return Linux;
#elif defined(Q_OS_WIN)
    return Windows;
#elif defined(Q_OS_MAC)
    return macOS;
#else
    return Linux;
#endif
}

bool ConsoleManager::isTerminalAvailable(int choice) const
{
    if (m_os == Windows)
        return true;
    if (m_os == macOS) {
        if (choice == 0) return true;
        if (choice == 1) {
            return QFileInfo::exists(QStringLiteral("/Applications/iTerm.app"))
                || QFileInfo::exists(QDir::homePath() + QStringLiteral("/Applications/iTerm.app"));
        }
        if (choice == 2) {
            return QFileInfo::exists(QStringLiteral("/Applications/Ghostty.app"))
                || QFileInfo::exists(QDir::homePath() + QStringLiteral("/Applications/Ghostty.app"))
                || !QStandardPaths::findExecutable(QStringLiteral("ghostty")).isEmpty();
        }
        return false;
    }
    if (m_os == Linux) {
        switch (choice) {
        case 0: return !QStandardPaths::findExecutable(QStringLiteral("gnome-terminal")).isEmpty();
        case 1: return !QStandardPaths::findExecutable(QStringLiteral("xfce4-terminal")).isEmpty();
        case 2: return !QStandardPaths::findExecutable(QStringLiteral("konsole")).isEmpty();
        case 3: return !QStandardPaths::findExecutable(QStringLiteral("ghostty")).isEmpty();
        default: return false;
        }
    }
    return false;
}

QString ConsoleManager::terminalDisplayName(int choice) const
{
    if (m_os == macOS) {
        switch (choice) {
        case 0: return QStringLiteral("macOS Terminal");
        case 1: return QStringLiteral("iTerm2 Terminal");
        case 2: return QStringLiteral("Ghostty Terminal");
        default: return QStringLiteral("macOS Terminal");
        }
    }
    if (m_os == Linux) {
        switch (choice) {
        case 0: return QStringLiteral("Gnome Terminal");
        case 1: return QStringLiteral("XFCE4 Terminal");
        case 2: return QStringLiteral("KDE Konsole");
        case 3: return QStringLiteral("Ghostty Terminal");
        default: return QStringLiteral("Gnome Terminal");
        }
    }
    return QStringLiteral("Terminal");
}

QString ConsoleManager::scrcpyScript(const QString &scriptDir, const QString &adbfilesDir, const QString &scrcpyDir) const
{
    if (m_os == Windows) {
        QString path = scriptDir + QStringLiteral("/scrcpy.bat");
        QFile file(path);
        if (!file.open(QFile::WriteOnly | QFile::Text)) {
            logfile(QStringLiteral("error creating scrcpy.bat!"));
            return QString();
        }
        QTextStream out(&file);
        out << QStringLiteral("echo off") << Qt::endl;
        out << QStringLiteral("set PATH=") + adbfilesDir + QStringLiteral(";") + scrcpyDir + QStringLiteral(";%PATH%") << Qt::endl;
        file.flush();
        file.close();
        return path;
    }

    QString path = scriptDir + QStringLiteral("/scrcpy.sh");
    QFile file(path);
    if (!file.open(QFile::WriteOnly | QFile::Text)) {
        logfile(QStringLiteral("error creating scrcpy.sh!"));
        return QString();
    }
    QTextStream out(&file);
    out << QStringLiteral("#!/bin/sh") << Qt::endl;
    out << QStringLiteral("export PATH=\"") + adbfilesDir + QStringLiteral("\":\"") + scrcpyDir + QStringLiteral("\":$PATH") << Qt::endl;
    file.flush();
    file.close();

    file.setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ExeOwner |
                        QFileDevice::ReadGroup | QFileDevice::ExeGroup |
                        QFileDevice::ReadOther | QFileDevice::ExeOther);
    return path;
}

void ConsoleManager::launchTerminal(const QString &scriptPath, int terminalChoice) const
{
    int effective = terminalChoice;
    if (!isTerminalAvailable(terminalChoice)) {
        logfile(QStringLiteral("Terminal %1 not found, falling back to %2")
                .arg(terminalDisplayName(terminalChoice), terminalDisplayName(0)));
        effective = 0;
    }
    QString cmd = terminalCommand(scriptPath, effective);
    if (!cmd.isEmpty()) {
        QStringList parts = QProcess::splitCommand(cmd);
        if (!parts.isEmpty()) {
            if (!QProcess::startDetached(parts.takeFirst(), parts)) {
                logfile(QStringLiteral("Failed to launch terminal: ") + cmd);
                QMessageBox msgBox;
                msgBox.setIcon(QMessageBox::Warning);
                msgBox.setWindowTitle(QStringLiteral("Terminal launch failed"));
                msgBox.setText(QStringLiteral("Failed to launch %1.").arg(terminalDisplayName(effective)));
                msgBox.setStandardButtons(QMessageBox::Ok);
                msgBox.setWindowModality(Qt::ApplicationModal);
                msgBox.exec();
            }
        }
    }
}

QString ConsoleManager::terminalCommand(const QString &scriptPath, int terminalChoice) const
{
    int effective = terminalChoice;
    if (!isTerminalAvailable(terminalChoice)) {
        logfile(QStringLiteral("Terminal %1 not found, falling back to %2")
                .arg(terminalDisplayName(terminalChoice), terminalDisplayName(0)));
        effective = 0;
    }
    if (m_os == Windows)
        return QStringLiteral("cmd.exe /c start \"\" ") + scriptPath;

    if (m_os == macOS) {
        switch (effective) {
        case 0:  return QStringLiteral("open -a Terminal.app ") + scriptPath;
        case 1:  return QStringLiteral("open -a iTerm.app ") + scriptPath;
        case 2:  return QStringLiteral("open -a Ghostty.app ") + scriptPath;
        default: return QStringLiteral("open -a Terminal.app ") + scriptPath;
        }
    }

    // Linux
    switch (effective) {
    case 0:  return QStringLiteral("/usr/bin/gnome-terminal -- ") + scriptPath;
    case 1:  return QStringLiteral("/usr/bin/xfce4-terminal -e ") + scriptPath;
    case 2:  return QStringLiteral("/usr/bin/konsole -e ") + scriptPath;
    case 3:  return QStringLiteral("/usr/bin/ghostty -e ") + scriptPath;
    default: return QStringLiteral("/usr/bin/gnome-terminal -- ") + scriptPath;
    }
}

void ConsoleManager::openConsole(const QString &scriptDir, const QString &appHome,
                                 const QString &dataBaseDir) const
{
    logfile("adb: " + getadbpath());
    logfile("detaching console process");

    QJsonObject obj;
    QJsonDocument doc(obj);
    QFile file(dataBaseDir + "adblink.json");
    (void)file.open(QIODevice::ReadOnly);
    doc = QJsonDocument::fromJson(file.readAll());
    obj = doc.object();
    int mcheck = obj["dropdown"].toInt();

    QString cstring;
    QString adbfilesDir = QCoreApplication::applicationDirPath() + "/adbfiles";

    if (m_os == Windows)
    {
        QString commstr = scriptDir + "/cpath.bat";
        QFile file(commstr);
        if (!file.open(QFile::WriteOnly | QFile::Text))
        {
            logfile("error creating cpath.bat!");
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.setWindowTitle(QString());
            msgBox.setText(QStringLiteral("Error creating bat file!"));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::ApplicationModal);
            msgBox.exec();
            return;
        }

        QTextStream out(&file);
        out << "echo off" << Qt::endl;
        if (getlocaladb().isEmpty())
            out << "set PATH=" + adbfilesDir + ";%PATH%" << Qt::endl;
        file.flush();
        file.close();

        QString outputString;
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QTextStream in(&file);
            outputString = in.readAll();
            file.close();
        }
        logfile("cpath.bat:");
        logfile(outputString);

        QProcess::startDetached("cmd.exe", QStringList() << "/c" << "start" << "" << commstr);
        return;
    }

    // macOS / Linux
    {
        QFileDevice::Permissions permissions = QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ExeOwner |
                                               QFileDevice::ReadGroup | QFileDevice::ExeGroup |
                                               QFileDevice::ReadOther | QFileDevice::ExeOther;

        QString commstr = scriptDir + "cpath.sh";
        QFile file(commstr);
        if (!file.open(QFile::WriteOnly | QFile::Text))
        {
            logfile("error creating cpath!");
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.setWindowTitle(QString());
            msgBox.setText(QStringLiteral("Error creating sh file!"));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::ApplicationModal);
            msgBox.exec();
            return;
        }

        QTextStream out(&file);
        out << "#!/bin/sh" << Qt::endl;
        if (getlocaladb().isEmpty())
            out << "export PATH=\"" + adbfilesDir + "\":$PATH" << Qt::endl;
        out << "/bin/sh" << Qt::endl;
        file.flush();
        file.close();

        QString outputString;
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QTextStream in(&file);
            outputString = in.readAll();
            file.close();
        }
        logfile("cpath.sh:");
        logfile(outputString);

        if (!file.setPermissions(permissions)) {
            logfile("Failed to set permissions for " + commstr);
            return;
        }
    }

    // Launch terminal
    {
        int effective = mcheck;
        bool fallback = false;
        if (!isTerminalAvailable(mcheck)) {
            logfile(QStringLiteral("Terminal %1 not found, falling back to %2")
                    .arg(terminalDisplayName(mcheck), terminalDisplayName(0)));
            effective = 0;
            fallback = true;
        }
        if (m_os == macOS)
        {
            switch (effective)
            {
            case 0:
                cstring = "open -a Terminal.app " + scriptDir + "cpath.sh";
                break;
            case 1:
                cstring = "open -a iTerm.app " + scriptDir + "cpath.sh";
                break;
            case 2:
                cstring = "open -a Ghostty.app " + scriptDir + "cpath.sh";
                break;
            default:
                cstring = "open -a Terminal.app " + scriptDir + "cpath.sh";
            }
        }
        else if (m_os == Linux)
        {
            switch (effective)
            {
            case 0:
                cstring = "/usr/bin/gnome-terminal --working-directory=" + appHome + " -x " + scriptDir + "cpath.sh";
                break;
            case 1:
                cstring = "/usr/bin/xfce4-terminal --working-directory=" + appHome + " -x " + scriptDir + "cpath.sh";
                break;
            case 2:
                cstring = "/usr/bin/konsole --workdir=" + appHome + " -e " + scriptDir + "cpath.sh";
                break;
            case 3:
                cstring = "/usr/bin/ghostty -e " + scriptDir + "cpath.sh";
                break;
            default:
                cstring = "/usr/bin/gnome-terminal --working-directory=" + appHome + " -x " + scriptDir + "cpath.sh";
            }
        }
        if (fallback) {
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Warning);
            msgBox.setWindowTitle(QStringLiteral("Terminal not found"));
            msgBox.setText(QStringLiteral("%1 not found. Falling back to %2. Change the terminal in Preferences.")
                           .arg(terminalDisplayName(mcheck), terminalDisplayName(effective)));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::ApplicationModal);
            msgBox.exec();
        }
    }

    {
        QStringList parts = QProcess::splitCommand(cstring);
        if (!parts.isEmpty()) {
            if (!QProcess::startDetached(parts.takeFirst(), parts)) {
                logfile(QStringLiteral("Failed to launch terminal: ") + cstring);
                QMessageBox msgBox;
                msgBox.setIcon(QMessageBox::Warning);
                msgBox.setWindowTitle(QStringLiteral("Terminal launch failed"));
                msgBox.setText(QStringLiteral("Failed to launch %1.").arg(terminalDisplayName(mcheck)));
                msgBox.setStandardButtons(QMessageBox::Ok);
                msgBox.setWindowModality(Qt::ApplicationModal);
                msgBox.exec();
            }
        }
    }
}

void ConsoleManager::openAdbShell(const QString &daddr, const QString &scriptDir,
                                   const QString &appHome, const QString &dataBaseDir) const
{
    logfile("adb: " + getadbpath());
    logfile("detaching console process");

    QJsonObject obj;
    QJsonDocument doc(obj);
    QFile file(dataBaseDir + "adblink.json");
    (void)file.open(QIODevice::ReadOnly);
    doc = QJsonDocument::fromJson(file.readAll());
    obj = doc.object();
    int mcheck = obj["dropdown"].toInt();

    QString cstring;

    if (m_os == Windows)
    {
        QString commstr = scriptDir + "/shell.bat";
        QFile file(commstr);
        if (!file.open(QFile::WriteOnly | QFile::Text))
        {
            logfile("error creating shell.bat!");
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.setWindowTitle(QString());
            msgBox.setText(QStringLiteral("Error creating bat file!"));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::ApplicationModal);
            msgBox.exec();
            return;
        }

        QTextStream out(&file);
        out << "echo off" << Qt::endl;
        QString adbPath = getadbpath();
        QFileInfo adbInfo(adbPath);
        out << "set PATH=" + adbInfo.absolutePath() + ";%PATH%" << Qt::endl;
        out << "\"" + adbPath + "\" -s " + daddr + " shell -t \"export PATH=\\\"$PATH:/data/local/tmp/adblink\\\"; export PS1=\\\"$HOSTNAME:$PWD\\\\$\\\"; sh -i\"" << Qt::endl;
        file.flush();
        file.close();

        QString outputString;
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QTextStream in(&file);
            outputString = in.readAll();
            file.close();
        }
        logfile("shell.bat:");
        logfile(outputString);

        QProcess::startDetached("cmd.exe", QStringList() << "/c" << "start" << "" << commstr);
        return;
    }

    // macOS / Linux
    {
        QString commstr = scriptDir + "console.sh";
        QFile::remove(commstr);
        QFile file(commstr);
        if (!file.open(QFile::WriteOnly))
        {
            logfile("error creating console.sh!");
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.setWindowTitle(QString());
            msgBox.setText(QStringLiteral("Error creating command file!"));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::ApplicationModal);
            msgBox.exec();
            return;
        }

        QTextStream out(&file);
        out << "#!/bin/sh" << Qt::endl;
        QString adbPath = getadbpath();
        out << "\"" + adbPath + "\" -s " + daddr + " shell -t \"export PATH=\\$PATH:/data/local/tmp/adblink; sh -i\"" << Qt::endl;
        out << cstring << Qt::endl;
        file.flush();
        file.close();

        QString outputString;
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QTextStream in(&file);
            outputString = in.readAll();
            file.close();
        }
        logfile("console.sh:");
        logfile(outputString);

        QString shelldir = '"' + scriptDir + "console.sh" + '"';

        QFileDevice::Permissions permissions = QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ExeOwner |
                                               QFileDevice::ReadGroup | QFileDevice::ExeGroup |
                                               QFileDevice::ReadOther | QFileDevice::ExeOther;

        if (!file.setPermissions(permissions)) {
            logfile("Failed to set permissions for " + shelldir);
            return;
        }

        {
            int effective = mcheck;
            bool fallback = false;
            if (!isTerminalAvailable(mcheck)) {
                logfile(QStringLiteral("Terminal %1 not found, falling back to %2")
                        .arg(terminalDisplayName(mcheck), terminalDisplayName(0)));
                effective = 0;
                fallback = true;
            }
            if (m_os == Linux)
            {
                switch (effective)
                {
                case 0:
                    cstring = "/usr/bin/gnome-terminal --working-directory=" + appHome + " -x " + shelldir;
                    break;
                case 1:
                    cstring = "/usr/bin/xfce4-terminal --working-directory=" + appHome + " -x " + shelldir;
                    break;
                case 2:
                    cstring = "/usr/bin/konsole --workdir=" + appHome + " -e " + shelldir;
                    break;
                case 3:
                    cstring = "/usr/bin/ghostty -e " + shelldir;
                    break;
                default:
                    cstring = "/usr/bin/gnome-terminal --working-directory=" + appHome + " -x " + shelldir;
                }
            }

            if (m_os == macOS)
            {
                switch (effective)
                {
                case 0:
                    cstring = "open -a Terminal.app " + shelldir;
                    break;
                case 1:
                    cstring = "open -a iTerm.app " + shelldir;
                    break;
                case 2:
                    cstring = "open -a Ghostty.app " + shelldir;
                    break;
                default:
                    cstring = "open -a Terminal.app " + shelldir;
                }
            }
            if (fallback) {
                QMessageBox msgBox;
                msgBox.setIcon(QMessageBox::Warning);
                msgBox.setWindowTitle(QStringLiteral("Terminal not found"));
                msgBox.setText(QStringLiteral("%1 not found. Falling back to %2. Change the terminal in Preferences.")
                               .arg(terminalDisplayName(mcheck), terminalDisplayName(effective)));
                msgBox.setStandardButtons(QMessageBox::Ok);
                msgBox.setWindowModality(Qt::ApplicationModal);
                msgBox.exec();
            }
        }
    }

    {
        QStringList parts = QProcess::splitCommand(cstring);
        if (!parts.isEmpty()) {
            if (!QProcess::startDetached(parts.takeFirst(), parts)) {
                logfile(QStringLiteral("Failed to launch terminal: ") + cstring);
                QMessageBox msgBox;
                msgBox.setIcon(QMessageBox::Warning);
                msgBox.setWindowTitle(QStringLiteral("Terminal launch failed"));
                msgBox.setText(QStringLiteral("Failed to launch %1.").arg(terminalDisplayName(mcheck)));
                msgBox.setStandardButtons(QMessageBox::Ok);
                msgBox.setWindowModality(Qt::ApplicationModal);
                msgBox.exec();
            }
        }
    }
}

void ConsoleManager::openScrcpy(QWidget *parent, const QString &daddr,
                                 const QString &scriptDir, const QString &appHome,
                                 const QString &dataBaseDir, const QString &adbfilesDir,
                                 const QString &scrcpyDir, const QString &scrcpyarg) const
{
    logfile("starting scrcpy function");

    QJsonObject obj;
    QJsonDocument doc(obj);
    QFile file(dataBaseDir + "adblink.json");
    (void)file.open(QIODevice::ReadOnly);
    doc = QJsonDocument::fromJson(file.readAll());
    obj = doc.object();
    bool scrcpy = doc.object()["scrcpy"].toBool();
    int mcheck = obj["dropdown"].toInt();

    QString scrcpybat = scriptDir + "scrcpy.bat";
    QString scrcpytxt = scriptDir + "scrcpy.txt";
    QString line;

    if (QFileInfo(scrcpytxt).exists())
    {
        QFile argfile(scrcpytxt);
        if (!argfile.open(QIODevice::ReadOnly)) {
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Information);
            msgBox.setWindowTitle(QStringLiteral("error"));
            msgBox.setText(argfile.errorString());
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::ApplicationModal);
            msgBox.exec();
        }

        QTextStream in(&argfile);
        while (!in.atEnd()) {
            line = in.readLine();
        }
        argfile.close();
    }

    logfile("detaching scrcpy console process");

    if (!scrcpyarg.isEmpty())
        line = scrcpyarg;

    QString argval = scrcpyarg;
    if (scrcpy)
    {
        scpDialog dialog;
        dialog.setArgs(line);

        if (dialog.exec() == QDialog::Accepted)
            argval = dialog.scpArgs();
        else
            return;
    }

    QString sernum = " -s " + daddr + " ";
    QString cstring;

    if (m_os == Windows)
    {
        QString commstr2 = scriptDir + "/scrcpy.txt";
        QFile file2(commstr2);
        if (!file2.open(QFile::WriteOnly | QFile::Text))
        {
            logfile("error creating scrcpy.txt!");
            QMessageBox msgBox(parent);
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.setWindowTitle(QString());
            msgBox.setText(QStringLiteral("Error saving arguments!"));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::WindowModal);
            msgBox.exec();
            return;
        }
        QTextStream out2(&file2);
        out2 << argval << Qt::endl;
        file2.flush();
        file2.close();

        QString commstr = scriptDir + "/scrcpy.bat";
        QFile batFile(commstr);
        if (!batFile.open(QFile::WriteOnly | QFile::Text))
        {
            logfile("error creating scrcpy.bat!");
            QMessageBox msgBox2(parent);
            msgBox2.setIcon(QMessageBox::Critical);
            msgBox2.setWindowTitle(QString());
            msgBox2.setText(QStringLiteral("Error creating bat file!"));
            msgBox2.setStandardButtons(QMessageBox::Ok);
            msgBox2.setWindowModality(Qt::WindowModal);
            msgBox2.exec();
            return;
        }
        QTextStream out(&batFile);
        out << "set PATH=" + adbfilesDir + ";" + scrcpyDir + ";%PATH%" << Qt::endl;
        out << "scrcpy.exe -s " + daddr + " " + argval << Qt::endl;
        batFile.flush();
        batFile.close();

        QProcess::startDetached("cmd.exe", QStringList() << "/c" << "start" << "" << commstr);
        return;
    }

    // macOS / Linux
    {
        QString commstr2 = scriptDir + "/scrcpy.txt";
        QFile file2(commstr2);
        if (!file2.open(QFile::WriteOnly | QFile::Text))
        {
            logfile("error saving arguments!");
            QMessageBox msgBox(parent);
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.setWindowTitle(QString());
            msgBox.setText(QStringLiteral("Error saving arguments!"));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::WindowModal);
            msgBox.exec();
            return;
        }
        QTextStream out2(&file2);
        out2 << argval << Qt::endl;
        file2.flush();
        file2.close();

        QString commstr = scriptDir + "/scrcpy.sh";
        QFile shFile(commstr);
        if (!shFile.open(QFile::WriteOnly | QFile::Text))
        {
            logfile("error creating cpath!");
            QMessageBox msgBox2(parent);
            msgBox2.setIcon(QMessageBox::Critical);
            msgBox2.setWindowTitle(QString());
            msgBox2.setText(QStringLiteral("Error creating script!"));
            msgBox2.setStandardButtons(QMessageBox::Ok);
            msgBox2.setWindowModality(Qt::WindowModal);
            msgBox2.exec();
            return;
        }

        QTextStream out(&shFile);
        out << "#!/bin/sh" << Qt::endl;
        out << "scrcpy -s " + daddr + " " + argval << Qt::endl;
        shFile.flush();
        shFile.close();

        QFileDevice::Permissions permissions = QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ExeOwner |
                                               QFileDevice::ReadGroup | QFileDevice::ExeGroup |
                                               QFileDevice::ReadOther | QFileDevice::ExeOther;

        if (!shFile.setPermissions(permissions)) {
            logfile("Failed to set permissions for " + commstr);
            return;
        }
    }

    {
        int effective = mcheck;
        bool fallback = false;
        if (!isTerminalAvailable(mcheck)) {
            logfile(QStringLiteral("Terminal %1 not found, falling back to %2")
                    .arg(terminalDisplayName(mcheck), terminalDisplayName(0)));
            effective = 0;
            fallback = true;
        }
        if (m_os == macOS)
        {
            switch (effective)
            {
            case 0:
                cstring = "open -a Terminal.app " + scriptDir + "/scrcpy.sh";
                break;
            case 1:
                cstring = "open -a iTerm.app " + scriptDir + "/scrcpy.sh";
                break;
            case 2:
                cstring = "open -a Ghostty.app " + scriptDir + "/scrcpy.sh";
                break;
            default:
                cstring = "open -a Terminal.app " + scriptDir + "/scrcpy.sh";
            }
        }
        else if (m_os == Linux)
        {
            switch (effective)
            {
            case 0:
                cstring = "gnome-terminal --working-directory=" + QDir::fromNativeSeparators(appHome) + " -x " + scriptDir + "/scrcpy.sh";
                break;
            case 1:
                cstring = "xfce4-terminal --working-directory=" + QDir::fromNativeSeparators(appHome) + " -x " + scriptDir + "/scrcpy.sh";
                break;
            case 2:
                cstring = "konsole --workdir=" + QDir::fromNativeSeparators(appHome) + " -e " + scriptDir + "/scrcpy.sh";
                break;
            case 3:
                cstring = "/usr/bin/ghostty -e " + scriptDir + "/scrcpy.sh";
                break;
            default:
                cstring = "gnome-terminal --working-directory=" + QDir::fromNativeSeparators(appHome) + " -x " + scriptDir + "/scrcpy.sh";
            }
        }
        if (fallback) {
            QMessageBox msgBox(parent);
            msgBox.setIcon(QMessageBox::Warning);
            msgBox.setWindowTitle(QStringLiteral("Terminal not found"));
            msgBox.setText(QStringLiteral("%1 not found. Falling back to %2. Change the terminal in Preferences.")
                           .arg(terminalDisplayName(mcheck), terminalDisplayName(effective)));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setWindowModality(Qt::WindowModal);
            msgBox.exec();
        }
    }

    {
        QStringList parts = QProcess::splitCommand(cstring);
        if (!parts.isEmpty()) {
            if (!QProcess::startDetached(parts.takeFirst(), parts)) {
                logfile(QStringLiteral("Failed to launch terminal: ") + cstring);
                QMessageBox msgBox(parent);
                msgBox.setIcon(QMessageBox::Warning);
                msgBox.setWindowTitle(QStringLiteral("Terminal launch failed"));
                msgBox.setText(QStringLiteral("Failed to launch %1.").arg(terminalDisplayName(mcheck)));
                msgBox.setStandardButtons(QMessageBox::Ok);
                msgBox.setWindowModality(Qt::WindowModal);
                msgBox.exec();
            }
        }
    }
}