13#include "ekos/manager.h"
14#include "fitsviewer/fitsdata.h"
15#include "ekos/guide/guide.h"
16#include "fitsviewer/fitsview.h"
23#include <QJsonDocument>
24#include <QNetworkReply>
26#include <ekos_guide_debug.h>
28#define MAX_SET_CONNECTED_RETRIES 3
38 events[
"Version"] = Version;
39 events[
"LockPositionSet"] = LockPositionSet;
40 events[
"Calibrating"] = Calibrating;
41 events[
"CalibrationComplete"] = CalibrationComplete;
42 events[
"StarSelected"] = StarSelected;
43 events[
"StartGuiding"] = StartGuiding;
44 events[
"Paused"] = Paused;
45 events[
"StartCalibration"] = StartCalibration;
46 events[
"AppState"] = AppState;
47 events[
"CalibrationFailed"] = CalibrationFailed;
48 events[
"CalibrationDataFlipped"] = CalibrationDataFlipped;
49 events[
"LoopingExposures"] = LoopingExposures;
50 events[
"LoopingExposuresStopped"] = LoopingExposuresStopped;
51 events[
"SettleBegin"] = SettleBegin;
52 events[
"Settling"] = Settling;
53 events[
"SettleDone"] = SettleDone;
54 events[
"StarLost"] = StarLost;
55 events[
"GuidingStopped"] = GuidingStopped;
56 events[
"Resumed"] = Resumed;
57 events[
"GuideStep"] = GuideStep;
58 events[
"GuidingDithered"] = GuidingDithered;
59 events[
"LockPositionLost"] = LockPositionLost;
60 events[
"Alert"] = Alert;
61 events[
"GuideParamChange"] = GuideParamChange;
62 events[
"ConfigurationChange"] = ConfigurationChange;
66 methodResults[
"capture_single_frame"] = CAPTURE_SINGLE_FRAME;
67 methodResults[
"clear_calibration"] = CLEAR_CALIBRATION_COMMAND_RECEIVED;
68 methodResults[
"dither"] = DITHER_COMMAND_RECEIVED;
73 methodResults[
"get_app_state"] = APP_STATE_RECEIVED;
76 methodResults[
"get_connected"] = IS_EQUIPMENT_CONNECTED;
78 methodResults[
"get_current_equipment"] = GET_CURRENT_EQUIPMENT;
79 methodResults[
"get_dec_guide_mode"] = DEC_GUIDE_MODE;
80 methodResults[
"get_exposure"] = EXPOSURE_TIME;
81 methodResults[
"get_exposure_durations"] = EXPOSURE_DURATIONS;
82 methodResults[
"get_lock_position"] = LOCK_POSITION;
86 methodResults[
"get_pixel_scale"] = PIXEL_SCALE;
91 methodResults[
"get_star_image"] = STAR_IMAGE;
93 methodResults[
"guide"] = GUIDE_COMMAND_RECEIVED;
95 methodResults[
"loop"] = LOOP;
98 methodResults[
"set_connected"] = CONNECTION_RESULT;
99 methodResults[
"set_dec_guide_mode"] = SET_DEC_GUIDE_MODE_COMMAND_RECEIVED;
100 methodResults[
"set_exposure"] = SET_EXPOSURE_COMMAND_RECEIVED;
101 methodResults[
"set_lock_position"] = SET_LOCK_POSITION;
104 methodResults[
"set_paused"] = SET_PAUSED_COMMAND_RECEIVED;
107 methodResults[
"stop_capture"] = STOP_CAPTURE_COMMAND_RECEIVED;
109 abortTimer =
new QTimer(
this);
112 if (state == CALIBRATING)
113 qCDebug(
KSTARS_EKOS_GUIDE) <<
"Abort timeout expired while calibrating, retrying to guide.";
114 else if (state == LOSTLOCK)
115 qCDebug(
KSTARS_EKOS_GUIDE) <<
"Abort timeout expired while reacquiring star, retrying to guide.";
121 ditherTimer =
new QTimer(
this);
124 qCDebug(
KSTARS_EKOS_GUIDE) <<
"ditherTimer expired, state" << state <<
"dithering" << isDitherActive <<
"settling" << isSettling;
126 isDitherActive =
false;
128 if (Options::ditherFailAbortsAutoGuide())
131 emit newStatus(GUIDE_DITHERING_ERROR);
135 emit newLog(
i18n(
"PHD2: There was no dithering response from PHD2, but continue guiding."));
136 emit newStatus(Ekos::GUIDE_DITHERING_SUCCESS);
140 stateTimer =
new QTimer(
this);
147 m_PHD2ReconnectCounter++;
148 if (m_PHD2ReconnectCounter > PHD2_RECONNECT_THRESHOLD)
151 emit newLog(
i18n(
"Giving up reconnecting."));
155 emit newLog(
i18n(
"Reconnecting to PHD2 Host: %1, on port %2. . .", Options::pHD2Host(), Options::pHD2Port()));
158#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
164 tcpSocket->connectToHost(Options::pHD2Host(), Options::pHD2Port());
168 m_PHD2ReconnectCounter = 0;
169 checkIfEquipmentConnected();
191 connection = CONNECTING;
192 emit newLog(
i18n(
"Connecting to PHD2 Host: %1, on port %2. . .", Options::pHD2Host(), Options::pHD2Port()));
195#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
202 tcpSocket->connectToHost(Options::pHD2Host(), Options::pHD2Port());
204 m_PHD2ReconnectCounter = 0;
205 stateTimer->start(PHD2_RECONNECT_TIMEOUT);
208 case EQUIPMENT_DISCONNECTED:
210 connectEquipment(
true);
222void PHD2::ResetConnectionState()
224 connection = DISCONNECTED;
227 pendingRpcResultType = NO_RESULT;
228 rpcRequestQueue.clear();
230 starImageRequested =
false;
232 isDitherActive =
false;
237 tcpSocket->disconnect(
this);
239 emit newStatus(GUIDE_DISCONNECTED);
242bool PHD2::Disconnect()
246 case EQUIPMENT_CONNECTED:
247 emit newLog(
i18n(
"Aborting any capture before disconnecting equipment..."));
249 connection = DISCONNECTING;
254 case EQUIPMENT_DISCONNECTED:
256 tcpSocket->disconnectFromHost();
257 ResetConnectionState();
259 tcpSocket->waitForDisconnected(5000);
260 emit newLog(
i18n(
"Disconnected from PHD2 Host: %1, on port %2.", Options::pHD2Host(), Options::pHD2Port()));
276 emit newLog(
i18n(
"The host disconnected."));
279 emit newLog(
i18n(
"The host was not found. Please check the host name and port settings in Guide options."));
282 emit newLog(
i18n(
"The connection was refused by the peer. Make sure the PHD2 is running, and check that "
283 "the host name and port settings are correct."));
286 emit newLog(
i18n(
"The following error occurred: %1.", tcpSocket->errorString()));
289 ResetConnectionState();
291 emit newStatus(GUIDE_DISCONNECTED);
296 while (!tcpSocket->atEnd() && tcpSocket->canReadLine())
308 emit newLog(
i18n(
"PHD2: invalid response received: %1",
QString(line)));
316 processPHD2Event(
jsonObj, line);
317 else if (
jsonObj.contains(
"error"))
318 processPHD2Error(
jsonObj, line);
319 else if (
jsonObj.contains(
"result"))
320 processPHD2Result(
jsonObj, line);
326 if (Options::verboseLogging())
345 case CalibrationComplete:
346 emit newLog(
i18n(
"PHD2: Calibration Complete."));
347 emit newStatus(Ekos::GUIDE_CALIBRATION_SUCCESS);
351 updateGuideParameters();
352 requestCurrentEquipmentUpdate();
356 emit newLog(
i18n(
"PHD2: Waiting for guiding to settle."));
360 handlePHD2AppState(PAUSED);
363 case StartCalibration:
364 handlePHD2AppState(CALIBRATING);
371 if (connection == CONNECTING)
373 emit newLog(
"PHD2: Connecting equipment and external guider...");
374 connectEquipment(
true);
378 case CalibrationFailed:
380 handlePHD2AppState(STOPPED);
383 case CalibrationDataFlipped:
384 emit newLog(
i18n(
"Calibration Data Flipped."));
387 case LoopingExposures:
388 handlePHD2AppState(LOOPING);
391 case LoopingExposuresStopped:
392 handlePHD2AppState(STOPPED);
404 if (state == PHD2::STOPPED)
417 isDitherActive =
false;
423 if (error && Options::ditherFailAbortsAutoGuide())
426 emit newStatus(GUIDE_DITHERING_ERROR);
431 emit newLog(
i18n(
"PHD2: There was a dithering error, but continue guiding."));
433 emit newStatus(Ekos::GUIDE_DITHERING_SUCCESS);
440 emit newLog(
i18n(
"PHD2: Settling failed, aborted."));
441 emit newStatus(GUIDE_ABORTED);
446 emit newLog(
i18n(
"PHD2: Settling complete, Guiding Started."));
447 emit newStatus(GUIDE_GUIDING);
454 handlePHD2AppState(SELECTED);
459 handlePHD2AppState(LOSTLOCK);
463 handlePHD2AppState(STOPPED);
467 handlePHD2AppState(GUIDING);
474 if (state == LOSTLOCK)
475 emit newLog(
i18n(
"PHD2: Star found, guiding is resuming..."));
507 if (std::isfinite(snr))
513 if(errorLog.size() > 50)
521 std::isfinite(snr) ? snr : 0, 0, 0);
526 for (
auto &point : errorLog)
538 if ( Options::guideSubframe() || currentCameraIsNotInEkos )
539 requestStarImage(32);
541 requestLockPosition();
545 case GuidingDithered:
548 case LockPositionSet:
549 handlePHD2AppState(SELECTED);
552 case LockPositionLost:
553 handlePHD2AppState(LOSTLOCK);
560 case GuideParamChange:
561 case ConfigurationChange:
579 handlePHD2AppState(STOPPED);
581 handlePHD2AppState(SELECTED);
583 handlePHD2AppState(CALIBRATING);
585 handlePHD2AppState(GUIDING);
587 handlePHD2AppState(LOSTLOCK);
589 handlePHD2AppState(PAUSED);
591 handlePHD2AppState(LOOPING);
595void PHD2::handlePHD2AppState(PHD2State
newstate)
608 emit newStatus(Ekos::GUIDE_CALIBRATION_ERROR);
611 emit newLog(
i18n(
"PHD2: Looping Exposures Stopped."));
612 emit newStatus(Ekos::GUIDE_IDLE);
616 emit newLog(
i18n(
"PHD2: Guiding Stopped."));
617 emit newStatus(Ekos::GUIDE_ABORTED);
620 if (connection == DISCONNECTING)
622 emit newLog(
"PHD2: Disconnecting equipment and external guider...");
623 connectEquipment(
false);
635 emit newLog(
i18n(
"PHD2: Lock Position Set."));
639 emit newStatus(Ekos::GUIDE_CALIBRATING);
646 emit newLog(
i18n(
"PHD2: Star Selected."));
647 emit newStatus(GUIDE_STAR_SELECT);
656 emit newLog(
i18n(
"PHD2: Dithering successful."));
658 emit newStatus(Ekos::GUIDE_DITHERING_SUCCESS);
661 emit newLog(
i18n(
"PHD2: Guiding started."));
663 emit newStatus(Ekos::GUIDE_GUIDING);
672 emit newLog(
i18n(
"PHD2: Lock Position Lost, continuing calibration."));
678 emit newLog(
i18n(
"PHD2: Star Lost. Trying to reacquire for %1s.", Options::guideLostStarTimeout()));
679 abortTimer->
start(
static_cast<int>(Options::guideLostStarTimeout()) * 1000);
680 qCDebug(
KSTARS_EKOS_GUIDE) <<
"PHD2: Lost star timeout started (" << Options::guideLostStarTimeout() <<
" sec)";
681 emit newStatus(Ekos::GUIDE_REACQUIRE);
684 emit newLog(
i18n(
"PHD2: Lock Position Lost."));
690 emit newLog(
i18n(
"PHD2: Guiding paused."));
691 emit newStatus(GUIDE_SUSPENDED);
695 emit newLog(
i18n(
"PHD2: Calibrating, timing out in %1s.", Options::guideCalibrationTimeout()));
696 abortTimer->
start(
static_cast<int>(Options::guideCalibrationTimeout()) * 1000);
697 emit newStatus(GUIDE_CALIBRATING);
704 emit newLog(
i18n(
"PHD2: Calibration turned to looping, failed."));
705 emit newStatus(GUIDE_CALIBRATION_ERROR);
708 emit newLog(
i18n(
"PHD2: Looping Exposures."));
709 emit newStatus(GUIDE_LOOPING);
714 emit newLog(
i18n(
"PHD2: Dithering started."));
715 emit newStatus(GUIDE_DITHERING);
724 PHD2ResultType resultType = takeRequestFromList(
jsonObj);
726 if (resultType == STAR_IMAGE)
738 case CAPTURE_SINGLE_FRAME:
741 case CLEAR_CALIBRATION_COMMAND_RECEIVED:
742 emit newLog(
i18n(
"PHD2: Calibration is cleared"));
745 case DITHER_COMMAND_RECEIVED:
746 handlePHD2AppState(DITHERING);
754 case APP_STATE_RECEIVED:
758 state =
jsonObj[
"result"].toString();
762 processPHD2State(state);
769 case IS_EQUIPMENT_CONNECTED:
771 bool isConnected =
jsonObj[
"result"].toBool();
778 connection = CONNECTED;
779 setEquipmentConnected();
781 else connectEquipment(
true);
787 setEquipmentConnected();
794 connection = EQUIPMENT_DISCONNECTED;
797 else connectEquipment(
false);
800 case EQUIPMENT_CONNECTED:
805 connection = EQUIPMENT_DISCONNECTED;
806 emit newStatus(Ekos::GUIDE_DISCONNECTED);
811 case EQUIPMENT_DISCONNECTED:
814 setEquipmentConnected();
821 case GET_CURRENT_EQUIPMENT:
824 currentCamera =
equipObject[
"camera"].toObject()[
"name"].toString();
825 currentMount =
equipObject[
"mount"].toObject()[
"name"].toString();
826 currentAuxMount =
equipObject[
"aux_mount"].toObject()[
"name"].toString();
828 emit guideEquipmentUpdated();
837 Ekos::Manager::Instance()->guideModule()->updateDirectionsFromPHD2(mode);
838 emit newLog(
i18n(
"PHD2: DEC Guide Mode is Set to: %1", mode));
847 Ekos::Manager::Instance()->guideModule()->setExposure(exposureTime);
853 case EXPOSURE_DURATIONS:
856 logValidExposureTimes =
i18n(
"PHD2: Valid Exposure Times: Auto, ");
861 logValidExposureTimes += Ekos::Manager::Instance()->guideModule()->setRecommendedExposureValues(values);
862 emit newLog(logValidExposureTimes);
867 if(
jsonObj[
"result"].toArray().count() == 2)
869 double x =
jsonObj[
"result"].toArray().at(0).toDouble();
870 double y =
jsonObj[
"result"].toArray().at(1).toDouble();
876 emit newStarPixmap(m_GuideFrame->getTrackingBoxPixmap());
885 pixelScale =
jsonObj[
"result"].toDouble();
887 emit newLog(
i18n(
"PHD2: Please set CCD and telescope parameters in PHD2, Pixel Scale is invalid."));
899 starImageRequested =
false;
907 case GUIDE_COMMAND_RECEIVED:
908 if (0 !=
jsonObj[
"result"].toInt(0))
910 emit newLog(
"PHD2: Guide command was rejected.");
911 handlePHD2AppState(STOPPED);
918 handlePHD2AppState(
jsonObj[
"result"].toBool() ? LOOPING : STOPPED);
924 case CONNECTION_RESULT:
925 checkIfEquipmentConnected();
928 case SET_DEC_GUIDE_MODE_COMMAND_RECEIVED:
932 case SET_EXPOSURE_COMMAND_RECEIVED:
933 requestExposureTime();
936 case SET_LOCK_POSITION:
937 handlePHD2AppState(SELECTED);
943 case SET_PAUSED_COMMAND_RECEIVED:
944 handlePHD2AppState(PAUSED);
949 case STOP_CAPTURE_COMMAND_RECEIVED:
950 handlePHD2AppState(STOPPED);
965 PHD2ResultType resultType = takeRequestFromList(
jsonError);
970 case SET_EXPOSURE_COMMAND_RECEIVED:
971 emit newLog(logValidExposureTimes);
975 case CONNECTION_RESULT:
976 connection = EQUIPMENT_DISCONNECTED;
977 emit newStatus(Ekos::GUIDE_DISCONNECTED);
980 case DITHER_COMMAND_RECEIVED:
983 isDitherActive =
false;
984 emit newStatus(GUIDE_DITHERING_ERROR);
986 if (Options::ditherFailAbortsAutoGuide())
989 emit newLog(
"PHD2: failing after dithering aborts.");
990 emit newStatus(GUIDE_ABORTED);
999 case GUIDE_COMMAND_RECEIVED:
1029 long naxes[2] = { width, height };
1093 fdata->loadFromBuffer(buffer,
"fits");
1095 m_GuideFrame->loadData(
fdata);
1097 m_GuideFrame->updateFrame();
1098 m_GuideFrame->setTrackingBox(
QRect(0, 0, width, height));
1099 emit newStarPixmap(m_GuideFrame->getTrackingBoxPixmap());
1102void PHD2::setEquipmentConnected()
1104 if (connection != EQUIPMENT_CONNECTED)
1106 setConnectedRetries = 0;
1107 connection = EQUIPMENT_CONNECTED;
1108 emit newStatus(Ekos::GUIDE_CONNECTED);
1109 updateGuideParameters();
1110 requestExposureDurations();
1111 requestCurrentEquipmentUpdate();
1115void PHD2::updateGuideParameters()
1117 if (pixelScale == 0)
1118 requestPixelScale();
1119 requestExposureTime();
1126void PHD2::captureSingleFrame()
1128 sendPHD2Request(
"capture_single_frame");
1132bool PHD2::clearCalibration()
1134 if (connection != EQUIPMENT_CONNECTED)
1136 emit newLog(
i18n(
"PHD2 Error: Equipment not connected."));
1137 emit newStatus(Ekos::GUIDE_ABORTED);
1144 sendPHD2Request(
"clear_calibration",
args);
1150bool PHD2::dither(
double pixels)
1152 if (connection != EQUIPMENT_CONNECTED)
1154 emit newLog(
i18n(
"PHD2 Error: Equipment not connected."));
1155 emit newStatus(Ekos::GUIDE_ABORTED);
1161 qCDebug(
KSTARS_EKOS_GUIDE) <<
"PHD2: ignoring dither requested while already settling";
1163 if (!isDitherActive)
1167 handlePHD2AppState(DITHERING);
1168 isDitherActive =
true;
1176 int ditherTimeout =
static_cast<int>(Options::ditherTimeout());
1178 settle.
insert(
"pixels",
static_cast<double>(Options::ditherThreshold()));
1179 settle.
insert(
"time",
static_cast<int>(Options::ditherSettle()));
1190 isDitherActive =
true;
1200 ditherTimer->start(
millis);
1202 sendPHD2Request(
"dither",
args);
1204 handlePHD2AppState(DITHERING);
1215void PHD2::requestAppState()
1217 sendPHD2Request(
"get_app_state");
1224void PHD2::checkIfEquipmentConnected()
1226 sendPHD2Request(
"get_connected");
1231void PHD2::requestCurrentEquipmentUpdate()
1233 sendPHD2Request(
"get_current_equipment");
1237void PHD2::checkDEGuideMode()
1239 sendPHD2Request(
"get_dec_guide_mode");
1243void PHD2::requestExposureTime()
1245 sendPHD2Request(
"get_exposure");
1249void PHD2::requestExposureDurations()
1251 sendPHD2Request(
"get_exposure_durations");
1255void PHD2::requestLockPosition()
1257 sendPHD2Request(
"get_lock_position");
1264void PHD2::requestPixelScale()
1266 sendPHD2Request(
"get_pixel_scale");
1275void PHD2::requestStarImage(
int size)
1277 if (starImageRequested)
1279 if (Options::verboseLogging())
1286 sendPHD2Request(
"get_star_image",
args2);
1288 starImageRequested =
true;
1296 if (state == GUIDING)
1298 emit newLog(
i18n(
"PHD2: Guiding is already running."));
1299 emit newStatus(Ekos::GUIDE_GUIDING);
1303 if (connection != EQUIPMENT_CONNECTED)
1305 emit newLog(
i18n(
"PHD2 Error: Equipment not connected."));
1306 emit newStatus(Ekos::GUIDE_ABORTED);
1313 settle.
insert(
"pixels",
static_cast<double>(Options::ditherThreshold()));
1314 settle.
insert(
"time",
static_cast<int>(Options::ditherSettle()));
1315 settle.
insert(
"timeout",
static_cast<int>(Options::ditherTimeout()));
1325 sendPHD2Request(
"guide",
args);
1334 sendPHD2Request(
"loop");
1340void PHD2::connectEquipment(
bool enable)
1342 if (connection == EQUIPMENT_CONNECTED && enable ==
true)
1345 if (connection == EQUIPMENT_DISCONNECTED && enable ==
false)
1348 if (setConnectedRetries++ > MAX_SET_CONNECTED_RETRIES)
1350 setConnectedRetries = 0;
1351 connection = EQUIPMENT_DISCONNECTED;
1352 emit newStatus(Ekos::GUIDE_DISCONNECTED);
1364 emit newLog(
i18n(
"PHD2: Connecting Equipment. . ."));
1366 emit newLog(
i18n(
"PHD2: Disconnecting Equipment. . ."));
1368 sendPHD2Request(
"set_connected",
args);
1393 sendPHD2Request(
"set_dec_guide_mode",
args);
1397void PHD2::requestSetExposureTime(
int time)
1401 sendPHD2Request(
"set_exposure",
args);
1405void PHD2::setLockPosition(
double x,
double y)
1409 args << x << y <<
false;
1410 sendPHD2Request(
"set_lock_position",
args);
1418 if (connection != EQUIPMENT_CONNECTED)
1420 emit newLog(
i18n(
"PHD2 Error: Equipment not connected."));
1421 emit newStatus(Ekos::GUIDE_ABORTED);
1432 sendPHD2Request(
"set_paused",
args);
1447 if (connection != EQUIPMENT_CONNECTED)
1449 emit newLog(
i18n(
"PHD2 Error: Equipment not connected."));
1450 emit newStatus(Ekos::GUIDE_ABORTED);
1459 sendPHD2Request(
"set_paused",
args);
1461 if (state == LOSTLOCK)
1464 abortTimer->
start(
static_cast<int>(Options::guideLostStarTimeout()) * 1000);
1476 if (connection != EQUIPMENT_CONNECTED)
1478 emit newLog(
i18n(
"PHD2 Error: Equipment not connected."));
1479 emit newStatus(Ekos::GUIDE_ABORTED);
1485 sendPHD2Request(
"stop_capture");
1490bool PHD2::calibrate()
1499void PHD2::sendRpcCall(
QJsonObject &call, PHD2ResultType resultType)
1501 assert(resultType != NO_RESULT);
1502 assert(pendingRpcResultType == NO_RESULT);
1506 int rpcId = nextRpcId++;
1515 qint64
const n = tcpSocket->write(request);
1517 if ((
int) n == request.
size())
1520 pendingRpcId =
rpcId;
1521 pendingRpcResultType = resultType;
1530void PHD2::sendNextRpcCall()
1532 if (pendingRpcResultType != NO_RESULT)
1535 if (rpcRequestQueue.empty())
1538 RpcCall &call = rpcRequestQueue.front();
1539 sendRpcCall(call.call, call.resultType);
1540 rpcRequestQueue.pop_front();
1547 PHD2ResultType resultType = methodResults[method];
1551 jsonRPC.insert(
"jsonrpc",
"2.0");
1552 jsonRPC.insert(
"method", method);
1557 if (pendingRpcResultType == NO_RESULT)
1560 sendRpcCall(
jsonRPC, resultType);
1567 if (Options::verboseLogging())
1570 rpcRequestQueue.push_back(RpcCall(
jsonRPC, resultType));
1588 qCDebug(
KSTARS_EKOS_GUIDE) <<
"PHD2: ignoring unexpected response with id" << id;
1592 PHD2ResultType val = pendingRpcResultType;
1593 pendingRpcResultType = NO_RESULT;
QString i18n(const char *text, const TYPE &arg...)
char * toString(const EngineQuery &query)
Ekos is an advanced Astrophotography tool for Linux.
void error(QWidget *parent, const QString &text, const QString &title, const KGuiItem &buttonOk, Options options=Notify)
NETWORKMANAGERQT_EXPORT NetworkManager::Status status()
void errorOccurred(QAbstractSocket::SocketError socketError)
QByteArray & append(QByteArrayView data)
QByteArray fromBase64(const QByteArray &base64, Base64Options options)
QByteArray fromRawData(const char *data, qsizetype size)
bool isEmpty() const const
qsizetype size() const const
bool contains(const Key &key) const const
T value(const Key &key) const const
QJsonDocument fromJson(const QByteArray &json, QJsonParseError *error)
QByteArray toJson(JsonFormat format) const const
iterator insert(QLatin1StringView key, const QJsonValue &value)
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
bool isEmpty() const const
QString number(double n, char format, int precision)
bool isActive() const const