/****************************************************************************
|
**
|
** Copyright (C) 2018 The Qt Company Ltd.
|
** Contact: https://www.qt.io/licensing/
|
**
|
** This file is part of the Qt VS Tools.
|
**
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
** Commercial License Usage
|
** Licensees holding valid commercial Qt licenses may use this file in
|
** accordance with the commercial license agreement provided with the
|
** Software or, alternatively, in accordance with the terms contained in
|
** a written agreement between you and The Qt Company. For licensing terms
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
** information use the contact form at https://www.qt.io/contact-us.
|
**
|
** GNU General Public License Usage
|
** Alternatively, this file may be used under the terms of the GNU
|
** General Public License version 3 as published by the Free Software
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
** included in the packaging of this file. Please review the following
|
** information to ensure the GNU General Public License requirements will
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
**
|
** $QT_END_LICENSE$
|
**
|
****************************************************************************/
|
|
using QtVsTools.Options;
|
using System;
|
using System.Collections.Concurrent;
|
using System.IO;
|
using System.Net.Sockets;
|
using System.Runtime.InteropServices;
|
using System.Runtime.Serialization;
|
using System.Runtime.Serialization.Json;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace QtVsTools.Qml.Debug.V4
|
{
|
enum DebugClientState { Unavailable, Disconnected, Connecting, Connected, Disconnecting }
|
|
interface IConnectionEventSink
|
{
|
bool QueryRuntimeFrozen();
|
|
void NotifyStateTransition(
|
DebugClient client,
|
DebugClientState oldState,
|
DebugClientState newState);
|
|
void NotifyMessageReceived(
|
DebugClient client,
|
string messageType,
|
byte[] messageParams);
|
}
|
|
class DebugClient : Finalizable
|
{
|
IConnectionEventSink sink;
|
IntPtr client;
|
Task clientThread;
|
EventWaitHandle clientCreated = new EventWaitHandle(false, EventResetMode.ManualReset);
|
EventWaitHandle clientConnected;
|
|
public uint? ThreadId { get; private set; }
|
|
DebugClientState state = DebugClientState.Unavailable;
|
public DebugClientState State
|
{
|
get
|
{
|
if (clientThread == null || clientThread.Status != TaskStatus.Running)
|
return DebugClientState.Unavailable;
|
|
return state;
|
}
|
set
|
{
|
if (state != value) {
|
var oldState = state;
|
state = value;
|
Task.Run(() => sink.NotifyStateTransition(this, oldState, value));
|
}
|
}
|
}
|
|
public static DebugClient Create(IConnectionEventSink sink)
|
{
|
var _this = new DebugClient();
|
return _this.Initialize(sink) ? _this : null;
|
}
|
|
private DebugClient()
|
{ }
|
|
private bool Initialize(IConnectionEventSink sink)
|
{
|
this.sink = sink;
|
|
Task.WaitAny(new[]
|
{
|
// Try to start client thread
|
// Unblock if thread was abruptly terminated (e.g. DLL not found)
|
clientThread = Task.Run(() => ClientThread()),
|
|
// Unblock if client was created (i.e. client thread is running)
|
Task.Run(() => clientCreated.WaitOne())
|
});
|
|
if (State == DebugClientState.Unavailable) {
|
// Client thread did not start
|
clientCreated.Set();
|
Dispose();
|
return false;
|
}
|
|
return true;
|
}
|
|
protected override void DisposeManaged()
|
{
|
clientCreated.Dispose();
|
|
EnterCriticalSection();
|
if (clientConnected != null) {
|
LeaveCriticalSection();
|
clientConnected.Dispose();
|
}
|
}
|
|
protected override void DisposeUnmanaged()
|
{
|
if (State != DebugClientState.Unavailable) {
|
NativeMethods.DebugClientShutdown(client);
|
clientThread.Wait();
|
}
|
}
|
|
private void ClientThread()
|
{
|
ThreadId = NativeMethods.GetCurrentThreadId();
|
|
var clientCreated =
|
new NativeMethods.QmlDebugClientCreated(ClientCreated);
|
var clientDestroyed =
|
new NativeMethods.QmlDebugClientDestroyed(ClientDestroyed);
|
var clientConnected =
|
new NativeMethods.QmlDebugClientConnected(ClientConnected);
|
var clientDisconnected =
|
new NativeMethods.QmlDebugClientDisconnected(ClientDisconnected);
|
var clientMessageReceived =
|
new NativeMethods.QmlDebugClientMessageReceived(ClientMessageReceived);
|
try {
|
NativeMethods.DebugClientThread(
|
clientCreated, clientDestroyed,
|
clientConnected, clientDisconnected,
|
clientMessageReceived);
|
} finally {
|
State = DebugClientState.Unavailable;
|
GC.KeepAlive(clientCreated);
|
GC.KeepAlive(clientDestroyed);
|
GC.KeepAlive(clientConnected);
|
GC.KeepAlive(clientDisconnected);
|
GC.KeepAlive(clientMessageReceived);
|
}
|
}
|
|
public EventWaitHandle Connect(string hostName, ushort hostPort)
|
{
|
if (State != DebugClientState.Disconnected)
|
return null;
|
|
clientConnected = new EventWaitHandle(false, EventResetMode.ManualReset);
|
State = DebugClientState.Connecting;
|
if (string.IsNullOrEmpty(hostName))
|
hostName = "localhost";
|
var hostNameData = Encoding.UTF8.GetBytes(hostName);
|
|
uint timeout = (uint)QtVsToolsPackage.Instance.Options.QmlDebuggerTimeout;
|
Task.Run(() =>
|
{
|
var connectTimer = new System.Diagnostics.Stopwatch();
|
connectTimer.Start();
|
|
var probe = new Socket(
|
AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
while (!probe.Connected
|
&& (timeout == 0 || connectTimer.ElapsedMilliseconds < timeout)) {
|
try {
|
probe.Connect(hostName, hostPort);
|
} catch {
|
Thread.Sleep(3000);
|
}
|
}
|
|
if (probe.Connected) {
|
probe.Disconnect(false);
|
|
NativeMethods.DebugClientConnect(client,
|
hostNameData, hostNameData.Length, hostPort);
|
connectTimer.Restart();
|
|
uint connectionTimeout = Math.Max(3000, timeout / 20);
|
while (!clientConnected.WaitOne(1000)) {
|
|
if (sink.QueryRuntimeFrozen()) {
|
connectTimer.Restart();
|
|
} else {
|
if (connectTimer.ElapsedMilliseconds > connectionTimeout) {
|
if (!Disposing)
|
clientConnected.Set();
|
|
if (Atomic(() => State == DebugClientState.Connected,
|
() => State = DebugClientState.Disconnecting)) {
|
NativeMethods.DebugClientDisconnect(client);
|
}
|
|
} else {
|
NativeMethods.DebugClientConnect(client,
|
hostNameData, hostNameData.Length, hostPort);
|
}
|
}
|
}
|
}
|
});
|
|
return clientConnected;
|
}
|
|
public EventWaitHandle StartLocalServer(string fileName)
|
{
|
if (State != DebugClientState.Disconnected)
|
return null;
|
|
clientConnected = new EventWaitHandle(false, EventResetMode.ManualReset);
|
State = DebugClientState.Connecting;
|
var fileNameData = Encoding.UTF8.GetBytes(fileName);
|
if (!NativeMethods.DebugClientStartLocalServer(client,
|
fileNameData, fileNameData.Length)) {
|
return null;
|
}
|
|
uint timeout = (uint)QtVsToolsPackage.Instance.Options.QmlDebuggerTimeout;
|
if (timeout != 0) {
|
Task.Run(() =>
|
{
|
var connectTimer = new System.Diagnostics.Stopwatch();
|
connectTimer.Start();
|
|
while (!clientConnected.WaitOne(100)) {
|
|
if (sink.QueryRuntimeFrozen()) {
|
connectTimer.Restart();
|
|
} else {
|
if (connectTimer.ElapsedMilliseconds > timeout) {
|
if (!Disposing)
|
clientConnected.Set();
|
|
if (Atomic(() => State == DebugClientState.Connected,
|
() => State = DebugClientState.Disconnecting)) {
|
NativeMethods.DebugClientDisconnect(client);
|
}
|
}
|
}
|
}
|
});
|
}
|
|
return clientConnected;
|
}
|
|
public bool Disconnect()
|
{
|
if (State != DebugClientState.Connected)
|
return false;
|
State = DebugClientState.Disconnecting;
|
return NativeMethods.DebugClientDisconnect(client);
|
}
|
|
public bool SendMessage(string messageType, byte[] messageParams)
|
{
|
if (State != DebugClientState.Connected)
|
return false;
|
var messageTypeData = Encoding.UTF8.GetBytes(messageType);
|
if (messageParams == null)
|
messageParams = new byte[0];
|
|
System.Diagnostics.Debug.WriteLine(string.Format(">> {0} {1}",
|
messageType, Encoding.UTF8.GetString(messageParams)));
|
|
return NativeMethods.DebugClientSendMessage(client,
|
messageTypeData, messageTypeData.Length,
|
messageParams, messageParams.Length);
|
}
|
|
void ClientCreated(IntPtr qmlDebugClient)
|
{
|
if (client != IntPtr.Zero || Disposing)
|
return;
|
|
client = qmlDebugClient;
|
State = DebugClientState.Disconnected;
|
clientCreated.Set();
|
}
|
|
void ClientDestroyed(IntPtr qmlDebugClient)
|
{
|
if (qmlDebugClient != client)
|
return;
|
State = DebugClientState.Unavailable;
|
}
|
|
void ClientConnected(IntPtr qmlDebugClient)
|
{
|
if (qmlDebugClient != client || Disposing)
|
return;
|
State = DebugClientState.Connected;
|
clientConnected.Set();
|
}
|
|
void ClientDisconnected(IntPtr qmlDebugClient)
|
{
|
if (qmlDebugClient != client)
|
return;
|
State = DebugClientState.Disconnected;
|
}
|
|
void ClientMessageReceived(
|
IntPtr qmlDebugClient,
|
byte[] messageTypeData,
|
int messageTypeLength,
|
byte[] messageParamsData,
|
int messageParamsLength)
|
{
|
if (Disposed)
|
return;
|
if (qmlDebugClient != client)
|
return;
|
var messageType = Encoding.UTF8.GetString(messageTypeData);
|
|
System.Diagnostics.Debug.WriteLine(string.Format("<< {0} {1}",
|
messageType, Encoding.UTF8.GetString(messageParamsData)));
|
|
sink.NotifyMessageReceived(this, messageType, messageParamsData);
|
}
|
|
#region //////////////////// Native Methods ///////////////////////////////////////////////
|
|
internal static class NativeMethods
|
{
|
public delegate void QmlDebugClientCreated(IntPtr qmlDebugClient);
|
public delegate void QmlDebugClientDestroyed(IntPtr qmlDebugClient);
|
public delegate void QmlDebugClientConnected(IntPtr qmlDebugClient);
|
public delegate void QmlDebugClientDisconnected(IntPtr qmlDebugClient);
|
public delegate void QmlDebugClientMessageReceived(
|
IntPtr qmlDebugClient,
|
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] messageTypeData,
|
int messageTypeLength,
|
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] byte[] messageParamsData,
|
int messageParamsLength);
|
|
[DllImport("vsqml",
|
CallingConvention = CallingConvention.Cdecl,
|
EntryPoint = "qmlDebugClientThread")]
|
public static extern bool DebugClientThread(
|
QmlDebugClientCreated clientCreated,
|
QmlDebugClientDestroyed clientDestroyed,
|
QmlDebugClientConnected clientConnected,
|
QmlDebugClientDisconnected clientDisconnected,
|
QmlDebugClientMessageReceived clientMessageReceived);
|
|
[DllImport("vsqml",
|
CallingConvention = CallingConvention.Cdecl,
|
EntryPoint = "qmlDebugClientDisconnect")]
|
public static extern bool DebugClientDisconnect(IntPtr qmlDebugClient);
|
|
[DllImport("vsqml",
|
CallingConvention = CallingConvention.Cdecl,
|
EntryPoint = "qmlDebugClientConnect")]
|
public static extern bool DebugClientConnect(
|
IntPtr qmlDebugClient,
|
[MarshalAs(UnmanagedType.LPArray)] byte[] hostNameData,
|
int hostNameLength,
|
ushort hostPort);
|
|
[DllImport("vsqml",
|
CallingConvention = CallingConvention.Cdecl,
|
EntryPoint = "qmlDebugClientStartLocalServer")]
|
public static extern bool DebugClientStartLocalServer(
|
IntPtr qmlDebugClient,
|
[MarshalAs(UnmanagedType.LPArray)] byte[] fileNameData,
|
int fileNameLength);
|
|
[DllImport("vsqml",
|
CallingConvention = CallingConvention.Cdecl,
|
EntryPoint = "qmlDebugClientSendMessage")]
|
public static extern bool DebugClientSendMessage(
|
IntPtr qmlDebugClient,
|
[MarshalAs(UnmanagedType.LPArray)] byte[] messageTypeData,
|
int messageTypeLength,
|
[MarshalAs(UnmanagedType.LPArray)] byte[] messageParamsData,
|
int messageParamsLength);
|
|
[DllImport("vsqml",
|
CallingConvention = CallingConvention.Cdecl,
|
EntryPoint = "qmlDebugClientShutdown")]
|
public static extern bool DebugClientShutdown(IntPtr qmlDebugClient);
|
|
[DllImport("kernel32.dll")]
|
public static extern uint GetCurrentThreadId();
|
}
|
|
#endregion //////////////////// Native Methods ////////////////////////////////////////////
|
|
}
|
}
|
