Plugin interfaces

Plugin interfaces. More...

Collaboration diagram for Plugin interfaces:

Modules
	Desktop class
	Terminal class

Classes
class	CBackend
	Backend interface. More...
class	CBackendThread
	The backend thread. More...
class	CFrmScroll
	The scroll form class. More...
class	CFrmViewer
	A widget which displays output image from a CConnectDesktop and sends input keypresses and mouse activity to the CConnectDesktop. More...
class	CManager
	Manage plugins. More...
class	COperate
	Operate interface. More...
class	CParameter
	Parameter interface. More...
class	CPlugin
	Plugin interface. More...

Detailed Description

Plugin interfaces.

• Thread module
  • Blocked: Most control protocol implementation library connections are blocking.

    See also

    CPluginClient COperateThread

  • No-blocking: eg: qt event. A thread can handle multiple connections.
    • The plugin does not have a background thread, and all connections use the main thread
    • The plugin has a background thread, and all connections use the same background thread

      See also

      CPluginClientThread COperateDesktop

• Class relationship
• Sequence diagram
• Write a plugin:
  • The format of the generated plug-in target name is: PluginClient${PROJECT_NAME}

    # Author: Kang Lin <kl222@126.com>
     
    project(FreeRDP
        DESCRIPTION "FreeRDP client plugin"
        )
     
    SET(FreeRDP_LIBS freerdp-client freerdp winpr Plugin)
     
    SET(FreeRDP_SOURCE_FILES
        ParameterFreeRDP.cpp
        PluginFreeRDP.cpp
        BackendFreeRDP.cpp
        OperateFreeRDP.cpp
        DlgSetFreeRDP.cpp
        ConvertKeyCode.cpp
        CursorFreeRDP.cpp
        ClipboardFreeRDP.cpp
        ClipboardMimeData.cpp
        DlgGetUserPasswordFreeRDP.cpp
        DlgDesktopSize.cpp
        )
     
    SET(FreeRDP_HEADER_FILES
        ParameterFreeRDP.h
        PluginFreeRDP.h
        BackendFreeRDP.h
        OperateFreeRDP.h
        DlgSetFreeRDP.h
        ConvertKeyCode.h
        CursorFreeRDP.h
        ClipboardFreeRDP.h
        ClipboardMimeData.h
        DlgGetUserPasswordFreeRDP.h
        DlgDesktopSize.h
        )
     
    SET(FreeRDP_UI_FILES
        DlgSetFreeRDP.ui
        DlgGetUserPasswordFreeRDP.ui
        DlgDesktopSize.ui
        )
     
    find_package(FreeRDP)
    if(FreeRDP_VERSION_MAJOR VERSION_GREATER_EQUAL 3)
        list(APPEND FreeRDP_HEADER_FILES ConnectLayer.h ConnectLayerQTcpSocket.h)
        list(APPEND FreeRDP_SOURCE_FILES ConnectLayer.cpp ConnectLayerQTcpSocket.cpp)
     
        find_package(libssh)
        if(libssh_FOUND)
            list(APPEND FreeRDP_HEADER_FILES ConnectLayerSSHTunnel.h)
            list(APPEND FreeRDP_SOURCE_FILES ConnectLayerSSHTunnel.cpp)
        endif()
    endif()
     
    if(WIN32)
        list(APPEND FreeRDP_LIBS Credui.dll)
    endif()
    if(MINGW)
        set(FreeRDP_OPTIONS -fpermissive)
    endif()
     
    set(FreeRDP_QT_COMPONENTS Widgets Multimedia PrintSupport SerialPort)
    find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS ${FreeRDP_QT_COMPONENTS})
    if(Qt${QT_VERSION_MAJOR}_FOUND)
        FOREACH(_COMPONENT ${FreeRDP_QT_COMPONENTS})
            list(APPEND FreeRDP_LIBS Qt${QT_VERSION_MAJOR}::${_COMPONENT})
        ENDFOREACH()
    endif()
    ADD_PLUGIN_TARGET(NAME PluginClient${PROJECT_NAME}
        ISPLUGIN
        SOURCE_FILES ${FreeRDP_SOURCE_FILES} ${FreeRDP_HEADER_FILES} ${FreeRDP_UI_FILES}
        PRIVATE_LIBS ${FreeRDP_LIBS}
        PRIVATE_INCLUDE_DIRS ${FreeRDP_INCLUDE_DIR} ${WinPR_INCLUDE_DIR}
        PRIVATE_DEFINITIONS ${FreeRDP_DEFINITIONS}
           PluginFreeDP_VERSION="${RabbitRemoteControl_VERSION}"
        PRIVATE_OPTIONS ${FreeRDP_OPTIONS}
        INSTALL_DIR ${PLUGIN_PATH}
        OUTPUT_DIR ${CMAKE_BINARY_DIR}/${PLUGIN_PATH}
        INSTALL_RPATH ${INSTALL_RPATH}
        VERSION ${RabbitRemoteControl_VERSION}
        )

  • Implement CPluginClient.
    • No background thread or Blocked background thread (A background thread handles a connection. The connection is blocked.). E.g. FreeRDP
      • Derive from CPluginClient. For example: CPluginFreeRDP
        • Implement the Qt interface in the class declaration:

              Q_INTERFACES(CPlugin)
           
          #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
              Q_PLUGIN_METADATA(IID CPlugin_iid)
          #endif

        • Initialize the operation in the constructor. For example: initializing resources, loading translation resources, etc.
        • Release resources in the destructor.
        • Implement properties and functions
          • Plugin name: This name must be the same as the project name (${PROJECT_NAME}). The translation file (${PROJECT_NAME}_*.ts)) name is associated with it. E.g. CPluginFreeRDP::Name()

            // Author: Kang Lin <kl222@126.com>
             
            #include "PluginFreeRDP.h"
            #include "OperateFreeRDP.h"
            #include "winpr/wlog.h"
             
            #include <QLoggingCategory>
             
            #ifdef HAVE_LIBSSH
                #include "ChannelSSHTunnel.h"
            #endif
             
            #include "freerdp/version.h"
             
            static Q_LOGGING_CATEGORY(log, "FreeRDP.Plugin")
            static Q_LOGGING_CATEGORY(LoggerFreeRDP, "FreeRDP.Log")
            static Q_LOGGING_CATEGORY(LoggerFreeRDPTrace, "FreeRDP.Log.Trace")
            static Q_LOGGING_CATEGORY(LoggerFreeRDPFatal, "FreeRDP.Log.Fatal")
             
            CPluginFreeRDP::CPluginFreeRDP(QObject *parent)
                : CPlugin(parent)
            {
                qDebug(log) << Q_FUNC_INFO;
                qInfo(log) << "FreeRDP version:" << freerdp_get_version_string()
                                    << "revision:" << freerdp_get_build_revision();
             
                static wLogCallbacks* pCbLog = new wLogCallbacks;
                BOOL bRet = WLog_SetLogAppenderType(WLog_GetRoot(), WLOG_APPENDER_CALLBACK);
                if(bRet && pCbLog)
                {
                    memset(pCbLog, 0, sizeof(wLogCallbacks));
                    pCbLog->message = [](const wLogMessage* msg)->BOOL{
                        switch(msg->Level)
                        {
                        case WLOG_TRACE:
                            qDebug(LoggerFreeRDPTrace) /*<< msg->PrefixString */ << msg->TextString;
                            break;
                        case WLOG_DEBUG:
                            qDebug(LoggerFreeRDP) /*<< msg->PrefixString */ << msg->TextString;
                            break;
                        case WLOG_INFO:
                            qInfo(LoggerFreeRDP) /*<< msg->PrefixString*/ << msg->TextString;
                            break;
                        case WLOG_WARN:
                            qWarning(LoggerFreeRDP) /*<< msg->PrefixString */<< msg->TextString;
                        case WLOG_ERROR:
                            qCritical(LoggerFreeRDP) /*<< msg->PrefixString*/ << msg->TextString;
                            break;
                        case WLOG_FATAL:
                        case WLOG_OFF:
                            qCritical(LoggerFreeRDPFatal) /*<< msg->PrefixString*/ << msg->TextString;
                            break;
                        default:
                            break;
                        }
                        return TRUE;
                    };
                    WLog_ConfigureAppender(WLog_GetLogAppender(WLog_GetRoot()), "callbacks", pCbLog);
                }
                WLog_SetLogLevel(WLog_GetRoot(), WLOG_TRACE);
            }
             
            CPluginFreeRDP::~CPluginFreeRDP()
            {
                qDebug(log) << Q_FUNC_INFO;
            }
             
            const CPlugin::TYPE CPluginFreeRDP::Type() const
            {
                return TYPE::RemoteDesktop;
            }
             
            const QString CPluginFreeRDP::Name() const
            {
                return "FreeRDP";
            }
             
            const QString CPluginFreeRDP::DisplayName() const
            {
                return tr("Free remote desktop protocol");
            }
             
            const QString CPluginFreeRDP::Description() const
            {
                return tr("RDP(Remote desktop Protocol): Access remote desktops such as windows.") + "\n"
                       + tr("It uses FreeRDP: https://github.com/FreeRDP/FreeRDP/");
            }
             
            const QString CPluginFreeRDP::Protocol() const
            {
                return "RDP";
            }
             
            const QIcon CPluginFreeRDP::Icon() const
            {
                return QIcon::fromTheme("windows");
            }
             
            const QString CPluginFreeRDP::Version() const
            {
                return PluginFreeDP_VERSION;
            }
             
            const QString CPluginFreeRDP::Details() const
            {
                QString szDetails;
                szDetails = "- " + tr("FreeRDP");
                szDetails += "\n";
                szDetails += "  - " + tr("version: ");
                szDetails += freerdp_get_version_string();
                szDetails += "\n";
                szDetails += "  - " + tr("Build version: ");
                szDetails += freerdp_get_build_revision();
                szDetails += ":";
                szDetails += freerdp_get_build_revision();
                szDetails += "\n";
            #if FREERDP_VERSION_MAJOR < 3
                szDetails += "  - " + tr("Build date: ");
                szDetails += freerdp_get_build_date();
                szDetails += "\n";
            #endif
                szDetails += "  - ";
                szDetails += freerdp_get_build_config();
             
            #ifdef HAVE_LIBSSH
                CChannelSSH channel(nullptr, nullptr);
                szDetails += channel.GetDetails();
            #endif
             
                return szDetails;
            }
             
            COperate *CPluginFreeRDP::OnCreateOperate(const QString &szId)
            {
                if(Id() == szId)
                    return new COperateFreeRDP(this);
             
                return nullptr;
            }

    • No-blocking background thread: One background thread handles multiple connections.(Not used yet) The connection is non-blocking.
      • Derive from CPluginClientThread.
        • Implement the Qt interface in the class declaration:

              Q_INTERFACES(CPlugin)
           
          #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
              Q_PLUGIN_METADATA(IID CPlugin_iid)
          #endif

        • Initialize the operation in the constructor. For example: initializing resources, loading translation resources, etc.

           
              //rfb::SecurityClient::setDefaults();
           

        • Release resources in the destructor.
        • Implement properties and functions
          • Plugin name: This name must be the same as the project name (${PROJECT_NAME}). The translation file (${PROJECT_NAME}_*.ts)) name is associated with it.

            // Author: Kang Lin <kl222@126.com>
             
            #include "PluginRabbitVNC.h"
             
            #include "RabbitCommonDir.h"
            #include "../../TigerVnc/Client/ConnecterVnc.h"
             
            #include <QLoggingCategory>
             
            Q_LOGGING_CATEGORY(log, "RabbitVNC")
             
            CPluginRabbitVNC::CPluginRabbitVNC(QObject *parent)
                : CPluginClient(parent)
            {
             
                //rfb::SecurityClient::setDefaults();
             
            }
             
            CPluginRabbitVNC::~CPluginRabbitVNC()
            {
                qDebug(log) << "CPluginRabbitVnc::~CPluginRabbitVnc()";
            }
             
            const CPluginRabbitVNC::TYPE CPluginRabbitVNC::Type() const
            {
                return TYPE::RemoteDesktop;
            }
             
            const QString CPluginRabbitVNC::Name() const
            {
                return "RabbitVNC";
            }
             
            const QString CPluginRabbitVNC::DisplayName() const
            {
                return tr("RabbitVNC");
            }
             
            const QString CPluginRabbitVNC::Description() const
            {
                return tr("VNC(Virtual Network Console): Access remote desktops such as unix/linux, windows, etc.") + "\n"
                       + tr("VNC is a set of programs using the RFB (Remote Frame Buffer) protocol.") + "\n"
                       + tr("The plugin is used RabbitVNC");
            }
             
            const QString CPluginRabbitVNC::Protocol() const
            {
                return "RFB";
            }
             
            const QIcon CPluginRabbitVNC::Icon() const
            {
                return QIcon::fromTheme("network-wired");
            }
             
            const QString CPluginRabbitVNC::Version() const
            {
                return PluginRabbitVNC_VERSION;
            }
             
            COperate *CPluginRabbitVNC::OnCreateOperate(const QString &szID)
            {
                if(Id() == szID)
                {
                    return new CConnecterVnc(this);
                }
                return nullptr;
            }

  • Implement COperate.
    • Implement remote desktop
      • Blocked: Implements a remote desktop background thread to handle a remote desktop connection, which can be derived from COperateThread. Eg: COperateFreeRDP
      • No-blocking: Implements a background thread to handle multiple remote desktop connections, which can be derived from COperateDesktop.
    • Implement remote console, which can be derived from COperateTerminal
    • If the above two cannot meet your needs, you can be derived from COperate
  • Implement a specific connection, derived from CConnect. For example: CConnectFreeRDP