//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processIncomingJdwpData(Device device, java.nio.channels.SocketChannel monitorSocket, int length) throws java.io.IOException
private void processIncomingJdwpData(Device device, SocketChannel monitorSocket, int length)
{
if (length >= 0)
{
// array for the current pids.
List <int?> pidList = new List <int?>();
// get the string data if there are any
if (length > 0)
{
var buffer = new byte[length];
string result = read(monitorSocket, buffer);
// split each line in its own list and create an array of integer pid
string[] pids = StringHelperClass.StringSplit(result, "\n", true); //$NON-NLS-1$
foreach (string pid in pids)
{
try
{
pidList.Add(Convert.ToInt32(pid));
}
catch (SystemException)
{
// looks like this pid is not really a number. Lets ignore it.
continue;
}
}
}
MonitorThread monitorThread = MonitorThread.instance;
// Now we merge the current list with the old one.
// this is the same mechanism as the merging of the device list.
// For each client in the current list, we look for a matching the pid in the new list.
// * if we find it, we do nothing, except removing the pid from its list,
// to mark it as "processed"
// * if we do not find any match, we remove the client from the current list.
// Once this is done, the new list contains pids for which we don't have clients yet,
// so we create clients for them, add them to the list, and start monitoring them.
IList <Client> clients = device.clientList;
bool changed = false;
// because MonitorThread#dropClient acquires first the monitorThread lock and then the
// Device client list lock (when removing the Client from the list), we have to make
// sure we acquire the locks in the same order, since another thread (MonitorThread),
// could call dropClient itself.
lock (monitorThread)
{
lock (clients)
{
for (int c = 0; c < clients.Count;)
{
Client client = clients[c];
int pid = client.clientData.pid;
// look for a matching pid
int?match = null;
foreach (int?matchingPid in pidList)
{
if (pid == (int)matchingPid)
{
match = matchingPid;
break;
}
}
if (match != null)
{
pidList.Remove(match);
c++; // move on to the next client.
}
else
{
// we need to drop the client. the client will remove itself from the
// list of its device which is 'clients', so there's no need to
// increment c.
// We ask the monitor thread to not send notification, as we'll do
// it once at the end.
monitorThread.dropClient(client, false); // notify
changed = true;
}
}
}
}
// at this point whatever pid is left in the list needs to be converted into Clients.
foreach (int newPid in pidList)
{
openClient(device, newPid, nextDebuggerPort, monitorThread);
changed = true;
}
if (changed)
{
mServer.deviceChanged(device, DeviceConstants.CHANGE_CLIENT_LIST);
}
}
}
private void deviceClientMonitorLoop()
{
do
{
try
{
// This synchronized block stops us from doing the select() if a new
// Device is being added.
// @see startMonitoringDevice()
lock (mDevices)
{
}
int count = mSelector.select();
if (mQuit)
{
return;
}
lock (mClientsToReopen)
{
if (mClientsToReopen.Count > 0)
{
var clients = mClientsToReopen.Keys;
MonitorThread monitorThread = MonitorThread.instance;
foreach (Client client in clients)
{
Device device = client.deviceImpl;
int pid = client.clientData.pid;
monitorThread.dropClient(client, false); // notify
// This is kinda bad, but if we don't wait a bit, the client
// will never answer the second handshake!
waitABit();
int port = mClientsToReopen[client];
if (port == DebugPortManager.DebugPortProvider.NO_STATIC_PORT)
{
port = nextDebuggerPort;
}
Log.d("DeviceMonitor", "Reopening " + client);
openClient(device, pid, port, monitorThread);
device.update(DeviceConstants.CHANGE_CLIENT_LIST);
}
mClientsToReopen.Clear();
}
}
if (count == 0)
{
continue;
}
var keys = mSelector.selectedKeys();
foreach (var key in keys)
{
//SelectionKey key = iter.Current;
//iter.remove();
if (key.valid && key.readable)
{
object attachment = key.attachment();
if (attachment is Device)
{
Device device = (Device)attachment;
SocketChannel socket = device.clientMonitoringSocket;
if (socket != null)
{
try
{
int length = readLength(socket, mLengthBuffer2);
processIncomingJdwpData(device, socket, length);
}
catch (IOException ioe)
{
Log.d("DeviceMonitor", "Error reading jdwp list: " + ioe.Message);
socket.close();
// restart the monitoring of that device
lock (mDevices)
{
if (mDevices.Contains(device))
{
Log.d("DeviceMonitor", "Restarting monitoring service for " + device);
startMonitoringDevice(device);
}
}
}
}
}
}
}
}
catch (IOException)
{
if (mQuit == false)
{
}
}
} while (mQuit == false);
}
