DEV Community: Anes Abismail

Autostart scrcpy on device connection.

Anes Abismail — Sun, 16 Aug 2020 13:03:40 +0000

OnCreateBlog:

When it comes to programming and setting up my workflow, I always try to find a solution to automate basic tasks and focus on what matters, also it gives me a sense of magic. One of the things that were bugging me lately is manually launching scrcpy every time I plug my phone to test my apps, in this blog post I will show you how I automated that process, note that this setup is for macOS.

There's a command-line tool allows to execute a command whenever a new device is connected to adb, but that didn't work for me, you can check out here.

My thought process:

As for each problem a plan is required, my initial thought was to set up some kind of Cron job that runs every second and check for new USB devices, but this is brute force and it's not efficient to run a job every second, even if we set the job to run every minute that would not be a good idea either if I plug my phone I might have to wait one minute for the job to launch scrcpy.

Okay what other options we have, let's run a job and write an infinite loop that checks for new USB devices. this solves the instant problem but it's not efficient.

I had one last thought and it's to set up some sort of a listener, callback on an event that gets triggered every time a USB device is plugged in. After doing some research I found out that it is possible thanks to launchd

What is launchd:

launchd is a service management tool used by macOS it was created by Apple, it's similar in some ways to systemd on Linux.

Another definition according to Apple:

The launchd process is used by macOS to manage daemons and agents, and you can use it to run your shell scripts.

But wait what are daemons and agents?

A Daemon is a computer program that runs on background without any direct control and interaction with the user, they are usually launched when the system boots. An example of a daemon is a backup schedule when you enable Time Machine.

An Agent is very familiar to a Daemon but it runs within the user session, which means that they are launched when the user logs in.

Based on the Apple documentation we can find the various daemons and agents managed by launchd by looking inside the following folders:

Tables	Are
/System/Library/LaunchDaemons	Apple-supplied system daemons
/System/Library/LaunchAgents	Apple-supplied agents that apply to all users on a per-user basis
/Library/LaunchDaemons	Third-party system daemons
/Library/LaunchAgents	Third-party agents that apply to all users on a per-user basis
~/Library/LaunchAgents	Third-party agents that apply only to the logged-in user

Creating a LaunchDaemon or LaunchAgent:

Based on those definitions, we will proceed with creating an Agent because it's more suitable to solve our problem, we don't want to launch scrcpy if the user is not logged in.

To create a new LaunchAgent we need to add our config file to the respective directory, I will be adding my config file to ~/Library/LaunchAgents.

Those files require a specific format: plist (property list) it holds the specific information of the task. Below are the required keys to include in the file:

Label: Unique task identifier.
Program or ProgramArguments: String Path to executable.
RunAtLoad: (True or False) Run job immediately when plist file is loaded.
LaunchOnlyOnce: Run job once, and never try again.
LaunchEvents: there is more than one trigger or launch event but the one that we are going to use is: I/O kit notifications - USB device.

Note that the difference between Program and ProgramArguments is that when using ProgramArguments you can specify the path to executable and an array of arguments arg[0],arg[1],....

So hers is my config file, which I name com.oneplus5t.scrcpy.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC -//Apple Computer//DTD PLIST 1.0//EN <http://www.apple.com/DTDs/PropertyList-1.0.dtd> >
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.oneplus5t.scrcpy</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/launch_iterm.bash</string>
        <string>scrcpy</string>
    </array>
    <key>LaunchEvents</key>
    <dict>
            <key>com.apple.iokit.matching</key>
            <dict>
                    <key>com.apple.device-attach</key>
                    <dict>
                            <key>idProduct</key>
                            <integer>1234</integer>
                            <key>idVendor</key>
                            <integer>1444</integer>
                            <key>IOProviderClass</key>
                            <string>IOUSBDevice</string>
                            <key>IOMatchLaunchStream</key>
                            <true/>
                    </dict>
            </dict>
    </dict>
</dict>
</plist>

To find your phone's idProduct and idVendor run this command:

ioreg -p IOUSB -l

Explaining what the above command does:

ioreg displays the I/O Kit registry.
-p option is to traverse IOUSB registry
-l to show more information about the displayed objects.

You may notice that we are running a script launch_iterm.bash, thanks to this script we can launch iTerm2 or any other terminal application, it uses AppleScript which is a scripting language created by (wait for it) → Apple. check out this.

#!/bin/bash
#
# Open new iTerm window from the command line using v3 syntax for `AppleScript` as needed in iTerm2 Version 3+
# This script blocks until the cmd is executed in the new iTerm2 window.  It then leaves the window open.
#
# See also <https://www.iterm2.com/documentation-scripting.html>
#
# Usage:
#     iterm                   Opens the current directory in a new iTerm window
#     iterm [PATH]            Open PATH in a new iTerm window
#     iterm [CMD]             Open a new iTerm window and execute CMD
#     iterm [PATH] [CMD] ...  You can probably guess
#
# Example:
#     iterm ~/Code/HelloWorld ./setup.sh
#
# References:
#     iTerm AppleScript Examples:
#     <https://gitlab.com/gnachman/iterm2/wikis/Applescript>
#
# Credit:
#     Forked from <https://gist.github.com/vyder/96891b93f515cb4ac559e9132e1c9086>
#     Inspired by tab.bash by @bobthecow
#     link: <https://gist.github.com/bobthecow/757788>

# OSX only
[ `uname -s` != "Darwin" ] && echo 'OS X Only' &&return

function iterm () {
    local cmd=""
    local wd="$PWD"
    local args="$@"

    if [ -d "$1" ]; then
        wd=$(cd "$1"; pwd)
        args="${@:2}"
    fi

    if [ -n "$args" ]; then
        # echo $args
        cmd="$args"
    fi

osascript <<EOF
    tell application "iTerm"
        activate
        set new_window to (create window with default profile)
        set cSession to current session of new_window
        tell new_window
            tell cSession
                delay 1
                write text "$cmd"
            end tell
        end tell
    end tell
EOF
}
iterm $@

One thing left to do is to load the Agent and plug your phone, to load the Agent we use the launch tool:

launchctl load com.oneplus5t.scrcpy.plist

After loading the configuration file, you will notice that it's repeatedly executed each 10s, as I understand this is caused because the scrcpy doesn't return a result and this causes the executable being called repeatedly (if I am mistaken please correct me). Thanks to this repo, our problem can be fixed:

Unload the configuration file

launchctl unload com.oneplus5t.scrcpy.plist

Clone the repo:

git clone <https://github.com/himbeles/mac-device-connect-daemon>

Build the event stream handler:

gcc -framework Foundation -o xpc_set_event_stream_handler xpc_set_event_stream_handler.m

Copy the result to /usr/local/bin/

cp xpc_set_event_stream_handler /usr/local/bin/

Update the LaunchAgent configuration file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC -//Apple Computer//DTD PLIST 1.0//EN <http://www.apple.com/DTDs/PropertyList-1.0.dtd> >
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.oneplus5t.scrcpy</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/xpc_set_event_stream_handler</string> <!-- Add this line -->
        <string>/usr/local/bin/launch_iterm.bash</string>
        <string>scrcpy</string>
    </array>
    <key>LaunchEvents</key>
    <dict>
            <key>com.apple.iokit.matching</key>
            <dict>
                    <key>com.apple.device-attach</key>
                    <dict>
                            <key>idProduct</key>
                            <integer>1234</integer>
                            <key>idVendor</key>
                            <integer>1444</integer>
                            <key>IOProviderClass</key>
                            <string>IOUSBDevice</string>
                            <key>IOMatchLaunchStream</key>
                            <true/>
                    </dict>
            </dict>
    </dict>
</dict>
</plist>

OnDestroyBlog:

This was a fun experiment, it opens a wide variety of automation ideas and improving my workflow, Thank you for reading I hope you learned something new and you had fun as I did, Feel free to reach out on Twitter if you have any questions.

Resources:

Launchd - At Your Service!

macOS: Know the difference between launch agents and daemons, and use them to automate processes

Daemons and Agents

Script management with launchd in Terminal on Mac

Mac device connect daemon

Bash function for opening up iterm form current directory

What I learned from 30 days of solving LeetCode problems.

Anes Abismail — Tue, 07 Jul 2020 11:32:13 +0000

Photo by Kevin Ku on Unsplash

Last month after I finished my Product Hunt client Android app I decided to try something new and challenge myself, so I ended up choosing to do LeetCode problems, my goal was to do one problem every day no matter what, I choose to do them in the morning because I feel more energetic and it's a good way to start your day with a challenge. In this blog post, I will be sharing with you my mistakes and what I learned from this experience.

Consistency:

My goal was to do one problem every day and develop a habit, at the beginning it didn't feel natural as I was trying something new and uncomfortable, but I can say that after two weeks it becomes natural every morning I pick up my laptop and notebook and start solving a problem without even noticing, it felt like a morning routine. I still missed some days but I made sure that I don't miss two days in a row.

Coding

As developers, we feel that we need to start coding as fast as we can and beet our last record of typing, but if you started solving a problem with coding you will be stuck and you feel overwhelmed because you didn't understand what you are trying to solve yet. Pick up an iPad or a pen and a piper (if you are poor like me) and start writing your inputs, outputs, try to visualize the problem, write down your thought process and then try to solve it in a simple intuitive way, after that you can start coding. Here is the step that I usually take to solve a problem:

Write down the input and the expected output.
Understand the problem by asking yourself different questions about it.
Try to identify Data Structures that might help you solve the problem.
Write down the steps required to solve the problem.
Write a brute force solution then try to improve it using different Data Structures and Algorithms.
Code.

Share and learn

After I solve a problem I always make sure to check other solutions and explanations, this helps me learn different ways of thinking and problem-solving techniques, also I learned to justify my choices eg: why did I use a LinkedList instead of an Array, etc...

I didn't mind checking solutions that are written in a different language than the one I use (Kotlin, Java) as that helps me learn more about other languages and different syntax.

One of the main resources to check other solutions are the Discuss tab on LeetCode, also GeeksForGeeks is a great resource, and sometimes I check some Youtube videos.

Documentation

I made sure that I track and document what I learned every day, even if it's simple, this helps me remember and reflect on my past self. and stay motivated to do continue learning and solving problems.

Uncomfortable

If you know me you know that I thrive when I see an error or a problem to solve, my friends were always blown away by this. I used to hunt errors and challenges. but after doing Android for a while I got a little comfortable (don't get me wrong there's always something new to learn in Android from Functional programming, Concurrency, new Kotlin features, etc..) But I didn't have the opportunity to challenge myself very ofter. Solving LeetCode problems brought back that feeling of excitement and eagerness to solve problems, it didn't matter if I fail or if it took me 2 hours to solve I just made sure that I learn something new.

Conclusion

My goal of this experiment was not to prepare for coding interviews or to apply for FANG companies, My goal was to challenge myself and get out of my comfort zone, and maybe get into Competitive Programming (who knows). I will still do one problem every day and commit to my repository because it's a habit now and it's been one of the best experiences, as I had the opportunity to fail and thus learn more. I hope this will give you the inspiration to take action and challenge yourself more and just have fun.

Thank you for reading, I hope you learned something new from this blog post. feel free to reach out on Twitter if you have any questions. and check out my LeetCode repository here.

Getting started with Zsh

Anes Abismail — Thu, 02 Jul 2020 12:01:30 +0000

A Shell is a user interface to access the operating system's services, it receives input from the user and executes programs based on that input. To put in simple words a shell is a program that takes input commands from the keyboard and sends them to the operating system to execute.

On most operating systems a program called Bash (Bourne Again Shell) acts as the default shell. But there are other shell programs that can be installed in your system that offer more features such as fish and Zsh. In this blog post, I will talk about how to setup Zsh.

What is Zsh:

Zsh, also called Z shell, is a Unix shell that can be used as an alternative to Bash and Fish. It's based on Bourne Shell, allowing it to have the same features as Bash because Bash is also built on top of Bourne Shell, moreover, it has plenty of features and support for plugins and themes.

Zsh features:

Zsh has many features, here is some:

Cd (Change directory): just type the name of the directory to change your current directory. eg: instead of cd Downloads, just type Downloads
Spelling correction and completion: don't worry if you make a mistake typing the name of a directory, Zsh has spelling correction and completion.
Plugins and themes: Zsh has a rich collection of plugins and themes that you can install to enhance your productivity and make your terminal look cool.

Installing Zsh:

macOS:

Starting from macOS Catalina, Zsh is installed as the default shell, so you can skip this part. If you are not running macOS Catalina installing Zsh is as simple as running this command Assuming you have Homebrew installed:

brew install zsh

To set Zsh as your default shell, execute the following command

chsh -s /usr/local/bin/zsh

for other OS you can check this link here.

Installing Oh My Zsh:

Zsh alone doesn't do much it, it just like Bash. To start installing plugins and themes you need a tool to manage Zsh configuration and my favourite tool is Oh My Zsh. Installing Oh My Zsh can be done using either curl or wget:

Using curl:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Using wget:

sh -c "$(wget -O- https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Install plugins and themes:

As stated before Zsh comes with a rich collection of plugins and themes. let's take a look at how we can enable plugins and themes.

Plugins:

List of Oh My Zsh plugins can be found here. If you spot a plugin and you'd like to install, you'll need to enable it in the ~/.zshrc , this file is the configuration for Zsh, you will find it in your HOME directory. Open the files with your favourite text editor and enable your favourites plugins by adding a theme to the plugins array:

# Which plugins would you like to load?
# Standard plugins can be found in $ZSH/plugins/
# Custom plugins may be added to $ZSH_CUSTOM/plugins/
# Example format: plugins=(rails git textmate ruby lighthouse)
# Add wisely, as too many plugins slow down shell startup.
plugins=(git colored-man-pages colorize brew osx zsh-syntax-highlighting zsh-autosuggestions)

Note that zsh-autosuggestions & zsh-syntax-highlighting are custom plugins and must be installed manually:

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

Themes:

List of Oh My Zsh themes can be found here. In order to enable a theme, you need to set ZSH_THEME to the name of the theme in your ~/.zshrc. for example:

# Set name of the theme to load --- if set to "random", it will
# load a random theme each time oh-my-zsh is loaded, in which case,
# to know which specific one was loaded, run: echo $RANDOM_THEME
ZSH_THEME="robbyrussell"

My favourite theme is powerlevel10k check it out here.

Conclusion:

Zsh is a powerful tool that can boost your productivity and make you life easier, I hope you enjoyed this small tutorial, if you know other plugins and tricks that improved your productivity with using Zsh feel free to reach out on Twitter, I would like to hear from you.

Dagger Hilt basics

Anes Abismail — Tue, 23 Jun 2020 08:05:10 +0000

Photo by Marc Reichelt on Unsplash
As you may be aware, Dagger Hilt is the new Dependency Injection library introduced by Google, it's the recommended approach for DI on Android, despite beginning it in Alpha in this small talk I will try to explain some basics about Dagger Hilt.
This article assumes that you are familiar with Architecture components and MVVM.

What is Dependency Injection?

Dependency Injection is a technique that allows an object to receive other objects that it depends on, the receiving object is called the client and the provided objects are called service. A Client depends on one Service or more. This helps us follow the SOLID's Single responsibility principle.

Single responsibility principle: means that a class should have only one responsibility and that means it has only one reason to change.

Ok, you might ask how?

Let's take an example:

class Repository {

    private val remoteDataSource = RemoteDataSource()
    private val localDataSource = LocalDataSource()

    fun getUser(id: Int): User {
        var user = localDataSource.getUser(id)
        if (user == null) {
            user = remoteDataSource.getUser(id)
        }
        return user
    }
}

As you see above the Repository class has 3 responsibilities:

Creating RemoteDataSource object.
Creating LocalDataSource object.
Retrieving Data from the data sources.

This has many problems:

The Repository class can change for a variety of reasons.
This makes testing the Repository class much harder, and writing tests is hard enough.

Ok, How we are going to fix this? Simply provide the RemoteDataSource and LocalDataSource in the constructor.

class Repository(
    private val remoteDataSource: RemoteDataSource,
    private val localDataSource: LocalDataSource
) {

    fun getUser(id: Int): User {
        var user = localDataSource.getUser(id)
        if (user == null) {
            user = remoteDataSource.getUser(id)
        }
        return user
    }
}

Now as you can see the Repository class has one responsibility and it's Retrieving Data from the data sources.

But you will ask how we can create an instance of the Repository class?

Let's take a look at our ViewModel

class MainViewModel: ViewModel() {

    private val remoteDataSource = RemoteDataSource()
    private val localDataSource = LocalDataSource()
    private val repository = Repository(remoteDataSource, localDataSource)

    private val _user: MutableLiveData<User> = MutableLiveData()
    val user: LiveData<User> = _user

    fun getUser(id: Int) {
        viewModelScope.launch {
            _user.value = repository.getUser(id)
        }
    }
}

And as you might guess the ViewModel has 4 responsibilities 😲:

Creating RemoteDataSource object.
Creating LocalDataSource object.
Creating Repository object.
Retrieving Data from the repository.

Ok let's fix this

class MainViewModel: ViewModel(private val repository: Repository) {

    private val _user: MutableLiveData<User> = MutableLiveData()
    val user: LiveData<User> = _user

    fun getUser(id: Int) {
        viewModelScope.launch {
            _user.value = repository.getUser(id)
        }
    }
}

Better huh. But wait we don't control the creation of a MainViewModel instance. ViewModel is an Android-specific class like Activity, Fragment and Service, so what is the solution?

Here comes our little friend Hilt that will solve our problems, but this isn't the only solution before Hilt developers use ViewModelFactory, but it introduced a lot of boilerplate code and if you have many ViewModels you will have to do some magic to only use one ViewModelFactory.

Setup

To be able to use Hilt, you need to add some dependencies. Note that at the time of writing this article, the current version is 2.28-alpha. Check out the documentation for the latest version.

build.gradle

dependencies {
        ...
        // Current version is 2.28-alpha
        classpath "com.google.dagger:hilt-android-gradle-plugin:2.28-alpha"
}

app/build.gradle:

...
apply plugin: "kotlin-kapt"
apply plugin: "dagger.hilt.android.plugin"

android {
    ...
}

dependencies {
        ...

        implementation "com.google.dagger:hilt-android:2.28-alpha"
        kapt "com.google.dagger:hilt-android-compiler:2.28-alpha"

        // For injecting ViewModel
        implementation "androidx.hilt:hilt-lifecycle-viewmodel:1.0.0-alpha01"
        // For injecting WorkManager    
        implementation "androidx.hilt:hilt-work:1.0.0-alpha01"

        kapt "androidx.hilt:hilt-compiler:1.0.0-alpha01"
}

How Hilt works

Hilt works by code generating and it uses different annotations to know how to provide the required dependencies at runtime. let's take a look at some of those annotations:

@Inject: is used to define how the Client would be constructed.
@ViewModelInject: is used to define how the ViewModel would be constructed.
@WorkerInject: is used to define how the Worker would be constructed.
@Provides: this is used in a Module class to define how certain dependency is provided (eg: Retrofit, Room database,..)
@Module: is a class that acts as a bridge between the provided dependency using @Provides and the consumer class.

Hilt example:

Ok let's take an example by and improve our previous solutions, for the sake of simplicity I will remove the data source classes:

/*
    As you can see here I used @Inject annotation.
    and as you probably have guessed we need a database instance.
*/
class Repository @Inject constructor(
    private val database: MyDatabase
) {

    fun getUser(id: Int): User {
        var user = database.getUser(id)
        return user
    }
}

Ok, now how we are going to provide a MyDatabase instance? since creating a Room database instance is more than just a constructor we will use the @Provides annotation:

/* 
    As you can see here I used @Module annotation
    Hilt will use this module to call the provideRoomDb function
    And get a MyDatabase instance
    Nb: we used the object keyword to avoid creating an instance of this module
    Will talk about @InstallIn later.
*/
@Module
@InstallIn(ApplicationComponent::class)
object RoomModule {

    @Provides 
    fun provideRoomDb(application: Application): MyDatabase =
        MyDatabase.getInstance(application)
}

Now Hilt nows how to provide MyDatabase instance and use it to create a Repository instance. But did you notice something strange? where will Hilt provide an application instance to create a MyDatabase instance?

Hilt comes with a set of default bindings that can be injected as dependencies, and Application is one of those bindings.

Components:

In the RoomModule above I used @InstallIn(ApplicationComponent::class). what the hell is it?

It tells Hilt where to install the Module meaning where it should be available as a dependency, in this example, we want to be able to use MyDatabase across the Application so we use the ApplicationComponent.

There are multiple components and using them depends on how you want to scope the provided dependency:

ApplicationComponent.
ServiceComponent.
ActivityRetainedComponent.
ActivityComponent.
FragmentComponent.
ViewComponent.
ViewWithFragmentComponent

You can take a look at the documentation and read more about each component.

ViewModel:

Now let's learn something new with MainViewModel. As you can see here I used @ViewModelInject annotation, this will tell Hilt that is a ViewModel and since ViewModels survive configuration changes, Hilt will make sure to return the same instance after configuration changes.

/* 
    As you can see here I used @ViewModelInject annotation
    it will tell Hilt that is a ViewModel class and since 
    ViewModels survive configuration changes, Hilt will make sure to return
    the same instance after configuration changes.
*/
class MainViewModel @ViewModelInject constructor(
        private val repository: Repository
    ): ViewModel() {

    private val remoteDataSource = RemoteDataSource()
    private val localDataSource = LocalDataSource()
    private val repository = Repository(remoteDataSource, localDataSource)

    private val _user: MutableLiveData<User> = MutableLiveData()
    val user: LiveData<User> = _user

    fun getUser(id: Int) {
        viewModelScope.launch {
            _user.value = repository.getUser(id)
        }
    }
}

and Now let's see some magic. In order to connect the dots we need to create an Application class and annotate it with @HiltAndroidApp :

@HiltAndroidApp
class MyApplication : Application() {

  override fun onCreate() {
     // Nb: Hilt injects the dependencies in super.onCreate() 
     // if you override onCreate make sure you call super.onCreate()
     super.onCreate()
  }
}

Entry Points:

Now after we told Hilt how to provide some dependencies, it's time to use those dependencies, for this example I will need Hilt to provide me with the MainViewModel instance, @AndroidEntryPoint will take care of that, which will take care of injecting the required dependencies for our activity.

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    @Inject lateinit var viewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
    // Nb: Hilt injects the dependencies in super.onCreate() 
       // if you override onCreate make sure you call super.onCreate()

        viewModel.doSomething() // will throw a runtime exeption

        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        viewModel.doSomething()
    }

}

And we are done. Hilt is much bigger than just what I coved in this article, but this is the should get you started.

Dependency Injection libraries can be hard to understand, so if you have any question feel free to reach me out on Twitter @anesabml I will happily answer your questions.
Lastly, if this article has helped you learn something new, feel free to share it with others and help them learn as well.

Resources:

Dagger Hilt documentation.