imToken v2.9.3版本的 MD5 值为：42af1a08a3f01f69d2f3782d81007b3c

以下内容为反编译后的 Dashboard.java 源代码，内容仅作参考

package com.subgraph.orchid.dashboard;

import com.subgraph.orchid.Threading;
import com.subgraph.orchid.data.IPv4Address;
import com.subgraph.orchid.misc.GuardedBy;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executor;
import java.util.logging.Logger;

public class Dashboard implements DashboardRenderable, DashboardRenderer {
    private static final String DASHBOARD_PORT_PROPERTY = "com.subgraph.orchid.dashboard.port";
    private static final int DEFAULT_FLAGS = 24;
    private static final int DEFAULT_LISTENING_PORT = 12345;
    private final Executor executor;

    @GuardedBy("this")
    private int flags = 24;

    @GuardedBy("this")
    private boolean isListening;

    @GuardedBy("this")
    private int listeningPort;

    @GuardedBy("this")
    private ServerSocket listeningSocket;
    private final List<DashboardRenderable> renderables;
    private static final Logger logger = Logger.getLogger(Dashboard.class.getName());
    private static final IPv4Address LOCALHOST = IPv4Address.createFromString("127.0.0.1");

    public Dashboard() {
        CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
        this.renderables = copyOnWriteArrayList;
        copyOnWriteArrayList.add(this);
        this.executor = Threading.newPool("Dashboard worker");
        this.listeningPort = chooseListeningPort();
    }

    private static int chooseListeningPort() {
        String property = System.getProperty(DASHBOARD_PORT_PROPERTY);
        int parsePortProperty = parsePortProperty(property);
        if (parsePortProperty > 0 && parsePortProperty <= 65535) {
            return parsePortProperty;
        }
        if (property == null) {
            return DEFAULT_LISTENING_PORT;
        }
        logger.warning("com.subgraph.orchid.dashboard.port was not a valid port value: " + property);
        return DEFAULT_LISTENING_PORT;
    }

    private static int parsePortProperty(String str) {
        if (str == null) {
            return -1;
        }
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException unused) {
            return -1;
        }
    }

    public void addRenderables(Object... objArr) {
        for (Object obj : objArr) {
            if (obj instanceof DashboardRenderable) {
                this.renderables.add((DashboardRenderable) obj);
            }
        }
    }

    public void addRenderable(DashboardRenderable dashboardRenderable) {
        this.renderables.add(dashboardRenderable);
    }

    public synchronized void enableFlag(int i) {
        this.flags = i | this.flags;
    }

    public synchronized void disableFlag(int i) {
        this.flags = (~i) & this.flags;
    }

    public synchronized boolean isEnabled(int i) {
        return (i & this.flags) != 0;
    }

    public synchronized void setListeningPort(int i) {
        if (i != this.listeningPort) {
            this.listeningPort = i;
            if (this.isListening) {
                stopListening();
                startListening();
            }
        }
    }

    public boolean isEnabledByProperty() {
        return System.getProperty(DASHBOARD_PORT_PROPERTY) != null;
    }

    public synchronized void startListening() {
        if (this.isListening) {
            return;
        }
        try {
            this.listeningSocket = new ServerSocket(this.listeningPort, 50, LOCALHOST.toInetAddress());
            this.isListening = true;
            logger.info("Dashboard listening on " + LOCALHOST + ":" + this.listeningPort);
            this.executor.execute(createAcceptLoopRunnable(this.listeningSocket));
        } catch (IOException e) {
            logger.warning("Failed to create listening Dashboard socket on port " + this.listeningPort + ": " + e);
        }
    }

    public synchronized void stopListening() {
        if (this.isListening) {
            if (this.listeningSocket != null) {
                closeQuietly(this.listeningSocket);
                this.listeningSocket = null;
            }
            this.isListening = false;
        }
    }

    public synchronized boolean isListening() {
        return this.isListening;
    }

    private Runnable createAcceptLoopRunnable(final ServerSocket serverSocket) {
        return new Runnable() {
            @Override
            public void run() {
                Dashboard.this.acceptConnections(serverSocket);
            }
        };
    }

    public void acceptConnections(ServerSocket serverSocket) {
        while (true) {
            try {
                this.executor.execute(new DashboardConnection(this, serverSocket.accept()));
            } catch (IOException e) {
                if (!serverSocket.isClosed()) {
                    logger.warning("IOException on dashboard server socket: " + e);
                }
                stopListening();
                return;
            }
        }
    }

    public void renderAll(PrintWriter printWriter) throws IOException {
        int i;
        synchronized (this) {
            i = this.flags;
        }
        Iterator<DashboardRenderable> it = this.renderables.iterator();
        while (it.hasNext()) {
            it.next().dashboardRender(this, printWriter, i);
        }
    }

    private void closeQuietly(ServerSocket serverSocket) {
        try {
            serverSocket.close();
        } catch (IOException unused) {
        }
    }

    @Override
    public void dashboardRender(DashboardRenderer dashboardRenderer, PrintWriter printWriter, int i) {
        printWriter.println("[Dashboard]");
        printWriter.println();
    }

    @Override
    public void renderComponent(PrintWriter printWriter, int i, Object obj) throws IOException {
        if (obj instanceof DashboardRenderable) {
            ((DashboardRenderable) obj).dashboardRender(this, printWriter, i);
        }
    }
}