🔄 Recap: What We Did in Part 1?

In Part 1, we successfully set up MITM Proxy to intercept network requests from a mobile app running on an Android/iOS device. We learned how to:

✅ Install MITM Proxy and start a proxy server.
✅ Configure proxy settings on a real device/emulator.
✅ Intercept HTTP & HTTPS requests using a MITM CA Certificate.

🚀 That was fun, but now let’s take it to the next level!

🔥 What’s Next?

We don’t just want to view network logs—we want to capture them programmatically in our automation framework.

And for that, we’ll use MITM Proxy’s Java Client!

---

🤖 What is the MITM Proxy Java Client?

The MITM Proxy Java Client (mitmproxy-java) acts as a bridge between MITM Proxy and your Java-based automation framework.

💡 Here’s how it works:

✅ MITM Proxy starts a WebSocket server.
✅ A Python plugin inside MITM Proxy sends network traffic to the Java client.
✅ The Java client captures and stores network requests for analysis.

With this setup, we can:
🔍 Capture API calls made by the mobile app.
📄 Save network logs for debugging.
🔗 Attach logs to test reports.

⚙️ Step 1: Install the Required Dependencies

📌 Prerequisites

Before setting up the Java client, make sure you have:

1️⃣ MITM Proxy v9+ installed and working.
2️⃣ Python 3.6+ (MITM Proxy uses async WebSockets).
3️⃣ WebSockets module installed:

pip3 install websockets

📌 Add MITM Proxy Java Dependency to Your Project

If you’re using Maven, add this dependency to your pom.xml:

<dependency>
  <groupId>io.appium</groupId>
  <artifactId>mitmproxy-java</artifactId>
  <version>2.0.2</version>
</dependency>

🚨 Note: The latest version is not yet available in the official repository, so you may need to clone the source code and build your own JAR.

📂 Step 2: Integrate MITM Proxy Java Client in Your Framework

🕒 Step 2.1: Create a Class to Store Intercepted Messages

To store network logs with timestamps, create InterceptedMessages.java:

import io.appium.mitmproxy.InterceptedMessage;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * Stores intercepted message along with timestamp.
 */
public class InterceptedMessages {
    @Accessors(chain = true)
    @Getter@Setter
    private Date timestamp;

    @Accessors(chain = true)
    @Getter@Setter
    private InterceptedMessage interceptedMessage;
}

🚀 Now every intercepted request will be saved with a timestamp!

---

🛠 Step 2.2: Add a Handler to Start & Stop MITM Proxy

Now, let’s create MITMProxy.java to:
✅ Start the proxy listener.
✅ Capture network traffic.
✅ Stop the proxy when needed.

import io.appium.mitmproxy.InterceptedMessage;
import io.appium.mitmproxy.MitmproxyJava;
import lombok.Getter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeoutException;

/**
 * MITM Proxy Utility for Capturing Network Logs in Automation Framework.
 */
public class MITMProxy {
    @Getter
    private final List<InterceptedMessages> networkCalls = new ArrayList<>();

    private static MITMProxy proxyInstance = null;
    private MitmproxyJava proxy;

    // Singleton Pattern to Ensure Single Instance
    private MITMProxy() {
        startProxyListener();
    }

    public static MITMProxy getProxy() {
        if (proxyInstance == null)
            proxyInstance = new MITMProxy();
        return proxyInstance;
    }

    /**
     * Starts MITM Proxy and Listens for Network Traffic
     */
    private void startProxyListener() {
        System.out.println("🚀 Starting MITM Proxy Listener...");

        List<String> extraMitmproxyParams = Arrays.asList("--showhost", "<domain-name-filter>");
        int mitmproxyPort = 8090;

        this.proxy = new MitmproxyJava(getMitmDumpPath(), (InterceptedMessage message) -> {
            InterceptedMessages interceptedMessage = new InterceptedMessages()
                    .setTimestamp(new Date())
                    .setInterceptedMessage(message);
            networkCalls.add(interceptedMessage);

            // Log each intercepted message
            System.out.println("🔍 Captured Network Request at: " + interceptedMessage.getTimestamp());
            System.out.println("📡 Request Details: " + message);

            return message;
        }, mitmproxyPort, extraMitmproxyParams);

        try {
            // Kill existing process on the same port if running
            String processId = ProcessExecutor.executeCommandSync("lsof -t -i:" + mitmproxyPort + " -sTCP:LISTEN").trim();
            if (!processId.isEmpty())
                ProcessExecutor.executeCommandSync("kill -9 " + processId);

            this.proxy.start();
        } catch (IOException | TimeoutException e) {
            throw new RuntimeException("❌ Failed to Start Proxy: " + e.getMessage());
        }

        System.out.println("✅ Proxy Listener Started Successfully!");
    }

    /**
     * Retrieves MITM Dump Path
     */
    private String getMitmDumpPath() {
        String result = ProcessExecutor.executeCommandSync("whereis mitmdump");
        return result.split("mitmdump: ")[1].split(" ")[0].trim();
    }

    /**
     * Stops MITM Proxy
     */
    public void stopProxyListener() {
        System.out.println("🛑 Stopping MITM Proxy Listener...");
        try {
            this.proxy.stop();
        } catch (InterruptedException e) {
            throw new RuntimeException("❌ Failed to Stop Proxy: " + e.getMessage());
        }
        System.out.println("✅ Proxy Listener Stopped Successfully!");
    }

    /**
     * Prints All Captured Network Logs
     */
    public void printCapturedLogs() {
        System.out.println("📜 Printing Captured Network Logs...");

        if (networkCalls.isEmpty()) {
            System.out.println("⚠️ No network requests were intercepted.");
            return;
        }

        for (InterceptedMessages msg : networkCalls) {
            System.out.println("⏳ Captured Request at: " + msg.getTimestamp());
            System.out.println("📡 Request Details: " + msg.getInterceptedMessage());
            System.out.println("--------------------------------------------------");
        }
    }
}

🔥 What Does This Class Do?

✅ Automatically starts MITM Proxy when called.
✅ Captures every intercepted request and stores it with a timestamp.
✅ Prevents port conflicts by killing any existing process on the same port.

---

🚀 Step 3: Start Capturing Network Logs

🎬 Start the Proxy

MITMProxy.getProxy();

👉 This starts the MITM Proxy and begins capturing network requests.

---

📄 Fetch Intercepted Logs

networkLogMessage = MITMProxy.getProxy().getNetworkCalls();

👉 This retrieves all captured network logs, which can be saved or attached to reports.

---

🛑 Stop the Proxy

MITMProxy.getProxy().stopProxyListener();

👉 This stops the proxy when tests are complete.

---

🔍 Verifying Captured Logs

Once your tests have run, print the captured logs to verify that requests are being intercepted:

for (InterceptedMessages msg : MITMProxy.getProxy().getNetworkCalls()) {
    System.out.println("Captured Request at: " + msg.getTimestamp());
    System.out.println("Request Details: " + msg.getInterceptedMessage());
}

🎉 Now you can capture and analyze every network request in your tests!

---

🎯 What’s Next?

✅ We can now intercept API calls from our mobile automation framework! 🎯

But what if we need to store these logs for later analysis? 🤔

👉 In Part 3, we’ll:
✅ Save network logs to files for debugging.
✅ Attach logs to automation test reports.
✅ Filter out unwanted noise from logs.

Stay tuned for Part 3! 🚀🔥

💬 Questions? Drop a comment below!