DEV Community: Nizar

Mocktender: simplified testing using entry points

Nizar — Tue, 25 Mar 2025 13:56:21 +0000

Hey folks. It's been a while since my last post...

What have I been up to, you may ask?
I have been struggling with testing.

So I built this tool to simplify testing.
And I'm here to share more about it.

Problem

I've learned to test behavior and to isolate integrations so the tests remain quick.

But now, to test a resolver that creates a post, for example, I would need roughly 3 tests.

The first test would start the server with mock handlers, ensuring the route calls the handler.
The second test would call the handler directly with a DB data stub, ensuring the handler returns the created post.
The third test would start the database, ensuring the query with fake data creates the post row.

If we were to add notifying subscribers by email, we'd need another one! So, we need an isolated test for every integration.

Yet, all these tests require maintenance.

Introducing mocktender

To address that, I built a tool that traces the code behavior across your layers and isolates the integrations.

Instead of writing and maintaining 3+ tests, I only need 1. I just need to test the entry-point, which in this case is my server route.

Mocktender traces how my server route interacts with the handler, how the handler interacts with the database method, and so on...

Then, mocktender isolates them so that my single test runs similarly to those 3 traditional tests, with each integration isolated (without sacrificing speed).

Example

The code from this example can be found here.

To demonstrate the example, we'll test a basic HTTP server with a route handler.

We're only going to handle the /hello route; otherwise, we'll return 404 not found.

// server.ts
import http from "http"

import { helloHandler } from "./handlers.ts"

const requestHandler = (req: http.IncomingMessage, res: http.ServerResponse) => {
  if (req.url?.startsWith("/hello")) {
    const { status, body } = helloHandler(req.url)
    res.writeHead(status, { 'Content-Type': 'text/plain' })
    res.end(body)
    return
  }

  res.writeHead(404, { 'Content-Type': 'text/plain' })
  res.end('Not Found')
}

export function createServer(): http.Server {
  return http.createServer(requestHandler)
}

Now that we have the server, we want to implement the helloHandler.

It accepts an optional query parameter name and returns 200 status with body Hello, ${name ?? 'world'}!.

// handlers.ts
import URL from "url"

function greet(name: string = "world") {
  return `Hello, ${name}!`
}

/** @bridge bridges the server request handler with the greet function */
export function helloHandler(url: string): { status: number; body: string } {
  const parsed = URL.parse(url, true)

  const name = Array.isArray(parsed.query.name)
    ? parsed.query.name[0]
    : parsed.query.name

  return {
    status: 200,
    body: greet(name)
  }
}

Notice the @bridge tag we added above helloHandler?
This helps mocktender identify where it should isolate the tests.

We still need to test the entry-point's behavior.

So, we'll start the server when we start testing, and close it when we're done testing.

During the test, we'll call each server route. The following routes should cover all the behaviors of our codebase:

/hello
/hello?name=John
/not-found

// server.test.ts

import { createServer } from "./server.ts"

type TestCase = {
  desc: string
  url: string
  want: {
    status: number
    body: string
  }
}

const tt: TestCase[] = [
  {
    desc: "greeting.default",
    url: "/hello",
    want: {
      status: 200,
      body: "Hello, world!"
    }
  },
  {
    desc: "greeting.withName",
    url: "/hello?name=John",
    want: {
      status: 200,
      body: "Hello, John!"
    }
  },
  {
    desc: "greeting.notFound",
    url: "/not-found",
    want: {
      status: 404,
      body: "Not Found"
    }
  }
]

// This test runs as both: end to end, and isolated integration test.
// Test the behavior, record it, and then replay it.
// Replaying the test is great for CI and isolating fixtures.
describe("server", () => {
  const server = createServer()

  beforeAll(() => {
    server.listen(8080)
  })

  afterAll(() => {
    server.close()
  })

  it.each(tt)("$desc", async (tc) => {
    global.__rid = tc.desc

    const res = await fetch(`http://localhost:8080${tc.url}`)

    const gotStatus = res.status
    expect(gotStatus).toBe(tc.want.status)

    const gotBody = await res.text()
    expect(gotBody).toBe(tc.want.body)
  })
})

Next up, I need to record the behavior of my codebase.
After adding mocktender's Jest plugin, I can run the following command.

yarn test:record

As a result, the following behaviors file gets generated.

This file is tracked by version control, so you can know exactly what changes whenever reviewing a pull request.

{
    "/app/example/handlers.ts": {
        "helloHandler": {           // the `@bridge` tagged function
            "greeting.default": [   // the first testcase
                {
                    "args": [
                        "/hello"
                    ],
                    "result": {
                        "status": 200,
                        "body": "Hello, world!"
                    }
                }
            ],
            "greeting.withName": [   // the second testcase
                {
                    "args": [
                        "/hello?name=John"
                    ],
                    "result": {
                        "status": 200,
                        "body": "Hello, John!"
                    }
                }
            ]
        }
    }
}

Finally, whenever I need to simulate the test run again, I can just run the following command.

yarn test:replay

Disclaimer

It’s in early proof-of-concept stage, dogfooding, with a working example.

It has a long way to go, so I'd love feedback/contributions—especially on a subject like testing.

nizarmah / mocktender

Simplified testing using entry-points.

mocktender

Serves mocks.

Mocktender is a test tracer that automatically records code behavior and replays it later, simplifying tests and mocks.

For example, testing a create post resolver, traditionally I would:

Test the resolver with a DB stub.
Test the DB integration with fake input.
Test server integration with a resolver mock.

Using mocktender, I would only need to test the entrypoint (the server route). Then:

Mocktender records the behavior across the server, resolver, and DB.
Mocktender automatically isolates each to match traditional tests.

Check example.

Early development

Only a proof of concept right now, but actively being developed.

If you need it, let me know — nizar.mah99@gmail.com. It can be reproduced in different languages.

Objectives

Test a codebase through its entrypoints.
Eventually, only run codebase through tests.
One day, simulate e2e tests with unit tests.

Technical guide

Check src.

View on GitHub

Building an Open Source Realtime Face Recognition Android App

Nizar — Thu, 21 May 2020 22:17:12 +0000

We've all seen things in movies we wish were real. The first thing that comes to my mind is The Matrix and the ability to download any skill onto a person's brain. While this is still far from possible, I've always wanted to create futuristic software I've seen in movies.

Kindly let me know in the comments: What's the first thing that comes to mind when you think of technology you've seen in movies or series?

Sadly, we are still far from creating an artificial intelligence as brilliant as the ones in Transcendence, Ex Machina or I, Robot. Even though I would love to start working on something that huge one day, I've also had this desire to build a live face recognition application for a while now.

I don't remember exactly when the idea came to mind; however, I know that face recognition is a pretty common thing in movies or series. So, I really wanted to start building one I could keep in my pocket.

So I decided to blog the process of me building one. There might be multiple stages. Small sneak peeks of possible future stages are collecting data on the go, setting up a smarter model, and updating and loading models online through dependency injection.

For now, we will be creating the code required for the application to detect the faces and communicate with the face recognition model.

Here's a quick demo video

I think I should mention that this works with multiple faces in the field of view of the camera at the same time. Sadly, at the time of recording the demo, I was alone.

Separating the Tasks

Before being able to start with the code, we need to envision how the application will be working.

This is the list of things we need to do, in the following order:

Previewing camera frames
Capturing camera frames
Face detection
Highlighting detected faces
Face recognition
Labeling highlighted faces

By building each part separately, we can, later on, improve certain aspects of the application without having to rewrite a lot of code.

Previewing Camera Frames

In order to display the camera frames to the user, I used AndroidX CameraView. This provided a simple view of what the camera sees. Also, it would be bound to the lifecycle of the activity/fragment. It was a better option than implementing my own preview because it resulted in much better FPS.

However, the camera view can be given different configurations and settings. A factory helped me specify which configuration I wanted to use, and it would get automatically applied to the camera view.

So, initializing the camera view looked something like this.

cameraView.apply {
    bindToLifecycle(this@FaceRecognitionFragment)

    CameraViewFactory.applyConfig(cameraView, cameraViewConfig)
}

Click here to check the Camera View Factory and Configs code

Capturing Camera Frames

The view was being shown thanks to the AndroidX CameraView. Yet, I still didn't have access to the frames, which I need to run the face detection model on.

Luckily, the AndroidX CameraX can analyze images. Following the CameraX Analyze images documentation, I created my own CameraAnalysisFactory, which analyzes images according to certain configurations passed to the factory.

I had to decrease the resolution of the images because the models and the devices and the models we have currently are far from being able to handle high quality pictures fast.

Thus, in the camera analysis configuration, I specified a low resolution. While the model is seeing low resolution frames, the user is still seeing great resolution frames in the camera view.

object LowResFaceDetectionCameraAnalysisConfig : CameraAnalysisConfig {
    override val resolution: Size = Size(240, 320)
    override val readerMode: ImageAnalysis.ImageReaderMode = ImageAnalysis.ImageReaderMode.ACQUIRE_LATEST_IMAGE
}

I also created a lambda function that receives the camera's image and rotation degrees from the camera frame analyzer, which later on deals with the frame received by the analyzer. Then, initialized a camera analyzer by giving the factory a camera analysis configuration and said lambda function.

private val cameraFameAnalyzer: CameraFrameAnalyzerLambdaType = { imageProxy, rotation ->  }

public val cameraFrameAnalysisConfig = LowResFaceDetectionCameraAnalysisConfig

public val cameraFrameAnalysis: ImageAnalysis = CameraAnalysisFactory.createCameraAnalysis(
    cameraFrameAnalysisConfig,
    analyzer = cameraFameAnalyzer
)

Now that I had the camera frame analysis object initialized, I had to bind it to our lifecycle, alongside with the camera view.

CameraX.bindToLifecycle(this, viewModel.cameraFrameAnalysis)

Click here to check the Camera Analysis Factory and Configs code

Face Detection

Since I just made a method to pass the frames from the camera to anything I wanted, I passed those frames onto the face detection model.

I chose Firebase MLKit for face detection since it is able to detect faces and track them as they move in the camera's field of view.

Accordingly, I created an abstract face detector object, with the necessary functionality. Meanwhile, the face detector objects inheriting that abstract class will have their own options for the firebase model.

Simply, I can, then, just initialize the face detector model I want to use.

private val faceDetector: FaceDetector = FaceDetector()

All that was left was to pass the frames I was getting from the analyzer onto the face detector. Following the Firebase MLKit Face Detection documentation, I specified the image's rotation and let the model process it.

private val cameraFameAnalyzer: CameraFrameAnalyzerLambdaType = { imageProxy, rotation ->
    val mediaImage = imageProxy?.image

    val imageRotation = when (rotation) {
        0 -> FirebaseVisionImageMetadata.ROTATION_0
        90 -> FirebaseVisionImageMetadata.ROTATION_90
        180 -> FirebaseVisionImageMetadata.ROTATION_180
        270 -> FirebaseVisionImageMetadata.ROTATION_270
        else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
    }

    mediaImage?.let {
        faceDetector.processImage(mediaImage, imageRotation, { faces, frame ->  })
    }
}

Click here to check the Face Detector code

Highlighting Detected Faces

Since the face detector model returns the faces and the frame read by the images, I sent those faces and their coordinates in the frame to a face highlighter object. The face highlighter object would be responsible for drawing the highlights around the faces.

Therefore, I created a lambda function, similar to the one passed to the faceDetector.processImage, where face highlight objects would be assigned to every detected face.

val highlightedFacesLiveData = MutableLiveData<List<FaceHighlight>>()
private val highlightDetectedFaces: (List<FirebaseVisionFace>) -> Unit = { faces ->
    val highlightedFacesList = ArrayList<FaceHighlight>()

    faces.forEach {
        highlightedFacesList.add(RectangularFaceHighlight(it))
    }

    highlightedFacesLiveData.postValue(highlightedFacesList)
}

Then, I would specify that lambda function as the callback for the faceDetector.processImage

faceDetector.processImage(mediaImage, imageRotation, highlightDetectedFaces)

But I wasn't done yet. Before I drew those highlights on top of the camera view, I remembered that the camera view and the frames passed to the face detector don't have the same resolution. Therefore, I had to create a transforming object to transform the coordinates of the face detected and their sizes to match the resolution of the camera view.

So, it was important to attach the face highlighter to both the camera view and the camera analyzer. The face highlighter would read the size of the camera view and the resolution of the camera analyzer and transform the highlights accordingly.

private val highlighterFaces: FaceHighlighter = findViewById(R.id.highlighter_faces)

highlighterFaces.attachCameraView(cameraView, cameraViewConfig)

highlighterFaces.attachCameraAnalysisConfig(viewModel.cameraFrameAnalysisConfig)

Following that, I took the face highlights posted through LiveData and drew them on the canvas.

viewModel.highlightedFacesLiveData.observe(this, Observer { highlightedFaces ->
    highlighterFaces.clear()

    highlightedFaces.forEach {
        highlighterFaces.add(it)
    }

    highlighterFaces.postInvalidate()
})

Click here to check the Face Highlighter and the Face Highlight Objects

Face Recognition

The face recognition model was already done previously as a university course project using the sklearn.fetch_lfw_dataset dataset, you can check it on github, Oracle. This model will be later on rebuilt with VGGFace2 and improved even further.

Following the Firebase MLKit Custom Models documentation, I converted the model I had to a Tensorflow Lite model and created a face classifier object which can initialize that model and communicate with it.

I needed to give myself the option to switch the model easily later on. So, I created the models as a configuration class so the face classifier object can know the input shape, output shape, labels, and model path (whether local or remote). For now, the face classifier only supports local models.

Initializing the face classifier was simple, I just get its instance based on the configuration I want to use.

var faceClassifier: FaceClassifier = FaceClassifier.getInstance(context, OracleFaceClassifierConfig)

After the face classifier was initialized, I tried passing every frame's detected faces onto the face classifier, on a separate thread. This resulted in a lot of lag, which made the face classifier not usable.

In order to solve that issue, I decided to approach this differently. I ended up running the face classifier only when a new face enters the camera's field of view. The highlight would be drawn as soon as the face is detected. However, the classification would run on a separate thread as soon as the face is detected.

Accordingly, I had to update the highlightDetectedFaces lambda function by keeping track of the trackingId given from the firebase face detection model and running the face classification only on newly detected faces or trackingIds.

private val highlightedFacesHashMap = HashMap<Int, Face>()
private val highlightDetectedFaces: onDetectLambdaType = { faces, frame ->
    faces.forEach {
        if (highlightedFacesHashMap.containsKey(it.trackingId)) {
            highlightedFacesHashMap[it.trackingId]?.updateFace(it, frame)
        } else {
            val face = Face(it, frame)
            highlightedFacesHashMap.put(it.trackingId, face)
            viewModelScope.launch {
                highlightedFacesHashMap[it.trackingId]?.apply { face.classifyFace(faceClassifier) }
            }
        }
    }

    val highlightedFacesList = ArrayList<FaceHighlight>()
    highlightedFacesHashMap.values.forEach {
        highlightedFacesList.add(LabeledRectangularFaceHighlight(it))
    }

    highlightedFacesLiveData.postValue(highlightedFacesList)
}

Click here to check the Face Classifier code

Labeling Highlighted Faces

I had just ran the face classification the way I wished. The result was coming up slightly delayed at first, but then was smooth while the user continued to move inside the camera's field of view. I just had to draw the label onto the screen for the user to see.

I already had a highlighter set, which can transform the highlights from small resolution frames to the resolution the view was using. I already had a rectangular highlight drawing around the person's face. And I was already getting the response from the model!

So I just created a highlight that inherits from my rectangular face highlight object. However, this new highlight checks if the face received by the model has a label or not. If the face does have a label, the label is drawn, and the highlights were being drawn every frame.

So, I created a new face object, instead of using the one provided by firebase. Simply, that face has a coroutine which is responsible for classifying the face. Once the result of that classification is out for that face, it is stored in that object. If the face is already in the camera's field of view, the face object doesn't change. So, I just wait for the classification to be done, and when it is, the face highlights drawn every frame would recognize that the face object being used has a label. Thus, it would draw the label under the face.

The face object's classification was shown in the previous code segment. But here it is again...

highlightedFacesHashMap[it.trackingId]?.apply { face.classifyFace(faceClassifier) }

Click here to check the Face object

It is important to note that the code shown in this post is segmented from a fragment, or view, and a viewmodel.

If you would like to fork or contribute, feel free to check out the repository.

nizarmah / trinity

Real-Time Face Recognition Android App

"Hacking" My Way to Automatic File Injection in Chrome Extensions

Nizar — Mon, 13 Apr 2020 02:41:39 +0000

A couple of days ago, it got to my attention that most websites where I read my articles have bad printable pages. So, I decided to make a chrome extension that "prettifies" the print preview for some popular websites that I print.

The idea was to write a certain set of rules and/or conditions, which once satisfied tell the extension which CSS file improves the print media for that page.

Among those websites were multiple Medium based websites such as TowardsDataScience, Medium, etc.. I had to find a solution that wasn't only url or host specific; otherwise, I would end up having to enter every Medium based website's url or host.

Thus, the solution was to check if a certain element existed in the page using a CSS selector, which meant that I had to be able to get the page's HTML source first... Moreover, the CSS print media file needed to be later on injected to the page automatically.

However, injecting the CSS file programmatically is done through chrome.tabs.insertCSS. The function requires the activeTab permission.

According to the chrome developer api, user gestures (through clicking a certain action or item, or using a keyboard shortcut command) are necessary to enable activeTab.

Yet again, the file needs to be injected automatically.

This post will be explaining how I managed to inject CSS files automatically without using activeTab permission or chrome.tabs.insertCSS

Here are the approaches I took, in order:

The Basic

The basic approach is the activeTab permission approach. Unfortunately, there is another problem to it, other than injecting the CSS file.

Getting the page's HTML source is not possible because the chrome developer api does not have any method to get a certain tab's HTML document. Consequently, I had to inject JS to the tab to query the selector and check if the element exists.

This prevented me from being able to check if a CSS selector matches an element in the page, or even inject the CSS print media file, unless I interact with the action to enable activeTab permission on that tab.

So clearly, I needed a different solution.

The Fantasy

Luckily, the fantasy unveiled itself to me while reading their developer guide. The thing that caught my eye was chrome.declarativeContent api. It had everything I could ever dream of...

PageStateMatcher that supports CSS matching and pageUrl matching.
RequestContentScript that supports injecting CSS and JS files after the rules and/or conditions were satisfied.

Please note that this api requires the use of the declarativeContent permission.

So this approach would work in the following way

How It Works

Chrome checks for the rules defined in the extension
For every rule, if one of the conditions or PageStateMatcher is satisfied, then Chrome executes the actions specified in the rule.

So, here's the rule I would be using for Medium based websites...

{
  conditions: [
    new chrome.declarativeContent.PageStateMatcher({
      css: [
        "meta[property='og:site_name'][content='Medium']"
      ]
    })
  ],
  actions: [
    new chrome.declarativeContent.RequestContentScript({
      css: [
        "css/medium.com.css"
      ]
    })
  ]
}

Check the whole code on GitHub

Oh, yes would be, because according to the api that action is not supported on stable builds of Chrome.

Since Chrome 38.

Declarative event action that injects a content script.

WARNING: This action is still experimental and is not supported on stable builds of Chrome.

I tried so hard and got so far, but in the end it didn't even matter

The "Hack" Fantasy

The fantasy approach was just too good to go unnoticed and ignored. It was the solution I needed, an automatic CSS file injection. Hence, I needed to implement it myself in a hacky way. To implement that hacky approach, I used two different apis.

Although we are using those apis, it is important to note that no permissions are needed in manifest.json

Additionally, the rules and/or conditions are defined in a similar way to chrome.declarativeContent.

new Rule({
  conditions: [
    new Condition({
      css: [
        "meta[property='og:site_name'][content='Medium']"
      ]
    })
  ],
  cssFiles: [
    "medium.com.css"
  ]
})

Check the whole code on GitHub

So here's how the hacky implementation worked.

Thought Process

injector.js that is loaded to all pages (<all_urls>).
injector.js sends to the extension
- page window.location
- page document object
Extension's background.js receives the message from the page
Extension's validator.js checks if any rules and/or conditions satisfies the page depending on:
- pageUrl matching
- CSS matching by selector
If a rule satisfies a page, the extension's background.js sends back the path of all the cssFiles associated with that Rule.
injector.js receives the response from the extension's background.js and adds the CSS file paths to the page.

Please note that there are multiple manifest.json attributes that need to be added in order to make all that possible. However, for the sake of keeping this short, the code is commented in detail on GitHub.

Check the whole implementation on GitHub

Special thanks to slice for his review and constructive comments.

Auto Pi Finder or Any Device Really

Nizar — Sun, 07 May 2017 13:31:01 +0000

The aim of this is to demonstrate how to automatically find a Pi on a network using an Android application.

To understand what is needed, we should discuss ARP tables and a fast segment of ip addresses, because why not.

What's an ARP Table ?

Well, ARP stands for Address Resolution Protocol. It links network addresses to physical addresses, in other words, links every ip Address to a mac Address.

That happens when two devices interact on a network, during that, the mac address of each device is shared with the other under a specific ip address and linking it accordingly.

But of course, storing all those interactions can clog up a device's memory; therefore, the ARP table is cleared from time to time.
But I still didn't explain what an ARP table; it is just a file containing each ip address and the mac address accompanying it.

ARP table get cleared as we said, but this differs between devices and how much they can handle. Android phones being, well, android phones, the table is cleared really frequently ( gonna approximate 5 mins ). And not having nmap doesn't help in listing the devices on the same network.

Moreover, who wouldn't like to check what devices are connected onto one's internet on one's phone.
Well, I don't know about you, but it was crucial to start the project I'm working on.

Fast Introduction to IP Addresses

Well, there are multiple classes of ip addresses that have multiple numbers of hosts. Let's say ip addresses are of the format a.b.c.d. Well, a specifies the class.

For a ranging between [1, 126], the hosts are about 6 million. (class a)
Ignore for when a = 127, it is the local network address.
For a ranging between [128, 191], the hosts are about 300 thousand. (class b)
For a ranging between [192, 223], the hosts are actually 253. (class c)

Now the latter is called class c. There are 2 others, but they aren't used for private ip addresses.

Now, why are the hosts like that ? Well, b, c, and d vary between being constant and alternating for each.

For class a, b, c, and d are varying. They vary between 0 and 255; however, there are some exceptions for d.
For class b, c and d are varying.
For class c, d is only varying.

So let's start!

Note that this only works for private ips networks of class c ( 192 - 223 : first part of the ip address )

But what's the fastest form of interaction between two devices and the easiest, well, pinging is!
Setting out the process, it would go from checking online hosts, to pinging them, then collecting the ARP table.

Checking online hosts

To check for online hosts, I worked on pinging all the hosts available on a network.
This is rather time consuming, but I couldn't find any alternative to this. Pinging the broadcasting ip of a network isn't faster too. Therefore, I had to limit it to a class C private ip address network.

You can do that using Java, ping all the ip addresses from 1 to 254.
I instead chose to do all the stuff using Android Shell.

We need to check the available hosts and then reping them, the reason is explain in the next step. To do that, we need to save which ones gave us a response.
That was done using the following terminal command.

((ping -c 1 192.168.1.etc) > /dev/null) && (echo "up") || (echo "down")

But wait on me, Android Shell has no bash automatically, so this command won't work. Thus, you have to include the sh tag with it.
Now to make it more efficient, I went ahead and made it almost Async. That way, all the devices that will give me a response give it at the same time.

Due to async, my counter bugged when two responses returned at the exact exact same time. To avoid that, I made a counter that deals with even and odd numbers just so that consecutive responses are never likely to reduce the counter at the same exact time and thus reducing it only once. ( By calling the counter at the same exact time I'm accessing the same value the variable had twice, and thus not reducing it twice, but only once ).

/*
 Setting a Counter to keep track
 Of the stuff that have finished
 In order to prevent Async Calling for
 Counter, had to delay it without actually
 Delaying it, so divided the Counting
*/
class Counter {
    int i = 0, j = 0;
    public Counter(int m) {
        if (m % 2 > 0) {
            this.i = (int) Math.floor((double) m / 2) + 1;
            this.j = (int) Math.floor((double) m / 2);
        } else {
            this.i = (int) Math.floor((double) m / 2) + 1;
            this.j = (int) Math.floor((double) m / 2);
        }
    }
    public void resize(int i) {
        this.i = i;
    }
}

I kept having a bug with one host not returning at all, knowing that 255 would not return in time, I looped from 1 to 255 and proceeded to the next function at 254 responses.

// This is a counter to keep track of what is done pinging
final Counter pingerCounter;
/*
 Asyncing ( the easy way ) Pinging each IP Address in order to
 Collect active ones with their Mac Address in ARP Cache Tables
 When done pinging, ARP runs to get the IP Address
 */
final Thread pinger;
pingerCounter = new Counter(254);
class Pinger implements Runnable {
    int y = 0, tempY = 0;

    Pinger (int y) {
        this.y = y;
    }

    public void run() {
        StringBuffer output = new StringBuffer();
        Process ping;
        try {
            /*
             Commands there cause ADB Shell on Android
             Doesn't support god damn inline operands
             So had to do it with Bash
             */
            String[] command = { "sh", "-c", "((ping -c 1 " + ipString + this.y + ") > /dev/null) && (echo 'up') || (echo 'down')" };
            ping = Runtime.getRuntime().exec(command);

            /*
             Setting TempY to store the valid Y
             Instead of storing the one after it
             */
            this.tempY = this.y;

            /*
             Here we're making sure that we end
             Up running all pings almost async
             */
            this.y -= 1;
            if (this.y > 0) new Thread(new Pinger(this.y)).start();

            ping.waitFor();

            // Log.i("PiFinder", "Checked host on " + ipString + this.tempY);
            // Log.i("PiFinder", (pingerCounter.i - 1) + " hosts to be check");

            // Grabbing output to know whether the address is up
            // So that we can easily read it into ARP Tables
            InputStream inStream = ping.getInputStream();
            // Needed to observe errors, thus this is here
            // InputStream errorStream = ping.getErrorStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inStream));
            String line = "";
            StringBuilder response = new StringBuilder();

            while ((line = bufferedReader.readLine()) != null) {
                response.append(line);

                if (line.equals("up")) {
                    Log.i("PiFinder", "Available host on " + ipString + this.tempY);
                    pingables.add(ipString + this.tempY);
                }
            }

            /*
             Here we're checking for how many pings
             Were completed, so that we proceed
             In order to prevent Async Calling for
             Counter, had to delay it without actually
             Delaying it, so divided the Counting
             */
            if ((this.tempY % 2) == 1)
                pingerCounter.i--;
            else pingerCounter.j--;
            if ((pingerCounter.i + pingerCounter.j) == 0)
                new Thread(new Pingable(pingables.size())).start();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
pinger = new Thread(new Pinger(255));
pinger.start();

Pinging Online Hosts

When I said I was gonna talk about ARP tables, I didn't mention everything.
There's a surprise I had to mention here, which is, that ARP tables have a specific number of lines sadly.
So pinging all the hosts would get some forgotten and buried under their brothers. We don't want that! So, we have to reping them.

Now note that, I assumed that there won't be more than 90 online hosts on a network of a person using my application, so I didn't go for measures to deal with more than 93 hosts.
Why 93 ? Because, after collecting the length of ARP tables of the android devices in my vicinity, I ended up with 93 on all of them. So, I assumed that ARP tables are gonna have a maximum of 93 devices.

So repinging them is similar to the process before using the -c1. But no need for the sh, even though I included it.

// List of Pingable Addresses or Online Hosts
final ArrayList<String> pingables = new ArrayList<String>();

// This is a counter to keep track of what is done pinging
final Counter pingableCounter = new Counter(0);
/*
 Repinging the Available Hosts to refresh
 the ARP Table Cache to make sure it's a Pi
 */
class Pingable implements Runnable {
    int i = 0, tempI = 0;

    Pingable(int m) {
        if (m == pingables.size()) {
            this.i = m - 1;
            pingableCounter.resize(m - 1);
        } else this.i = m;
    }

    public void run() {
        try {
            if (pingables.size() == 0)
                arp.start();
            else {
                String[] command = { "sh", "-c", "ping -c 1 " + pingables.get(this.i) };
                Process ping = Runtime.getRuntime().exec(command);

                // Setting TempY to store the valid I
                // Instead of storing the one after it
                this.tempI = this.i;

                // Here we're making sure that we end
                // Up running all pings almost async
                this.i -= 1;
                if (this.i > -1) new Thread(new Pingable(this.i)).start();

                Log.i("PiFinder", "Pinged host on " + pingables.get(this.tempI));

                ping.waitFor();

                /*
                 Here we're checking for how many pings
                 Were completed, so that we proceed
                 In order to prevent Async Calling for
                 Counter, had to delay it without actually
                 Delaying it, so divided the Counting
                 */
                if ((this.tempI % 2) == 0)
                    pingableCounter.i--;
                else pingableCounter.j--;
                if ((pingableCounter.i + pingableCounter.j) == 0)
                    arp.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Collecting ARP table

There's a specific file in the Android root folders where the table is cached.
The file is in /proc/net/arp.

Well, in my case, I wanted to find a specific device in that ARP table. I was searching for a Raspberry Pi. Oh well, damn it, I guess now you know I'm working on something for the Raspberry Pi.

Anyway, I added some operands to use grep and search for the specific mac address a raspberry pi starts with, the famous b8:27:eb.

Thus what I did was, the following.

/*
 After getting the online hosts use ARP to get mac addresses
 Knowing that Pis start with B8:27:EB, group them accordingly
 This runs after the bottom thread pinger runs
 */
class ARP implements Runnable {
    public void run() {

        try {
            /*
             Commands there cause ADB Shell on Android
             Doesn't support god damn inline operands
             So had to do it with Bash
             */
            String[] command = { "sh", "-c", "arp -vn | grep -i ' b8:27:eb'" };
            Process arpa = Runtime.getRuntime().exec(command);

            arpa.waitFor();

            Log.i("PiFinder", "Collected ARP Table");

            // Read out available Pi addresses
            InputStream inStream = arpa.getInputStream();
            // Needed to observe errors, thus this is here
            // InputStream errorStream = ping.getErrorStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inStream));
            String line = "";
            StringBuilder response = new StringBuilder();

            ArrayList<ArrayList<String>> pis = new ArrayList<ArrayList<String>>();

            /*
             Since each line is an address, then
             Execute on each line read by buffer
             Then split to get the necessary fields
             */
            while ((line = bufferedReader.readLine()) != null) {
                response.append(line);

                String[] tempLine = line.split("\\s+");

                ArrayList<String> pi = new ArrayList<String>();
                pi.add(tempLine[1].substring(1, tempLine[1].length() - 1));
                pi.add(tempLine[3]);

                pis.add(pi);
            }
                if (pis.size() == 0) {
                    Log.i("PiFinder", "No Pis found");
                    // Use a callback function here (negative)
                } else { // Use a callback function here (positive) }
        } catch (IOException e){
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
final Thread arp = new Thread(new ARP());

Now if you don't wish to collect any specific something, you can read the file with Java. You can also go for removing the part after arp -vn and then change the collection of each line to be specific device with the mac and ip address.

But what about the ip field we're missing ?!

I'm sorry about this, I forgot about it...
Here it is.

WifiManager manager = (WifiManager) getApplicationContext().getSystemService(getApplicationContext().WIFI_SERVICE);
WifiInfo info = manager.getConnectionInfo();

long infoIp = info.getIpAddress();

String address = (infoIp & 0xFF) +
        "." + ((infoIp >> 8) & 0xFF) +
        "." + ((infoIp >> 16) & 0xFF) +
        "." + ((infoIp >> 24) & 0xFF);

String[] ip = address.split("\\.");
ipAddress = new String[]{ ip[0], ip[1], ip[2] };

for (int i = 0; i < ipAddress.length; i++)
    ipString = ipString + ipAddress[i] + ".";

And declare those globally...

String[] ipAddress;
String ipString = "";

Well, this was my journey. I hope my tutorial was clear and not abstract.
I've tested the code and pretty sure it works.
For them all in one place, use this.

import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class MainActivity extends AppCompatActivity {

    String[] ipAddress;
    String ipString = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_process);

        findMePi();
    }

    private void findMePi() {
        WifiManager manager = (WifiManager) getApplicationContext().getSystemService(getApplicationContext().WIFI_SERVICE);
        WifiInfo info = manager.getConnectionInfo();

        long infoIp = info.getIpAddress();

        String address = (infoIp & 0xFF) +
                "." + ((infoIp >> 8) & 0xFF) +
                "." + ((infoIp >> 16) & 0xFF) +
                "." + ((infoIp >> 24) & 0xFF);

        String[] ip = address.split("\\.");
        ipAddress = new String[]{ ip[0], ip[1], ip[2] };

        for (int i = 0; i < ipAddress.length; i++)
            ipString = ipString + ipAddress[i] + ".";

        class Counter {
            int i = 0, j = 0;
            public Counter(int m) {
                if (m % 2 > 0) {
                    this.i = (int) Math.floor((double) m / 2) + 1;
                    this.j = (int) Math.floor((double) m / 2);
                } else {
                    this.i = (int) Math.floor((double) m / 2) + 1;
                    this.j = (int) Math.floor((double) m / 2);
                }
            }
            public void resize(int i) {
                this.i = i;
            }
        }

        class ARP implements Runnable {
            public void run() {

                try {
                    String[] command = { "sh", "-c", "arp -vn | grep -i ' b8:27:eb'" };
                    Process arpa = Runtime.getRuntime().exec(command);

                    arpa.waitFor();

                    Log.i("PiFinder", "Collected ARP Table");

                    // Read out available Pi addresses
                    InputStream inStream = arpa.getInputStream();
                    // Needed to observe errors, thus this is here
                    // InputStream errorStream = ping.getErrorStream();
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inStream));
                    String line = "";
                    StringBuilder response = new StringBuilder();

                    ArrayList<ArrayList<String>> pis = new ArrayList<ArrayList<String>>();

                    while ((line = bufferedReader.readLine()) != null) {
                        response.append(line);

                        String[] tempLine = line.split("\\s+");

                        ArrayList<String> pi = new ArrayList<String>();
                        pi.add(tempLine[1].substring(1, tempLine[1].length() - 1));
                        pi.add(tempLine[3]);

                        pis.add(pi);
                    }
                    if (pis.size() == 0) {
                        Log.i("PiFinder", "No Pis found");
                        // Use Callback Here ( Negative )
                    } else {
                        // Use Callback Here ( Positive )
                    }
                } catch (IOException e){
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        final Thread arp = new Thread(new ARP());

        final ArrayList<String> pingables = new ArrayList<String>();

        final Counter pingableCounter = new Counter(0);

        class Pingable implements Runnable {
            int i = 0, tempI = 0;

            Pingable(int m) {
                if (m == pingables.size()) {
                    this.i = m - 1;
                    pingableCounter.resize(m - 1);
                } else this.i = m;
            }

            public void run() {
                try {
                    if (pingables.size() == 0)
                        arp.start();
                    else {
                        String[] command = { "sh", "-c", "ping -c 1 " + pingables.get(this.i) };
                        Process ping = Runtime.getRuntime().exec(command);

                        this.tempI = this.i;

                        this.i -= 1;
                        if (this.i > -1) new Thread(new Pingable(this.i)).start();

                        Log.i("PiFinder", "Pinged host on " + pingables.get(this.tempI));

                        ping.waitFor();

                        if ((this.tempI % 2) == 0)
                            pingableCounter.i--;
                        else pingableCounter.j--;
                        if ((pingableCounter.i + pingableCounter.j) == 0)
                            arp.start();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        final Counter pingerCounter;

        final Thread pinger;
        pingerCounter = new Counter(254);
        class Pinger implements Runnable {
            int y = 0, tempY = 0;

            Pinger (int y) {
                this.y = y;
            }

            public void run() {
                StringBuffer output = new StringBuffer();
                Process ping;
                try {
                    String[] command = { "sh", "-c", "((ping -c 1 " + ipString + this.y + ") > /dev/null) && (echo 'up') || (echo 'down')" };
                    ping = Runtime.getRuntime().exec(command);

                    this.tempY = this.y;

                    this.y -= 1;
                    if (this.y > 0) new Thread(new Pinger(this.y)).start();

                    ping.waitFor();
                    InputStream inStream = ping.getInputStream();
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inStream));
                    String line = "";
                    StringBuilder response = new StringBuilder();

                    while ((line = bufferedReader.readLine()) != null) {
                        response.append(line);

                        if (line.toString().equals("up")) {
                            Log.i("PiFinder", "Available host on " + ipString + this.tempY);
                            pingables.add(ipString + this.tempY);
                        }
                    }

                    if ((this.tempY % 2) == 1)
                        pingerCounter.i--;
                    else pingerCounter.j--;
                    if ((pingerCounter.i + pingerCounter.j) == 0)
                        new Thread(new Pingable(pingables.size())).start();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        pinger = new Thread(new Pinger(255));
        pinger.start();
    }
}

I hope my code isn't that bad.

Hi, I'm Nizar

Nizar — Sat, 25 Feb 2017 20:34:40 +0000

I have been coding since I was 12.

You can find me on Twitter as @nizarmah_
You can also check out my website

I eat a lot, I talk a lot, and I work a lot.

I like to work on my own libraries and apis to use.

I also build websites and apps for the fun of it including designing them.

Getting into AI without AI knowledge.
Tough road but slow and steady.

Have a good day!