/****************************************************************************
** Meta object code from reading C++ file 'calladapter.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.10.2)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../jami-client-qt/src/app/calladapter.h"
#include <QtNetwork/QSslError>
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'calladapter.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.10.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN11CallAdapterE_t {};
} // unnamed namespace

template <> constexpr inline auto CallAdapter::qt_create_metaobjectdata<qt_meta_tag_ZN11CallAdapterE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CallAdapter",
        "QML.Singleton",
        "true",
        "hasCallChanged",
        "",
        "callInformationListChanged",
        "callStatusChanged",
        "index",
        "accountId",
        "convUid",
        "updateTimeText",
        "time",
        "onShowIncomingCallView",
        "onShowCallView",
        "onAccountChanged",
        "onCallStatusChanged",
        "callId",
        "code",
        "onCallAddedToConference",
        "conversationId",
        "confId",
        "onCallStarted",
        "onCallEnded",
        "onCallInfosChanged",
        "onFallbackConversationSelected",
        "conversationUid",
        "startTimerInformation",
        "stopTimerInformation",
        "startAudioOnlyCall",
        "startCall",
        "endCall",
        "setCallMedia",
        "videoMuted",
        "acceptCall",
        "connectCallModel",
        "sipInputPanelPlayDTMF",
        "key",
        "setActiveStream",
        "uri",
        "deviceId",
        "streamId",
        "minimizeParticipant",
        "showGridConferenceLayout",
        "isCurrentHost",
        "participantIsHost",
        "setModerator",
        "state",
        "isHandRaised",
        "raiseHand",
        "holdThisCallToggle",
        "recordThisCallToggle",
        "muteAudioToggle",
        "isMuted",
        "connectPtt",
        "disconnectPtt",
        "muteCameraToggle",
        "isRecordingThisCall",
        "muteParticipant",
        "accountUri",
        "sinkId",
        "getMuteState",
        "MuteStates",
        "disconnectParticipant",
        "updateCall",
        "forceCallOnly",
        "getCallDurationTime",
        "resetCallInfo",
        "setCallInfo",
        "updateAdvancedInformation",
        "takeScreenshot",
        "QImage",
        "image",
        "path",
        "hasCall",
        "callInformationList",
        "QVariant",
        "UNMUTED",
        "LOCAL_MUTED",
        "MODERATOR_MUTED",
        "BOTH_MUTED"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'hasCallChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'callInformationListChanged'
        QtMocHelpers::SignalData<void()>(5, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'callStatusChanged'
        QtMocHelpers::SignalData<void(int, const QString &, const QString &)>(6, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 7 }, { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Signal 'updateTimeText'
        QtMocHelpers::SignalData<void(const QString &)>(10, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'onShowIncomingCallView'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(12, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Slot 'onShowCallView'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(13, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Slot 'onAccountChanged'
        QtMocHelpers::SlotData<void()>(14, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onCallStatusChanged'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(15, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 16 },
        }}),
        // Slot 'onCallStatusChanged'
        QtMocHelpers::SlotData<void(const QString &, const QString &, int)>(15, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 16 }, { QMetaType::Int, 17 },
        }}),
        // Slot 'onCallAddedToConference'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &)>(18, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 }, { QMetaType::QString, 19 }, { QMetaType::QString, 20 },
        }}),
        // Slot 'onCallStarted'
        QtMocHelpers::SlotData<void(const QString &)>(21, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 },
        }}),
        // Slot 'onCallEnded'
        QtMocHelpers::SlotData<void(const QString &)>(22, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 },
        }}),
        // Slot 'onCallInfosChanged'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(23, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 16 },
        }}),
        // Slot 'onFallbackConversationSelected'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(24, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 25 },
        }}),
        // Method 'startTimerInformation'
        QtMocHelpers::MethodData<void()>(26, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'stopTimerInformation'
        QtMocHelpers::MethodData<void()>(27, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'startAudioOnlyCall'
        QtMocHelpers::MethodData<void()>(28, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'startCall'
        QtMocHelpers::MethodData<void()>(29, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'endCall'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(30, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Method 'setCallMedia'
        QtMocHelpers::MethodData<void(const QString &, const QString &, bool)>(31, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 }, { QMetaType::Bool, 32 },
        }}),
        // Method 'acceptCall'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(33, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Method 'connectCallModel'
        QtMocHelpers::MethodData<void(const QString &)>(34, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'sipInputPanelPlayDTMF'
        QtMocHelpers::MethodData<void(const QString &)>(35, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Method 'endCall'
        QtMocHelpers::MethodData<void(const QString &)>(30, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 },
        }}),
        // Method 'setActiveStream'
        QtMocHelpers::MethodData<void(const QString &, const QString &, const QString &)>(37, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 }, { QMetaType::QString, 39 }, { QMetaType::QString, 40 },
        }}),
        // Method 'minimizeParticipant'
        QtMocHelpers::MethodData<void(const QString &)>(41, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 },
        }}),
        // Method 'showGridConferenceLayout'
        QtMocHelpers::MethodData<void()>(42, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'endCall'
        QtMocHelpers::MethodData<void()>(30, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'isCurrentHost'
        QtMocHelpers::MethodData<bool() const>(43, 4, QMC::AccessPublic, QMetaType::Bool),
        // Method 'participantIsHost'
        QtMocHelpers::MethodData<bool(const QString &) const>(44, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 38 },
        }}),
        // Method 'setModerator'
        QtMocHelpers::MethodData<void(const QString &, const bool)>(45, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 }, { QMetaType::Bool, 46 },
        }}),
        // Method 'isHandRaised'
        QtMocHelpers::MethodData<bool(const QString &) const>(47, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 38 },
        }}),
        // Method 'isHandRaised'
        QtMocHelpers::MethodData<bool() const>(47, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Method 'raiseHand'
        QtMocHelpers::MethodData<void(const QString &, const QString &, bool)>(48, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 }, { QMetaType::QString, 39 }, { QMetaType::Bool, 46 },
        }}),
        // Method 'holdThisCallToggle'
        QtMocHelpers::MethodData<void()>(49, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'recordThisCallToggle'
        QtMocHelpers::MethodData<void()>(50, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'muteAudioToggle'
        QtMocHelpers::MethodData<void()>(51, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'isMuted'
        QtMocHelpers::MethodData<bool(const QString &)>(52, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 16 },
        }}),
        // Method 'connectPtt'
        QtMocHelpers::MethodData<void()>(53, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'disconnectPtt'
        QtMocHelpers::MethodData<void()>(54, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'muteCameraToggle'
        QtMocHelpers::MethodData<void()>(55, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'isRecordingThisCall'
        QtMocHelpers::MethodData<bool()>(56, 4, QMC::AccessPublic, QMetaType::Bool),
        // Method 'muteParticipant'
        QtMocHelpers::MethodData<void(const QString &, const QString &, const QString &, const bool)>(57, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 58 }, { QMetaType::QString, 39 }, { QMetaType::QString, 59 }, { QMetaType::Bool, 46 },
        }}),
        // Method 'getMuteState'
        QtMocHelpers::MethodData<enum MuteStates(const QString &) const>(60, 4, QMC::AccessPublic, 0x80000000 | 61, {{
            { QMetaType::QString, 38 },
        }}),
        // Method 'disconnectParticipant'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(62, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 }, { QMetaType::QString, 39 },
        }}),
        // Method 'updateCall'
        QtMocHelpers::MethodData<void(const QString &, const QString &, bool)>(63, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 }, { QMetaType::QString, 8 }, { QMetaType::Bool, 64 },
        }}),
        // Method 'updateCall'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(63, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 9 }, { QMetaType::QString, 8 },
        }}),
        // Method 'updateCall'
        QtMocHelpers::MethodData<void(const QString &)>(63, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 9 },
        }}),
        // Method 'updateCall'
        QtMocHelpers::MethodData<void()>(63, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'getCallDurationTime'
        QtMocHelpers::MethodData<QString(const QString &, const QString &)>(65, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Method 'resetCallInfo'
        QtMocHelpers::MethodData<void()>(66, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'setCallInfo'
        QtMocHelpers::MethodData<void()>(67, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'updateAdvancedInformation'
        QtMocHelpers::MethodData<void()>(68, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'takeScreenshot'
        QtMocHelpers::MethodData<bool(const QImage &, const QString &)>(69, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 70, 71 }, { QMetaType::QString, 72 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'hasCall'
        QtMocHelpers::PropertyData<bool>(73, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
        // property 'callInformationList'
        QtMocHelpers::PropertyData<QVariant>(74, 0x80000000 | 75, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'MuteStates'
        QtMocHelpers::EnumData<enum MuteStates>(61, 61, QMC::EnumFlags{}).add({
            {   76, MuteStates::UNMUTED },
            {   77, MuteStates::LOCAL_MUTED },
            {   78, MuteStates::MODERATOR_MUTED },
            {   79, MuteStates::BOTH_MUTED },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<CallAdapter, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject CallAdapter::staticMetaObject = { {
    QMetaObject::SuperData::link<QmlAdapterBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11CallAdapterE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11CallAdapterE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11CallAdapterE_t>.metaTypes,
    nullptr
} };

void CallAdapter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CallAdapter *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->hasCallChanged(); break;
        case 1: _t->callInformationListChanged(); break;
        case 2: _t->callStatusChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 3: _t->updateTimeText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->onShowIncomingCallView((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 5: _t->onShowCallView((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 6: _t->onAccountChanged(); break;
        case 7: _t->onCallStatusChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 8: _t->onCallStatusChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 9: _t->onCallAddedToConference((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 10: _t->onCallStarted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 11: _t->onCallEnded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 12: _t->onCallInfosChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 13: _t->onFallbackConversationSelected((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 14: _t->startTimerInformation(); break;
        case 15: _t->stopTimerInformation(); break;
        case 16: _t->startAudioOnlyCall(); break;
        case 17: _t->startCall(); break;
        case 18: _t->endCall((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 19: _t->setCallMedia((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 20: _t->acceptCall((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 21: _t->connectCallModel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 22: _t->sipInputPanelPlayDTMF((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 23: _t->endCall((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 24: _t->setActiveStream((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 25: _t->minimizeParticipant((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->showGridConferenceLayout(); break;
        case 27: _t->endCall(); break;
        case 28: { bool _r = _t->isCurrentHost();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 29: { bool _r = _t->participantIsHost((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 30: _t->setModerator((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 31: { bool _r = _t->isHandRaised((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 32: { bool _r = _t->isHandRaised();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 33: _t->raiseHand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 34: _t->holdThisCallToggle(); break;
        case 35: _t->recordThisCallToggle(); break;
        case 36: _t->muteAudioToggle(); break;
        case 37: { bool _r = _t->isMuted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 38: _t->connectPtt(); break;
        case 39: _t->disconnectPtt(); break;
        case 40: _t->muteCameraToggle(); break;
        case 41: { bool _r = _t->isRecordingThisCall();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 42: _t->muteParticipant((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 43: { enum MuteStates _r = _t->getMuteState((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<enum MuteStates*>(_a[0]) = std::move(_r); }  break;
        case 44: _t->disconnectParticipant((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 45: _t->updateCall((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 46: _t->updateCall((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 47: _t->updateCall((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 48: _t->updateCall(); break;
        case 49: { QString _r = _t->getCallDurationTime((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 50: _t->resetCallInfo(); break;
        case 51: _t->setCallInfo(); break;
        case 52: _t->updateAdvancedInformation(); break;
        case 53: { bool _r = _t->takeScreenshot((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CallAdapter::*)()>(_a, &CallAdapter::hasCallChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (CallAdapter::*)()>(_a, &CallAdapter::callInformationListChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (CallAdapter::*)(int , const QString & , const QString & )>(_a, &CallAdapter::callStatusChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (CallAdapter::*)(const QString & )>(_a, &CallAdapter::updateTimeText, 3))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->hasCall_; break;
        case 1: *reinterpret_cast<QVariant*>(_v) = _t->get_callInformationList(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0:
            if (QtMocHelpers::setProperty(_t->hasCall_, *reinterpret_cast<bool*>(_v)))
                Q_EMIT _t->hasCallChanged();
            break;
        default: break;
        }
    }
}

const QMetaObject *CallAdapter::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *CallAdapter::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11CallAdapterE_t>.strings))
        return static_cast<void*>(this);
    return QmlAdapterBase::qt_metacast(_clname);
}

int CallAdapter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QmlAdapterBase::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 54)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 54;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 54)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 54;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void CallAdapter::hasCallChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void CallAdapter::callInformationListChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void CallAdapter::callStatusChanged(int _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2, _t3);
}

// SIGNAL 3
void CallAdapter::updateTimeText(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
QT_WARNING_POP
