LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Automated import from //branches/donutburger/...@140700,140700

Browse Source
This commit is contained in:
Andy McFadden
2009-03-24 18:15:56 -07:00
committed by The Android Open Source Project
parent 9c03440f19
commit 024d1c2375
4 changed files with 241 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tools/ddms/libs/ddmlib/src/com/android/ddmlib/AndroidDebugBridge.java
View File

@@ -194,6 +194,7 @@ public final class AndroidDebugBridge {
HandleThread.register(monitorThread);
HandleHeap.register(monitorThread);
HandleWait.register(monitorThread);
HandleProfiling.register(monitorThread);
}
/**

41
tools/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHeap.java
View File

@@ -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);
@@ -220,6 +223,44 @@ final class HandleHeap extends ChunkHandler {
client.sendAndConsume(packet, mInst);
}
/**
* 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.
*/

37
tools/ddms/libs/ddmlib/src/com/android/ddmlib/HandleHello.java
View File

@@ -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);
}
}

163
tools/ddms/libs/ddmlib/src/com/android/ddmlib/HandleProfiling.java Normal file
View File

@@ -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");
}
}
}