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 */
DdmHandleHello()50     private DdmHandleHello() {}
51 
52     /**
53      * Register for the messages we're interested in.
54      */
register()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      */
connected()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      */
disconnected()81     public void disconnected() {
82         if (false)
83             Log.v("ddm-hello", "Disconnected!");
84     }
85 
86     /**
87      * Handle a chunk of data.
88      */
handleChunk(Chunk request)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      */
handleHELO(Chunk request)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         DdmHandleAppName.Names names = DdmHandleAppName.getNames();
130         String appName = names.getAppName();
131         String pkgName = names.getPkgName();
132 
133         VMRuntime vmRuntime = VMRuntime.getRuntime();
134         String instructionSetDescription =
135             vmRuntime.is64Bit() ? "64-bit" : "32-bit";
136         String vmInstructionSet = vmRuntime.vmInstructionSet();
137         if (vmInstructionSet != null && vmInstructionSet.length() > 0) {
138           instructionSetDescription += " (" + vmInstructionSet + ")";
139         }
140         String vmFlags = "CheckJNI="
141             + (vmRuntime.isCheckJniEnabled() ? "true" : "false");
142         boolean isNativeDebuggable = vmRuntime.isNativeDebuggable();
143 
144         ByteBuffer out = ByteBuffer.allocate(32
145                             + vmIdent.length() * 2
146                             + appName.length() * 2
147                             + instructionSetDescription.length() * 2
148                             + vmFlags.length() * 2
149                             + 1
150                             + pkgName.length() * 2);
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         out.putInt(pkgName.length());
165         putString(out, pkgName);
166 
167         Chunk reply = new Chunk(CHUNK_HELO, out);
168 
169         /*
170          * Take the opportunity to inform DDMS if we are waiting for a
171          * debugger to attach.
172          */
173         if (Debug.waitingForDebugger())
174             sendWAIT(0);
175 
176         return reply;
177     }
178 
179     /*
180      * Handle request for list of supported features.
181      */
handleFEAT(Chunk request)182     private Chunk handleFEAT(Chunk request) {
183         // TODO: query the VM to ensure that support for these features
184         // is actually compiled in
185         final String[] vmFeatures = Debug.getVmFeatureList();
186 
187         if (false)
188             Log.v("ddm-heap", "Got feature list request");
189 
190         int size = 4 + 4 * (vmFeatures.length + FRAMEWORK_FEATURES.length);
191         for (int i = vmFeatures.length-1; i >= 0; i--)
192             size += vmFeatures[i].length() * 2;
193         for (int i = FRAMEWORK_FEATURES.length-1; i>= 0; i--)
194             size += FRAMEWORK_FEATURES[i].length() * 2;
195 
196         ByteBuffer out = ByteBuffer.allocate(size);
197         out.order(ChunkHandler.CHUNK_ORDER);
198         out.putInt(vmFeatures.length + FRAMEWORK_FEATURES.length);
199         for (int i = vmFeatures.length-1; i >= 0; i--) {
200             out.putInt(vmFeatures[i].length());
201             putString(out, vmFeatures[i]);
202         }
203         for (int i = FRAMEWORK_FEATURES.length-1; i >= 0; i--) {
204             out.putInt(FRAMEWORK_FEATURES[i].length());
205             putString(out, FRAMEWORK_FEATURES[i]);
206         }
207 
208         return new Chunk(CHUNK_FEAT, out);
209     }
210 
211     /**
212      * Send up a WAIT chunk.  The only currently defined value for "reason"
213      * is zero, which means "waiting for a debugger".
214      */
sendWAIT(int reason)215     public static void sendWAIT(int reason) {
216         byte[] data = new byte[] { (byte) reason };
217         Chunk waitChunk = new Chunk(CHUNK_WAIT, data, 0, 1);
218         DdmServer.sendChunk(waitChunk);
219     }
220 }
221 
222