Ejemplo n.º 1
0
        /// <summary>
        /// Processes an incoming device message from the socket </summary>
        /// <param name="socket"> </param>
        /// <param name="length"> </param>
        /// <exception cref="IOException"> </exception>
        //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
        //ORIGINAL LINE: private void processIncomingDeviceData(int length) throws java.io.IOException
        private void processIncomingDeviceData(int length)
        {
            List <Device> list = new List <Device>();

            if (length > 0)
            {
                var    buffer = new byte[length];
                string result = read(mMainAdbConnection, buffer);

                string[] devices = StringHelperClass.StringSplit(result, "\n", true); //$NON-NLS-1$

                foreach (string d in devices)
                {
                    string[] param = StringHelperClass.StringSplit(d, "\t", true); //$NON-NLS-1$
                    if (param.Length == 2)
                    {
                        // new adb uses only serial numbers to identify devices
                        Device device = new Device(this, param[0], DeviceState.getState(param[1])); //serialnumber

                        //add the device to the list
                        list.Add(device);
                    }
                }
            }

            // now merge the new devices with the old ones.
            updateDevices(list);
        }
Ejemplo n.º 2
0
		/// <summary>
		/// Reads line from the console socket. This call is blocking until we read the lines:
		/// <ul>
		/// <li>OK\r\n</li>
		/// <li>KO<msg>\r\n</li>
		/// </ul> </summary>
		/// <returns> the array of strings read from the emulator. </returns>
		private string[] readLines()
		{
			try
			{
				ByteBuffer buf = ByteBuffer.wrap(mBuffer, 0, mBuffer.Length);
				int numWaits = 0;
				bool stop = false;

				while (buf.position != buf.limit && stop == false)
				{
					int count;

					count = mSocketChannel.read(buf);
					if (count < 0)
					{
						return null;
					}
					else if (count == 0)
					{
						if (numWaits * WAIT_TIME > STD_TIMEOUT)
						{
							return null;
						}
						// non-blocking spin
						try
						{
							Thread.Sleep(WAIT_TIME);
						}
						catch (ThreadInterruptedException)
						{
						}
						numWaits++;
					}
					else
					{
						numWaits = 0;
					}

					// check the last few char aren't OK. For a valid message to test
					// we need at least 4 bytes (OK/KO + \r\n)
					if (buf.position >= 4)
					{
						int pos = buf.position;
						if (endsWithOK(pos) || lastLineIsKO(pos))
						{
							stop = true;
						}
					}
				}

				string msg = mBuffer.getString(0, buf.position, DEFAULT_ENCODING);
				return StringHelperClass.StringSplit(msg, "\r\n", true); //$NON-NLS-1$
			}
			catch (IOException)
			{
				return null;
			}
		}
Ejemplo n.º 3
0
            public override void processNewLines(string[] lines)
            {
                foreach (string line in lines)
                {
                    // no need to handle empty lines.
                    if (line.Length == 0)
                    {
                        continue;
                    }

                    // run the line through the regexp
                    var m = sLsPattern.Match(line);
                    if (m.Success == false)
                    {
                        continue;
                    }

                    // get the name
                    string name = m.Groups[6].Value;

                    // if the parent is root, we only accept selected items
                    if (mParentEntry.root)
                    {
                        bool found = false;
                        foreach (string approved in sRootLevelApprovedItems)
                        {
                            if (approved.Equals(name))
                            {
                                found = true;
                                break;
                            }
                        }

                        // if it's not in the approved list we skip this entry.
                        if (found == false)
                        {
                            continue;
                        }
                    }

                    // get the rest of the groups
                    string permissions = m.Groups[0].Value;
                    string owner = m.Groups[1].Value;
                    string group = m.Groups[2].Value;
                    string size = m.Groups[3].Value;
                    string date = m.Groups[4].Value;
                    string time = m.Groups[5].Value;
                    string info = null;

                    // and the type
                    int objectType = TYPE_OTHER;
                    switch (permissions[0])
                    {
                        case '-':
                            objectType = TYPE_FILE;
                            break;
                        case 'b':
                            objectType = TYPE_BLOCK;
                            break;
                        case 'c':
                            objectType = TYPE_CHARACTER;
                            break;
                        case 'd':
                            objectType = TYPE_DIRECTORY;
                            break;
                        case 'l':
                            objectType = TYPE_LINK;
                            break;
                        case 's':
                            objectType = TYPE_SOCKET;
                            break;
                        case 'p':
                            objectType = TYPE_FIFO;
                            break;
                    }


                    // now check what we may be linking to
                    if (objectType == TYPE_LINK)
                    {
                        string[] segments = StringHelperClass.StringSplit(name, "\\s->\\s", true); //$NON-NLS-1$

                        // we should have 2 segments
                        if (segments.Length == 2)
                        {
                            // update the entry name to not contain the link
                            name = segments[0];

                            // and the link name
                            info = segments[1];

                            // now get the path to the link
                            string[] pathSegments = StringHelperClass.StringSplit(info, FILE_SEPARATOR, true);
                            if (pathSegments.Length == 1)
                            {
                                // the link is to something in the same directory,
                                // unless the link is ..
                                if ("..".Equals(pathSegments[0])) //$NON-NLS-1$
                                {
                                    // set the type and we're done.
                                    objectType = TYPE_DIRECTORY_LINK;
                                }
                                else
                                {
                                    // either we found the object already
                                    // or we'll find it later.
                                }
                            }
                        }

                        // add an arrow in front to specify it's a link.
                        info = "-> " + info; //$NON-NLS-1$;
                    }

                    // get the entry, either from an existing one, or a new one
                    FileEntry entry = getExistingEntry(name);
                    if (entry == null)
                    {
                        entry = new FileEntry(mParentEntry, name, objectType, false); // isRoot
                    }

                    // add some misc info
                    entry.permissions_Renamed = permissions;
                    entry.size_Renamed = size;
                    entry.date_Renamed = date;
                    entry.time_Renamed = time;
                    entry.owner = owner;
                    entry.group = group;
                    if (objectType == TYPE_LINK)
                    {
                        entry.info_Renamed = info;
                    }

                    mEntryList.Add(entry);
                }
            }
Ejemplo n.º 4
0
        //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);
                }
            }
        }