[原创]HierarchyView的实现原理和Android设备无法使用HierarchyView的解决方法

  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 com.android.server.wm;
 18 
 19 
 20 import android.util.Slog;
 21 
 22 import java.net.ServerSocket;
 23 import java.net.Socket;
 24 import java.net.InetAddress;
 25 import java.util.concurrent.ExecutorService;
 26 import java.util.concurrent.Executors;
 27 import java.io.IOException;
 28 import java.io.BufferedReader;
 29 import java.io.InputStreamReader;
 30 import java.io.OutputStream;
 31 import java.io.BufferedWriter;
 32 import java.io.OutputStreamWriter;
 33 
 34 /**
 35  * The ViewServer is local socket server that can be used to communicate with the
 36  * views of the opened windows. Communication with the views is ensured by the
 37  * {@link com.android.server.wm.WindowManagerService} and is a cross-process operation.
 38  *
 39  * {@hide}
 40  */
 41 class ViewServer implements Runnable {
 42     /**
 43      * The default port used to start view servers.
 44      */
 45     public static final int VIEW_SERVER_DEFAULT_PORT = 4939;
 46 
 47     private static final int VIEW_SERVER_MAX_CONNECTIONS = 10;
 48 
 49     // Debug facility
 50     private static final String LOG_TAG = "ViewServer";
 51 
 52     private static final String VALUE_PROTOCOL_VERSION = "4";
 53     private static final String VALUE_SERVER_VERSION = "4";
 54 
 55     // Protocol commands
 56     // Returns the protocol version
 57     private static final String COMMAND_PROTOCOL_VERSION = "PROTOCOL";
 58     // Returns the server version
 59     private static final String COMMAND_SERVER_VERSION = "SERVER";
 60     // Lists all of the available windows in the system
 61     private static final String COMMAND_WINDOW_MANAGER_LIST = "LIST";
 62     // Keeps a connection open and notifies when the list of windows changes
 63     private static final String COMMAND_WINDOW_MANAGER_AUTOLIST = "AUTOLIST";
 64     // Returns the focused window
 65     private static final String COMMAND_WINDOW_MANAGER_GET_FOCUS = "GET_FOCUS";
 66 
 67     private ServerSocket mServer;
 68     private Thread mThread;
 69 
 70     private final WindowManagerService mWindowManager;
 71     private final int mPort;
 72 
 73     private ExecutorService mThreadPool;
 74 
 75     /**
 76      * Creates a new ViewServer associated with the specified window manager on the
 77      * specified local port. The server is not started by default.
 78      *
 79      * @param windowManager The window manager used to communicate with the views.
 80      * @param port The port for the server to listen to.
 81      *
 82      * @see #start()
 83      */
 84     ViewServer(WindowManagerService windowManager, int port) {
 85         mWindowManager = windowManager;
 86         mPort = port;
 87     }
 88 
 89     /**
 90      * Starts the server.
 91      *
 92      * @return True if the server was successfully created, or false if it already exists.
 93      * @throws IOException If the server cannot be created.
 94      *
 95      * @see #stop()
 96      * @see #isRunning()
 97      * @see WindowManagerService#startViewServer(int)
 98      */
 99     boolean start() throws IOException {
100         if (mThread != null) {
101             return false;
102         }
103 
104         mServer = new ServerSocket(mPort, VIEW_SERVER_MAX_CONNECTIONS, InetAddress.getLocalHost());
105         mThread = new Thread(this, "Remote View Server [port=" + mPort + "]");
106         mThreadPool = Executors.newFixedThreadPool(VIEW_SERVER_MAX_CONNECTIONS);
107         mThread.start();
108 
109         return true;
110     }
111 
112     /**
113      * Stops the server.
114      *
115      * @return True if the server was stopped, false if an error occured or if the
116      *         server wasn't started.
117      *
118      * @see #start()
119      * @see #isRunning()
120      * @see WindowManagerService#stopViewServer()
121      */
122     boolean stop() {
123         if (mThread != null) {
124 
125             mThread.interrupt();
126             if (mThreadPool != null) {
127                 try {
128                     mThreadPool.shutdownNow();
129                 } catch (SecurityException e) {
130                     Slog.w(LOG_TAG, "Could not stop all view server threads");
131                 }
132             }
133             mThreadPool = null;
134             mThread = null;
135             try {
136                 mServer.close();
137                 mServer = null;
138                 return true;
139             } catch (IOException e) {
140                 Slog.w(LOG_TAG, "Could not close the view server");
141             }
142         }
143         return false;
144     }
145 
146     /**
147      * Indicates whether the server is currently running.
148      *
149      * @return True if the server is running, false otherwise.
150      *
151      * @see #start()
152      * @see #stop()
153      * @see WindowManagerService#isViewServerRunning()  
154      */
155     boolean isRunning() {
156         return mThread != null && mThread.isAlive();
157     }
158 
159     /**
160      * Main server loop.
161      */
162     public void run() {
163         while (Thread.currentThread() == mThread) {
164             // Any uncaught exception will crash the system process
165             try {
166                 Socket client = mServer.accept();
167                 if (mThreadPool != null) {
168                     mThreadPool.submit(new ViewServerWorker(client));
169                 } else {
170                     try {
171                         client.close();
172                     } catch (IOException e) {
173                         e.printStackTrace();
174                     }
175                 }
176             } catch (Exception e) {
177                 Slog.w(LOG_TAG, "Connection error: ", e);
178             }
179         }
180     }
181 
182     private static boolean writeValue(Socket client, String value) {
183         boolean result;
184         BufferedWriter out = null;
185         try {
186             OutputStream clientStream = client.getOutputStream();
187             out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
188             out.write(value);
189             out.write("
");
190             out.flush();
191             result = true;
192         } catch (Exception e) {
193             result = false;
194         } finally {
195             if (out != null) {
196                 try {
197                     out.close();
198                 } catch (IOException e) {
199                     result = false;
200                 }
201             }
202         }
203         return result;
204     }
205 
206     class ViewServerWorker implements Runnable, WindowManagerService.WindowChangeListener {
207         private Socket mClient;
208         private boolean mNeedWindowListUpdate;
209         private boolean mNeedFocusedWindowUpdate;
210 
211         public ViewServerWorker(Socket client) {
212             mClient = client;
213             mNeedWindowListUpdate = false;
214             mNeedFocusedWindowUpdate = false;
215         }
216 
217         public void run() {
218 
219             BufferedReader in = null;
220             try {
221                 in = new BufferedReader(new InputStreamReader(mClient.getInputStream()), 1024);
222 
223                 final String request = in.readLine();
224 
225                 String command;
226                 String parameters;
227 
228                 int index = request.indexOf(' ');
229                 if (index == -1) {
230                     command = request;
231                     parameters = "";
232                 } else {
233                     command = request.substring(0, index);
234                     parameters = request.substring(index + 1);
235                 }
236 
237                 boolean result;
238                 if (COMMAND_PROTOCOL_VERSION.equalsIgnoreCase(command)) {
239                     result = writeValue(mClient, VALUE_PROTOCOL_VERSION);
240                 } else if (COMMAND_SERVER_VERSION.equalsIgnoreCase(command)) {
241                     result = writeValue(mClient, VALUE_SERVER_VERSION);
242                 } else if (COMMAND_WINDOW_MANAGER_LIST.equalsIgnoreCase(command)) {
243                     result = mWindowManager.viewServerListWindows(mClient);
244                 } else if (COMMAND_WINDOW_MANAGER_GET_FOCUS.equalsIgnoreCase(command)) {
245                     result = mWindowManager.viewServerGetFocusedWindow(mClient);
246                 } else if (COMMAND_WINDOW_MANAGER_AUTOLIST.equalsIgnoreCase(command)) {
247                     result = windowManagerAutolistLoop();
248                 } else {
249                     result = mWindowManager.viewServerWindowCommand(mClient,
250                             command, parameters);
251                 }
252 
253                 if (!result) {
254                     Slog.w(LOG_TAG, "An error occurred with the command: " + command);
255                 }
256             } catch(IOException e) {
257                 Slog.w(LOG_TAG, "Connection error: ", e);
258             } finally {
259                 if (in != null) {
260                     try {
261                         in.close();
262 
263                     } catch (IOException e) {
264                         e.printStackTrace();
265                     }
266                 }
267                 if (mClient != null) {
268                     try {
269                         mClient.close();
270                     } catch (IOException e) {
271                         e.printStackTrace();
272                     }
273                 }
274             }
275         }
276 
277         public void windowsChanged() {
278             synchronized(this) {
279                 mNeedWindowListUpdate = true;
280                 notifyAll();
281             }
282         }
283 
284         public void focusChanged() {
285             synchronized(this) {
286                 mNeedFocusedWindowUpdate = true;
287                 notifyAll();
288             }
289         }
290 
291         private boolean windowManagerAutolistLoop() {
292             mWindowManager.addWindowChangeListener(this);
293             BufferedWriter out = null;
294             try {
295                 out = new BufferedWriter(new OutputStreamWriter(mClient.getOutputStream()));
296                 while (!Thread.interrupted()) {
297                     boolean needWindowListUpdate = false;
298                     boolean needFocusedWindowUpdate = false;
299                     synchronized (this) {
300                         while (!mNeedWindowListUpdate && !mNeedFocusedWindowUpdate) {
301                             wait();
302                         }
303                         if (mNeedWindowListUpdate) {
304                             mNeedWindowListUpdate = false;
305                             needWindowListUpdate = true;
306                         }
307                         if (mNeedFocusedWindowUpdate) {
308                             mNeedFocusedWindowUpdate = false;
309                             needFocusedWindowUpdate = true;
310                         }
311                     }
312                     if (needWindowListUpdate) {
313                         out.write("LIST UPDATE
");
314                         out.flush();
315                     }
316                     if (needFocusedWindowUpdate) {
317                         out.write("ACTION_FOCUS UPDATE
");
318                         out.flush();
319                     }
320                 }
321             } catch (Exception e) {
322                 // Ignore
323             } finally {
324                 if (out != null) {
325                     try {
326                         out.close();
327                     } catch (IOException e) {
328                         // Ignore
329                     }
330                 }
331                 mWindowManager.removeWindowChangeListener(this);
332             }
333             return true;
334         }
335     }
336 }

  1 /*
  2  * Copyright (C) 2011 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 com.server;
 18 
 19 import android.app.Activity;
 20 import android.content.Context;
 21 import android.content.pm.ApplicationInfo;
 22 import android.os.Build;
 23 import android.text.TextUtils;
 24 import android.util.Log;
 25 import android.view.View;
 26 import android.view.ViewDebug;
 27 
 28 import java.io.BufferedReader;
 29 import java.io.BufferedWriter;
 30 import java.io.IOException;
 31 import java.io.InputStreamReader;
 32 import java.io.OutputStream;
 33 import java.io.OutputStreamWriter;
 34 import java.lang.reflect.Method;
 35 import java.net.InetAddress;
 36 import java.net.ServerSocket;
 37 import java.net.Socket;
 38 import java.util.HashMap;
 39 import java.util.List;
 40 import java.util.Map.Entry;
 41 import java.util.concurrent.CopyOnWriteArrayList;
 42 import java.util.concurrent.ExecutorService;
 43 import java.util.concurrent.Executors;
 44 import java.util.concurrent.locks.ReentrantReadWriteLock;
 45 
 46 /**
 47  * <p>This class can be used to enable the use of HierarchyViewer inside an
 48  * application. HierarchyViewer is an Android SDK tool that can be used
 49  * to inspect and debug the user interface of running applications. For
 50  * security reasons, HierarchyViewer does not work on production builds
 51  * (for instance phones bought in store.) By using this class, you can
 52  * make HierarchyViewer work on any device. You must be very careful
 53  * however to only enable HierarchyViewer when debugging your
 54  * application.</p>
 55  * <p/>
 56  * <p>To use this view server, your application must require the INTERNET
 57  * permission.</p>
 58  * <p/>
 59  * <p>The recommended way to use this API is to register activities when
 60  * they are created, and to unregister them when they get destroyed:</p>
 61  * <p/>
 62  * <pre>
 63  * public class MyActivity extends Activity {
 64  *     public void onCreate(Bundle savedInstanceState) {
 65  *         super.onCreate(savedInstanceState);
 66  *         // Set content view, etc.
 67  *         ViewServer.get(this).addWindow(this);
 68  *     }
 69  *
 70  *     public void onDestroy() {
 71  *         super.onDestroy();
 72  *         ViewServer.get(this).removeWindow(this);
 73  *     }
 74  *
 75  *     public void onResume() {
 76  *         super.onResume();
 77  *         ViewServer.get(this).setFocusedWindow(this);
 78  *     }
 79  * }
 80  * </pre>
 81  * <p/>
 82  * <p>
 83  * In a similar fashion, you can use this API with an InputMethodService:
 84  * </p>
 85  * <p/>
 86  * <pre>
 87  * public class MyInputMethodService extends InputMethodService {
 88  *     public void onCreate() {
 89  *         super.onCreate();
 90  *         View decorView = getWindow().getWindow().getDecorView();
 91  *         String name = "MyInputMethodService";
 92  *         ViewServer.get(this).addWindow(decorView, name);
 93  *     }
 94  *
 95  *     public void onDestroy() {
 96  *         super.onDestroy();
 97  *         View decorView = getWindow().getWindow().getDecorView();
 98  *         ViewServer.get(this).removeWindow(decorView);
 99  *     }
100  *
101  *     public void onStartInput(EditorInfo attribute, boolean restarting) {
102  *         super.onStartInput(attribute, restarting);
103  *         View decorView = getWindow().getWindow().getDecorView();
104  *         ViewServer.get(this).setFocusedWindow(decorView);
105  *     }
106  * }
107  * </pre>
108  */
109 public class ViewServer implements Runnable {
110     /**
111      * The default port used to start view servers.
112      */
113     private static final int VIEW_SERVER_DEFAULT_PORT = 4939;
114     private static final int VIEW_SERVER_MAX_CONNECTIONS = 10;
115     private static final String BUILD_TYPE_USER = "user";
116 
117     // Debug facility
118     private static final String LOG_TAG = "ViewServer";
119 
120     private static final String VALUE_PROTOCOL_VERSION = "4";
121     private static final String VALUE_SERVER_VERSION = "4";
122 
123     // Protocol commands
124     // Returns the protocol version
125     private static final String COMMAND_PROTOCOL_VERSION = "PROTOCOL";
126     // Returns the server version
127     private static final String COMMAND_SERVER_VERSION = "SERVER";
128     // Lists all of the available windows in the system
129     private static final String COMMAND_WINDOW_MANAGER_LIST = "LIST";
130     // Keeps a connection open and notifies when the list of windows changes
131     private static final String COMMAND_WINDOW_MANAGER_AUTOLIST = "AUTOLIST";
132     // Returns the focused window
133     private static final String COMMAND_WINDOW_MANAGER_GET_FOCUS = "GET_FOCUS";
134 
135     private ServerSocket mServer;
136     private final int mPort;
137 
138     private Thread mThread;
139     private ExecutorService mThreadPool;
140 
141     private final List<WindowListener> mListeners =
142             new CopyOnWriteArrayList<WindowListener>();
143 
144     private final HashMap<View, String> mWindows = new HashMap<View, String>();
145     private final ReentrantReadWriteLock mWindowsLock = new ReentrantReadWriteLock();
146 
147     private View mFocusedWindow;
148     private final ReentrantReadWriteLock mFocusLock = new ReentrantReadWriteLock();
149 
150     private static ViewServer sServer;
151 
152     /**
153      * Returns a unique instance of the ViewServer. This method should only be
154      * called from the main thread of your application. The server will have
155      * the same lifetime as your process.
156      * <p/>
157      * If your application does not have the <code>android:debuggable</code>
158      * flag set in its manifest, the server returned by this method will
159      * be a dummy object that does not do anything. This allows you to use
160      * the same code in debug and release versions of your application.
161      *
162      * @param context A Context used to check whether the application is
163      *                debuggable, this can be the application context
164      */
165     public static ViewServer get(Context context) {
166         ApplicationInfo info = context.getApplicationInfo();
167         if (BUILD_TYPE_USER.equals(Build.TYPE) &&
168                 (info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
169             if (sServer == null) {
170                 sServer = new ViewServer(ViewServer.VIEW_SERVER_DEFAULT_PORT);
171             }
172 
173             if (!sServer.isRunning()) {
174                 try {
175                     sServer.start();
176                 } catch (IOException e) {
177                     Log.d(LOG_TAG, "Error:", e);
178                 }
179             }
180         } else {
181             sServer = new NoopViewServer();
182         }
183 
184         return sServer;
185     }
186 
187     private ViewServer() {
188         mPort = -1;
189     }
190 
191     /**
192      * Creates a new ViewServer associated with the specified window manager on the
193      * specified local port. The server is not started by default.
194      *
195      * @param port The port for the server to listen to.
196      * @see #start()
197      */
198     private ViewServer(int port) {
199         mPort = port;
200     }
201 
202     /**
203      * Starts the server.
204      *
205      * @return True if the server was successfully created, or false if it already exists.
206      * @throws java.io.IOException If the server cannot be created.
207      * @see #stop()
208      * @see #isRunning()
209      */
210     public boolean start() throws IOException {
211         if (mThread != null) {
212             return false;
213         }
214 
215         mThread = new Thread(this, "Local View Server [port=" + mPort + "]");
216         mThreadPool = Executors.newFixedThreadPool(VIEW_SERVER_MAX_CONNECTIONS);
217         mThread.start();
218 
219         return true;
220     }
221 
222     /**
223      * Stops the server.
224      *
225      * @return True if the server was stopped, false if an error occurred or if the
226      * server wasn't started.
227      * @see #start()
228      * @see #isRunning()
229      */
230     public boolean stop() {
231         if (mThread != null) {
232             mThread.interrupt();
233             if (mThreadPool != null) {
234                 try {
235                     mThreadPool.shutdownNow();
236                 } catch (SecurityException e) {
237                     Log.w(LOG_TAG, "Could not stop all view server threads");
238                 }
239             }
240 
241             mThreadPool = null;
242             mThread = null;
243 
244             try {
245                 mServer.close();
246                 mServer = null;
247                 return true;
248             } catch (IOException e) {
249                 Log.w(LOG_TAG, "Could not close the view server");
250             }
251         }
252 
253         mWindowsLock.writeLock().lock();
254         try {
255             mWindows.clear();
256         } finally {
257             mWindowsLock.writeLock().unlock();
258         }
259 
260         mFocusLock.writeLock().lock();
261         try {
262             mFocusedWindow = null;
263         } finally {
264             mFocusLock.writeLock().unlock();
265         }
266 
267         return false;
268     }
269 
270     /**
271      * Indicates whether the server is currently running.
272      *
273      * @return True if the server is running, false otherwise.
274      * @see #start()
275      * @see #stop()
276      */
277     public boolean isRunning() {
278         return mThread != null && mThread.isAlive();
279     }
280 
281     /**
282      * Invoke this method to register a new view hierarchy.
283      *
284      * @param activity The activity whose view hierarchy/window to register
285      * @see #addWindow(android.view.View, String)
286      * @see #removeWindow(android.app.Activity)
287      */
288     public void addWindow(Activity activity) {
289         String name = activity.getTitle().toString();
290         if (TextUtils.isEmpty(name)) {
291             name = activity.getClass().getCanonicalName() +
292                     "/0x" + System.identityHashCode(activity);
293         } else {
294             name += "(" + activity.getClass().getCanonicalName() + ")";
295         }
296         addWindow(activity.getWindow().getDecorView(), name);
297     }
298 
299     /**
300      * Invoke this method to unregister a view hierarchy.
301      *
302      * @param activity The activity whose view hierarchy/window to unregister
303      * @see #addWindow(android.app.Activity)
304      * @see #removeWindow(android.view.View)
305      */
306     public void removeWindow(Activity activity) {
307         removeWindow(activity.getWindow().getDecorView());
308     }
309 
310     /**
311      * Invoke this method to register a new view hierarchy.
312      *
313      * @param view A view that belongs to the view hierarchy/window to register
314      * @name name The name of the view hierarchy/window to register
315      * @see #removeWindow(android.view.View)
316      */
317     public void addWindow(View view, String name) {
318         mWindowsLock.writeLock().lock();
319         try {
320             mWindows.put(view.getRootView(), name);
321         } finally {
322             mWindowsLock.writeLock().unlock();
323         }
324         fireWindowsChangedEvent();
325     }
326 
327     /**
328      * Invoke this method to unregister a view hierarchy.
329      *
330      * @param view A view that belongs to the view hierarchy/window to unregister
331      * @see #addWindow(android.view.View, String)
332      */
333     public void removeWindow(View view) {
334         mWindowsLock.writeLock().lock();
335         try {
336             mWindows.remove(view.getRootView());
337         } finally {
338             mWindowsLock.writeLock().unlock();
339         }
340         fireWindowsChangedEvent();
341     }
342 
343     /**
344      * Invoke this method to change the currently focused window.
345      *
346      * @param activity The activity whose view hierarchy/window hasfocus,
347      *                 or null to remove focus
348      */
349     public void setFocusedWindow(Activity activity) {
350         setFocusedWindow(activity.getWindow().getDecorView());
351     }
352 
353     /**
354      * Invoke this method to change the currently focused window.
355      *
356      * @param view A view that belongs to the view hierarchy/window that has focus,
357      *             or null to remove focus
358      */
359     public void setFocusedWindow(View view) {
360         mFocusLock.writeLock().lock();
361         try {
362             mFocusedWindow = view == null ? null : view.getRootView();
363         } finally {
364             mFocusLock.writeLock().unlock();
365         }
366         fireFocusChangedEvent();
367     }
368 
369     /**
370      * Main server loop.
371      */
372     public void run() {
373         try {
374             InetAddress address = InetAddress.getLocalHost();
375             mServer = new ServerSocket(mPort, VIEW_SERVER_MAX_CONNECTIONS, address);
376         } catch (Exception e) {
377             Log.w(LOG_TAG, "Starting ServerSocket error: ", e);
378         }
379 
380         while (mServer != null && Thread.currentThread() == mThread) {
381             // Any uncaught exception will crash the system process
382             try {
383                 Socket client = mServer.accept();
384                 if (mThreadPool != null) {
385                     mThreadPool.submit(new ViewServerWorker(client));
386                 } else {
387                     try {
388                         client.close();
389                     } catch (IOException e) {
390                         e.printStackTrace();
391                     }
392                 }
393             } catch (Exception e) {
394                 Log.w(LOG_TAG, "Connection error: ", e);
395             }
396         }
397     }
398 
399     private static boolean writeValue(Socket client, String value) {
400         boolean result;
401         BufferedWriter out = null;
402         try {
403             OutputStream clientStream = client.getOutputStream();
404             out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
405             out.write(value);
406             out.write("
");
407             out.flush();
408             result = true;
409         } catch (Exception e) {
410             result = false;
411         } finally {
412             if (out != null) {
413                 try {
414                     out.close();
415                 } catch (IOException e) {
416                     result = false;
417                 }
418             }
419         }
420         return result;
421     }
422 
423     private void fireWindowsChangedEvent() {
424         for (WindowListener listener : mListeners) {
425             listener.windowsChanged();
426         }
427     }
428 
429     private void fireFocusChangedEvent() {
430         for (WindowListener listener : mListeners) {
431             listener.focusChanged();
432         }
433     }
434 
435     private void addWindowListener(WindowListener listener) {
436         if (!mListeners.contains(listener)) {
437             mListeners.add(listener);
438         }
439     }
440 
441     private void removeWindowListener(WindowListener listener) {
442         mListeners.remove(listener);
443     }
444 
445     private interface WindowListener {
446         void windowsChanged();
447 
448         void focusChanged();
449     }
450 
451 
452     private class ViewServerWorker implements Runnable, WindowListener {
453         private Socket mClient;
454         private boolean mNeedWindowListUpdate;
455         private boolean mNeedFocusedWindowUpdate;
456 
457         private final Object[] mLock = new Object[0];
458 
459         public ViewServerWorker(Socket client) {
460             mClient = client;
461             mNeedWindowListUpdate = false;
462             mNeedFocusedWindowUpdate = false;
463         }
464 
465         public void run() {
466             BufferedReader in = null;
467             try {
468                 in = new BufferedReader(new InputStreamReader(mClient.getInputStream()), 1024);
469 
470                 final String request = in.readLine();
471 
472                 Log.i("Command", "===>" + request);
473 
474                 String command;
475                 String parameters;
476 
477                 int index = request.indexOf(' ');
478                 if (index == -1) {
479                     command = request;
480                     parameters = "";
481                 } else {
482                     command = request.substring(0, index);
483                     parameters = request.substring(index + 1);
484                 }
485 
486                 boolean result;
487                 if (COMMAND_PROTOCOL_VERSION.equalsIgnoreCase(command)) {
488                     result = writeValue(mClient, VALUE_PROTOCOL_VERSION);
489                 } else if (COMMAND_SERVER_VERSION.equalsIgnoreCase(command)) {
490                     result = writeValue(mClient, VALUE_SERVER_VERSION);
491                 } else if (COMMAND_WINDOW_MANAGER_LIST.equalsIgnoreCase(command)) {
492                     result = listWindows(mClient);
493                 } else if (COMMAND_WINDOW_MANAGER_GET_FOCUS.equalsIgnoreCase(command)) {
494                     result = getFocusedWindow(mClient);
495                 } else if (COMMAND_WINDOW_MANAGER_AUTOLIST.equalsIgnoreCase(command)) {
496                     result = windowManagerAutolistLoop();
497                 } else {
498                     result = windowCommand(mClient, command, parameters);
499                 }
500 
501                 if (!result) {
502                     Log.w(LOG_TAG, "An error occurred with the command: " + command);
503                 }
504             } catch (IOException e) {
505                 Log.w(LOG_TAG, "Connection error: ", e);
506             } finally {
507                 if (in != null) {
508                     try {
509                         in.close();
510 
511                     } catch (IOException e) {
512                         e.printStackTrace();
513                     }
514                 }
515                 if (mClient != null) {
516                     try {
517                         mClient.close();
518                     } catch (IOException e) {
519                         e.printStackTrace();
520                     }
521                 }
522             }
523         }
524 
525         private boolean windowCommand(Socket client, String command, String parameters) {
526             boolean success = true;
527             BufferedWriter out = null;
528 
529             try {
530                 // Find the hash code of the window
531                 int index = parameters.indexOf(' ');
532                 if (index == -1) {
533                     index = parameters.length();
534                 }
535                 final String code = parameters.substring(0, index);
536                 int hashCode = (int) Long.parseLong(code, 16);
537 
538                 // Extract the command's parameter after the window description
539                 if (index < parameters.length()) {
540                     parameters = parameters.substring(index + 1);
541                 } else {
542                     parameters = "";
543                 }
544 
545                 final View window = findWindow(hashCode);
546                 if (window == null) {
547                     return false;
548                 }
549 
550                 // call stuff
551                 final Method dispatch = ViewDebug.class.getDeclaredMethod("dispatchCommand",
552                         View.class, String.class, String.class, OutputStream.class);
553                 dispatch.setAccessible(true);
554                 dispatch.invoke(null, window, command, parameters,
555                         new UncloseableOutputStream(client.getOutputStream()));
556 
557                 if (!client.isOutputShutdown()) {
558                     out = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
559                     out.write("DONE
");
560                     out.flush();
561                 }
562 
563             } catch (Exception e) {
564                 Log.w(LOG_TAG, "Could not send command " + command +
565                         " with parameters " + parameters, e);
566                 success = false;
567             } finally {
568                 if (out != null) {
569                     try {
570                         out.close();
571                     } catch (IOException e) {
572                         success = false;
573                     }
574                 }
575             }
576 
577             return success;
578         }
579 
580         private View findWindow(int hashCode) {
581             if (hashCode == -1) {
582                 View window = null;
583                 mWindowsLock.readLock().lock();
584                 try {
585                     window = mFocusedWindow;
586                 } finally {
587                     mWindowsLock.readLock().unlock();
588                 }
589                 return window;
590             }
591 
592 
593             mWindowsLock.readLock().lock();
594             try {
595                 for (Entry<View, String> entry : mWindows.entrySet()) {
596                     if (System.identityHashCode(entry.getKey()) == hashCode) {
597                         return entry.getKey();
598                     }
599                 }
600             } finally {
601                 mWindowsLock.readLock().unlock();
602             }
603 
604             return null;
605         }
606 
607         private boolean listWindows(Socket client) {
608             boolean result = true;
609             BufferedWriter out = null;
610 
611             try {
612                 mWindowsLock.readLock().lock();
613 
614                 OutputStream clientStream = client.getOutputStream();
615                 out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
616 
617                 for (Entry<View, String> entry : mWindows.entrySet()) {
618                     out.write(Integer.toHexString(System.identityHashCode(entry.getKey())));
619                     out.write(' ');
620                     out.append(entry.getValue());
621                     out.write('
');
622                 }
623 
624                 out.write("DONE.
");
625                 out.flush();
626             } catch (Exception e) {
627                 result = false;
628             } finally {
629                 mWindowsLock.readLock().unlock();
630 
631                 if (out != null) {
632                     try {
633                         out.close();
634                     } catch (IOException e) {
635                         result = false;
636                     }
637                 }
638             }
639 
640             return result;
641         }
642 
643         private boolean getFocusedWindow(Socket client) {
644             boolean result = true;
645             String focusName = null;
646 
647             BufferedWriter out = null;
648             try {
649                 OutputStream clientStream = client.getOutputStream();
650                 out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
651 
652                 View focusedWindow = null;
653 
654                 mFocusLock.readLock().lock();
655                 try {
656                     focusedWindow = mFocusedWindow;
657                 } finally {
658                     mFocusLock.readLock().unlock();
659                 }
660 
661                 if (focusedWindow != null) {
662                     mWindowsLock.readLock().lock();
663                     try {
664                         focusName = mWindows.get(mFocusedWindow);
665                     } finally {
666                         mWindowsLock.readLock().unlock();
667                     }
668 
669                     out.write(Integer.toHexString(System.identityHashCode(focusedWindow)));
670                     out.write(' ');
671                     out.append(focusName);
672                 }
673                 out.write('
');
674                 out.flush();
675             } catch (Exception e) {
676                 result = false;
677             } finally {
678                 if (out != null) {
679                     try {
680                         out.close();
681                     } catch (IOException e) {
682                         result = false;
683                     }
684                 }
685             }
686 
687             return result;
688         }
689 
690         public void windowsChanged() {
691             synchronized (mLock) {
692                 mNeedWindowListUpdate = true;
693                 mLock.notifyAll();
694             }
695         }
696 
697         public void focusChanged() {
698             synchronized (mLock) {
699                 mNeedFocusedWindowUpdate = true;
700                 mLock.notifyAll();
701             }
702         }
703 
704         private boolean windowManagerAutolistLoop() {
705             addWindowListener(this);
706             BufferedWriter out = null;
707             try {
708                 out = new BufferedWriter(new OutputStreamWriter(mClient.getOutputStream()));
709                 while (!Thread.interrupted()) {
710                     boolean needWindowListUpdate = false;
711                     boolean needFocusedWindowUpdate = false;
712                     synchronized (mLock) {
713                         while (!mNeedWindowListUpdate && !mNeedFocusedWindowUpdate) {
714                             mLock.wait();
715                         }
716                         if (mNeedWindowListUpdate) {
717                             mNeedWindowListUpdate = false;
718                             needWindowListUpdate = true;
719                         }
720                         if (mNeedFocusedWindowUpdate) {
721                             mNeedFocusedWindowUpdate = false;
722                             needFocusedWindowUpdate = true;
723                         }
724                     }
725                     if (needWindowListUpdate) {
726                         out.write("LIST UPDATE
");
727                         out.flush();
728                     }
729                     if (needFocusedWindowUpdate) {
730                         out.write("FOCUS UPDATE
");
731                         out.flush();
732                     }
733                 }
734             } catch (Exception e) {
735                 Log.w(LOG_TAG, "Connection error: ", e);
736             } finally {
737                 if (out != null) {
738                     try {
739                         out.close();
740                     } catch (IOException e) {
741                         // Ignore
742                     }
743                 }
744                 removeWindowListener(this);
745             }
746             return true;
747         }
748     }
749 
750     private static class UncloseableOutputStream extends OutputStream {
751         private final OutputStream mStream;
752 
753         UncloseableOutputStream(OutputStream stream) {
754             mStream = stream;
755         }
756 
757         public void close() throws IOException {
758             // Don't close the stream
759         }
760 
761         public boolean equals(Object o) {
762             return mStream.equals(o);
763         }
764 
765         public void flush() throws IOException {
766             mStream.flush();
767         }
768 
769         public int hashCode() {
770             return mStream.hashCode();
771         }
772 
773         public String toString() {
774             return mStream.toString();
775         }
776 
777         public void write(byte[] buffer, int offset, int count)
778                 throws IOException {
779             mStream.write(buffer, offset, count);
780         }
781 
782         public void write(byte[] buffer) throws IOException {
783             mStream.write(buffer);
784         }
785 
786         public void write(int oneByte) throws IOException {
787             mStream.write(oneByte);
788         }
789     }
790 
791     /**
792      * 一个空的ViewServer类
793      */
794     private static class NoopViewServer extends ViewServer {
795         private NoopViewServer() {
796         }
797 
798         @Override
799         public boolean start() throws IOException {
800             return false;
801         }
802 
803         @Override
804         public boolean stop() {
805             return false;
806         }
807 
808         @Override
809         public boolean isRunning() {
810             return false;
811         }
812 
813         @Override
814         public void addWindow(Activity activity) {
815         }
816 
817         @Override
818         public void removeWindow(Activity activity) {
819         }
820 
821         @Override
822         public void addWindow(View view, String name) {
823         }
824 
825         @Override
826         public void removeWindow(View view) {
827         }
828 
829         @Override
830         public void setFocusedWindow(Activity activity) {
831         }
832 
833         @Override
834         public void setFocusedWindow(View view) {
835         }
836 
837         @Override
838         public void run() {
839         }
840     }
841 }