StephenDev0/idevice
1
0
Fork 0
mirror of https://github.com/jkcoxson/idevice.git synced 2026-03-02 06:26:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Remove cpp 17 features and implement Rust into CPP

Browse Source
This commit is contained in:
Jackson Coxson
2025-08-29 14:19:28 -06:00
parent 4fde7cf06b
commit 1169408da1
41 changed files with 1638 additions and 1212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
cpp/examples/location_simulation.cpp
View File

@@ -2,7 +2,6 @@
#include <cstdlib>
#include <iostream>
#include <optional>
#include <string>
#include <thread>
@@ -17,6 +16,7 @@
using namespace IdeviceFFI;
[[noreturn]]
static void die(const char* msg, const FfiError& e) {
std::cerr << msg << ": " << e.message << "\n";
std::exit(1);
@@ -26,8 +26,8 @@ int main(int argc, char** argv) {
// Usage:
// simulate_location clear
// simulate_location set <lat> <lon>
bool do_clear = false;
std::optional<double> lat, lon;
bool do_clear = false;
Option<double> lat, lon;
if (argc == 2 && std::string(argv[1]) == "clear") {
do_clear = true;
@@ -41,95 +41,82 @@ int main(int argc, char** argv) {
return 2;
}
FfiError err;
// 1) usbmuxd → pick first device
auto mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0);
if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
// 1) Connect to usbmuxd and pick first device
auto mux = UsbmuxdConnection::default_new(/*tag*/ 0, err);
if (!mux)
die("failed to connect to usbmuxd", err);
auto devices = mux->get_devices(err);
if (!devices)
die("failed to list devices", err);
if (devices->empty()) {
auto devices = mux.unwrap().get_devices();
if_let_err(devices, err, { die("failed to list devices", err); });
if (devices.unwrap().empty()) {
std::cerr << "no devices connected\n";
return 1;
}
auto& dev = (*devices)[0];
auto udidOpt = dev.get_udid();
if (!udidOpt) {
auto& dev = (devices.unwrap())[0];
auto udid = dev.get_udid();
if (udid.is_none()) {
std::cerr << "device has no UDID\n";
return 1;
}
auto idOpt = dev.get_id();
if (!idOpt) {
auto mux_id = dev.get_id();
if (mux_id.is_none()) {
std::cerr << "device has no mux id\n";
return 1;
}
// 2) Make a Provider for this device via default addr
auto addr = UsbmuxdAddr::default_new();
// 2) Provider via default usbmuxd addr
auto addr = IdeviceFFI::UsbmuxdAddr::default_new();
const uint32_t tag = 0;
const std::string label = "simulate_location-jkcoxson";
const uint32_t tag = 0;
const std::string label = "debug-proxy-jkcoxson";
auto provider = IdeviceFFI::Provider::usbmuxd_new(
std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label);
if_let_err(provider, err, { die("failed to create provider", err); });
auto provider = Provider::usbmuxd_new(std::move(addr), tag, *udidOpt, *idOpt, label, err);
if (!provider)
die("failed to create provider", err);
// 3) CoreDeviceProxy
auto cdp = CoreDeviceProxy::connect(provider.unwrap())
.unwrap_or_else([](FfiError e) -> CoreDeviceProxy {
die("failed to connect CoreDeviceProxy", e);
});
// 3) Connect CoreDeviceProxy (borrow provider)
auto cdp = CoreDeviceProxy::connect(*provider, err);
if (!cdp)
die("failed to connect CoreDeviceProxy", err);
auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
[](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
// 4) Read handshake’s server RSD port
auto rsd_port = cdp->get_server_rsd_port(err);
if (!rsd_port)
die("failed to get server RSD port", err);
// 4) Create software tunnel adapter (consumes proxy)
auto adapter = std::move(cdp).create_tcp_adapter();
if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); });
// 5) Create software tunnel adapter (consumes proxy)
auto adapter = std::move(*cdp).create_tcp_adapter(err);
if (!adapter)
die("failed to create software tunnel adapter", err);
// 5) Connect adapter to RSD → ReadWrite stream
auto stream = adapter.unwrap().connect(rsd_port);
if_let_err(stream, err, { die("failed to connect RSD stream", err); });
// 6) Connect adapter to RSD port → ReadWrite stream
auto stream = adapter->connect(*rsd_port, err);
if (!stream)
die("failed to connect RSD stream", err);
// 7) RSD handshake (consumes stream)
auto rsd = RsdHandshake::from_socket(std::move(*stream), err);
if (!rsd)
die("failed RSD handshake", err);
// 6) RSD handshake (consumes stream)
auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap()));
if_let_err(rsd, err, { die("failed RSD handshake", err); });
// 8) RemoteServer over RSD (borrows adapter + handshake)
auto rs = RemoteServer::connect_rsd(*adapter, *rsd, err);
if (!rs)
die("failed to connect RemoteServer", err);
auto rs = RemoteServer::connect_rsd(adapter.unwrap(), rsd.unwrap());
if_let_err(rs, err, { die("failed to connect RemoteServer", err); });
// 9) LocationSimulation client (borrows RemoteServer)
auto sim = LocationSimulation::create(*rs, err);
if (!sim)
die("failed to create LocationSimulation client", err);
auto sim_res = LocationSimulation::create(rs.unwrap());
if_let_err(sim_res, err, { die("failed to create LocationSimulation client", err); });
auto& sim = sim_res.unwrap();
if (do_clear) {
if (!sim->clear(err))
die("clear failed", err);
if_let_err(sim.clear(), err, { die("clear failed", err); });
std::cout << "Location cleared!\n";
return 0;
}
// set path
if (!sim->set(*lat, *lon, err))
die("set failed", err);
std::cout << "Location set to (" << *lat << ", " << *lon << ")\n";
if_let_err(sim.set(lat.unwrap(), lon.unwrap()), err, { die("set failed", err); });
std::cout << "Location set to (" << lat.unwrap() << ", " << lon.unwrap() << ")\n";
std::cout << "Press Ctrl-C to stop\n";
// keep process alive like the Rust example
for (;;) {
if (!sim->set(*lat, *lon, err))
die("set failed", err);
if_let_err(sim.set(lat.unwrap(), lon.unwrap()), err, { die("set failed", err); });
std::this_thread::sleep_for(std::chrono::seconds(3));
}
}