io.qt.bluetooth.QBluetoothSocket Maven / Gradle / Ivy

Go to download
package io.qt.bluetooth;

import io.qt.*;


/**
 * Enables connection to a Bluetooth device running a bluetooth server
 * Java wrapper for Qt class QBluetoothSocket
 */
public class QBluetoothSocket extends io.qt.core.QIODevice
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * This variable stores the meta-object for the class.
     */
    public static final io.qt.core.@NonNull QMetaObject staticMetaObject = io.qt.core.QMetaObject.forType(QBluetoothSocket.class);
    
    /**
     * Java wrapper for Qt enum QBluetoothSocket::SocketError
     */
    public enum SocketError implements QtEnumerator {
        /**
         * Representing QBluetoothSocket::NoSocketError
         */
        NoSocketError(-2),
        /**
         * Representing QBluetoothSocket::UnknownSocketError
         */
        UnknownSocketError(-1),
        /**
         * Representing QBluetoothSocket::RemoteHostClosedError
         */
        RemoteHostClosedError(1),
        /**
         * Representing QBluetoothSocket::HostNotFoundError
         */
        HostNotFoundError(2),
        /**
         * Representing QBluetoothSocket::ServiceNotFoundError
         */
        ServiceNotFoundError(9),
        /**
         * Representing QBluetoothSocket::NetworkError
         */
        NetworkError(7),
        /**
         * Representing QBluetoothSocket::UnsupportedProtocolError
         */
        UnsupportedProtocolError(8),
        /**
         * Representing QBluetoothSocket::OperationError
         */
        OperationError(19);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private SocketError(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull SocketError resolve(int value) {
            switch (value) {
            case -2: return NoSocketError;
            case -1: return UnknownSocketError;
            case 1: return RemoteHostClosedError;
            case 2: return HostNotFoundError;
            case 9: return ServiceNotFoundError;
            case 7: return NetworkError;
            case 8: return UnsupportedProtocolError;
            case 19: return OperationError;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothSocket::SocketState
     */
    public enum SocketState implements QtEnumerator {
        /**
         * Representing QBluetoothSocket::UnconnectedState
         */
        UnconnectedState(0),
        /**
         * Representing QBluetoothSocket::ServiceLookupState
         */
        ServiceLookupState(1),
        /**
         * Representing QBluetoothSocket::ConnectingState
         */
        ConnectingState(2),
        /**
         * Representing QBluetoothSocket::ConnectedState
         */
        ConnectedState(3),
        /**
         * Representing QBluetoothSocket::BoundState
         */
        BoundState(4),
        /**
         * Representing QBluetoothSocket::ClosingState
         */
        ClosingState(6),
        /**
         * Representing QBluetoothSocket::ListeningState
         */
        ListeningState(5);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private SocketState(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull SocketState resolve(int value) {
            switch (value) {
            case 0: return UnconnectedState;
            case 1: return ServiceLookupState;
            case 2: return ConnectingState;
            case 3: return ConnectedState;
            case 4: return BoundState;
            case 6: return ClosingState;
            case 5: return ListeningState;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    

    /**
     * See QBluetoothSocket::connected()
     */
    public final @NonNull Signal0 connected = new Signal0();

    /**
     * See QBluetoothSocket::disconnected()
     */
    public final @NonNull Signal0 disconnected = new Signal0();

    /**
     * See QBluetoothSocket::error(QBluetoothSocket::SocketError)
     */
    public final @NonNull Signal1 error = new Signal1<>();

    /**
     * See QBluetoothSocket::stateChanged(QBluetoothSocket::SocketState)
     */
    public final @NonNull Signal1 stateChanged = new Signal1<>();
    
    /**
     * See QBluetoothSocket::QBluetoothSocket(QBluetoothServiceInfo::Protocol,QObject*)
     */
    public QBluetoothSocket(io.qt.bluetooth.QBluetoothServiceInfo.@NonNull Protocol socketType, io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, socketType, parent);
    }
    
    private native static void initialize_native(QBluetoothSocket instance, io.qt.bluetooth.QBluetoothServiceInfo.Protocol socketType, io.qt.core.QObject parent);
    
    /**
     * See QBluetoothSocket::QBluetoothSocket(QObject*)
     */
    public QBluetoothSocket(io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, parent);
    }
    
    private native static void initialize_native(QBluetoothSocket instance, io.qt.core.QObject parent);
    
    /**
     * See QBluetoothSocket::abort()
     */
    @QtUninvokable
    public final void abort(){
        abort_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void abort_native(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::connectToService(QBluetoothAddress,QBluetoothUuid,QIODevice::OpenMode)
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, io.qt.bluetooth.@NonNull QBluetoothUuid uuid, io.qt.core.QIODevice.@NonNull OpenMode openMode){
        connectToService_native_cref_QBluetoothAddress_cref_QBluetoothUuid_QIODevice_OpenMode(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(address), QtJambi_LibraryUtilities.internal.checkedNativeId(uuid), openMode.value());
    }
    
    @QtUninvokable
    private native void connectToService_native_cref_QBluetoothAddress_cref_QBluetoothUuid_QIODevice_OpenMode(long __this__nativeId, long address, long uuid, int openMode);
    
    /**
     * See QBluetoothSocket::connectToService(QBluetoothAddress,QBluetoothUuid::ServiceClassUuid,QIODevice::OpenMode)
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, io.qt.bluetooth.QBluetoothUuid.@NonNull ServiceClassUuid uuid, io.qt.core.QIODevice.@NonNull OpenMode mode){
        connectToService_native_cref_QBluetoothAddress_QBluetoothUuid_ServiceClassUuid_QIODevice_OpenMode(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(address), uuid.value(), mode.value());
    }
    
    @QtUninvokable
    private native void connectToService_native_cref_QBluetoothAddress_QBluetoothUuid_ServiceClassUuid_QIODevice_OpenMode(long __this__nativeId, long address, int uuid, int mode);
    
    /**
     * See QBluetoothSocket::connectToService(QBluetoothAddress,quint16,QIODevice::OpenMode)
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, short port, io.qt.core.QIODevice.@NonNull OpenMode openMode){
        connectToService_native_cref_QBluetoothAddress_quint16_QIODevice_OpenMode(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(address), port, openMode.value());
    }
    
    @QtUninvokable
    private native void connectToService_native_cref_QBluetoothAddress_quint16_QIODevice_OpenMode(long __this__nativeId, long address, short port, int openMode);
    
    /**
     * See QBluetoothSocket::connectToService(QBluetoothServiceInfo,QIODevice::OpenMode)
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothServiceInfo service, io.qt.core.QIODevice.@NonNull OpenMode openMode){
        connectToService_native_cref_QBluetoothServiceInfo_QIODevice_OpenMode(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(service), openMode.value());
    }
    
    @QtUninvokable
    private native void connectToService_native_cref_QBluetoothServiceInfo_QIODevice_OpenMode(long __this__nativeId, long service, int openMode);
    
    /**
     * See QBluetoothSocket::disconnectFromService()
     */
    @QtUninvokable
    public final void disconnectFromService(){
        disconnectFromService_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void disconnectFromService_native(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::doDeviceDiscovery(QBluetoothServiceInfo,QIODevice::OpenMode)
     */
    @QtUninvokable
    protected final void doDeviceDiscovery(io.qt.bluetooth.@NonNull QBluetoothServiceInfo service, io.qt.core.QIODevice.@NonNull OpenMode openMode){
        doDeviceDiscovery_native_cref_QBluetoothServiceInfo_QIODevice_OpenMode(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(service), openMode.value());
    }
    
    @QtUninvokable
    private native void doDeviceDiscovery_native_cref_QBluetoothServiceInfo_QIODevice_OpenMode(long __this__nativeId, long service, int openMode);
    
    /**
     * See QBluetoothSocket::error()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetoothSocket.@NonNull SocketError error(){
        return io.qt.bluetooth.QBluetoothSocket.SocketError.resolve(error_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int error_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::errorString()const
     */
    @QtUninvokable
    public final java.lang.@NonNull String socketErrorString(){
        return socketErrorString_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String socketErrorString_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::localAddress()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.@NonNull QBluetoothAddress localAddress(){
        return localAddress_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.bluetooth.QBluetoothAddress localAddress_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::localName()const
     */
    @QtUninvokable
    public final java.lang.@NonNull String localName(){
        return localName_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String localName_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::localPort()const
     */
    @QtUninvokable
    public final short localPort(){
        return localPort_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native short localPort_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::peerAddress()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.@NonNull QBluetoothAddress peerAddress(){
        return peerAddress_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.bluetooth.QBluetoothAddress peerAddress_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::peerName()const
     */
    @QtUninvokable
    public final java.lang.@NonNull String peerName(){
        return peerName_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String peerName_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::peerPort()const
     */
    @QtUninvokable
    public final short peerPort(){
        return peerPort_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native short peerPort_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::preferredSecurityFlags()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetooth.@NonNull SecurityFlags preferredSecurityFlags(){
        return new io.qt.bluetooth.QBluetooth.SecurityFlags(preferredSecurityFlags_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int preferredSecurityFlags_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::setPreferredSecurityFlags(QBluetooth::SecurityFlags)
     */
    @QtUninvokable
    public final void setPreferredSecurityFlags(io.qt.bluetooth.QBluetooth.@NonNull SecurityFlags flags){
        setPreferredSecurityFlags_native_QBluetooth_SecurityFlags(QtJambi_LibraryUtilities.internal.nativeId(this), flags.value());
    }
    
    @QtUninvokable
    private native void setPreferredSecurityFlags_native_QBluetooth_SecurityFlags(long __this__nativeId, int flags);
    
    /**
     * See QBluetoothSocket::setSocketDescriptor(int,QBluetoothServiceInfo::Protocol,QBluetoothSocket::SocketState,QIODevice::OpenMode)
     */
    @QtUninvokable
    public final boolean setSocketDescriptor(int socketDescriptor, io.qt.bluetooth.QBluetoothServiceInfo.@NonNull Protocol socketType, io.qt.bluetooth.QBluetoothSocket.@NonNull SocketState socketState, io.qt.core.QIODevice.@NonNull OpenMode openMode){
        return setSocketDescriptor_native_int_QBluetoothServiceInfo_Protocol_QBluetoothSocket_SocketState_QIODevice_OpenMode(QtJambi_LibraryUtilities.internal.nativeId(this), socketDescriptor, socketType.value(), socketState.value(), openMode.value());
    }
    
    @QtUninvokable
    private native boolean setSocketDescriptor_native_int_QBluetoothServiceInfo_Protocol_QBluetoothSocket_SocketState_QIODevice_OpenMode(long __this__nativeId, int socketDescriptor, int socketType, int socketState, int openMode);
    
    /**
     * See QBluetoothSocket::setSocketError(QBluetoothSocket::SocketError)
     */
    @QtUninvokable
    protected final void setSocketError(io.qt.bluetooth.QBluetoothSocket.@NonNull SocketError error){
        setSocketError_native_QBluetoothSocket_SocketError(QtJambi_LibraryUtilities.internal.nativeId(this), error.value());
    }
    
    @QtUninvokable
    private native void setSocketError_native_QBluetoothSocket_SocketError(long __this__nativeId, int error);
    
    /**
     * See QBluetoothSocket::setSocketState(QBluetoothSocket::SocketState)
     */
    @QtUninvokable
    protected final void setSocketState(io.qt.bluetooth.QBluetoothSocket.@NonNull SocketState state){
        setSocketState_native_QBluetoothSocket_SocketState(QtJambi_LibraryUtilities.internal.nativeId(this), state.value());
    }
    
    @QtUninvokable
    private native void setSocketState_native_QBluetoothSocket_SocketState(long __this__nativeId, int state);
    
    /**
     * See QBluetoothSocket::socketDescriptor()const
     */
    @QtUninvokable
    public final int socketDescriptor(){
        return socketDescriptor_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int socketDescriptor_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::socketType()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetoothServiceInfo.@NonNull Protocol socketType(){
        return io.qt.bluetooth.QBluetoothServiceInfo.Protocol.resolve(socketType_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int socketType_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothSocket::state()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetoothSocket.@NonNull SocketState state(){
        return io.qt.bluetooth.QBluetoothSocket.SocketState.resolve(state_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int state_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::bytesAvailable()const
     */
    @QtUninvokable
    public long bytesAvailable(){
        return bytesAvailable_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long bytesAvailable_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::bytesToWrite()const
     */
    @QtUninvokable
    public long bytesToWrite(){
        return bytesToWrite_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long bytesToWrite_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::canReadLine()const
     */
    @QtUninvokable
    public boolean canReadLine(){
        return canReadLine_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean canReadLine_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::close()
     */
    @QtUninvokable
    public void close(){
        close_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void close_native(long __this__nativeId);
    
    /**
     * See QIODevice::isSequential()const
     */
    @QtUninvokable
    @Override
    public boolean isSequential(){
        return isSequential_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isSequential_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::readData(char*,qint64)
     */
    @QtUninvokable
    protected int readData(java.nio.@Nullable ByteBuffer data){
        return readData_native_char_ptr_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), data);
    }
    
    @QtUninvokable
    private native int readData_native_char_ptr_qint64(long __this__nativeId, java.nio.ByteBuffer data);
    
    /**
     * See QIODevice::writeData(const char*,qint64)
     */
    @QtUninvokable
    protected int writeData(java.nio.@Nullable ByteBuffer data){
        return writeData_native_const_char_ptr_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), data);
    }
    
    @QtUninvokable
    private native int writeData_native_const_char_ptr_qint64(long __this__nativeId, java.nio.ByteBuffer data);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QBluetoothSocket(QPrivateConstructor p) { super(p); } 
    
    /**
     * Constructor for internal use only.
     * It is not allowed to call the declarative constructor from inside Java.
     * @hidden
     */
    @NativeAccess
    protected QBluetoothSocket(QDeclarativeConstructor constructor) {
        super((QPrivateConstructor)null);
        initialize_native(this, constructor);
    } 
    
    @QtUninvokable
    private static native void initialize_native(QBluetoothSocket instance, QDeclarativeConstructor constructor);
    
    
    /**
     * Overloaded constructor for {@link #QBluetoothSocket(io.qt.bluetooth.QBluetoothServiceInfo.Protocol, io.qt.core.QObject)}
     *  with parent = null.
     */
    public QBluetoothSocket(io.qt.bluetooth.QBluetoothServiceInfo.@NonNull Protocol socketType) {
        this(socketType, (io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QBluetoothSocket(io.qt.core.QObject)}
     *  with parent = null.
     */
    public QBluetoothSocket() {
        this((io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothAddress, io.qt.bluetooth.QBluetoothUuid, io.qt.core.QIODevice.OpenMode)}
     *  with openMode = new io.qt.core.QIODevice.OpenMode(3).
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, io.qt.bluetooth.@NonNull QBluetoothUuid uuid) {
        connectToService(address, uuid, new io.qt.core.QIODevice.OpenMode(3));
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothAddress, io.qt.bluetooth.QBluetoothUuid, io.qt.core.QIODevice.OpenMode)}.
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, io.qt.bluetooth.@NonNull QBluetoothUuid uuid, io.qt.core.QIODevice.@NonNull OpenModeFlag @NonNull... openMode) {
        connectToService(address, uuid, new io.qt.core.QIODevice.OpenMode(openMode));
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothAddress, io.qt.bluetooth.QBluetoothUuid.ServiceClassUuid, io.qt.core.QIODevice.OpenMode)}
     *  with mode = new io.qt.core.QIODevice.OpenMode(3).
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, io.qt.bluetooth.QBluetoothUuid.@NonNull ServiceClassUuid uuid) {
        connectToService(address, uuid, new io.qt.core.QIODevice.OpenMode(3));
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothAddress, io.qt.bluetooth.QBluetoothUuid.ServiceClassUuid, io.qt.core.QIODevice.OpenMode)}.
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, io.qt.bluetooth.QBluetoothUuid.@NonNull ServiceClassUuid uuid, io.qt.core.QIODevice.@NonNull OpenModeFlag @NonNull... mode) {
        connectToService(address, uuid, new io.qt.core.QIODevice.OpenMode(mode));
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothAddress, short, io.qt.core.QIODevice.OpenMode)}
     *  with openMode = new io.qt.core.QIODevice.OpenMode(3).
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, short port) {
        connectToService(address, port, new io.qt.core.QIODevice.OpenMode(3));
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothAddress, short, io.qt.core.QIODevice.OpenMode)}.
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothAddress address, short port, io.qt.core.QIODevice.@NonNull OpenModeFlag @NonNull... openMode) {
        connectToService(address, port, new io.qt.core.QIODevice.OpenMode(openMode));
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothServiceInfo, io.qt.core.QIODevice.OpenMode)}
     *  with openMode = new io.qt.core.QIODevice.OpenMode(3).
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothServiceInfo service) {
        connectToService(service, new io.qt.core.QIODevice.OpenMode(3));
    }
    
    /**
     * Overloaded function for {@link #connectToService(io.qt.bluetooth.QBluetoothServiceInfo, io.qt.core.QIODevice.OpenMode)}.
     */
    @QtUninvokable
    public final void connectToService(io.qt.bluetooth.@NonNull QBluetoothServiceInfo service, io.qt.core.QIODevice.@NonNull OpenModeFlag @NonNull... openMode) {
        connectToService(service, new io.qt.core.QIODevice.OpenMode(openMode));
    }
    
    /**
     * Overloaded function for {@link #doDeviceDiscovery(io.qt.bluetooth.QBluetoothServiceInfo, io.qt.core.QIODevice.OpenMode)}.
     */
    @QtUninvokable
    protected final void doDeviceDiscovery(io.qt.bluetooth.@NonNull QBluetoothServiceInfo service, io.qt.core.QIODevice.@NonNull OpenModeFlag @NonNull... openMode) {
        doDeviceDiscovery(service, new io.qt.core.QIODevice.OpenMode(openMode));
    }
    
    /**
     * Overloaded function for {@link #setPreferredSecurityFlags(io.qt.bluetooth.QBluetooth.SecurityFlags)}.
     */
    @QtUninvokable
    public final void setPreferredSecurityFlags(io.qt.bluetooth.QBluetooth.@NonNull Security @NonNull... flags) {
        setPreferredSecurityFlags(new io.qt.bluetooth.QBluetooth.SecurityFlags(flags));
    }
    
    /**
     * Overloaded function for {@link #setSocketDescriptor(int, io.qt.bluetooth.QBluetoothServiceInfo.Protocol, io.qt.bluetooth.QBluetoothSocket.SocketState, io.qt.core.QIODevice.OpenMode)}
     *  with openMode = new io.qt.core.QIODevice.OpenMode(3).
     */
    @QtUninvokable
    public final boolean setSocketDescriptor(int socketDescriptor, io.qt.bluetooth.QBluetoothServiceInfo.@NonNull Protocol socketType, io.qt.bluetooth.QBluetoothSocket.@NonNull SocketState socketState) {
        return setSocketDescriptor(socketDescriptor, socketType, socketState, new io.qt.core.QIODevice.OpenMode(3));
    }
    
    /**
     * Overloaded function for {@link #setSocketDescriptor(int, io.qt.bluetooth.QBluetoothServiceInfo.Protocol, io.qt.bluetooth.QBluetoothSocket.SocketState, io.qt.core.QIODevice.OpenMode)}
     * with: 

     * socketState = io.qt.bluetooth.QBluetoothSocket.SocketState.ConnectedState
     * openMode = new io.qt.core.QIODevice.OpenMode(3)
     * 
     */
    @QtUninvokable
    public final boolean setSocketDescriptor(int socketDescriptor, io.qt.bluetooth.QBluetoothServiceInfo.@NonNull Protocol socketType) {
        return setSocketDescriptor(socketDescriptor, socketType, io.qt.bluetooth.QBluetoothSocket.SocketState.ConnectedState, new io.qt.core.QIODevice.OpenMode(3));
    }
    
    /**
     * Overloaded function for {@link #setSocketDescriptor(int, io.qt.bluetooth.QBluetoothServiceInfo.Protocol, io.qt.bluetooth.QBluetoothSocket.SocketState, io.qt.core.QIODevice.OpenMode)}.
     */
    @QtUninvokable
    public final boolean setSocketDescriptor(int socketDescriptor, io.qt.bluetooth.QBluetoothServiceInfo.@NonNull Protocol socketType, io.qt.bluetooth.QBluetoothSocket.@NonNull SocketState socketState, io.qt.core.QIODevice.@NonNull OpenModeFlag @NonNull... openMode) {
        return setSocketDescriptor(socketDescriptor, socketType, socketState, new io.qt.core.QIODevice.OpenMode(openMode));
    }
}