/*
|
* Copyright (C) 2007 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 android.ddm;
|
|
import android.os.Debug;
|
import android.os.UserHandle;
|
import android.util.Log;
|
|
import dalvik.system.VMRuntime;
|
|
import org.apache.harmony.dalvik.ddmc.Chunk;
|
import org.apache.harmony.dalvik.ddmc.ChunkHandler;
|
import org.apache.harmony.dalvik.ddmc.DdmServer;
|
|
import java.nio.ByteBuffer;
|
|
/**
|
* Handle "hello" messages and feature discovery.
|
*/
|
public class DdmHandleHello extends ChunkHandler {
|
|
public static final int CHUNK_HELO = type("HELO");
|
public static final int CHUNK_WAIT = type("WAIT");
|
public static final int CHUNK_FEAT = type("FEAT");
|
|
private static final int CLIENT_PROTOCOL_VERSION = 1;
|
|
private static DdmHandleHello mInstance = new DdmHandleHello();
|
|
private static final String[] FRAMEWORK_FEATURES = new String[] {
|
"opengl-tracing",
|
"view-hierarchy",
|
};
|
|
/* singleton, do not instantiate */
|
private DdmHandleHello() {}
|
|
/**
|
* Register for the messages we're interested in.
|
*/
|
public static void register() {
|
DdmServer.registerHandler(CHUNK_HELO, mInstance);
|
DdmServer.registerHandler(CHUNK_FEAT, mInstance);
|
}
|
|
/**
|
* Called when the DDM server connects. The handler is allowed to
|
* send messages to the server.
|
*/
|
public void connected() {
|
if (false)
|
Log.v("ddm-hello", "Connected!");
|
|
if (false) {
|
/* test spontaneous transmission */
|
byte[] data = new byte[] { 0, 1, 2, 3, 4, -4, -3, -2, -1, 127 };
|
Chunk testChunk =
|
new Chunk(ChunkHandler.type("TEST"), data, 1, data.length-2);
|
DdmServer.sendChunk(testChunk);
|
}
|
}
|
|
/**
|
* Called when the DDM server disconnects. Can be used to disable
|
* periodic transmissions or clean up saved state.
|
*/
|
public void disconnected() {
|
if (false)
|
Log.v("ddm-hello", "Disconnected!");
|
}
|
|
/**
|
* Handle a chunk of data.
|
*/
|
public Chunk handleChunk(Chunk request) {
|
if (false)
|
Log.v("ddm-heap", "Handling " + name(request.type) + " chunk");
|
int type = request.type;
|
|
if (type == CHUNK_HELO) {
|
return handleHELO(request);
|
} else if (type == CHUNK_FEAT) {
|
return handleFEAT(request);
|
} else {
|
throw new RuntimeException("Unknown packet "
|
+ ChunkHandler.name(type));
|
}
|
}
|
|
/*
|
* Handle introductory packet. This is called during JNI_CreateJavaVM
|
* before frameworks native methods are registered, so be careful not
|
* to call any APIs that depend on frameworks native code.
|
*/
|
private Chunk handleHELO(Chunk request) {
|
if (false)
|
return createFailChunk(123, "This is a test");
|
|
/*
|
* Process the request.
|
*/
|
ByteBuffer in = wrapChunk(request);
|
|
int serverProtoVers = in.getInt();
|
if (false)
|
Log.v("ddm-hello", "Server version is " + serverProtoVers);
|
|
/*
|
* Create a response.
|
*/
|
String vmName = System.getProperty("java.vm.name", "?");
|
String vmVersion = System.getProperty("java.vm.version", "?");
|
String vmIdent = vmName + " v" + vmVersion;
|
|
//String appName = android.app.ActivityThread.currentPackageName();
|
//if (appName == null)
|
// appName = "unknown";
|
String appName = DdmHandleAppName.getAppName();
|
|
VMRuntime vmRuntime = VMRuntime.getRuntime();
|
String instructionSetDescription =
|
vmRuntime.is64Bit() ? "64-bit" : "32-bit";
|
String vmInstructionSet = vmRuntime.vmInstructionSet();
|
if (vmInstructionSet != null && vmInstructionSet.length() > 0) {
|
instructionSetDescription += " (" + vmInstructionSet + ")";
|
}
|
String vmFlags = "CheckJNI="
|
+ (vmRuntime.isCheckJniEnabled() ? "true" : "false");
|
boolean isNativeDebuggable = vmRuntime.isNativeDebuggable();
|
|
ByteBuffer out = ByteBuffer.allocate(28
|
+ vmIdent.length() * 2
|
+ appName.length() * 2
|
+ instructionSetDescription.length() * 2
|
+ vmFlags.length() * 2
|
+ 1);
|
out.order(ChunkHandler.CHUNK_ORDER);
|
out.putInt(CLIENT_PROTOCOL_VERSION);
|
out.putInt(android.os.Process.myPid());
|
out.putInt(vmIdent.length());
|
out.putInt(appName.length());
|
putString(out, vmIdent);
|
putString(out, appName);
|
out.putInt(UserHandle.myUserId());
|
out.putInt(instructionSetDescription.length());
|
putString(out, instructionSetDescription);
|
out.putInt(vmFlags.length());
|
putString(out, vmFlags);
|
out.put((byte)(isNativeDebuggable ? 1 : 0));
|
|
Chunk reply = new Chunk(CHUNK_HELO, out);
|
|
/*
|
* Take the opportunity to inform DDMS if we are waiting for a
|
* debugger to attach.
|
*/
|
if (Debug.waitingForDebugger())
|
sendWAIT(0);
|
|
return reply;
|
}
|
|
/*
|
* Handle request for list of supported features.
|
*/
|
private Chunk handleFEAT(Chunk request) {
|
// TODO: query the VM to ensure that support for these features
|
// is actually compiled in
|
final String[] vmFeatures = Debug.getVmFeatureList();
|
|
if (false)
|
Log.v("ddm-heap", "Got feature list request");
|
|
int size = 4 + 4 * (vmFeatures.length + FRAMEWORK_FEATURES.length);
|
for (int i = vmFeatures.length-1; i >= 0; i--)
|
size += vmFeatures[i].length() * 2;
|
for (int i = FRAMEWORK_FEATURES.length-1; i>= 0; i--)
|
size += FRAMEWORK_FEATURES[i].length() * 2;
|
|
ByteBuffer out = ByteBuffer.allocate(size);
|
out.order(ChunkHandler.CHUNK_ORDER);
|
out.putInt(vmFeatures.length + FRAMEWORK_FEATURES.length);
|
for (int i = vmFeatures.length-1; i >= 0; i--) {
|
out.putInt(vmFeatures[i].length());
|
putString(out, vmFeatures[i]);
|
}
|
for (int i = FRAMEWORK_FEATURES.length-1; i >= 0; i--) {
|
out.putInt(FRAMEWORK_FEATURES[i].length());
|
putString(out, FRAMEWORK_FEATURES[i]);
|
}
|
|
return new Chunk(CHUNK_FEAT, out);
|
}
|
|
/**
|
* Send up a WAIT chunk. The only currently defined value for "reason"
|
* is zero, which means "waiting for a debugger".
|
*/
|
public static void sendWAIT(int reason) {
|
byte[] data = new byte[] { (byte) reason };
|
Chunk waitChunk = new Chunk(CHUNK_WAIT, data, 0, 1);
|
DdmServer.sendChunk(waitChunk);
|
}
|
}
|
