org.jetbrains.android.logcat.AndroidLogcatUtil.java Source code

Introduction

Here is the source code for org.jetbrains.android.logcat.AndroidLogcatUtil.java

Source

/*
 * Copyright 2000-2010 JetBrains s.r.o.
 *
 * 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 org.jetbrains.android.logcat;

import com.android.ddmlib.*;
import com.intellij.diagnostic.logging.LogConsoleBase;
import com.intellij.execution.process.ProcessOutputTypes;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.Messages;
import com.intellij.openapi.util.Pair;
import com.intellij.util.ui.UIUtil;
import org.jetbrains.android.run.LoggingReceiver;
import org.jetbrains.android.util.AndroidBundle;
import org.jetbrains.android.util.AndroidOutputReceiver;
import org.jetbrains.android.util.AndroidUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.io.*;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by IntelliJ IDEA.
 * User: Eugene.Kudelevsky
 * Date: Sep 12, 2009
 * Time: 7:06:44 PM
 * To change this template use File | Settings | File Templates.
 */
public class AndroidLogcatUtil {
    private static final Logger LOG = Logger.getInstance("#org.jetbrains.android.run.AndroidDebugRunner");
    private static Map<String, Log.LogLevel> ourLogLevels;

    private AndroidLogcatUtil() {
    }

    @Nullable
    public synchronized static Log.LogLevel getLogLevel(String s) {
        if (ourLogLevels == null) {
            ourLogLevels = new HashMap<String, Log.LogLevel>();

            for (Log.LogLevel level : Log.LogLevel.values()) {
                ourLogLevels.put(level.name(), level);
            }
        }
        return ourLogLevels.get(s);
    }

    private static void startLogging(IDevice device, AndroidOutputReceiver receiver)
            throws IOException, ShellCommandUnresponsiveException, AdbCommandRejectedException, TimeoutException {
        AndroidUtils.executeCommandOnDevice(device, "logcat -v long", receiver, true);
    }

    public static void clearLogcat(final Project project, IDevice device) {
        try {
            AndroidUtils.executeCommandOnDevice(device, "logcat -c", new LoggingReceiver(LOG), false);
        } catch (final Exception e) {
            LOG.info(e);
            ApplicationManager.getApplication().invokeLater(new Runnable() {
                @Override
                public void run() {
                    Messages.showErrorDialog(project, "Error: " + e.getMessage(),
                            AndroidBundle.message("android.logcat.error.dialog.title"));
                }
            });
        }
    }

    @Nullable
    public static Pair<Reader, Writer> startLoggingThread(final Project project, final IDevice device,
            final boolean clearLogcat, @NotNull final LogConsoleBase console) {
        UIUtil.invokeAndWaitIfNeeded(new Runnable() {
            @Override
            public void run() {
                console.clear();
            }
        });
        PipedWriter logWriter = new PipedWriter();
        final AndroidLogcatReceiver receiver = new AndroidLogcatReceiver(device, logWriter);
        final PipedReader logReader;
        try {
            logReader = new PipedReader(logWriter) {
                @Override
                public void close() throws IOException {
                    super.close();
                    receiver.cancel();
                }

                @Override
                public synchronized boolean ready() {
                    // We have to avoid Logging error in LogConsoleBase if logcat is finished incorrectly
                    try {
                        return super.ready();
                    } catch (IOException e) {
                        LOG.debug(e);
                        return false;
                    }
                }
            };
        } catch (IOException e) {
            LOG.info(e);
            console.writeToConsole("Unable to run logcat. IOException: " + e.getMessage() + '\n',
                    ProcessOutputTypes.STDERR);
            return null;
        }
        ApplicationManager.getApplication().invokeLater(new Runnable() {
            @Override
            public void run() {
                ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
                    @Override
                    public void run() {
                        if (clearLogcat) {
                            clearLogcat(project, device);
                        }
                        try {
                            startLogging(device, receiver);
                        } catch (final Exception e) {
                            LOG.info(e);
                            console.writeToConsole(e.getMessage() + '\n', ProcessOutputTypes.STDERR);
                        }
                    }
                });
            }
        });
        return new Pair<Reader, Writer>(logReader, logWriter);
    }
}