Add logcat output to JadX Debugger

jadx-gui/src/main/java/jadx/gui/device/debugger/LogcatController.java

@@ -0,0 +1,390 @@
+package jadx.gui.device.debugger;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.gui.device.protocol.ADBDevice;
+import jadx.gui.ui.panel.LogcatPanel;
+
+public class LogcatController {
+	private static final Logger LOG = LoggerFactory.getLogger(LogcatController.class);
+
+	private final ADBDevice adbDevice;
+	private final LogcatPanel logcatPanel;
+	private Timer timer;
+	private final String timezone;
+	private LogcatInfo recent = null;
+	private ArrayList<LogcatInfo> events = new ArrayList<>();
+	private LogcatFilter filter = new LogcatFilter(null, null);
+	private String status = "null";
+
+	public LogcatController(LogcatPanel logcatPanel, ADBDevice adbDevice) throws IOException {
+		this.adbDevice = adbDevice;
+		this.logcatPanel = logcatPanel;
+		this.timezone = adbDevice.getTimezone();
+		this.startLogcat();
+	}
+
+	public void startLogcat() {
+		timer = new Timer();
+		timer.schedule(new TimerTask() {
+			@Override
+			public void run() {
+				getLog();
+			}
+		}, 0, 1000);
+		this.status = "running";
+	}
+
+	public void stopLogcat() {
+		timer.cancel();
+		this.status = "stopped";
+	}
+
+	public String getStatus() {
+		return this.status;
+	}
+
+	public void clearLogcat() {
+		try {
+			adbDevice.clearLogcat();
+			clearEvents();
+		} catch (IOException e) {
+			LOG.error("Failed to clear Logcat", e);
+		}
+	}
+
+	private void getLog() {
+		if (!logcatPanel.isReady()) {
+			return;
+		}
+		try {
+			byte[] buf;
+			if (recent == null) {
+				buf = adbDevice.getBinaryLogcat();
+			} else {
+				buf = adbDevice.getBinaryLogcat(recent.getAfterTimestamp());
+			}
+			if (buf == null) {
+				return;
+			}
+			ByteBuffer in = ByteBuffer.wrap(buf);
+			in.order(ByteOrder.LITTLE_ENDIAN);
+			while (in.remaining() > 20) {
+
+				LogcatInfo eInfo = null;
+				byte[] msgBuf;
+				short eLen = in.getShort();
+				short eHdrLen = in.getShort();
+				if (eLen + eHdrLen > in.remaining()) {
+					return;
+				}
+				switch (eHdrLen) {
+					case 20: // header length 20 == version 1
+						eInfo = new LogcatInfo(eLen, eHdrLen, in.getInt(), in.getInt(), in.getInt(), in.getInt(), in.get());
+						msgBuf = new byte[eLen];
+						in.get(msgBuf, 0, eLen - 1);
+						eInfo.setMsg(msgBuf);
+						break;
+					case 24: // header length 24 == version 2 / 3
+						eInfo = new LogcatInfo(eLen, eHdrLen, in.getInt(), in.getInt(), in.getInt(), in.getInt(), in.getInt(), in.get());
+						msgBuf = new byte[eLen];
+						in.get(msgBuf, 0, eLen - 1);
+						eInfo.setMsg(msgBuf);
+						break;
+					case 28: // header length 28 == version 4
+						eInfo = new LogcatInfo(eLen, eHdrLen, in.getInt(), in.getInt(), in.getInt(), in.getInt(), in.getInt(), in.getInt(),
+								in.get());
+						msgBuf = new byte[eLen];
+						in.get(msgBuf, 0, eLen - 1);
+						eInfo.setMsg(msgBuf);
+						break;
+					default:
+
+						break;
+				}
+				if (eInfo == null) {
+					return;
+				}
+				if (recent == null) {
+					recent = eInfo;
+				} else if (recent.getInstant().isBefore(eInfo.getInstant())) {
+					recent = eInfo;
+				}
+
+				if (filter.doFilter(eInfo)) {
+					logcatPanel.log(eInfo);
+				}
+				events.add(eInfo);
+			}
+
+		} catch (Exception e) {
+			LOG.error("Failed to get logcat message", e);
+		}
+	}
+
+	public boolean reload() {
+		stopLogcat();
+		boolean ok = logcatPanel.clearLogcatArea();
+		if (ok) {
+			events.forEach((eInfo) -> {
+				if (filter.doFilter(eInfo)) {
+					logcatPanel.log(eInfo);
+				}
+			});
+			startLogcat();
+		}
+		return true;
+	}
+
+	public void clearEvents() {
+		this.recent = null;
+		this.events = new ArrayList<>();
+	}
+
+	public void exit() {
+		stopLogcat();
+		filter = new LogcatFilter(null, null);
+		recent = null;
+	}
+
+	public LogcatFilter getFilter() {
+		return this.filter;
+	}
+
+	public class LogcatFilter {
+		private final ArrayList<Integer> pid;
+		private ArrayList<Byte> msgType = new ArrayList<Byte>() {
+			{
+				add((byte) 1);
+				add((byte) 2);
+				add((byte) 3);
+				add((byte) 4);
+				add((byte) 5);
+				add((byte) 6);
+				add((byte) 7);
+				add((byte) 8);
+			}
+		};
+
+		public LogcatFilter(ArrayList<Integer> pid, ArrayList<Byte> msgType) {
+			if (pid != null) {
+				this.pid = pid;
+			} else {
+				this.pid = new ArrayList<>();
+			}
+
+			if (msgType != null) {
+				this.msgType = msgType;
+			}
+		}
+
+		public void addPid(int pid) {
+
+			if (!this.pid.contains(pid)) {
+				this.pid.add(pid);
+			}
+		}
+
+		public void removePid(int pid) {
+			int pidPos = this.pid.indexOf(pid);
+			if (pidPos >= 0) {
+				this.pid.remove(pidPos);
+			}
+		}
+
+		public void togglePid(int pid, boolean state) {
+			if (state) {
+				addPid(pid);
+			} else {
+				removePid(pid);
+			}
+		}
+
+		public void addMsgType(byte msgType) {
+			if (!this.msgType.contains(msgType)) {
+				this.msgType.add(msgType);
+			}
+		}
+
+		public void removeMsgType(byte msgType) {
+			int typePos = this.msgType.indexOf(msgType);
+			if (typePos >= 0) {
+				this.msgType.remove(typePos);
+			}
+		}
+
+		public void toggleMsgType(byte msgType, boolean state) {
+			if (state) {
+				addMsgType(msgType);
+			} else {
+				removeMsgType(msgType);
+			}
+		}
+
+		public boolean doFilter(LogcatInfo inInfo) {
+			if (pid.contains(inInfo.getPid())) {
+				return msgType.contains(inInfo.getMsgType());
+			}
+			return false;
+		}
+
+		public ArrayList<LogcatInfo> getFilteredList(ArrayList<LogcatInfo> inInfoList) {
+			ArrayList<LogcatInfo> outInfoList = new ArrayList<LogcatInfo>();
+			inInfoList.forEach((inInfo) -> {
+				if (doFilter(inInfo)) {
+					outInfoList.add(inInfo);
+				}
+			});
+			return outInfoList;
+		}
+	}
+
+	public class LogcatInfo {
+		private String msg;
+		private final byte msgType;
+		private final int nsec;
+		private final int pid;
+		private final int sec;
+		private final int tid;
+		private final short hdrSize;
+		private final short len;
+		private final short version;
+		private int lid;
+		private int uid;
+
+		public LogcatInfo(short len, short hdrSize, int pid, int tid, int sec, int nsec, byte msgType) {
+			this.hdrSize = hdrSize;
+			this.len = len;
+			this.msgType = msgType;
+			this.nsec = nsec;
+			this.pid = pid;
+			this.sec = sec;
+			this.tid = tid;
+			this.version = 1;
+		}
+
+		// Version 2 and 3 both have the same arguments
+		public LogcatInfo(short len, short hdrSize, int pid, int tid, int sec, int nsec, int lid, byte msgType) {
+			this.hdrSize = hdrSize;
+			this.len = len;
+			this.lid = lid;
+			this.msgType = msgType;
+			this.nsec = nsec;
+			this.pid = pid;
+			this.sec = sec;
+			this.tid = tid;
+			this.version = 3;
+		}
+
+		public LogcatInfo(short len, short hdrSize, int pid, int tid, int sec, int nsec, int lid, int uid, byte msgType) {
+			this.hdrSize = hdrSize;
+			this.len = len;
+			this.lid = lid;
+			this.msgType = msgType;
+			this.nsec = nsec;
+			this.pid = pid;
+			this.sec = sec;
+			this.tid = tid;
+			this.uid = uid;
+			this.version = 4;
+		}
+
+		public void setMsg(byte[] msg) {
+			this.msg = new String(msg);
+		}
+
+		public short getVersion() {
+			return this.version;
+		}
+
+		public short getLen() {
+			return this.len;
+		}
+
+		public short getHeaderLen() {
+			return this.hdrSize;
+		}
+
+		public int getPid() {
+			return this.pid;
+		}
+
+		public int getTid() {
+			return this.tid;
+		}
+
+		public int getSec() {
+			return this.sec;
+		}
+
+		public int getNSec() {
+			return this.nsec;
+		}
+
+		public int getLid() {
+			return this.lid;
+		}
+
+		public int getUid() {
+			return this.uid;
+		}
+
+		public Instant getInstant() {
+			return Instant.ofEpochSecond(getSec(), getNSec());
+		}
+
+		public String getTimestamp() {
+			DateTimeFormatter dtFormat = DateTimeFormatter.ofPattern("MM-dd HH:mm:ss.SSS").withZone(ZoneId.of(timezone));
+			return dtFormat.format(getInstant());
+		}
+
+		public String getAfterTimestamp() {
+			DateTimeFormatter dtFormat = DateTimeFormatter.ofPattern("MM-dd HH:mm:ss.SSS").withZone(ZoneId.of(timezone));
+			return dtFormat.format(getInstant().plusMillis(1));
+		}
+
+		public byte getMsgType() {
+			return this.msgType;
+		}
+
+		public String getMsgTypeString() {
+			switch (getMsgType()) {
+				case 0:
+					return "Unknown";
+				case 1:
+					return "Default";
+				case 2:
+					return "Verbose";
+				case 3:
+					return "Debug";
+				case 4:
+					return "Info";
+				case 5:
+					return "Warn";
+				case 6:
+					return "Error";
+				case 7:
+					return "Fatal";
+				case 8:
+					return "Silent";
+				default:
+					return "Unknown";
+			}
+		}
+
+		public String getMsg() {
+			return this.msg;
+		}
+	}
+}