Java IDebugPortProvider类代码示例

import com.android.ddmlib.DebugPortManager.IDebugPortProvider; //导入依赖的package包/类
/**
 * Check that the client is opened with the proper debugger port for the
 * specified application name, and if not, reopen it.
 * @param client
 * @param uiThread
 * @param appName
 * @return
 */
protected static Client checkDebuggerPortForAppName(Client client, String appName) {
    IDebugPortProvider provider = DebugPortManager.getProvider();
    if (provider != null) {
        Device device = client.getDeviceImpl();
        int newPort = provider.getPort(device, appName);

        if (newPort != IDebugPortProvider.NO_STATIC_PORT &&
                newPort != client.getDebuggerListenPort()) {

            AndroidDebugBridge bridge = AndroidDebugBridge.getBridge();
            if (bridge != null) {
                DeviceMonitor deviceMonitor = bridge.getDeviceMonitor();
                if (deviceMonitor != null) {
                    deviceMonitor.addClientToDropAndReopen(client, newPort);
                    client = null;
                }
            }
        }
    }

    return client;
}
 

import com.android.ddmlib.DebugPortManager.IDebugPortProvider; //导入依赖的package包/类
/**
 * Return information for the first full JDWP packet in the buffer.
 *
 * If we don't yet have a full packet, return null.
 *
 * If we haven't yet received the JDWP handshake, we watch for it here
 * and consume it without admitting to have done so.  Upon receipt
 * we send out the "HELO" message, which is why this can throw an
 * IOException.
 */
JdwpPacket getJdwpPacket() throws IOException {

    /*
     * On entry, the data starts at offset 0 and ends at "position".
     * "limit" is set to the buffer capacity.
     */
    if (mConnState == ST_AWAIT_SHAKE) {
        /*
         * The first thing we get from the client is a response to our
         * handshake.  It doesn't look like a packet, so we have to
         * handle it specially.
         */
        int result;

        result = JdwpPacket.findHandshake(mReadBuffer);
        //Log.v("ddms", "findHand: " + result);
        switch (result) {
            case JdwpPacket.HANDSHAKE_GOOD:
                Log.d("ddms",
                    "Good handshake from client, sending HELO to " + mClientData.getPid());
                JdwpPacket.consumeHandshake(mReadBuffer);
                mConnState = ST_NEED_DDM_PKT;
                HandleHello.sendHelloCommands(this, SERVER_PROTOCOL_VERSION);
                // see if we have another packet in the buffer
                return getJdwpPacket();
            case JdwpPacket.HANDSHAKE_BAD:
                Log.d("ddms", "Bad handshake from client");
                if (MonitorThread.getInstance().getRetryOnBadHandshake()) {
                    // we should drop the client, but also attempt to reopen it.
                    // This is done by the DeviceMonitor.
                    mDevice.getMonitor().addClientToDropAndReopen(this,
                            IDebugPortProvider.NO_STATIC_PORT);
                } else {
                    // mark it as bad, close the socket, and don't retry
                    mConnState = ST_NOT_JDWP;
                    close(true /* notify */);
                }
                break;
            case JdwpPacket.HANDSHAKE_NOTYET:
                Log.d("ddms", "No handshake from client yet.");
                break;
            default:
                Log.e("ddms", "Unknown packet while waiting for client handshake");
        }
        return null;
    } else if (mConnState == ST_NEED_DDM_PKT ||
        mConnState == ST_NOT_DDM ||
        mConnState == ST_READY) {
        /*
         * Normal packet traffic.
         */
        if (mReadBuffer.position() != 0) {
            if (Log.Config.LOGV) Log.v("ddms",
                "Checking " + mReadBuffer.position() + " bytes");
        }
        return JdwpPacket.findPacket(mReadBuffer);
    } else {
        /*
         * Not expecting data when in this state.
         */
        Log.e("ddms", "Receiving data in state = " + mConnState);
    }

    return null;
}
 

import com.android.ddmlib.DebugPortManager.IDebugPortProvider; //导入依赖的package包/类
private void processDebuggerData(SelectionKey key) {
    Debugger dbg = (Debugger)key.attachment();

    try {
        /*
         * Read pending data.
         */
        dbg.read();

        /*
         * See if we have a full packet in the buffer. It's possible we have
         * more than one packet, so we have to loop.
         */
        JdwpPacket packet = dbg.getJdwpPacket();
        while (packet != null) {
            Log.v("ddms", "Forwarding dbg req 0x"
                    + Integer.toHexString(packet.getId()) + " to "
                    + dbg.getClient());

            dbg.forwardPacketToClient(packet);

            packet = dbg.getJdwpPacket();
        }
    } catch (IOException ioe) {
        /*
         * Close data connection; automatically un-registers dbg from
         * selector. The failure could be caused by the debugger going away,
         * or by the client going away and failing to accept our data.
         * Either way, the debugger connection does not need to exist any
         * longer. We also need to recycle the connection to the client, so
         * that the VM sees the debugger disconnect. For a DDM-aware client
         * this won't be necessary, and we can just send a "debugger
         * disconnected" message.
         */
        Log.d("ddms", "Closing connection to debugger " + dbg);
        dbg.closeData();
        Client client = dbg.getClient();
        if (client.isDdmAware()) {
            // TODO: soft-disconnect DDM-aware clients
            Log.d("ddms", " (recycling client connection as well)");

            // we should drop the client, but also attempt to reopen it.
            // This is done by the DeviceMonitor.
            client.getDeviceImpl().getMonitor().addClientToDropAndReopen(client,
                    IDebugPortProvider.NO_STATIC_PORT);
        } else {
            Log.d("ddms", " (recycling client connection as well)");
            // we should drop the client, but also attempt to reopen it.
            // This is done by the DeviceMonitor.
            client.getDeviceImpl().getMonitor().addClientToDropAndReopen(client,
                    IDebugPortProvider.NO_STATIC_PORT);
        }
    }
}