diff options
5 files changed, 243 insertions, 3 deletions
diff --git a/ddms/libs/ddmlib/src/com/android/ddmlib/AndroidDebugBridge.java b/ddms/libs/ddmlib/src/com/android/ddmlib/AndroidDebugBridge.java index 795bf88..0957171 100644 --- a/ddms/libs/ddmlib/src/com/android/ddmlib/AndroidDebugBridge.java +++ b/ddms/libs/ddmlib/src/com/android/ddmlib/AndroidDebugBridge.java @@ -194,6 +194,7 @@ public final class AndroidDebugBridge { HandleThread.register(monitorThread); HandleHeap.register(monitorThread); HandleWait.register(monitorThread); + HandleProfiling.register(monitorThread); } /** diff --git a/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHeap.java b/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHeap.java index 5752b86..5111638 100644 --- a/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHeap.java +++ b/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHeap.java @@ -32,6 +32,7 @@ final class HandleHeap extends ChunkHandler { public static final int CHUNK_HPEN = type("HPEN"); public static final int CHUNK_HPSG = type("HPSG"); public static final int CHUNK_HPGC = type("HPGC"); + public static final int CHUNK_HPDU = type("HPDU"); public static final int CHUNK_REAE = type("REAE"); public static final int CHUNK_REAQ = type("REAQ"); public static final int CHUNK_REAL = type("REAL"); @@ -98,6 +99,8 @@ final class HandleHeap extends ChunkHandler { client.update(Client.CHANGE_HEAP_DATA); } else if (type == CHUNK_HPSG) { handleHPSG(client, data); + } else if (type == CHUNK_HPDU) { + handleHPDU(client, data); } else if (type == CHUNK_REAQ) { handleREAQ(client, data); client.update(Client.CHANGE_HEAP_ALLOCATION_STATUS); @@ -221,6 +224,44 @@ final class HandleHeap extends ChunkHandler { } /** + * Sends an HPDU request to the client. + * + * We will get an HPDU response when the heap dump has completed. On + * failure we get a generic failure response. + * + * @param fileName name of output file (on device) + */ + public static void sendHPDU(Client client, String fileName) + throws IOException { + ByteBuffer rawBuf = allocBuffer(4 + fileName.length() * 2); + JdwpPacket packet = new JdwpPacket(rawBuf); + ByteBuffer buf = getChunkDataBuf(rawBuf); + + buf.putInt(fileName.length()); + putString(buf, fileName); + + finishChunkPacket(packet, CHUNK_HPDU, buf.position()); + Log.d("ddm-heap", "Sending " + name(CHUNK_HPDU) + " '" + fileName +"'"); + client.sendAndConsume(packet, mInst); + } + + /* + * Handle notification of completion of a HeaP DUmp. + */ + private void handleHPDU(Client client, ByteBuffer data) { + byte result; + + result = data.get(); + + if (result == 0) { + Log.i("ddm-heap", "Heap dump request has finished"); + // TODO: stuff + } else { + Log.w("ddm-heap", "Heap dump request failed (check device log)"); + } + } + + /** * Sends a REAE (REcent Allocation Enable) request to the client. */ public static void sendREAE(Client client, boolean enable) diff --git a/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHello.java b/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHello.java index 5ba5aeb..fb9697c 100644 --- a/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHello.java +++ b/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHello.java @@ -20,11 +20,12 @@ import java.io.IOException; import java.nio.ByteBuffer; /** - * Handle the "hello" chunk (HELO). + * Handle the "hello" chunk (HELO) and feature discovery. */ final class HandleHello extends ChunkHandler { public static final int CHUNK_HELO = ChunkHandler.type("HELO"); + public static final int CHUNK_FEAT = ChunkHandler.type("FEAT"); private static final HandleHello mInst = new HandleHello(); @@ -65,6 +66,8 @@ final class HandleHello extends ChunkHandler { if (type == CHUNK_HELO) { assert isReply; handleHELO(client, data); + } else if (type == CHUNK_FEAT) { + handleFEAT(client, data); } else { handleUnknownChunk(client, type, data, isReply, msgId); } @@ -126,5 +129,37 @@ final class HandleHello extends ChunkHandler { + " ID=0x" + Integer.toHexString(packet.getId())); client.sendAndConsume(packet, mInst); } + + /** + * Handle a reply to our FEAT request. + */ + private static void handleFEAT(Client client, ByteBuffer data) { + int featureCount; + int i; + + featureCount = data.getInt(); + for (i = 0; i < featureCount; i++) { + int len = data.getInt(); + String feature = getString(data, len); + + Log.d("ddm-hello", "Feature: " + feature); + } + } + + /** + * Send a FEAT request to the client. + */ + public static void sendFEAT(Client client) throws IOException { + ByteBuffer rawBuf = allocBuffer(0); + JdwpPacket packet = new JdwpPacket(rawBuf); + ByteBuffer buf = getChunkDataBuf(rawBuf); + + // no data + + finishChunkPacket(packet, CHUNK_FEAT, buf.position()); + Log.d("ddm-heap", "Sending " + name(CHUNK_FEAT)); + client.sendAndConsume(packet, mInst); + } + } diff --git a/ddms/libs/ddmlib/src/com/android/ddmlib/HandleProfiling.java b/ddms/libs/ddmlib/src/com/android/ddmlib/HandleProfiling.java new file mode 100644 index 0000000..e8e8103 --- /dev/null +++ b/ddms/libs/ddmlib/src/com/android/ddmlib/HandleProfiling.java @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.ddmlib; + +import java.io.IOException; +import java.nio.ByteBuffer; + +/** + * Handle heap status updates. + */ +final class HandleProfiling extends ChunkHandler { + + public static final int CHUNK_MPRS = type("MPRS"); + public static final int CHUNK_MPRE = type("MPRE"); + public static final int CHUNK_MPRQ = type("MPRQ"); + + private static final HandleProfiling mInst = new HandleProfiling(); + + private HandleProfiling() {} + + /** + * Register for the packets we expect to get from the client. + */ + public static void register(MonitorThread mt) { + mt.registerChunkHandler(CHUNK_MPRE, mInst); + mt.registerChunkHandler(CHUNK_MPRQ, mInst); + } + + /** + * Client is ready. + */ + @Override + public void clientReady(Client client) throws IOException {} + + /** + * Client went away. + */ + @Override + public void clientDisconnected(Client client) {} + + /** + * Chunk handler entry point. + */ + @Override + public void handleChunk(Client client, int type, ByteBuffer data, + boolean isReply, int msgId) { + + Log.d("ddm-prof", "handling " + ChunkHandler.name(type)); + + if (type == CHUNK_MPRE) { + handleMPRE(client, data); + } else if (type == CHUNK_MPRQ) { + handleMPRQ(client, data); + } else { + handleUnknownChunk(client, type, data, isReply, msgId); + } + } + + /** + * Send a MPRS (Method PRofiling Start) request to the client. + * + * @param fileName is the name of the file to which profiling data + * will be written (on the device); it will have ".trace" + * appended if necessary + * @param bufferSize is the desired buffer size in bytes (8MB is good) + * @param flags should be zero + */ + public static void sendMPRS(Client client, String fileName, int bufferSize, + int flags) throws IOException { + + ByteBuffer rawBuf = allocBuffer(3*4 + fileName.length() * 2); + JdwpPacket packet = new JdwpPacket(rawBuf); + ByteBuffer buf = getChunkDataBuf(rawBuf); + + buf.putInt(bufferSize); + buf.putInt(flags); + buf.putInt(fileName.length()); + putString(buf, fileName); + + finishChunkPacket(packet, CHUNK_MPRS, buf.position()); + Log.d("ddm-prof", "Sending " + name(CHUNK_MPRS) + " '" + fileName + + "', size=" + bufferSize + ", flags=" + flags); + client.sendAndConsume(packet, mInst); + } + + /** + * Send a MPRE (Method PRofiling End) request to the client. + */ + public static void sendMPRE(Client client) throws IOException { + ByteBuffer rawBuf = allocBuffer(0); + JdwpPacket packet = new JdwpPacket(rawBuf); + ByteBuffer buf = getChunkDataBuf(rawBuf); + + // no data + + finishChunkPacket(packet, CHUNK_MPRE, buf.position()); + Log.d("ddm-prof", "Sending " + name(CHUNK_MPRE)); + client.sendAndConsume(packet, mInst); + } + + /** + * Handle notification that method profiling has finished writing + * data to disk. + */ + private void handleMPRE(Client client, ByteBuffer data) { + byte result; + + result = data.get(); + + if (result == 0) { + Log.i("ddm-prof", "Method profiling has finished"); + } else { + Log.w("ddm-prof", "Method profiling has failed (check device log)"); + } + + // TODO: stuff + } + + /** + * Send a MPRQ (Method PRofiling Query) request to the client. + */ + public static void sendMPRQ(Client client) throws IOException { + ByteBuffer rawBuf = allocBuffer(0); + JdwpPacket packet = new JdwpPacket(rawBuf); + ByteBuffer buf = getChunkDataBuf(rawBuf); + + // no data + + finishChunkPacket(packet, CHUNK_MPRQ, buf.position()); + Log.d("ddm-prof", "Sending " + name(CHUNK_MPRQ)); + client.sendAndConsume(packet, mInst); + } + + /** + * Receive response to query. + */ + private void handleMPRQ(Client client, ByteBuffer data) { + byte result; + + result = data.get(); + + if (result == 0) { + Log.i("ddm-prof", "Method profiling is not running"); + } else { + Log.i("ddm-prof", "Method profiling is running"); + } + } +} + diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml b/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml index 19cd509..6022a20 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml +++ b/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml @@ -98,7 +98,7 @@ <wizard canFinishEarly="false" category="com.android.ide.eclipse.wizards.category" - class="com.android.ide.eclipse.adt.wizards.newxmlfile.NewXmlFileWizard" + class="com.android.ide.eclipse.editors.wizards.NewXmlFileWizard" finalPerspective="org.eclipse.jdt.ui.JavaPerspective" hasPages="true" icon="icons/android.png" @@ -220,7 +220,7 @@ value="com.android.ide.eclipse.adt.AndroidNature"> </filter> <action - class="com.android.ide.eclipse.adt.wizards.actions.NewXmlFileWizardAction" + class="com.android.ide.eclipse.adt.project.NewXmlFileWizardAction" enablesFor="1" id="com.android.ide.eclipse.adt.project.NewXmlFileWizardAction" label="New Resource File..." |