Home | History | Annotate | Download | only in ddm 
      1 /*
      2  * Copyright (C) 2007 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.ddm;
     18 
     19 import android.os.Debug;
     20 import android.os.UserHandle;
     21 import android.util.Log;
     22 
     23 import dalvik.system.VMRuntime;
     24 
     25 import org.apache.harmony.dalvik.ddmc.Chunk;
     26 import org.apache.harmony.dalvik.ddmc.ChunkHandler;
     27 import org.apache.harmony.dalvik.ddmc.DdmServer;
     28 
     29 import java.nio.ByteBuffer;
     30 
     31 /**
     32  * Handle "hello" messages and feature discovery.
     33  */
     34 public class DdmHandleHello extends ChunkHandler {
     35 
     36     public static final int CHUNK_HELO = type("HELO");
     37     public static final int CHUNK_WAIT = type("WAIT");
     38     public static final int CHUNK_FEAT = type("FEAT");
     39 
     40     private static final int CLIENT_PROTOCOL_VERSION = 1;
     41 
     42     private static DdmHandleHello mInstance = new DdmHandleHello();
     43 
     44     private static final String[] FRAMEWORK_FEATURES = new String[] {
     45         "opengl-tracing",
     46         "view-hierarchy",
     47     };
     48 
     49     /* singleton, do not instantiate */
     50     private DdmHandleHello() {}
     51 
     52     /**
     53      * Register for the messages we're interested in.
     54      */
     55     public static void register() {
     56         DdmServer.registerHandler(CHUNK_HELO, mInstance);
     57         DdmServer.registerHandler(CHUNK_FEAT, mInstance);
     58     }
     59 
     60     /**
     61      * Called when the DDM server connects.  The handler is allowed to
     62      * send messages to the server.
     63      */
     64     public void connected() {
     65         if (false)
     66             Log.v("ddm-hello", "Connected!");
     67 
     68         if (false) {
     69             /* test spontaneous transmission */
     70             byte[] data = new byte[] { 0, 1, 2, 3, 4, -4, -3, -2, -1, 127 };
     71             Chunk testChunk =
     72                 new Chunk(ChunkHandler.type("TEST"), data, 1, data.length-2);
     73             DdmServer.sendChunk(testChunk);
     74         }
     75     }
     76 
     77     /**
     78      * Called when the DDM server disconnects.  Can be used to disable
     79      * periodic transmissions or clean up saved state.
     80      */
     81     public void disconnected() {
     82         if (false)
     83             Log.v("ddm-hello", "Disconnected!");
     84     }
     85 
     86     /**
     87      * Handle a chunk of data.
     88      */
     89     public Chunk handleChunk(Chunk request) {
     90         if (false)
     91             Log.v("ddm-heap", "Handling " + name(request.type) + " chunk");
     92         int type = request.type;
     93 
     94         if (type == CHUNK_HELO) {
     95             return handleHELO(request);
     96         } else if (type == CHUNK_FEAT) {
     97             return handleFEAT(request);
     98         } else {
     99             throw new RuntimeException("Unknown packet "
    100                 + ChunkHandler.name(type));
    101         }
    102     }
    103 
    104     /*
    105      * Handle introductory packet. This is called during JNI_CreateJavaVM
    106      * before frameworks native methods are registered, so be careful not
    107      * to call any APIs that depend on frameworks native code.
    108      */
    109     private Chunk handleHELO(Chunk request) {
    110         if (false)
    111             return createFailChunk(123, "This is a test");
    112 
    113         /*
    114          * Process the request.
    115          */
    116         ByteBuffer in = wrapChunk(request);
    117 
    118         int serverProtoVers = in.getInt();
    119         if (false)
    120             Log.v("ddm-hello", "Server version is " + serverProtoVers);
    121 
    122         /*
    123          * Create a response.
    124          */
    125         String vmName = System.getProperty("java.vm.name", "?");
    126         String vmVersion = System.getProperty("java.vm.version", "?");
    127         String vmIdent = vmName + " v" + vmVersion;
    128 
    129         //String appName = android.app.ActivityThread.currentPackageName();
    130         //if (appName == null)
    131         //    appName = "unknown";
    132         String appName = DdmHandleAppName.getAppName();
    133 
    134         VMRuntime vmRuntime = VMRuntime.getRuntime();
    135         String instructionSetDescription =
    136             vmRuntime.is64Bit() ? "64-bit" : "32-bit";
    137         String vmInstructionSet = vmRuntime.vmInstructionSet();
    138         if (vmInstructionSet != null && vmInstructionSet.length() > 0) {
    139           instructionSetDescription += " (" + vmInstructionSet + ")";
    140         }
    141         String vmFlags = "CheckJNI="
    142             + (vmRuntime.isCheckJniEnabled() ? "true" : "false");
    143         boolean isNativeDebuggable = vmRuntime.isNativeDebuggable();
    144 
    145         ByteBuffer out = ByteBuffer.allocate(28
    146                             + vmIdent.length() * 2
    147                             + appName.length() * 2
    148                             + instructionSetDescription.length() * 2
    149                             + vmFlags.length() * 2
    150                             + 1);
    151         out.order(ChunkHandler.CHUNK_ORDER);
    152         out.putInt(CLIENT_PROTOCOL_VERSION);
    153         out.putInt(android.os.Process.myPid());
    154         out.putInt(vmIdent.length());
    155         out.putInt(appName.length());
    156         putString(out, vmIdent);
    157         putString(out, appName);
    158         out.putInt(UserHandle.myUserId());
    159         out.putInt(instructionSetDescription.length());
    160         putString(out, instructionSetDescription);
    161         out.putInt(vmFlags.length());
    162         putString(out, vmFlags);
    163         out.put((byte)(isNativeDebuggable ? 1 : 0));
    164 
    165         Chunk reply = new Chunk(CHUNK_HELO, out);
    166 
    167         /*
    168          * Take the opportunity to inform DDMS if we are waiting for a
    169          * debugger to attach.
    170          */
    171         if (Debug.waitingForDebugger())
    172             sendWAIT(0);
    173 
    174         return reply;
    175     }
    176 
    177     /*
    178      * Handle request for list of supported features.
    179      */
    180     private Chunk handleFEAT(Chunk request) {
    181         // TODO: query the VM to ensure that support for these features
    182         // is actually compiled in
    183         final String[] vmFeatures = Debug.getVmFeatureList();
    184 
    185         if (false)
    186             Log.v("ddm-heap", "Got feature list request");
    187 
    188         int size = 4 + 4 * (vmFeatures.length + FRAMEWORK_FEATURES.length);
    189         for (int i = vmFeatures.length-1; i >= 0; i--)
    190             size += vmFeatures[i].length() * 2;
    191         for (int i = FRAMEWORK_FEATURES.length-1; i>= 0; i--)
    192             size += FRAMEWORK_FEATURES[i].length() * 2;
    193 
    194         ByteBuffer out = ByteBuffer.allocate(size);
    195         out.order(ChunkHandler.CHUNK_ORDER);
    196         out.putInt(vmFeatures.length + FRAMEWORK_FEATURES.length);
    197         for (int i = vmFeatures.length-1; i >= 0; i--) {
    198             out.putInt(vmFeatures[i].length());
    199             putString(out, vmFeatures[i]);
    200         }
    201         for (int i = FRAMEWORK_FEATURES.length-1; i >= 0; i--) {
    202             out.putInt(FRAMEWORK_FEATURES[i].length());
    203             putString(out, FRAMEWORK_FEATURES[i]);
    204         }
    205 
    206         return new Chunk(CHUNK_FEAT, out);
    207     }
    208 
    209     /**
    210      * Send up a WAIT chunk.  The only currently defined value for "reason"
    211      * is zero, which means "waiting for a debugger".
    212      */
    213     public static void sendWAIT(int reason) {
    214         byte[] data = new byte[] { (byte) reason };
    215         Chunk waitChunk = new Chunk(CHUNK_WAIT, data, 0, 1);
    216         DdmServer.sendChunk(waitChunk);
    217     }
    218 }
    219 
    220