luxferre/bananarchy
1
0
Fork 0
Code Issues Actions Activity
Files
5646f03ebe5d73822b0c5b0a2b5ec91712f7dab0
bananarchy/src/dwm-plugins/modem_plugin.cpp
T

1904 lines
67 KiB
C++
Raw Blame History

// SPDX-License-Identifier: GPL-2.0-only
// Bananarchy Modem, Dual-SIM & PIN/PUK Manager Plugin (modem.so / xmodem)
#include "phone_data.h"
#include "../sxmo-dwm/dwm_plugin.h"
#include <X11/Xatom.h>
#include <X11/Xft/Xft.h>
#include <X11/Xutil.h>
#include <pango/pangoxft.h>
#include <poll.h>
#include <sys/stat.h>
#include <clocale>
#ifdef None
#undef None
#endif
namespace {
using namespace bananarchy;
volatile sig_atomic_t gRunning = 1;
void handleSignal(int) {
gRunning = 0;
}
enum class TabId {
SimCards = 0,
RadioInfo = 1,
AtConsole = 2,
ModemLog = 3,
};
enum class ModalMode {
None = 0,
SimActions = 1,
VerifyPin = 2,
UnblockPuk = 3,
TogglePinLock = 4,
ChangePin = 5,
UssdDialog = 6,
};
struct SimSlotInfo {
int slotNum = 1;
std::string state = "absent"; // present, absent, error
std::string rawState = "absent";
std::string appType = "none"; // usim, sim, none
std::string appState = "none";
std::string aid;
std::string pin1State = "not-initialized";
int pin1Retries = 0;
int puk1Retries = 0;
std::string upinState = "not-initialized";
int upinRetries = 0;
int upukRetries = 0;
bool isActiveProvisioned = false;
bool isPreferred = false;
bool needsPin() const {
return state == "present" &&
(pin1State == "enabled-not-verified" || appState == "pin1");
}
bool needsPuk() const {
return state == "present" &&
(pin1State == "blocked" || appState == "puk1");
}
bool isPinEnabled() const {
return pin1State == "enabled-not-verified" ||
pin1State == "enabled-verified" ||
pin1State == "blocked";
}
};
struct ModemStatusData {
bool qmiAvailable = false;
int preferredSlot = 1;
int primaryGwSlot = 0;
SimSlotInfo slots[2];
bool mmPresent = false;
std::string mmState = "nomodem";
std::string mmFailedReason;
std::string mmPowerState = "off";
std::string mmUnlockRequired;
int mmPinRetries = -1;
int mmPukRetries = -1;
std::string operatorName;
std::string operatorCode;
std::string accessTech;
int signalQuality = 0;
std::string imei;
std::string imei2;
std::string imeiSv;
std::string ownNumber;
std::string simDbusPath;
std::string simIccid;
std::string simOperatorName;
std::string currentModes;
int modePresetIdx = 0;
};
struct RadioModePreset {
const char* label;
const char* allowed;
const char* preferred;
};
constexpr RadioModePreset kRadioModes[] = {
{"2G/3G/4G (4G Pref)", "2g|3g|4g", "4g"},
{"2G/3G/4G (3G Pref)", "2g|3g|4g", "3g"},
{"2G/3G (3G Pref)", "2g|3g", "3g"},
{"4G LTE Only", "4g", "none"},
{"3G UMTS Only", "3g", "none"},
{"2G GSM Only", "2g", "none"},
};
constexpr int kNumRadioModes =
static_cast<int>(sizeof(kRadioModes) / sizeof(kRadioModes[0]));
struct ModemLogRow {
std::string timeStr;
std::string eventType;
std::string target;
std::string detail;
};
constexpr const char* kAtPresets[] = {
"AT",
"ATI",
"AT+CGSN",
"AT+CSQ",
"AT+CREG?",
"AT+COPS?",
"AT+CPIN?",
"AT+CCID",
"AT+CGDCONT?",
"AT+CGPADDR",
"AT+CFUN?",
"AT+CLCC",
};
constexpr int kNumAtPresets =
static_cast<int>(sizeof(kAtPresets) / sizeof(kAtPresets[0]));
enum class AtTextMode {
Upper = 0, // ABC
Lower = 1, // abc
Num = 2, // 123
Sym = 3, // Sym
};
const char* kAtTapMap[10] = {
" 0+=",
"+?=,1\"':;/-_",
"ABC2",
"DEF3",
"GHI4",
"JKL5",
"MNO6",
"PQRS7",
"TUV8",
"WXYZ9"
};
void parseKvLines(const std::string& text,
std::unordered_map<std::string, std::string>& out,
char sep) {
std::istringstream ss(text);
std::string line;
while (std::getline(ss, line)) {
size_t pos = line.find(sep);
if (pos == std::string::npos) continue;
std::string k = trimStr(line.substr(0, pos));
std::string v = trimStr(line.substr(pos + 1));
if (!k.empty()) {
out[k] = v;
}
}
}
ModemStatusData queryModemAndSimStatus() {
ModemStatusData d;
d.slots[0].slotNum = 1;
d.slots[1].slotNum = 2;
// 1. Query QMI UIM status for both physical slots via helper
std::string uimOut = runCaptureCmd(
"doas -n /usr/libexec/msm-modem-uim-selection status 2>/dev/null || "
"/usr/libexec/msm-modem-uim-selection status 2>/dev/null");
std::unordered_map<std::string, std::string> uimKv;
parseKvLines(uimOut, uimKv, '=');
d.qmiAvailable = (uimKv["MODEM_AVAILABLE"] == "1");
if (!uimKv["PREFERRED_SLOT"].empty()) {
d.preferredSlot = std::clamp(std::atoi(uimKv["PREFERRED_SLOT"].c_str()), 1, 2);
}
if (!uimKv["PRIMARY_GW_SLOT"].empty()) {
d.primaryGwSlot = std::atoi(uimKv["PRIMARY_GW_SLOT"].c_str());
}
for (int i = 0; i < 2; ++i) {
std::string pfx = "SLOT" + std::to_string(i + 1) + "_";
auto& s = d.slots[i];
s.slotNum = i + 1;
if (!uimKv[pfx + "STATE"].empty()) s.state = uimKv[pfx + "STATE"];
if (!uimKv[pfx + "RAW_STATE"].empty()) s.rawState = uimKv[pfx + "RAW_STATE"];
if (!uimKv[pfx + "APP_TYPE"].empty()) s.appType = uimKv[pfx + "APP_TYPE"];
if (!uimKv[pfx + "APP_STATE"].empty()) s.appState = uimKv[pfx + "APP_STATE"];
s.aid = uimKv[pfx + "AID"];
if (!uimKv[pfx + "PIN1_STATE"].empty()) s.pin1State = uimKv[pfx + "PIN1_STATE"];
if (!uimKv[pfx + "PIN1_RETRIES"].empty()) {
s.pin1Retries = std::atoi(uimKv[pfx + "PIN1_RETRIES"].c_str());
}
if (!uimKv[pfx + "PUK1_RETRIES"].empty()) {
s.puk1Retries = std::atoi(uimKv[pfx + "PUK1_RETRIES"].c_str());
}
if (!uimKv[pfx + "UPIN_STATE"].empty()) s.upinState = uimKv[pfx + "UPIN_STATE"];
if (!uimKv[pfx + "UPIN_RETRIES"].empty()) {
s.upinRetries = std::atoi(uimKv[pfx + "UPIN_RETRIES"].c_str());
}
if (!uimKv[pfx + "UPUK_RETRIES"].empty()) {
s.upukRetries = std::atoi(uimKv[pfx + "UPUK_RETRIES"].c_str());
}
s.isActiveProvisioned = (d.primaryGwSlot == (i + 1));
s.isPreferred = (d.preferredSlot == (i + 1));
}
// 2. Query ModemManager (-m any -K)
std::string mmOut = runCaptureCmd("mmcli -m any -K 2>/dev/null");
std::unordered_map<std::string, std::string> mmKv;
parseKvLines(mmOut, mmKv, ':');
auto cleanMmVal = [](const std::string& v) -> std::string {
return (v == "--") ? "" : v;
};
if (!mmKv["modem.dbus-path"].empty()) {
d.mmPresent = true;
d.mmState = cleanMmVal(mmKv["modem.generic.state"]);
d.mmFailedReason = cleanMmVal(mmKv["modem.generic.state-failed-reason"]);
d.mmPowerState = cleanMmVal(mmKv["modem.generic.power-state"]);
d.mmUnlockRequired = cleanMmVal(mmKv["modem.generic.unlock-required"]);
d.operatorName = cleanMmVal(mmKv["modem.3gpp.operator-name"]);
d.operatorCode = cleanMmVal(mmKv["modem.3gpp.operator-code"]);
d.accessTech = cleanMmVal(mmKv["modem.generic.access-technologies.value[1]"]);
if (d.accessTech.empty()) {
d.accessTech = cleanMmVal(mmKv["modem.generic.access-technologies"]);
}
std::string sigStr = cleanMmVal(mmKv["modem.generic.signal-quality.value"]);
if (!sigStr.empty()) {
d.signalQuality = std::clamp(std::atoi(sigStr.c_str()), 0, 100);
}
d.imei = cleanMmVal(mmKv["modem.3gpp.imei"]);
if (d.imei.empty()) {
d.imei = cleanMmVal(mmKv["modem.generic.equipment-identifier"]);
}
DeviceImeis devImeis = queryDeviceImeis();
if (!devImeis.imei1.empty()) d.imei = devImeis.imei1;
if (!devImeis.imei2.empty()) d.imei2 = devImeis.imei2;
if (!devImeis.imeiSv.empty()) d.imeiSv = devImeis.imeiSv;
if (d.imei2.empty()) d.imei2 = d.imei;
d.ownNumber = cleanMmVal(mmKv["modem.generic.own-numbers.value[1]"]);
d.simDbusPath = cleanMmVal(mmKv["modem.generic.sim"]);
d.currentModes = cleanMmVal(mmKv["modem.generic.current-modes"]);
if (d.currentModes.find("allowed: 2g, 3g, 4g; preferred: 4g") != std::string::npos) {
d.modePresetIdx = 0;
} else if (d.currentModes.find("allowed: 2g, 3g, 4g; preferred: 3g") != std::string::npos) {
d.modePresetIdx = 1;
} else if (d.currentModes.find("allowed: 2g, 3g; preferred: 3g") != std::string::npos) {
d.modePresetIdx = 2;
} else if (d.currentModes.find("allowed: 4g") != std::string::npos) {
d.modePresetIdx = 3;
} else if (d.currentModes.find("allowed: 3g") != std::string::npos) {
d.modePresetIdx = 4;
} else if (d.currentModes.find("allowed: 2g") != std::string::npos) {
d.modePresetIdx = 5;
}
// Parse unlock-retries if present, e.g. "sim-pin (3), sim-puk (10)"
for (int idx = 1; idx <= 6; ++idx) {
std::string rk = "modem.generic.unlock-retries.value[" + std::to_string(idx) + "]";
std::string rv = cleanMmVal(mmKv[rk]);
if (rv.empty()) break;
if (rv.find("sim-pin (") != std::string::npos) {
size_t p = rv.find('(');
if (p != std::string::npos) d.mmPinRetries = std::atoi(rv.c_str() + p + 1);
} else if (rv.find("sim-puk (") != std::string::npos) {
size_t p = rv.find('(');
if (p != std::string::npos) d.mmPukRetries = std::atoi(rv.c_str() + p + 1);
}
}
}
// 3. Query active SIM object if available
if (!d.simDbusPath.empty()) {
std::string simOut = runCaptureCmd(
"mmcli -i " + shellQuote(d.simDbusPath) + " -K 2>/dev/null");
std::unordered_map<std::string, std::string> simKv;
parseKvLines(simOut, simKv, ':');
d.simIccid = cleanMmVal(simKv["sim.properties.iccid"]);
d.simOperatorName = cleanMmVal(simKv["sim.properties.operator-name"]);
if (d.operatorName.empty() && !d.simOperatorName.empty()) {
d.operatorName = d.simOperatorName;
}
}
// Sync ModemManager lock info into active slot if QMI didn't report retries
int actIdx = (d.primaryGwSlot >= 1 && d.primaryGwSlot <= 2)
? (d.primaryGwSlot - 1)
: (d.preferredSlot - 1);
if (actIdx >= 0 && actIdx < 2) {
if (d.mmUnlockRequired == "sim-pin" && d.slots[actIdx].pin1State == "not-initialized") {
d.slots[actIdx].state = "present";
d.slots[actIdx].pin1State = "enabled-not-verified";
} else if (d.mmUnlockRequired == "sim-puk") {
d.slots[actIdx].state = "present";
d.slots[actIdx].pin1State = "blocked";
}
if (d.mmPinRetries >= 0 && d.slots[actIdx].pin1Retries == 0) {
d.slots[actIdx].pin1Retries = d.mmPinRetries;
}
if (d.mmPukRetries >= 0 && d.slots[actIdx].puk1Retries == 0) {
d.slots[actIdx].puk1Retries = d.mmPukRetries;
}
}
return d;
}
std::vector<ModemLogRow> loadRecentModemLog(const ContactBook& book,
size_t maxEntries = 80) {
std::vector<ModemLogRow> out;
std::ifstream in(getModemLogFilePath());
if (!in.is_open()) return out;
std::vector<std::string> lines;
std::string line;
while (std::getline(in, line)) {
if (!line.empty()) lines.push_back(line);
}
for (auto it = lines.rbegin();
it != lines.rend() && out.size() < maxEntries; ++it) {
size_t t1 = it->find('\t');
if (t1 == std::string::npos) continue;
size_t t2 = it->find('\t', t1 + 1);
if (t2 == std::string::npos) continue;
size_t t3 = it->find('\t', t2 + 1);
ModemLogRow row;
row.timeStr = formatShortTime(trimStr(it->substr(0, t1)));
row.eventType = trimStr(it->substr(t1 + 1, t2 - t1 - 1));
std::string rawNum = trimStr(
t3 == std::string::npos ? it->substr(t2 + 1)
: it->substr(t2 + 1, t3 - t2 - 1));
std::string cname = book.resolveName(rawNum);
row.target = cname.empty() ? rawNum : (cname + " (" + rawNum + ")");
if (t3 != std::string::npos) {
row.detail = trimStr(it->substr(t3 + 1));
}
out.push_back(row);
}
return out;
}
int runModemApp(int argc, char** argv) {
gRunning = 1;
std::setlocale(LC_ALL, "");
XSetLocaleModifiers("");
bool isPreload = false;
std::string openArg;
for (int i = 1; i < argc; ++i) {
if (!argv[i]) continue;
if (std::strcmp(argv[i], "--preload") == 0) {
isPreload = true;
} else if (argv[i][0] != '-' && openArg.empty()) {
openArg = argv[i];
}
}
std::string daemonPidPath = getPluginDaemonPidPath("modem");
std::string activePidPath = getRuntimeFile("xmodem.pid");
if (isPluginDaemonAlive("modem")) {
if (!isPreload) {
sendPluginCommand("modem",
openArg.empty() ? "OPEN" : ("OPEN " + openArg));
}
return 0;
}
writeIntFile(daemonPidPath, static_cast<int>(::getpid()));
int fifoFd = setupPluginDaemonFifo("modem");
struct sigaction sa {};
sa.sa_handler = handleSignal;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, nullptr);
sigaction(SIGTERM, &sa, nullptr);
Display* dpy = XOpenDisplay(nullptr);
if (!dpy) {
if (fifoFd >= 0) ::close(fifoFd);
::unlink(daemonPidPath.c_str());
return 1;
}
int screen = DefaultScreen(dpy);
Window root = RootWindow(dpy, screen);
Visual* visual = DefaultVisual(dpy, screen);
Colormap cmap = DefaultColormap(dpy, screen);
ThemeSpec initSpec;
initSpec.loadActive(dpy, screen);
XSetWindowAttributes swa {};
swa.override_redirect = True;
swa.background_pixel = initSpec.bgMain;
swa.border_pixel = initSpec.selBg;
swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask |
VisibilityChangeMask | StructureNotifyMask;
Window win = XCreateWindow(
dpy, root, kWinX, kWinY, kWinWidth, kWinHeight, 0,
DefaultDepth(dpy, screen), CopyFromParent, visual,
CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWEventMask, &swa);
XClassHint ch {};
char resName[] = "xmodem";
char resClass[] = "XModem";
ch.res_name = resName;
ch.res_class = resClass;
XSetClassHint(dpy, win, &ch);
XStoreName(dpy, win, "Modem & SIM");
Pixmap pix = XCreatePixmap(dpy, win, kWinWidth, kWinHeight,
DefaultDepth(dpy, screen));
GC gc = XCreateGC(dpy, pix, 0, nullptr);
XftDraw* xftDraw = XftDrawCreate(dpy, pix, visual, cmap);
PluginTheme pt;
pt.init(dpy, screen, visual, cmap, win);
auto& layoutMain = pt.layoutMain;
auto& layoutSmall = pt.layoutSmall;
auto& layoutIcon = pt.layoutIcon;
auto& colWhite = pt.colWhite;
auto& colLight = pt.colLight;
auto& colMuted = pt.colMuted;
auto& colYellow = pt.colYellow;
auto& colGreen = pt.colGreen;
auto& colBlue = pt.colBlue;
auto& colOrange = pt.colOrange;
auto& colRed = pt.colRed;
ContactBook book;
ModemStatusData status;
std::vector<ModemLogRow> logRows;
TabId activeTab = TabId::SimCards;
ModalMode modal = ModalMode::None;
int simRowSel = 0; // 0 = SIM 1, 1 = SIM 2, 2 = Switch Active, 3 = Unlock PIN/PUK, 4 = PIN Lock Toggle, 5 = Change PIN
int radioRowSel = 0; // 0 = Network Mode, 1 = USSD, 2 = Modem Power, 3 = Restart MM, 4 = Refresh
int logRowSel = 0;
int actionSel = 0;
int targetSlot = 1;
// PIN / PUK / Change PIN wizard state
int wizardStep = 0;
bool revealDigits = false;
std::string inputPin1;
std::string inputPin2;
std::string inputPin3;
std::string modalError;
// USSD state
std::string ussdInput = "*100#";
std::string ussdResponse;
bool ussdWaitingReply = false;
// AT Console state
int atFocusRow = 0; // 0 = Input, 1 = Preset/Port, 2 = Output scroll
int atPresetIdx = 0;
int atPortIdx = 0; // 0 = auto, 1 = wwan0at0, 2 = wwan0at1
std::string atInput = "AT";
std::string atOutput = "Enter an AT command and press Send.\nUse Preset row (< >) for common commands.";
int atScrollLine = 0;
AtTextMode atTextMode = AtTextMode::Upper;
int atLastTapKey = -1;
int atLastTapIdx = 0;
int64_t atLastTapMs = 0;
std::string statusBanner;
int64_t statusBannerUntilMs = 0;
bool visible = false;
int64_t openStartMs = 0;
int64_t startupIgnoreUntilMs = 0;
int64_t lastRefreshMs = 0;
bool initialSoftkeysReleased = true;
int softkeyPending = 0;
int64_t softkeyDeadlineMs = 0;
auto setBanner = [&](const std::string& msg, int durationMs = 2400) {
statusBanner = msg;
statusBannerUntilMs = nowMs() + durationMs;
};
auto refreshData = [&](bool reloadLog = false) {
status = queryModemAndSimStatus();
if (reloadLog || activeTab == TabId::ModemLog) {
book.load();
logRows = loadRecentModemLog(book);
if (logRowSel >= static_cast<int>(logRows.size())) {
logRowSel = std::max(0, static_cast<int>(logRows.size()) - 1);
}
}
lastRefreshMs = nowMs();
};
auto openPinOrPukModalForSlot = [&](int slotNum) {
targetSlot = std::clamp(slotNum, 1, 2);
const auto& s = status.slots[targetSlot - 1];
wizardStep = 0;
revealDigits = false;
inputPin1.clear();
inputPin2.clear();
inputPin3.clear();
modalError.clear();
if (s.needsPuk() || status.mmUnlockRequired == "sim-puk") {
modal = ModalMode::UnblockPuk;
} else {
modal = ModalMode::VerifyPin;
}
};
auto applyOpenArg = [&](const std::string& arg) {
std::string a = toLowerStr(trimStr(arg));
modal = ModalMode::None;
if (a == "unlock" || a == "pin" || a == "puk") {
activeTab = TabId::SimCards;
int lockSlot = (status.primaryGwSlot >= 1 && status.primaryGwSlot <= 2)
? status.primaryGwSlot
: status.preferredSlot;
if (status.slots[0].needsPin() || status.slots[0].needsPuk()) {
lockSlot = 1;
} else if (status.slots[1].needsPin() || status.slots[1].needsPuk()) {
lockSlot = 2;
}
simRowSel = lockSlot - 1;
openPinOrPukModalForSlot(lockSlot);
} else if (a == "info" || a == "status" || a == "radio") {
activeTab = TabId::RadioInfo;
} else if (a == "log" || a == "logs") {
activeTab = TabId::ModemLog;
book.load();
logRows = loadRecentModemLog(book);
} else if (a == "at" || a == "atcmd") {
activeTab = TabId::AtConsole;
} else if (a == "ussd") {
activeTab = TabId::RadioInfo;
modal = ModalMode::UssdDialog;
ussdResponse.clear();
ussdWaitingReply = false;
} else {
activeTab = TabId::SimCards;
// If active SIM is locked, auto-highlight it
if (status.slots[0].needsPin() || status.slots[0].needsPuk()) {
simRowSel = 0;
} else if (status.slots[1].needsPin() || status.slots[1].needsPuk()) {
simRowSel = 1;
}
}
};
auto drawPango = [&](PangoLayout* layout, XftColor* color, int x, int y, int h,
const std::string& text, int maxW = -1) -> int {
pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.size()));
if (maxW > 0) {
pango_layout_set_width(layout, maxW * PANGO_SCALE);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
} else {
pango_layout_set_width(layout, -1);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
}
int tw = 0, th = 0;
pango_layout_get_pixel_size(layout, &tw, &th);
int dy = y + std::max(0, (h - th) / 2);
pango_xft_render_layout(xftDraw, color, layout, x * PANGO_SCALE,
dy * PANGO_SCALE);
return tw;
};
auto pangoTextWidth = [&](PangoLayout* layout, const std::string& text) -> int {
pango_layout_set_width(layout, -1);
pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.size()));
int tw = 0, th = 0;
pango_layout_get_pixel_size(layout, &tw, &th);
return tw;
};
auto drawSoftkeyBar = [&](const std::string& leftLabel,
const std::string& centerLabel,
const std::string& rightLabel) {
const int barY = kWinHeight - 26;
XSetForeground(dpy, gc, pt.spec.bgFooter);
XFillRectangle(dpy, pix, gc, 0, barY, kWinWidth, 26);
XSetForeground(dpy, gc, pt.spec.divider);
XDrawLine(dpy, pix, gc, 0, barY, kWinWidth, barY);
drawPango(layoutMain, &colBlue, 6, barY, 26, leftLabel);
int cw = pangoTextWidth(layoutMain, centerLabel);
drawPango(layoutMain, &colWhite, (kWinWidth - cw) / 2, barY, 26, centerLabel);
int rw = pangoTextWidth(layoutMain, rightLabel);
drawPango(layoutMain, &colLight, kWinWidth - rw - 6, barY, 26, rightLabel);
};
auto drawSignalBars = [&](int x, int y, int pct) {
int bars = (pct <= 0) ? 0 : (pct < 25 ? 1 : (pct < 50 ? 2 : (pct < 75 ? 3 : 4)));
for (int i = 0; i < 4; ++i) {
int bh = 4 + i * 3;
int bx = x + i * 5;
int by = y + (14 - bh);
XSetForeground(dpy, gc, (i < bars) ? pt.spec.success : pt.spec.border);
XFillRectangle(dpy, pix, gc, bx, by, 3, bh);
}
};
auto maskPinStr = [&](const std::string& s) -> std::string {
if (revealDigits) return s;
return std::string(s.size(), '*');
};
auto render = [&]() {
if (!visible) return;
pt.checkAndReload();
XSetForeground(dpy, gc, pt.spec.bgMain);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, kWinHeight);
// Top Tab Bar (Y=0..30)
XSetForeground(dpy, gc, pt.spec.bgHeader);
XFillRectangle(dpy, pix, gc, 0, 0, kWinWidth, 30);
XSetForeground(dpy, gc, pt.spec.border);
XDrawLine(dpy, pix, gc, 0, 29, kWinWidth, 29);
const char* tabLabels[4] = {"1:SIMs", "2:Radio", "3:AT", "4:Log"};
int tabW = kWinWidth / 4;
for (int t = 0; t < 4; ++t) {
bool isSel = (static_cast<int>(activeTab) == t);
if (isSel) {
XSetForeground(dpy, gc, pt.spec.selBg);
XFillRectangle(dpy, pix, gc, t * tabW, 0, tabW, 29);
XSetForeground(dpy, gc, pt.spec.accent);
XFillRectangle(dpy, pix, gc, t * tabW, 27, tabW, 2);
}
int tw = pangoTextWidth(layoutSmall, tabLabels[t]);
drawPango(layoutSmall, isSel ? &colWhite : &colMuted,
t * tabW + (tabW - tw) / 2, 0, 28, tabLabels[t]);
}
const int contentY = 32;
const int contentH = kWinHeight - 32 - 26;
if (activeTab == TabId::SimCards) {
// Draw SIM 1 & SIM 2 Cards (height 68px each)
for (int i = 0; i < 2; ++i) {
const auto& s = status.slots[i];
int cardY = contentY + i * 70;
bool rowSelected = (simRowSel == i);
XSetForeground(dpy, gc, rowSelected ? pt.spec.selBg : pt.spec.bgAltEven);
XFillRectangle(dpy, pix, gc, 4, cardY, kWinWidth - 8, 66);
XSetForeground(dpy, gc, rowSelected ? pt.spec.accent : pt.spec.border);
XDrawRectangle(dpy, pix, gc, 4, cardY, kWinWidth - 9, 65);
drawPango(layoutIcon, s.state == "present" ? &colGreen : &colMuted,
10, cardY + 2, 22, kIconSim);
std::string title = "SIM Slot " + std::to_string(s.slotNum);
if (s.isActiveProvisioned) {
title += " [ACTIVE]";
} else if (s.isPreferred) {
title += " [PREF]";
}
drawPango(layoutMain, rowSelected ? &colWhite : &colLight,
30, cardY + 2, 22, title, 198);
std::string line2;
XftColor* line2Col = &colMuted;
if (s.state == "present") {
if (s.needsPuk()) {
line2 = "BLOCKED (Enter PUK)";
line2Col = &colRed;
} else if (s.needsPin()) {
line2 = "LOCKED (Enter PIN)";
line2Col = &colOrange;
} else if (s.isActiveProvisioned) {
std::string op = status.operatorName.empty() ? "Ready" : status.operatorName;
if (!status.ownNumber.empty()) op += " " + status.ownNumber;
line2 = op;
line2Col = &colGreen;
} else {
line2 = "Present (Standby " + s.appType + ")";
line2Col = &colBlue;
}
} else if (s.state == "error") {
line2 = "No SIM (No ATR)";
} else {
line2 = "Empty Slot";
}
drawPango(layoutSmall, line2Col, 10, cardY + 24, 20, line2, 220);
std::string line3;
if (s.state == "present") {
std::string pState = s.pin1State;
if (pState == "enabled-not-verified") pState = "PIN Req";
else if (pState == "enabled-verified") pState = "PIN On";
else if (pState == "disabled") pState = "PIN Off";
else if (pState == "blocked") pState = "PUK Req";
line3 = pState + " (PIN:" + std::to_string(s.pin1Retries) +
" PUK:" + std::to_string(s.puk1Retries) + ")";
} else {
line3 = "Insert nano-SIM & restart/switch";
}
drawPango(layoutSmall, rowSelected ? &colLight : &colMuted,
10, cardY + 44, 18, line3, 220);
}
// Quick Action Rows below the 2 SIM cards (4 rows, 24px each)
int actSlot = (simRowSel == 1) ? 2 : 1;
int otherSlot = (status.preferredSlot == 1) ? 2 : 1;
std::string quickRows[4] = {
std::string(kIconRefresh) + " Switch Active to SIM " + std::to_string(otherSlot),
std::string(kIconUnlock) + " Unlock SIM (PIN / PUK)",
std::string(kIconLock) + " Enable / Disable SIM PIN",
std::string(kIconKey) + " Change SIM PIN Code",
};
(void)actSlot;
int baseY = contentY + 142;
for (int r = 0; r < 4; ++r) {
int ry = baseY + r * 23;
bool isSel = (simRowSel == (r + 2));
XSetForeground(dpy, gc, isSel ? pt.spec.selBg : ((r % 2 == 0) ? pt.spec.bgAltEven : pt.spec.bgAltOdd));
XFillRectangle(dpy, pix, gc, 4, ry, kWinWidth - 8, 22);
drawPango(layoutSmall, isSel ? &colWhite : &colLight,
10, ry, 22, quickRows[r], kWinWidth - 20);
}
drawSoftkeyBar("Actions", "Select", "Close");
} else if (activeTab == TabId::RadioInfo) {
// Modem summary card (height 102px)
XSetForeground(dpy, gc, pt.spec.bgAltEven);
XFillRectangle(dpy, pix, gc, 4, contentY, kWinWidth - 8, 102);
XSetForeground(dpy, gc, pt.spec.border);
XDrawRectangle(dpy, pix, gc, 4, contentY, kWinWidth - 9, 101);
std::string stStr = status.mmPresent ? status.mmState : "nomodem";
if (!status.mmFailedReason.empty()) {
stStr += " (" + status.mmFailedReason + ")";
}
XftColor* stCol = &colRed;
if (status.mmState == "connected" || status.mmState == "registered") {
stCol = &colGreen;
} else if (status.mmState == "searching" || status.mmState == "connecting") {
stCol = &colOrange;
}
drawPango(layoutMain, stCol, 10, contentY + 2, 22,
"State: " + stStr, 185);
drawSignalBars(kWinWidth - 32, contentY + 6, status.signalQuality);
std::string opLine = "Operator: " +
(status.operatorName.empty() ? "--" : status.operatorName);
if (!status.accessTech.empty()) {
opLine += " [" + status.accessTech + "]";
}
drawPango(layoutSmall, &colLight, 10, contentY + 24, 18, opLine, 220);
std::string sigLine = "Signal: " + std::to_string(status.signalQuality) +
"% | Slot: SIM " +
(status.primaryGwSlot > 0 ? std::to_string(status.primaryGwSlot) : "--");
drawPango(layoutSmall, &colLight, 10, contentY + 42, 18, sigLine, 220);
std::string imei1Line = "IMEI 1: " + (status.imei.empty() ? "--" : status.imei);
drawPango(layoutSmall, &colMuted, 10, contentY + 60, 18, imei1Line, 220);
std::string imei2Line = "IMEI 2: " + (status.imei2.empty() ? "--" : status.imei2);
drawPango(layoutSmall, &colMuted, 10, contentY + 78, 18, imei2Line, 220);
// 5 Interactive Radio Control Rows
std::string modeLabel = kRadioModes[status.modePresetIdx].label;
bool powerOn = (status.mmPowerState == "on" || status.mmState == "registered" ||
status.mmState == "connected" || status.mmState == "searching");
std::string radioRows[5] = {
std::string(kIconSignal) + " Mode: < " + modeLabel + " >",
std::string(kIconPhone) + " USSD Code (" + ussdInput + ")",
std::string(kIconFlash) + " Radio Power: " + (powerOn ? "ON" : "OFF"),
std::string(kIconRefresh) + " Restart ModemManager",
std::string(kIconInfo) + " Refresh Status Now",
};
int baseY = contentY + 106;
for (int r = 0; r < 5; ++r) {
int ry = baseY + r * 25;
bool isSel = (radioRowSel == r);
XSetForeground(dpy, gc, isSel ? pt.spec.selBg : ((r % 2 == 0) ? pt.spec.bgAltEven : pt.spec.bgAltOdd));
XFillRectangle(dpy, pix, gc, 4, ry, kWinWidth - 8, 24);
drawPango(layoutSmall, isSel ? &colWhite : &colLight,
10, ry, 24, radioRows[r], kWinWidth - 20);
}
drawSoftkeyBar("Refresh", "Apply", "Close");
} else if (activeTab == TabId::AtConsole) {
const char* modeBadge = "[ABC]";
if (atTextMode == AtTextMode::Lower) modeBadge = "[abc]";
else if (atTextMode == AtTextMode::Num) modeBadge = "[123]";
else if (atTextMode == AtTextMode::Sym) modeBadge = "[Sym]";
const char* portNames[3] = {"auto", "wwan0at0", "wwan0at1"};
const char* portLabels[3] = {"Auto", "SIM1 (at0)", "SIM2 (at1)"};
(void)portNames;
// Row 0: AT Command Input Box (Y=contentY..contentY+46)
drawPango(layoutSmall, &colYellow, 8, contentY, 18,
std::string(kIconTerm) + " AT Command (# mode, * +?=):");
int mbW = pangoTextWidth(layoutSmall, modeBadge);
drawPango(layoutSmall, &colGreen, kWinWidth - mbW - 8, contentY, 18, modeBadge);
bool focus0 = (atFocusRow == 0);
XSetForeground(dpy, gc, focus0 ? pt.spec.bgInputFocus : pt.spec.bgAltEven);
XFillRectangle(dpy, pix, gc, 6, contentY + 19, kWinWidth - 12, 26);
XSetForeground(dpy, gc, focus0 ? pt.spec.accent : pt.spec.border);
XDrawRectangle(dpy, pix, gc, 6, contentY + 19, kWinWidth - 13, 25);
drawPango(layoutMain, &colWhite, 12, contentY + 19, 26,
atInput + (focus0 ? "_" : ""), kWinWidth - 24);
// Row 1: Preset & AT Port Selector (Y=contentY+49..contentY+73)
bool focus1 = (atFocusRow == 1);
XSetForeground(dpy, gc, focus1 ? pt.spec.selBg : pt.spec.bgAltOdd);
XFillRectangle(dpy, pix, gc, 6, contentY + 48, kWinWidth - 12, 24);
std::string presetRow = "< Preset: " + std::string(kAtPresets[atPresetIdx]) +
" | *Port: " + portLabels[atPortIdx] + " >";
drawPango(layoutSmall, focus1 ? &colWhite : &colLight,
10, contentY + 48, 24, presetRow, kWinWidth - 20);
// Row 2: AT Response Output Area (Y=contentY+75..contentY+contentH-2)
bool focus2 = (atFocusRow == 2);
int outY = contentY + 75;
int outH = contentH - 77;
XSetForeground(dpy, gc, pt.spec.bgAltEven);
XFillRectangle(dpy, pix, gc, 6, outY, kWinWidth - 12, outH);
XSetForeground(dpy, gc, focus2 ? pt.spec.accent : pt.spec.border);
XDrawRectangle(dpy, pix, gc, 6, outY, kWinWidth - 13, outH - 1);
pango_layout_set_width(layoutSmall, (kWinWidth - 24) * PANGO_SCALE);
pango_layout_set_wrap(layoutSmall, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize(layoutSmall, PANGO_ELLIPSIZE_NONE);
pango_layout_set_text(layoutSmall, atOutput.c_str(),
static_cast<int>(atOutput.size()));
int lineCount = pango_layout_get_line_count(layoutSmall);
int maxVisLines = std::max(1, (outH - 8) / 17);
if (atScrollLine > std::max(0, lineCount - maxVisLines)) {
atScrollLine = std::max(0, lineCount - maxVisLines);
}
int curY = outY + 4;
for (int li = atScrollLine;
li < lineCount && (li - atScrollLine) < maxVisLines; ++li) {
PangoLayoutLine* pl = pango_layout_get_line_readonly(layoutSmall, li);
if (pl) {
PangoRectangle ink{}, logical{};
pango_layout_line_get_pixel_extents(pl, &ink, &logical);
pango_xft_render_layout_line(
xftDraw, &colLight, pl, 12 * PANGO_SCALE,
(curY - logical.y) * PANGO_SCALE);
curY += std::max(16, logical.height + 1);
}
}
pango_layout_set_width(layoutSmall, -1);
drawSoftkeyBar("Send", "Send",
(atFocusRow == 0 && !atInput.empty()) ? "Clear" : "Close");
} else if (activeTab == TabId::ModemLog) {
if (logRows.empty()) {
drawPango(layoutMain, &colMuted, 16, contentY + 60, 24,
"No modem events logged.");
} else {
const int rowH = 38;
const int maxVis = contentH / rowH; // 6 rows
int startIdx = std::clamp(logRowSel - maxVis / 2, 0,
std::max(0, static_cast<int>(logRows.size()) - maxVis));
for (int i = 0; i < maxVis && (startIdx + i) < static_cast<int>(logRows.size()); ++i) {
int idx = startIdx + i;
const auto& row = logRows[idx];
int ry = contentY + i * rowH;
bool isSel = (idx == logRowSel);
XSetForeground(dpy, gc, isSel ? pt.spec.selBg
: ((i % 2 == 0) ? pt.spec.bgAltEven : pt.spec.bgAltOdd));
XFillRectangle(dpy, pix, gc, 0, ry, kWinWidth, rowH - 1);
const char* ic = kIconInfo;
XftColor* icCol = &colBlue;
if (row.eventType.find("missed") != std::string::npos) {
ic = kIconMissedCall;
icCol = &colRed;
} else if (row.eventType.find("call_") != std::string::npos) {
ic = kIconPhone;
icCol = &colGreen;
} else if (row.eventType.find("txt") != std::string::npos) {
ic = kIconSms;
icCol = &colYellow;
}
drawPango(layoutIcon, icCol, 6, ry + 2, 18, ic);
drawPango(layoutSmall, isSel ? &colWhite : &colLight,
26, ry + 2, 18, row.eventType + " | " + row.timeStr, 208);
std::string sub = row.target;
if (!row.detail.empty()) sub += " - " + row.detail;
drawPango(layoutSmall, isSel ? &colLight : &colMuted,
26, ry + 19, 17, sub, 208);
}
}
drawSoftkeyBar("Refresh", "Call/SMS", "Close");
}
// Modal Overlays
if (modal == ModalMode::SimActions) {
XSetForeground(dpy, gc, pt.spec.bgOverlay);
XFillRectangle(dpy, pix, gc, 12, 44, kWinWidth - 24, 196);
XSetForeground(dpy, gc, pt.spec.accent);
XDrawRectangle(dpy, pix, gc, 12, 44, kWinWidth - 25, 195);
std::string hdr = "SIM Slot " + std::to_string(targetSlot) + " Actions";
drawPango(layoutMain, &colYellow, 20, 48, 24, hdr, kWinWidth - 40);
const char* actLabels[5] = {
"Set as Active SIM Slot",
"Unlock SIM (Enter PIN)",
"Unblock SIM (Enter PUK)",
"Enable / Disable SIM PIN",
"Change SIM PIN Code",
};
for (int i = 0; i < 5; ++i) {
int ry = 76 + i * 30;
bool isSel = (actionSel == i);
XSetForeground(dpy, gc, isSel ? pt.spec.selBg : pt.spec.bgButton);
XFillRectangle(dpy, pix, gc, 18, ry, kWinWidth - 36, 26);
drawPango(layoutSmall, isSel ? &colWhite : &colLight,
24, ry, 26, actLabels[i], kWinWidth - 48);
}
drawSoftkeyBar("Select", "OK", "Back");
} else if (modal == ModalMode::VerifyPin ||
modal == ModalMode::UnblockPuk ||
modal == ModalMode::TogglePinLock ||
modal == ModalMode::ChangePin) {
XSetForeground(dpy, gc, pt.spec.bgOverlay);
XFillRectangle(dpy, pix, gc, 10, 40, kWinWidth - 20, 210);
XSetForeground(dpy, gc, pt.spec.accent);
XDrawRectangle(dpy, pix, gc, 10, 40, kWinWidth - 21, 209);
const auto& s = status.slots[targetSlot - 1];
std::string title;
std::string prompt;
std::string activeInput;
std::string retriesText;
if (modal == ModalMode::VerifyPin) {
title = "Unlock SIM " + std::to_string(targetSlot) + " (PIN)";
prompt = "Enter 4-8 digit SIM PIN:";
activeInput = maskPinStr(inputPin1);
retriesText = "PIN attempts remaining: " + std::to_string(s.pin1Retries);
} else if (modal == ModalMode::UnblockPuk) {
title = "Unblock SIM " + std::to_string(targetSlot) + " (PUK)";
retriesText = "PUK attempts remaining: " + std::to_string(s.puk1Retries);
if (wizardStep == 0) {
prompt = "Step 1/3: Enter 8-digit PUK:";
activeInput = revealDigits ? inputPin1 : inputPin1; // PUK is usually visible or toggleable
} else if (wizardStep == 1) {
prompt = "Step 2/3: Enter New PIN (4-8 digits):";
activeInput = maskPinStr(inputPin2);
} else {
prompt = "Step 3/3: Confirm New PIN:";
activeInput = maskPinStr(inputPin3);
}
} else if (modal == ModalMode::TogglePinLock) {
bool enableTarget = !s.isPinEnabled();
title = (enableTarget ? "Enable" : "Disable") +
std::string(" SIM ") + std::to_string(targetSlot) + " PIN";
prompt = "Enter current SIM PIN:";
activeInput = maskPinStr(inputPin1);
retriesText = "PIN attempts remaining: " + std::to_string(s.pin1Retries);
} else if (modal == ModalMode::ChangePin) {
title = "Change SIM " + std::to_string(targetSlot) + " PIN";
retriesText = "PIN attempts remaining: " + std::to_string(s.pin1Retries);
if (wizardStep == 0) {
prompt = "Step 1/3: Current SIM PIN:";
activeInput = maskPinStr(inputPin1);
} else if (wizardStep == 1) {
prompt = "Step 2/3: New SIM PIN (4-8 digits):";
activeInput = maskPinStr(inputPin2);
} else {
prompt = "Step 3/3: Confirm New SIM PIN:";
activeInput = maskPinStr(inputPin3);
}
}
drawPango(layoutMain, &colYellow, 18, 46, 24, title, kWinWidth - 36);
drawPango(layoutSmall, (s.pin1Retries <= 1 && s.pin1Retries > 0) ? &colRed : &colOrange,
18, 72, 20, retriesText, kWinWidth - 36);
drawPango(layoutSmall, &colLight, 18, 98, 20, prompt, kWinWidth - 36);
// Input box
XSetForeground(dpy, gc, pt.spec.bgInputFocus);
XFillRectangle(dpy, pix, gc, 18, 122, kWinWidth - 36, 34);
XSetForeground(dpy, gc, pt.spec.accent);
XDrawRectangle(dpy, pix, gc, 18, 122, kWinWidth - 37, 33);
std::string dispBox = activeInput + "_";
drawPango(layoutMain, &colWhite, 26, 122, 34, dispBox, kWinWidth - 52);
drawPango(layoutSmall, &colMuted, 18, 164, 18,
"Press [*] to Show/Hide digits", kWinWidth - 36);
drawPango(layoutSmall, &colMuted, 18, 182, 18,
"Press [BackSpace] to delete digit", kWinWidth - 36);
if (!modalError.empty()) {
drawPango(layoutSmall, &colRed, 18, 204, 20, modalError, kWinWidth - 36);
}
drawSoftkeyBar("Submit", "OK", "Cancel");
} else if (modal == ModalMode::UssdDialog) {
XSetForeground(dpy, gc, pt.spec.bgOverlay);
XFillRectangle(dpy, pix, gc, 10, 40, kWinWidth - 20, 210);
XSetForeground(dpy, gc, pt.spec.accent);
XDrawRectangle(dpy, pix, gc, 10, 40, kWinWidth - 21, 209);
drawPango(layoutMain, &colYellow, 18, 46, 24,
ussdWaitingReply ? "USSD Reply" : "Send USSD Code", kWinWidth - 36);
XSetForeground(dpy, gc, pt.spec.bgInputFocus);
XFillRectangle(dpy, pix, gc, 18, 74, kWinWidth - 36, 30);
XSetForeground(dpy, gc, pt.spec.accent);
XDrawRectangle(dpy, pix, gc, 18, 74, kWinWidth - 37, 29);
drawPango(layoutMain, &colWhite, 24, 74, 30, ussdInput + "_", kWinWidth - 48);
// Response area
XSetForeground(dpy, gc, pt.spec.bgInput);
XFillRectangle(dpy, pix, gc, 18, 110, kWinWidth - 36, 130);
std::string respText = ussdResponse.empty()
? "Dial e.g. *100# and press Send."
: ussdResponse;
pango_layout_set_width(layoutSmall, (kWinWidth - 48) * PANGO_SCALE);
pango_layout_set_wrap(layoutSmall, PANGO_WRAP_WORD_CHAR);
pango_layout_set_text(layoutSmall, respText.c_str(),
static_cast<int>(respText.size()));
pango_xft_render_layout(xftDraw, &colLight, layoutSmall,
24 * PANGO_SCALE, 116 * PANGO_SCALE);
drawSoftkeyBar("Send", "Send", "Close");
}
// Status Toast Banner
if (!statusBanner.empty() && nowMs() < statusBannerUntilMs) {
XSetForeground(dpy, gc, pt.spec.bgToast);
XFillRectangle(dpy, pix, gc, 8, kWinHeight - 56, kWinWidth - 16, 26);
XSetForeground(dpy, gc, pt.spec.accent);
XDrawRectangle(dpy, pix, gc, 8, kWinHeight - 56, kWinWidth - 17, 25);
drawPango(layoutSmall, &colWhite, 14, kWinHeight - 56, 26,
statusBanner, kWinWidth - 28);
}
XCopyArea(dpy, pix, win, gc, 0, 0, kWinWidth, kWinHeight, 0, 0);
XFlush(dpy);
};
auto grabKeys = [&]() {
for (int i = 0; i < 6; ++i) {
if (XGrabKeyboard(dpy, win, True, GrabModeAsync, GrabModeAsync,
CurrentTime) == GrabSuccess) {
break;
}
usleep(15000);
}
};
auto showWindow = [&](const std::string& arg = "") {
closeOtherPlugins("modem");
refreshData(true);
applyOpenArg(arg);
writeIntFile(activePidPath, static_cast<int>(::getpid()));
if (!visible) {
XMapRaised(dpy, win);
visible = true;
} else {
XRaiseWindow(dpy, win);
}
openStartMs = nowMs();
startupIgnoreUntilMs = openStartMs + 180;
initialSoftkeysReleased = (querySoftkeysDown(dpy) == 0);
softkeyPending = 0;
grabKeys();
render();
};
auto hideWindow = [&]() {
if (!visible) return;
int xfdLocal = ConnectionNumber(dpy);
int64_t drainDeadline = nowMs() + 180;
while (nowMs() < drainDeadline && querySoftkeysDown(dpy) != 0) {
while (XPending(dpy) > 0) {
XEvent ev;
XNextEvent(dpy, &ev);
}
struct pollfd pfd {};
pfd.fd = xfdLocal;
pfd.events = POLLIN;
::poll(&pfd, 1, 10);
}
writeSoftkeySuppress(nowMs() + 450);
XUngrabKeyboard(dpy, CurrentTime);
XUnmapWindow(dpy, win);
XFlush(dpy);
visible = false;
modal = ModalMode::None;
::unlink(activePidPath.c_str());
};
auto switchSimSlotNow = [&](int slotNum) {
slotNum = std::clamp(slotNum, 1, 2);
setBanner("Switching active SIM to Slot " + std::to_string(slotNum) + "...");
render();
int rc = 0;
runCaptureCmd("doas -n /usr/libexec/msm-modem-uim-selection switch " +
std::to_string(slotNum) + " >/dev/null 2>&1", &rc);
runAsyncCmd("sxmo_hook_statusbar.sh modem >/dev/null 2>&1");
refreshData(false);
if (rc == 0) {
setBanner("Active SIM set to Slot " + std::to_string(slotNum));
} else {
setBanner("Failed to switch SIM slot");
}
};
auto submitModalInput = [&]() {
if (modal == ModalMode::VerifyPin) {
if (inputPin1.size() < 4 || inputPin1.size() > 8) {
modalError = "PIN must be 4 to 8 digits";
return;
}
setBanner("Verifying SIM PIN...");
render();
int rc = -1;
runCaptureCmd("doas -n /usr/libexec/msm-modem-uim-selection verify-pin " +
std::to_string(targetSlot) + " " + shellQuote(inputPin1) +
" >/dev/null 2>&1", &rc);
refreshData(false);
runAsyncCmd("sxmo_hook_statusbar.sh modem >/dev/null 2>&1");
if (rc == 0) {
modal = ModalMode::None;
setBanner("SIM " + std::to_string(targetSlot) + " unlocked");
} else {
inputPin1.clear();
modalError = "Incorrect PIN";
}
} else if (modal == ModalMode::UnblockPuk) {
if (wizardStep == 0) {
if (inputPin1.size() != 8) {
modalError = "PUK must be 8 digits";
return;
}
modalError.clear();
wizardStep = 1;
} else if (wizardStep == 1) {
if (inputPin2.size() < 4 || inputPin2.size() > 8) {
modalError = "New PIN must be 4-8 digits";
return;
}
modalError.clear();
wizardStep = 2;
} else {
if (inputPin3 != inputPin2) {
inputPin3.clear();
modalError = "PIN confirmation does not match";
return;
}
setBanner("Unblocking SIM with PUK...");
render();
int rc = -1;
runCaptureCmd("doas -n /usr/libexec/msm-modem-uim-selection unblock-puk " +
std::to_string(targetSlot) + " " + shellQuote(inputPin1) +
" " + shellQuote(inputPin2) + " >/dev/null 2>&1", &rc);
refreshData(false);
runAsyncCmd("sxmo_hook_statusbar.sh modem >/dev/null 2>&1");
if (rc == 0) {
modal = ModalMode::None;
setBanner("SIM unblocked and new PIN set");
} else {
wizardStep = 0;
inputPin1.clear();
inputPin2.clear();
inputPin3.clear();
modalError = "PUK unblock failed";
}
}
} else if (modal == ModalMode::TogglePinLock) {
if (inputPin1.size() < 4 || inputPin1.size() > 8) {
modalError = "PIN must be 4 to 8 digits";
return;
}
bool enableTarget = !status.slots[targetSlot - 1].isPinEnabled();
std::string modeStr = enableTarget ? "enable" : "disable";
setBanner((enableTarget ? "Enabling" : "Disabling") + std::string(" SIM PIN..."));
render();
int rc = -1;
runCaptureCmd("doas -n /usr/libexec/msm-modem-uim-selection set-pin-lock " +
std::to_string(targetSlot) + " " + modeStr + " " +
shellQuote(inputPin1) + " >/dev/null 2>&1", &rc);
refreshData(false);
if (rc == 0) {
modal = ModalMode::None;
setBanner(std::string("SIM PIN protection ") +
(enableTarget ? "enabled" : "disabled"));
} else {
inputPin1.clear();
modalError = "Failed (wrong PIN?)";
}
} else if (modal == ModalMode::ChangePin) {
if (wizardStep == 0) {
if (inputPin1.size() < 4 || inputPin1.size() > 8) {
modalError = "Current PIN must be 4-8 digits";
return;
}
modalError.clear();
wizardStep = 1;
} else if (wizardStep == 1) {
if (inputPin2.size() < 4 || inputPin2.size() > 8) {
modalError = "New PIN must be 4-8 digits";
return;
}
modalError.clear();
wizardStep = 2;
} else {
if (inputPin3 != inputPin2) {
inputPin3.clear();
modalError = "New PINs do not match";
return;
}
setBanner("Changing SIM PIN...");
render();
int rc = -1;
runCaptureCmd("doas -n /usr/libexec/msm-modem-uim-selection change-pin " +
std::to_string(targetSlot) + " " + shellQuote(inputPin1) +
" " + shellQuote(inputPin2) + " >/dev/null 2>&1", &rc);
refreshData(false);
if (rc == 0) {
modal = ModalMode::None;
setBanner("SIM PIN changed successfully");
} else {
wizardStep = 0;
inputPin1.clear();
inputPin2.clear();
inputPin3.clear();
modalError = "Failed to change PIN";
}
}
} else if (modal == ModalMode::UssdDialog) {
if (ussdInput.empty()) return;
if (ussdInput == "*#06#") {
DeviceImeis im = queryDeviceImeis();
ussdResponse = "IMEI 1: " + (im.imei1.empty() ? "--" : im.imei1) +
"\nIMEI 2: " + (im.imei2.empty() ? "--" : im.imei2) +
"\nIMEI SV: " + (im.imeiSv.empty() ? "--" : im.imeiSv);
ussdWaitingReply = false;
return;
}
ussdResponse = "Sending USSD " + ussdInput + "...";
render();
ussdResponse = sendModemUssd(ussdInput, ussdWaitingReply, &ussdWaitingReply);
if (ussdWaitingReply) {
ussdInput.clear();
}
}
};
auto applyRadioModePreset = [&](int presetIdx) {
presetIdx = (presetIdx + kNumRadioModes) % kNumRadioModes;
status.modePresetIdx = presetIdx;
const auto& p = kRadioModes[presetIdx];
setBanner(std::string("Setting mode: ") + p.label);
render();
std::string cmd = "mmcli -m any --set-allowed-modes=" +
shellQuote(p.allowed);
if ( std::strcmp(p.preferred, "none") != 0) {
cmd += " --set-preferred-mode=" + shellQuote(p.preferred);
}
cmd += " >/dev/null 2>&1";
int rc = 0;
runCaptureCmd(cmd, &rc);
refreshData(false);
setBanner(rc == 0 ? (std::string("Mode: ") + p.label) : "Mode change failed");
};
auto triggerSimRowAction = [&](int row) {
if (row == 0 || row == 1) {
targetSlot = row + 1;
actionSel = 0;
modal = ModalMode::SimActions;
} else if (row == 2) {
int otherSlot = (status.preferredSlot == 1) ? 2 : 1;
switchSimSlotNow(otherSlot);
} else if (row == 3) {
int slot = (status.primaryGwSlot >= 1 && status.primaryGwSlot <= 2)
? status.primaryGwSlot
: status.preferredSlot;
openPinOrPukModalForSlot(slot);
} else if (row == 4) {
targetSlot = (status.primaryGwSlot >= 1 && status.primaryGwSlot <= 2)
? status.primaryGwSlot
: status.preferredSlot;
wizardStep = 0;
inputPin1.clear();
modalError.clear();
modal = ModalMode::TogglePinLock;
} else if (row == 5) {
targetSlot = (status.primaryGwSlot >= 1 && status.primaryGwSlot <= 2)
? status.primaryGwSlot
: status.preferredSlot;
wizardStep = 0;
inputPin1.clear();
inputPin2.clear();
inputPin3.clear();
modalError.clear();
modal = ModalMode::ChangePin;
}
};
auto executeAtCommand = [&]() {
std::string cmd = trimStr(atInput);
if (cmd.empty()) {
setBanner("AT command cannot be empty");
return;
}
const char* portArg = (atPortIdx == 1)
? "/dev/wwan0at0"
: (atPortIdx == 2 ? "/dev/wwan0at1" : "auto");
atOutput = "Sending: " + cmd + " ...";
atScrollLine = 0;
render();
std::string out = trimStr(runCaptureCmd(
"doas -n /usr/libexec/msm-modem-uim-selection at " +
shellQuote(portArg) + " " + shellQuote(cmd) + " 2>&1"));
if (out.empty()) {
atOutput = "> " + cmd + "\n(No response)";
} else {
atOutput = "> " + cmd + "\n" + out;
}
atScrollLine = 0;
setBanner("AT response received");
};
auto handleLeftSoftkey = [&]() {
if (modal == ModalMode::SimActions) {
int act = actionSel;
modal = ModalMode::None;
if (act == 0) {
switchSimSlotNow(targetSlot);
} else if (act == 1) {
wizardStep = 0;
inputPin1.clear();
modalError.clear();
modal = ModalMode::VerifyPin;
} else if (act == 2) {
wizardStep = 0;
inputPin1.clear();
inputPin2.clear();
inputPin3.clear();
modalError.clear();
modal = ModalMode::UnblockPuk;
} else if (act == 3) {
wizardStep = 0;
inputPin1.clear();
modalError.clear();
modal = ModalMode::TogglePinLock;
} else if (act == 4) {
wizardStep = 0;
inputPin1.clear();
inputPin2.clear();
inputPin3.clear();
modalError.clear();
modal = ModalMode::ChangePin;
}
return;
}
if (modal != ModalMode::None) {
submitModalInput();
return;
}
if (activeTab == TabId::SimCards) {
targetSlot = (simRowSel == 1) ? 2 : 1;
actionSel = 0;
modal = ModalMode::SimActions;
} else if (activeTab == TabId::RadioInfo) {
refreshData(false);
setBanner("Modem status refreshed");
} else if (activeTab == TabId::AtConsole) {
executeAtCommand();
} else if (activeTab == TabId::ModemLog) {
refreshData(true);
setBanner("Modem log refreshed");
}
};
auto handleRightSoftkey = [&]() {
if (modal != ModalMode::None) {
if (modal == ModalMode::UssdDialog) {
runAsyncCmd("mmcli -m any --3gpp-ussd-cancel >/dev/null 2>&1");
}
modal = ModalMode::None;
return;
}
hideWindow();
};
auto handleEnterKey = [&]() {
if (modal == ModalMode::SimActions) {
handleLeftSoftkey();
return;
}
if (modal != ModalMode::None) {
submitModalInput();
return;
}
if (activeTab == TabId::SimCards) {
triggerSimRowAction(simRowSel);
} else if (activeTab == TabId::RadioInfo) {
if (radioRowSel == 0) {
applyRadioModePreset(status.modePresetIdx + 1);
} else if (radioRowSel == 1) {
modal = ModalMode::UssdDialog;
ussdResponse.clear();
ussdWaitingReply = false;
} else if (radioRowSel == 2) {
bool powerOn = (status.mmPowerState == "on" ||
status.mmState == "registered" ||
status.mmState == "connected" ||
status.mmState == "searching");
setBanner(powerOn ? "Disabling modem..." : "Enabling modem...");
render();
runCaptureCmd(powerOn ? "mmcli -m any -d >/dev/null 2>&1"
: "mmcli -m any -e >/dev/null 2>&1");
refreshData(false);
runAsyncCmd("sxmo_hook_statusbar.sh modem >/dev/null 2>&1");
} else if (radioRowSel == 3) {
setBanner("Restarting ModemManager...");
render();
runCaptureCmd("doas -n rc-service modemmanager restart >/dev/null 2>&1");
refreshData(false);
setBanner("ModemManager restarted");
} else if (radioRowSel == 4) {
refreshData(false);
setBanner("Refreshed");
}
} else if (activeTab == TabId::AtConsole) {
if (atFocusRow == 1) {
atPortIdx = (atPortIdx + 1) % 3;
} else {
executeAtCommand();
}
} else if (activeTab == TabId::ModemLog) {
if (!logRows.empty() && logRowSel >= 0 &&
logRowSel < static_cast<int>(logRows.size())) {
const auto& r = logRows[logRowSel];
std::string num = normalizePhone(r.target);
if (!num.empty()) {
if (r.eventType.find("txt") != std::string::npos) {
hideWindow();
if (!sendPluginCommand("sms", "OPEN thread:" + num)) {
runAsyncArgv("xsms", "tailtextlog", num.c_str());
}
} else {
hideWindow();
if (!sendPluginCommand("dialer", "OPEN " + num)) {
runAsyncArgv("xdialer", num.c_str());
}
}
}
}
}
};
if (!isPreload) {
showWindow(openArg);
}
int xfd = ConnectionNumber(dpy);
while (gRunning) {
while (XPending(dpy) > 0) {
XEvent ev;
XNextEvent(dpy, &ev);
if (ev.type == Expose && ev.xexpose.count == 0) {
render();
} else if (ev.type == VisibilityNotify && visible &&
ev.xvisibility.state != VisibilityUnobscured) {
XRaiseWindow(dpy, win);
} else if (ev.type == KeyRelease) {
if (!initialSoftkeysReleased && querySoftkeysDown(dpy) == 0) {
initialSoftkeysReleased = true;
}
} else if (ev.type == KeyPress && visible) {
int64_t now = nowMs();
if (now < startupIgnoreUntilMs) continue;
KeySym sym = XLookupKeysym(&ev.xkey, 0);
unsigned int kc = ev.xkey.keycode;
bool isLSK = (kc == 135 || sym == XK_F1 || sym == XK_Menu ||
sym == XF86XK_TaskPane);
bool isRSK = (kc == 166 || sym == XK_F2 || sym == XF86XK_Back ||
sym == XK_Escape ||
sym == static_cast<KeySym>(XF86XK_KbdLcdMenu2));
if (isLSK || isRSK) {
if (!initialSoftkeysReleased) continue;
int mask = querySoftkeysDown(dpy);
if (mask == 3 || (softkeyPending != 0 &&
((isLSK && softkeyPending == 2) ||
(isRSK && softkeyPending == 1)))) {
softkeyPending = 0;
writeSoftkeySuppress(now + 400);
hideWindow();
sendPluginCommand("xdrawer", "TOGGLE");
continue;
}
softkeyPending = isLSK ? 1 : 2;
softkeyDeadlineMs = now + 90;
continue;
}
if (sym == XF86XK_HangupPhone || sym == XK_Cancel) {
hideWindow();
continue;
}
// Modal numeric / code input handling
if (modal == ModalMode::VerifyPin ||
modal == ModalMode::UnblockPuk ||
modal == ModalMode::TogglePinLock ||
modal == ModalMode::ChangePin) {
char dch = mapDialKey(sym, kc, ev.xkey.state);
if (dch == '*') {
revealDigits = !revealDigits;
render();
continue;
}
std::string* curStr = &inputPin1;
size_t maxLen = (modal == ModalMode::UnblockPuk && wizardStep == 0) ? 8 : 8;
if ((modal == ModalMode::UnblockPuk || modal == ModalMode::ChangePin) &&
wizardStep == 1) {
curStr = &inputPin2;
} else if ((modal == ModalMode::UnblockPuk || modal == ModalMode::ChangePin) &&
wizardStep == 2) {
curStr = &inputPin3;
}
if (dch >= '0' && dch <= '9') {
if (curStr->size() < maxLen) {
curStr->push_back(dch);
modalError.clear();
render();
}
continue;
}
if (sym == XK_BackSpace || sym == XK_Delete) {
if (!curStr->empty()) {
curStr->pop_back();
modalError.clear();
render();
} else if (wizardStep > 0) {
--wizardStep;
render();
}
continue;
}
if (sym == XK_Return || sym == XK_KP_Enter) {
submitModalInput();
render();
continue;
}
continue;
}
if (modal == ModalMode::UssdDialog) {
char dch = mapDialKey(sym, kc, ev.xkey.state);
if (dch != '\0') {
if (ussdInput.size() < 32) {
ussdInput.push_back(dch);
render();
}
continue;
}
if (sym == XK_BackSpace || sym == XK_Delete) {
if (!ussdInput.empty()) {
ussdInput.pop_back();
render();
}
continue;
}
if (sym == XK_Return || sym == XK_KP_Enter ||
sym == XF86XK_Send || sym == XF86XK_Phone ||
sym == XF86XK_PickupPhone) {
submitModalInput();
render();
continue;
}
continue;
}
if (modal == ModalMode::SimActions) {
if (sym == XK_Up || sym == XK_KP_Up) {
actionSel = (actionSel + 4) % 5;
render();
} else if (sym == XK_Down || sym == XK_KP_Down) {
actionSel = (actionSel + 1) % 5;
render();
} else if (sym == XK_Return || sym == XK_KP_Enter) {
handleEnterKey();
render();
}
continue;
}
// AT Console text input when atFocusRow == 0
char dch = mapDialKey(sym, kc, ev.xkey.state);
if (activeTab == TabId::AtConsole && atFocusRow == 0) {
if (sym == XK_BackSpace || sym == XK_Delete) {
if (!atInput.empty()) {
atInput.pop_back();
atLastTapKey = -1;
render();
}
continue;
}
if (dch == '#') {
atTextMode = static_cast<AtTextMode>(
(static_cast<int>(atTextMode) + 1) % 4);
atLastTapKey = -1;
render();
continue;
}
if (dch == '*') {
const char* syms = "+?=,1\"':;/-_*#";
int len = static_cast<int>(std::strlen(syms));
if (atLastTapKey == 10 && (now - atLastTapMs) < 850 &&
!atInput.empty()) {
atLastTapIdx = (atLastTapIdx + 1) % len;
atInput.back() = syms[atLastTapIdx];
} else if (atInput.size() < 64) {
atLastTapKey = 10;
atLastTapIdx = 0;
atInput.push_back(syms[0]);
}
atLastTapMs = now;
render();
continue;
}
if (dch >= '0' && dch <= '9') {
int digit = dch - '0';
if (atTextMode == AtTextMode::Num) {
if (atInput.size() < 64) {
atInput.push_back(dch);
atLastTapKey = -1;
}
} else if (atTextMode == AtTextMode::Sym) {
const char* symTable = "+?=,.\"':;/-_";
char sc = symTable[digit % 10];
if (atInput.size() < 64) {
atInput.push_back(sc);
atLastTapKey = -1;
}
} else {
const char* seq = kAtTapMap[digit];
int len = static_cast<int>(std::strlen(seq));
if (atLastTapKey == digit && (now - atLastTapMs) < 850 &&
!atInput.empty()) {
atLastTapIdx = (atLastTapIdx + 1) % len;
char chOut = seq[atLastTapIdx];
if (atTextMode == AtTextMode::Lower) {
chOut = static_cast<char>(
std::tolower(static_cast<unsigned char>(chOut)));
}
atInput.back() = chOut;
} else if (atInput.size() < 64) {
atLastTapKey = digit;
atLastTapIdx = 0;
char chOut = seq[0];
if (atTextMode == AtTextMode::Lower) {
chOut = static_cast<char>(
std::tolower(static_cast<unsigned char>(chOut)));
}
atInput.push_back(chOut);
}
atLastTapMs = now;
}
render();
continue;
}
}
// Main View Navigation (4 tabs: 1:SIMs, 2:Radio, 3:AT, 4:Log)
if (dch == '1') {
activeTab = TabId::SimCards;
render();
continue;
} else if (dch == '2') {
activeTab = TabId::RadioInfo;
render();
continue;
} else if (dch == '3') {
activeTab = TabId::AtConsole;
render();
continue;
} else if (dch == '4') {
activeTab = TabId::ModemLog;
refreshData(true);
render();
continue;
} else if (activeTab == TabId::AtConsole && dch == '*') {
atPortIdx = (atPortIdx + 1) % 3;
render();
continue;
}
if (sym == XK_Left || sym == XK_KP_Left) {
if (activeTab == TabId::RadioInfo && radioRowSel == 0) {
applyRadioModePreset(status.modePresetIdx - 1);
} else if (activeTab == TabId::AtConsole && atFocusRow == 1) {
atPresetIdx = (atPresetIdx + kNumAtPresets - 1) % kNumAtPresets;
atInput = kAtPresets[atPresetIdx];
} else {
activeTab = static_cast<TabId>((static_cast<int>(activeTab) + 3) % 4);
if (activeTab == TabId::ModemLog) refreshData(true);
}
render();
} else if (sym == XK_Right || sym == XK_KP_Right) {
if (activeTab == TabId::RadioInfo && radioRowSel == 0) {
applyRadioModePreset(status.modePresetIdx + 1);
} else if (activeTab == TabId::AtConsole && atFocusRow == 1) {
atPresetIdx = (atPresetIdx + 1) % kNumAtPresets;
atInput = kAtPresets[atPresetIdx];
} else {
activeTab = static_cast<TabId>((static_cast<int>(activeTab) + 1) % 4);
if (activeTab == TabId::ModemLog) refreshData(true);
}
render();
} else if (sym == XK_Up || sym == XK_KP_Up) {
if (activeTab == TabId::SimCards) {
simRowSel = (simRowSel + 5) % 6;
} else if (activeTab == TabId::RadioInfo) {
radioRowSel = (radioRowSel + 4) % 5;
} else if (activeTab == TabId::AtConsole) {
if (atFocusRow == 2 && atScrollLine > 0) {
--atScrollLine;
} else {
atFocusRow = (atFocusRow + 2) % 3;
}
} else if (activeTab == TabId::ModemLog && !logRows.empty()) {
logRowSel = std::max(0, logRowSel - 1);
}
render();
} else if (sym == XK_Down || sym == XK_KP_Down) {
if (activeTab == TabId::SimCards) {
simRowSel = (simRowSel + 1) % 6;
} else if (activeTab == TabId::RadioInfo) {
radioRowSel = (radioRowSel + 1) % 5;
} else if (activeTab == TabId::AtConsole) {
if (atFocusRow == 2) {
++atScrollLine;
} else {
atFocusRow = (atFocusRow + 1) % 3;
}
} else if (activeTab == TabId::ModemLog && !logRows.empty()) {
logRowSel = std::min(static_cast<int>(logRows.size()) - 1, logRowSel + 1);
}
render();
} else if (sym == XK_Return || sym == XK_KP_Enter ||
sym == XF86XK_Send || sym == XF86XK_Phone ||
sym == XF86XK_PickupPhone) {
handleEnterKey();
render();
}
}
}
int timeoutMs = -1;
int64_t now = nowMs();
if (visible) {
if (softkeyPending != 0) {
int64_t rem = softkeyDeadlineMs - now;
if (rem <= 0) {
int pend = softkeyPending;
softkeyPending = 0;
if (querySoftkeysDown(dpy) == 3) {
writeSoftkeySuppress(now + 400);
hideWindow();
sendPluginCommand("xdrawer", "TOGGLE");
} else if (pend == 1) {
handleLeftSoftkey();
render();
} else if (pend == 2) {
handleRightSoftkey();
render();
}
} else {
timeoutMs = static_cast<int>(rem);
}
}
if (!statusBanner.empty()) {
int64_t bRem = statusBannerUntilMs - now;
if (bRem <= 0) {
statusBanner.clear();
render();
} else if (timeoutMs < 0 || bRem < timeoutMs) {
timeoutMs = static_cast<int>(bRem);
}
}
// Periodic 5-second status refresh while visible on SIM/Radio tabs
if (modal == ModalMode::None && activeTab != TabId::ModemLog &&
activeTab != TabId::AtConsole) {
int64_t rRem = (lastRefreshMs + 5000) - now;
if (rRem <= 0) {
refreshData(false);
render();
rRem = 5000;
}
if (timeoutMs < 0 || rRem < timeoutMs) {
timeoutMs = static_cast<int>(rRem);
}
}
}
struct pollfd pfds[2];
pfds[0].fd = xfd;
pfds[0].events = POLLIN;
pfds[1].fd = fifoFd;
pfds[1].events = POLLIN;
int pr = ::poll(pfds, (fifoFd >= 0) ? 2 : 1, timeoutMs);
if (pr > 0 && fifoFd >= 0 && (pfds[1].revents & POLLIN)) {
for (const auto& cmd : readFifoLines(fifoFd)) {
if (cmd == "CLOSE") {
hideWindow();
} else if (cmd == "RELOAD_THEME") {
pt.reload();
if (visible) render();
} else if (cmd == "TOGGLE") {
if (visible) hideWindow();
else showWindow();
} else if (cmd.rfind("OPEN", 0) == 0) {
std::string arg = (cmd.size() > 5) ? trimStr(cmd.substr(5)) : "";
showWindow(arg);
}
}
}
}
hideWindow();
if (fifoFd >= 0) ::close(fifoFd);
::unlink(daemonPidPath.c_str());
XftDrawDestroy(xftDraw);
XFreePixmap(dpy, pix);
XFreeGC(dpy, gc);
XDestroyWindow(dpy, win);
XCloseDisplay(dpy);
return 0;
}
int pluginInit(const DwmHostApi* host) {
if (host && host->spawn_plugin) {
host->spawn_plugin("modem", "--preload");
}
return 0;
}
void pluginCleanup(void) {}
} // namespace
extern "C" __attribute__((visibility("default"))) const DwmPlugin dwm_plugin_entry = {
DWM_PLUGIN_API_VERSION,
"modem",
"Bananarchy Dual-SIM, PIN/PUK & Modem Manager (240x320)",
pluginInit,
pluginCleanup,
nullptr,
nullptr,
nullptr,
runModemApp
};
Reference in New Issue View Git Blame Copy Permalink