gt:                 IViewPart view = page.findView(LogCatView.ID);
context: /*
   * Copyright (C) 2011 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.ide.eclipse.ddms;
  
  import com.android.ddmlib.AndroidDebugBridge;
  import com.android.ddmlib.AndroidDebugBridge.IDeviceChangeListener;
  import com.android.ddmlib.IDevice;
  import com.android.ddmlib.Log.LogLevel;
  import com.android.ddmuilib.logcat.ILogCatBufferChangeListener;
  import com.android.ddmuilib.logcat.LogCatMessage;
  import com.android.ddmuilib.logcat.LogCatReceiver;
  import com.android.ddmuilib.logcat.LogCatReceiverFactory;
  import com.android.ide.eclipse.ddms.views.LogCatView;
  
  import org.eclipse.jface.preference.IPreferenceStore;
  import org.eclipse.jface.util.IPropertyChangeListener;
  import org.eclipse.jface.util.PropertyChangeEvent;
  import org.eclipse.jface.window.Window;
  import org.eclipse.swt.widgets.Display;
  import org.eclipse.swt.widgets.Shell;
  import org.eclipse.ui.IViewPart;
  import org.eclipse.ui.IWorkbenchPage;
  import org.eclipse.ui.IWorkbenchWindow;
  import org.eclipse.ui.PartInitException;
  import org.eclipse.ui.PlatformUI;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.atomic.AtomicBoolean;
  
  /**
   * LogCatMonitor helps in monitoring the logcat output from a set of devices.
   * It scans through the received logcat messages, and activates the logcat view
   * if any message is deemed important.
   */
  public class LogCatMonitor {
      public static final String AUTO_MONITOR_PREFKEY = "ddms.logcat.automonitor"; //$NON-NLS-1$
      public static final String AUTO_MONITOR_LOGLEVEL = "ddms.logcat.auotmonitor.level"; //$NON-NLS-1$
      private static final String AUTO_MONITOR_PROMPT_SHOWN = "ddms.logcat.automonitor.userprompt"; //$NON-NLS-1$
  
      private IPreferenceStore mPrefStore;
      private Map<String, DeviceData> mMonitoredDevices;
      private IDebuggerConnector[] mConnectors;
  
      private int mMinMessagePriority;
  
      /**
       * Flag that controls when the logcat stream is checked. This flag is set when the user
       * performs a launch, and is reset as soon as the logcat view is displayed.
       */
      final AtomicBoolean mMonitorEnabled = new AtomicBoolean(false);
  
      public LogCatMonitor(IDebuggerConnector[] debuggerConnectors, IPreferenceStore prefStore) {
          mConnectors = debuggerConnectors;
          mPrefStore = prefStore;
          mMinMessagePriority =
                  LogLevel.getByString(mPrefStore.getString(AUTO_MONITOR_LOGLEVEL)).getPriority();
  
          mMonitoredDevices = new HashMap<String, DeviceData>();
  
          AndroidDebugBridge.addDeviceChangeListener(new IDeviceChangeListener() {
              @Override
              public void deviceDisconnected(IDevice device) {
                  unmonitorDevice(device.getSerialNumber());
                  mMonitoredDevices.remove(device.getSerialNumber());
              }
  
              @Override
              public void deviceConnected(IDevice device) {
              }
  
              @Override
              public void deviceChanged(IDevice device, int changeMask) {
              }
          });
  
          mPrefStore.addPropertyChangeListener(new IPropertyChangeListener() {
              @Override
              public void propertyChange(PropertyChangeEvent event) {
                  if (AUTO_MONITOR_PREFKEY.equals(event.getProperty())
                          && event.getNewValue().equals(false)) {
                      unmonitorAllDevices();
                  } else if (AUTO_MONITOR_LOGLEVEL.equals(event.getProperty())) {
                      mMinMessagePriority =
                              LogLevel.getByString((String) event.getNewValue()).getPriority();
                  }
              }
          });
      }
  
      private void unmonitorAllDevices() {
          for (String device : mMonitoredDevices.keySet()) {
              unmonitorDevice(device);
          }
  
          mMonitoredDevices.clear();
      }
  
      private void unmonitorDevice(String deviceSerial) {
          DeviceData data = mMonitoredDevices.get(deviceSerial);
          if (data == null) {
              return;
          }
  
          data.receiver.removeMessageReceivedEventListener(data.bufferChangeListener);
      }
  
      public void monitorDevice(final IDevice device) {
          if (!mPrefStore.getBoolean(AUTO_MONITOR_PREFKEY)) {
              // do not monitor device if auto monitoring is off
              return;
          }
  
          mMonitorEnabled.set(true);
  
          if (mMonitoredDevices.keySet().contains(device.getSerialNumber())) {
              // the device is already monitored
              return;
          }
  
          LogCatReceiver r = LogCatReceiverFactory.INSTANCE.newReceiver(device, mPrefStore);
          ILogCatBufferChangeListener l = new ILogCatBufferChangeListener() {
              @Override
              public void bufferChanged(List<LogCatMessage> addedMessages,
                      List<LogCatMessage> deletedMessages) {
                  checkMessages(addedMessages, device);
              }
          };
          r.addMessageReceivedEventListener(l);
  
          mMonitoredDevices.put(device.getSerialNumber(), new DeviceData(r, l));
      }
  
      private void checkMessages(List<LogCatMessage> receivedMessages, IDevice device) {
          if (!mMonitorEnabled.get()) {
              return;
          }
  
          // check the received list of messages to see if any of them are
          // significant enough to be seen by the user. If so, activate the logcat view
          // to display those messages
          for (LogCatMessage m : receivedMessages) {
              if (isImportantMessage(m)) {
                  focusLogCatView(device, m.getAppName());
  
                  // now that logcat view is active, no need to check messages until the next
                  // time user launches an application.
                  mMonitorEnabled.set(false);
                  break;
              }
          }
      }
  
      /**
       * Check whether a message is "important". Currently, we assume that a message is important if
       * it is of severity level error or higher, and it belongs to an app currently in the workspace.
       */
      private boolean isImportantMessage(LogCatMessage m) {
          if (m.getLogLevel().getPriority() < mMinMessagePriority) {
              return false;
          }
  
          String app = m.getAppName();
          for (IDebuggerConnector c : mConnectors) {
              if (c.isWorkspaceApp(app)) {
                  return true;
              }
          }
  
          return false;
      }
  
      private void focusLogCatView(final IDevice device, final String appName) {
          Display.getDefault().asyncExec(new Runnable() {
              @Override
              public void run() {
                  IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
                  if (window == null) {
                      return;
                  }
  
                  IWorkbenchPage page = window.getActivePage();
                  if (page == null) {
                      return;
                  }
  
                  // if the logcat view is not visible, then prompt the user once to set
                  // logcat monitoring preferences
                  if (!isLogCatViewVisible(page)) {
                      boolean showLogCatView = promptUserOnce(page.getWorkbenchWindow().getShell());
                      if (!showLogCatView) {
                          return;
                      }
                  }
  
                  // display view
                  final LogCatView v = displayLogCatView(page);
                  if (v == null) {
                      return;
                  }
  
                  // select correct device
                  v.selectionChanged(device);
  
                  // select appropriate filter
                  v.selectTransientAppFilter(appName);
              }
  
              private boolean isLogCatViewVisible(IWorkbenchPage page) {
  