DEV Community: Burhanuddin Rashid

Creating A Habit: Reading Books

Burhanuddin Rashid — Wed, 06 Jan 2021 02:37:11 +0000

For more visibility posting this here. The original article is posted on my website. Let's get started :)

This year 2020, I tweeted about my reading.

// Detect dark theme var iframe = document.getElementById('tweet-1344553122522284033-360'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1344553122522284033&theme=dark" }

Many people reach out and asked me "How did you pull this off? ". Since I like the DRY(Don't Repeat Yourself) principle I thought of putting this into a blog post so I don't have to repeat myself 😂

Let's get started.

How I started reading books

I was one of those kids who loves to read comics. My parents brought me one comic book of Chacha Chaudhary while visiting Udaipur. We don't get such kind of comics in the village. So I was excited.

After that whenever they went outside the village I asked for more comic books. I read Chacha Chaudary, Billoo, Pinki, Nagraj, and Dhruva(For Non-Indian this are all Indian superheroes and character). As I grew up, I started playing more video games and lost my interest in reading comics.

The point is that most people have a reading habit. It can be in form of comics, storybooks, and newspapers. I always had an interest in reading but somewhere I lost it.

Fast-forward 15 years, I was about to complete my two years as an android developer in the software industry. Most of the things I learned from videos and technical blogs. I realized those things are most helpful to get things done. But I wanted to have a deeper understanding of it

One day I saw the book "Zero to One" on my colleague's desk and Borrowed it.

In excitement, I completed half of the book in 4 days. As we know excitement and motivation do not last long. I stopped reading in a few weeks. I picked up again. Read for 2 days and stopped. It went on for 3 months, just to read a 250-page book.

I realized two things.

My Reading was not consistent. I was reading on random days as I feel.
I did not value the book because I got it free from my colleague. I won't lose anything from not reading it.

At the same time, I was struggling to write clean code (I Still do :)). One of my colleague suggested reading "Clean Code" book.

At that time, my monthly salary was not sufficient enough to afford this book. But I brought it anyway thinking this as an investment to grow my skills professionally.

Similar thing happened again. I was not able to read consistently. But this time the gap was less because now I've invested my money in it which forces me to read 10-15 min regardless of my "Mood".

One day I was scrolling through Twitter and saw a tweet by Donn Felker on reading 10 pages daily.
It hit me. I thought "okay, Reading 10 pages daily is not that hard ". I can do that.

// Detect dark theme var iframe = document.getElementById('tweet-1040289491297161217-7'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1040289491297161217&theme=dark" }

So keeping the consistency of reading daily 10 pages regardless of my "Mood". I was able to complete the book in 5 months.

// Detect dark theme var iframe = document.getElementById('tweet-1073983454797316097-694'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1073983454797316097&theme=dark" }

It was the beginning. After that, I read Working Effectively with Legacy Code, Refactoring, The Pragmatic Programmer , and the list goes on.

I found that reading was not that difficult. As a developer, we read a lot of code and documentation. We are used to it. The challenging part is to have discipline and consistency which eventually leads to creating a good habit.

Discipline is doing what you know needs to be done even if you don't want to do it.

Why creating a good habit is important.

Habits are the compound interest of self-improvement.

Many things in life are not in our control except habits.

Habit is not created in day or week. It takes time, consistency, and discipline.

We as a human are not design or born with good habits. We need to learn and develop habits. Like child who is born will do all sort wrong or not good things. The child need to understand and develop new habits and as parents it's our responsibility to let them teach them properly.
James Clear, Atomic Habits

Reading 10 pages per day is nothing but doing 1% better every day.

Improving by 1 percent isn’t particularly notable—sometimes it isn’t even noticeable — but it can be far more meaningful, especially in the long run. The difference, a tiny improvement can make over time, is astounding.
James Clear, Atomic Habits

Habit is not a one time job. It's a never-ending process. In the beginning, it looks difficult, but over a periods of time, it becomes easy.

All big things come from small beginnings. The seed of every habit is a single, tiny decision.

Everything has a trade-off. Reading books have as well.

Advantages of reading books.

Open One's Mind:
- Books help us to understand different ideas or ways of thinking. Creativity is nothing but combining different ideas in your own unique way.
Connecting Dots:
- I used to avoid refactoring the code because of the fear that I will break something. I knew I was missing something, but did not know exactly what?. Then I read the book Refactoring where it mentioned to "having a test before refactoring". That's where it clicked me on how to properly refactor the code. I've experienced many examples of such instances.
Learning from other people mistakes:
- I have not failed. I've just found 10,000 ways that won't work. Thomas A. Edison
- There are two ways to learn anything. First from your own mistake, and seconds from someone else mistake. I would prefer the second one.
- If we're trying to do something for the first time, we better ask someone who already did that. Most of the time, it will save a lot of trouble and time for us.
- Reading on the subject before we dive completely into it helps.
Writing Well:
- Improving writing by reading is like, watch and learn.
- Reading more will help us understand how to form a sentence, making your point, when to give an example, when it's appropriate to make a joke, how to ask a question and how to explain the answers, what's the part we should leave for audience's imagination, etc.
- Reading opens one's mind and helps one to write down their thoughts in an organized manner.

Disadvantage of reading books.

Few books are good:
- Best selling does not mean a great book. I've read a few of them and they were not even close to a decent book. Most of those book can be turned into 2-3 blog posts.
- You have to be picky. The checklist I follow before reading a book is
  1. Watch 10-15 minute summary on Youtube.
  2. Check how old the book is.
  3. Read reviews.
  4. Check the index of the book.
  5. You can also check my reading list where I write short summaries.
Analysis paralysis :
- Now we know 50 ways of doing one thing, sometimes we overanalyze or overthink a situation which can make our decision-making to become "paralyzed". Earlier I used to get sucked into this a lot. As time passes I learned that we need to balance things out. This is something we learn as we go.
Tracking Knowledge:
- If you are reading just for fun then you might wanna skip this. If that's not the case then you need to preserve all the knowledge in the form of writing. Building your second brain. Our brains have a very limited memory. It keeps forgetting stuff. There are a few tools that can help. Will talk more about it in the next section.

Myths of Reading Books

Readers Never Makes a Mistake:
- People assume that you are hardly going to make a mistake if you read a lot. I still do a lot of silly mistakes. Does that mean whatever I read is a waste? Definitely No.
- You don't run fast instantly by reading a book on "How to run fast." Once you start practicing, you will fall and will go through a lot of pain. Those books are there to give you a good head start. Books can show you the doors. But you have to open it yourself and while doing that you make a lot of mistakes.
More Knowledgeable:
- In some context it's true. But just knowing is not enough. Most of the time we misunderstand "Knowledge" with "Understanding". We understand something when we experience it or put it into practice.

// Detect dark theme var iframe = document.getElementById('tweet-1338626702264582146-175'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1338626702264582146&theme=dark" }

Theory without practice is empty, practice without theory is blind.

Organize and Tracking Knowledge

I used the combination of Evernote and Notion.

Tracking Tools

I used Notion to keep track of my reading. You don't need any advanced tech knowledge to use notion. You can use any reading template in notion to get started.

I started with a simple book name and status. As I progressed I added a few more fields and kept improving. Now it looks like this.

For a more advanced use case, I linked my reading's table to the my daily Bullet Journal. This helps me to understand how much time and the number of days I take to finish a book.

It looks like a lot of work. But in reality it's not. It will take only 5 min per day to log the entry. We just need to be consistent.

Highlighting Notes

Highlighting notes help to take out important points to remember. For the physical book, we usually use a pencil or a highlighter. But please don't do this.

We highlight notes to reference back the important points in the book.

But searching notes from a physical book is time-consuming. We need to convert those notes into digital format. I use Evernote for its offline supports and powerful search.

Now you might be wondering how do I convert the physical notes into digital ones. The answer is simple. Type notes manually. Now, this is a lot of work. If you earning well then hire someone to do it. If not then you can ask any family member or friend to help you out. In my case, my father does this for me.

To ease the process, I use Google lens to scan app and convert the page into text format. It won't be accurate all the time. But 90% of the time it gives accurate text. If you have any better ways or suggestions for doing this, let me know in the comment section.

We are living in a digital era. Now someone might argue to buy a kindle and avoid all this task.
Yes, that will save a lot of time and space.
Also, I would recommend to create the reading habit first and then go for kindle when you are confident enough.
If you are a person who travels a lot then kindle will save a lot of space in your bag. But I don't see any much of traveling in 2021 or anytime soon.

Short Review

After completing each book. I write short summary of my learnings, takeaways, and action items. Sometimes I share that on social media as well.

Conclusion

Reading books has helped me to think, write, and speak more clearly. The habit creation process is long and needs patience. It took me 2 years to build this habit and the tracking system. I will repeat it. It took me TWO YEARS.

Don't just read this blog and move on. Execute it. I will be happier to hear stories from people who have created the reading habit.

If you are still finding it hard to read. The best way is to start with small storybooks or even comics. Once you get used to it then you can pick up more technical or lengthy books.

Don't give up if you don't see a result in the first few months/weeks.

Just keep it consistent and remember to Read 10 pages regularly and become "1% better every day".

Finally, I will conclude this by Naval Tweet.

// Detect dark theme var iframe = document.getElementById('tweet-1002068699761659905-538'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1002068699761659905&theme=dark" }

Thank you for taking the time to read my blog.

In case of any question, you can reach me on Twitter or Email me.

If you like this kind of content then you can subscribe to my blog and be the first one to get notified when any new content is published.

If you like this article, please like and share it with your friends/colleagues and help me to spread the word.

Photo by Alfons Morales on Unsplash.

Manually Generate apk using Github Actions

Burhanuddin Rashid — Sun, 03 Jan 2021 07:02:05 +0000

For more visibility posting this on dev.to. The original article is posted on my website. Let's get started :)

Have you been in a situation where you want to test a feature from a specific branch? But you don't have an environment set up in the local? Or you are out somewhere and don't have access to your PC? Or your client/QA is pinging you all the time to provide APK with specific configuration and features?

In this blog, we will talk about how we can solve above problems by manually generating APK using Github actions. So Let's get started.

Prerequisite

Github actions.
Basic understanding of android build using gradle.
Basic of bash scripting.

What problem we are trying to solve?

The problem might differ based on your working environment, team size, and clients. Let's try to understand each of them.

Indie Developer:
- If you are an Indie developer working solely on the project, then you might be overwhelmed by this approach. The reason might be
  1. Fewer dependencies of people on you.
  2. You have the environment set up in your local.
  3. No one asking for the APK to test on daily basis.
- You can skip this whole article. But it's good to be aware of this approach because eventually, your team size will grow, and you need be well prepared for it.
Setting up the environment:
- Let say our non-technical client wants to test a feature on the stagging environment which we have pushed to a specific branch. There are two solutions to this.
  1. Call the developer and ask for the apk with the required parameters.
  2. Setup the android environment in the client local machine, check out the branch, tweak the parameters, and build the apk. (I don't think a non-technical client will like this solution)
- We can avoid this by providing a GUI to build the apk with configurable parameters. That's exactly what run workflow UI does. (More on this next section)
- The same problem mention above can be applied to QA as well. The major difference is QA is technically sound. They can get the apk by using GitHub trigger like push, pull_request, etc. The problem here is why to create this unnecessary push and pull request trigger to just generate apk. It will clutter the git history and unnecessary PR requests.
Configurability :
- The ability to build apk with configured parameters is something I find very useful. The most common parameters we configure in apps are.
  1. API Endpoints
  2. Secret/Access Keys.
  3. Other business based params like Threshold values, Number of Re attempts. etc.

How do we solve this problem ?

Github Actions provides various trigger events to run your workflow. Following is an example of some of the trigger events, like pushing a commit on the main branch, creating pull requests, tags, etc.

on:
  # Trigger the workflow on push or pull request,
  # but only for the main branch
  push:
    branches:
      - main

  pull_request:
    branches:
      - main

    branches:    
      # Push events on main branch
      - main
      # Push events to branches matching refs/heads/mona/octocat
      - 'mona/octocat'
      # Push events to branches matching refs/heads/releases/10
      - 'releases/**'

    tags:        
      - v1             # Push events to v1 tag
      - v1.*

To trigger an event manually, Github actions have added a new trigger event called workflow_dispatch. Below is the sample code and UI. (More in the next section)

on: 
  workflow_dispatch:
    inputs:
      logLevel:
        description: 'Log level'     
        required: true
        default: 'warning'
      tags:
        description: 'Test scenario tags'

Setup

First we need to setup a configurable parameters in android and then we can update those params using GitHub inputs in the workflow. So will start with android first.

Configurable properties in android.

We need to set up the configurable parameters in a file. In this case, we are putting this into local.properties file, which we usually do not check-in VCS. Note: It can be any file. We just to point to that file in build.gradle.

Create or update the local.properties file like this.

BASE_URL="https://production.example.com/api/v1"
MAP_KEY="production_sample_key"
RETRY_ATTEMPTS=3
THRESHOLD_VALUE=0.05

Update build.gradle in the app like this.

def localProperties = new Properties()
localProperties.load(new FileInputStream(rootProject.file("local.properties")))

android {

    defaultConfig {
        //...
        buildConfigField("String", "APP_BASE_URL", localProperties['BASE_URL'])
        buildConfigField("int", "APP_RETRY_ATTEMPTS", localProperties['RETRY_ATTEMPTS'])
        buildConfigField("float", "APP_THRESHOLD_VALUE", localProperties['THRESHOLD_VALUE'])
    }

    buildTypes {
        debug {
            resValue("string", "maps_key", localProperties['MAP_KEY'])
        }
        release {
           //..
        }
    }
}

We can refer local properties using BuildConfig in this app like this.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val txtConfig = findViewById<TextView>(R.id.txtConfig)

        val configText = """
            BASE URL :  ${BuildConfig.APP_BASE_URL}
            MAP_KEY :  ${getString(R.string.maps_key)}
            RE-ATTEMPT :  ${BuildConfig.APP_RETRY_ATTEMPTS}
            THRESHOLD VALUE :  ${BuildConfig.APP_THRESHOLD_VALUE}
        """.trimIndent()

        txtConfig.text = configText
    }
}

Note: Sometimes the local.properties do not create BuildConfig on sync. It will get generated when we build the apk. Ref

The output will look like this when we run the apk.

If you are facing any issues. You can check out the sample workflow app here. For setting the local.properties please checkout this mindork blog.

Setup Github workflow

We create yaml file inside .github/workflow folder. To trigger the workflow manually we will use workflow_dispatch as a trigger. This will show the Run Workflow UI which we have seen above.

name: Manual Generate APK
on:
  workflow_dispatch:
    /....

To show the input config values, we use inputs here. The baseUrl is an input key which we will use to read the value.

name: Manual Generate APK
on:
  workflow_dispatch:
    inputs:

      baseUrl:
        description: 'Base URL'
        required: true
        default: 'https://production.example.com/api/v1'

      mapKey:
        description: 'Map Key'
        required: true
        default: 'production_sample_key'

      reAttempt:
        description: 'Number of re-attempts'
        default: '3'

      thresholdValue:
        description: 'Threshold value'
        default: '0.05'

Setting required params as true show an asterisk indicating a mandatory field. The description is shown as the field name in the UI. The default param will set the default value in the input field.

We will add command to build the apk.

- name: Assemble app debug APK
  run: bash ./gradlew assembleDebug --stacktrace

Setting up bash script

If we try to run this workflow now, it will fail with error local.properties not found. This is because we have not checked-in that file in our VCS. We can fix this by creating local.properties on the fly while running the github workflow. We can do this by running the linux command in the workflow which creates local.properties file with all config values.

It's a better to wrap this sequence of linux command into bash script. It will avoid the clutter code in the workflow and provide more flexibility to update the script.

Now we will create and checked in the bash script file update_properties.sh in the VCS which will look this.

#!/bin/bash

touch local.properties
echo "BASE_URL=\"$1\"" >> local.properties
echo "MAP_KEY=\"$2\"" >> local.properties
echo "RETRY_ATTEMPTS=$3" >> local.properties
echo "THRESHOLD_VALUE=$4" >> local.properties

$1, $2,$3, and $4 are the 4 arguments that will be passed into the script from the inputs values.

We need to run the bash script with input values before building the apk. We get these values by using github.event.inputs.{key} properties. You can find the source file here.

- name: Print Params Values
  run: |
          bash update_properties.sh ${{ github.event.inputs.baseUrl }} ${{ github.event.inputs.mapKey }} ${{ github.event.inputs.reAttempt }} ${{ github.event.inputs.thresholdValue }}
- name: Assemble app debug APK
  run: bash ./gradlew assembleDebug --stacktrace

Fun Fact: I was able to run the script after 17 failed attempts. So don't worry if the script does not work for the first time. Keep googling as I did 😂

Run the workflow

We can now run the workflow from UI in github action tab.

If you want to update the existing local.properties or any other file which you are already using then you need to change your script. Please check this branch for example.

Key things to remember

The workflow UI won't show up if the workflow is pushed into a separate branch but not in the main/master branch. The workflow will only be visible if it is pushed to main/master branch.
It won't run on a branch that does not have the workflow. The UI will look like this.

The linux text replace sed -i command will work on github action which runs on the linux. For mac we need use sed -i ""
Sometimes the local.properties do not create BuildConfig on sync. It will get generated when we build the apk. Ref

Conclusion

The GitHub manually trigger was something the dev asked for when the action was initially launched. Because it provides more flexibility and ease of use, especially for clients/QA's. They also have an API to trigger this workflow which opens the door for more automation.

In case of any question and issue, you can reach me on Twitter. Stay updated by subscribing to my blog. Thank you for taking the time to read this article. If you like this article, please like and share it with your friends/colleagues and spread the word.

Resources

Getting started with Firebase emulators suite for Android

Burhanuddin Rashid — Fri, 25 Sep 2020 06:51:29 +0000

For more visibility posting this on dev.to. The original article is posted on my website.Let's get started :)

Do you know a friend/colleague who tests their application directly in the production environment?

Yeah, that’s a bad practice. We should have a local or staging environment where we test our code before we push to the production. That’s where the Firebase emulator comes into the picture. Firebase emulator is a tool that helps us to test various firebase services in our local environment altogether.

What is Firebase Emulator?

According to the official documentation

The Firebase Local Emulator Suite consists of individual service emulators built to accurately mimic the behavior of Firebase services. This means you can connect your app directly to these emulators to perform integration testing or QA without touching production data.

Currently, there are 5 services available in the emulator.

Cloud Firestore
Realtime database
Cloud Functions
Hosting
Cloud Pub/Sub

Note: However your app will still continue to communicate with production Firebase services when emulators are not available or configured.

Why do we need Firebase Emulator? What problem does it solve?

We need the Firestore emulator to safely read and write documents in testing. Since all services are connected to the local environment, these trigger the events in each other’s services.

For example, The realtime database writes may trigger the cloud functions in the emulator.

Because of a lack of testing we face the following issues.

1. Time Consuming

No one writes a perfect code in the first attempt. It’s an iterative process. We need a fast feedback loop. Let’s say that if we are writing a cloud function without an emulator, then every time we do a change we need to push to the server which will take around 20-30 seconds which is a waste of time, causes distraction, and hamper the productivity.

2. Debugging

While developing we make a lot of assumptions and mistakes which are fixed by debugging. Without a local setup, debugging directly on the server is a nightmare. No, having console.log() in each line of the code is not a good solution either. Having a local environment allows us to debug more effectively using our favorite IDE.

3. Data Modeling

The most FAQ on firebase is about data modeling for the database. We keep experimenting with the structure of the database and if we don’t have a local environment then it’s become very difficult to define a clear boundary between the test data and the production data.

The chances of messing up the production data are very high, by doing a typo, using the wrong key, or deleting a document by mistake.

There is one workaround for this which I am going to talk about in the next section.

4. Integration testing using CI/CD

Each individual product emulator in the Emulator Suite responds to SDK and REST API calls just like production Firebase services. So we can use our own testing tools integrating into our CI/CD to write self-contained integration tests that use the Local Emulator Suite as the backend.

5. Cost Real Money

The first thing we need to check for any third-party services is “pricing”. I hope you have already checked for the firebase. If not then please visit pricing.

The pricing won’t cause any problem if you are working on a project as a hobby which does not have any real users. But if you plan for the real customers/users then you will reach a point where you have let say, 10K users. Due to the increase in the number of users, the usage of services will grow proportionally.

Realtime DB will have a thousand simultaneous connections. Firestore will have more read/write/deletes. The cloud function will have high invokes which eventually cost you a lot of money.

So we should be aware of any unnecessary reads and downloads from the firebase especially while testing because we used to push all kinds of junk data to test various scenarios.

I recommend watching this video for firestore pricing.

For Hindi:

6. Work-around with Multiple Projects

Since we have one database per project most developers create multiple projects to handle production and test environments separately.

For example, I will create a Firebase project with the name “My Prod App” adding my app with package com.burhanrashid52.firebase.sampleapp, and then I’ll create another project called “My Test App” with package name com.burhanrashid52.firebase.sampleapp.testing.

This will help to avoid the issue because firebase pricing is project-based, not account-based.

How to get started?

When I was writing the first draft of this section. I wrote the entire step by step command in order to set up the firebase emulator suite, which firebase documentation already has. So why reinvent the wheel? Please go through the official documentation for setting this up. If you are a person who understands things more visually. Please check out this video.

Here is my short version of that steps with given commands:

Setup the CLI → npm install -g firebase-tools
Login to the firebase account → firebase login
Select the project.
Initialize firebase for the project → firebase init
Select the products you need.
Start the emulator → firebase emulators:start
- (Optional) Rum specific feature using —only
- Firestore: firebase emulators:start --only firestore
- RealtimeDB : firebase emulators:start --only database
- Cloud Functions : firebase emulators:start --only functions

7.Run localhost:4000 in the browser and you will see an emulator suite console.

More details here

The dashboard displays the status(On/Off) of each service emulator with a port number. We connect our client app to those port numbers. (More on this later).

We can also change the port if any of the default ports are occupied.

Connect Android (client) to firebase emulator

Our firebase emulator suite is up and running. Now we need to connect our client to the emulator suite. After that our client will be able to push and pull the data of this emulator and we can observe the changes on the emulator UI page.

I am using Android as the client here. If you are using the iOS or Web as a client then check out this official document.

Since we run android on the “android emulator” we cannot use localhost:8080 as a host. We need to use 10.0.2.2:8080 as the “android emulator” IP. We can test that by running 10.0.2.2:8080 in the android emulator browser and verify that firebase emulator UI is displayed in the android emulator browser.

Following are code snippets to set the host. The port is different for each service.

1. Firestore for Android

    val instance = FirebaseFirestore.getInstance()
    val settings = FirebaseFirestoreSettings.Builder()
            .setHost("10.0.2.2:8080")
            .setSslEnabled(false)
            .setPersistenceEnabled(false)
            .build()

    instance.firestoreSettings = settings

2. Realtime database for Android

For realtime DB we need to add a project-id in the URL. We can find this in the firebase project setting or directly copy from the realtime database tab from the firebase emulator UI.

val instance = FirebaseDatabase.getInstance("http://10.0.2.2:9000?ns=projectId")

3. Cloud Function for Android

In case of manually calling cloud function from the client.

val instance = FirebaseFunctions.getInstance();
instance.useEmulator("10.0.2.2", 5001)

We just need to make sure that we operating on the created instance. Otherwise it will get connect to the production firebase db. A better practice would be to injecting a singleton class which provide the same instance throughout the application.

4. Dependency Injection using Koin

We are using koin module and making all the dependency as a singleton using single {} Lamba and injecting that same instance where it required using

val firebaseModule = module {

    single {
        val instance = FirebaseFirestore.getInstance()

        val settings = if (isFirebaseLocal) {
            FirebaseFirestoreSettings.Builder()
                    .setHost("10.0.2.2:8080")
                    .setSslEnabled(false)
                    .setPersistenceEnabled(false)
                    .build()
        } else {
            FirebaseFirestoreSettings.Builder()
                    .setSslEnabled(false)
                    .setPersistenceEnabled(false)
                    .build()
        }
        instance.firestoreSettings = settings
        instance

    }

    single {
        if (isFirebaseLocal) {
            FirebaseDatabase.getInstance("http://10.0.2.2:9000?ns=projectId")
        } else {
            FirebaseDatabase.getInstance()
        }
    }

    single {
        val instance = FirebaseFunctions.getInstance()
        if (isFirebaseLocal) {
            instance.useEmulator("10.0.2.2", 5001)
        }
        instance
    }
}

var isFirebaseLocal = false

We used a flag isFirebaseLocal and set at MyApp class. It helps to toggle between local and production database. We can put this flag in the gradle setting as well.

We can inject using Koin.

val firestore by inject<FirebaseFirestore>()

5. Release builds

For release build, I always make this flag as false. For that, I’ve done something like this. So that I don’t accidentally put true for the release build. There are better ways to do this. But for simplicity, I am going with this.

class MyApp : Application() {

    override fun onCreate() {
        super.onCreate()

        if (BuildConfig.DEBUG) {
            isFirebaseLocal = false
        }
        // Start Koin
        startKoin {
            androidLogger()
            modules(firebaseModule)
        }
    }
}

Key things to remember.

Double-check your host IP and port on a client-side. I wasted 3 hours of debugging on “why my client app is not connecting to the emulator suite”.
Firebase emulator does not persist data locally. It clears all the data when we restart the server. A similar action can be achieved by clicking on the clear data button on firestore tab. This will be a pain if we have a huge amount of data and various scenarios to test. I’ve referred a fix in the know issue section.
We might see this error if we try to update real-time database using cloud functions.
If we want to perform an operation on the realtime database from the cloud function then we need to set the local URL of the realtime database when we initialize the app. More here. Don’t forget to switch back to the production URL when you are deploying.

   admin.initializeApp({
        credential: admin.credential.applicationDefault(),
        databaseURL: 'http://localhost:9000?ns=projectId'
    });

5.Double-check your keys which we are using for firestore and realtime time. A typo can drain all your mental, physical, and spiritual energy.

Known Issues

Firebase emulator suite is new and far from perfect and sometimes it has bugs.

Firestore UI bug: When we push data using the client we are not able to see the data in the firestore emulator page. But our data is pushed correctly from the client and the functionality is working as expected. I’ve already filed an issue here. Please upvote if you find the same.
Persist data locally: Already discuss this in the above section. The Import/Export button on UI might help as we do for realtime using the JSON file.
Authentication is not available locally.

Conclusion

I’ve developed an app using firebase before and believe me this feature saves a lot of time and energy.

Now tell your friend/colleague that we have a better way of testing the code using a firebase emulator instead of doing in production. It’s just beginning.

Looking forward to more features and bugs fixes. Thanks to Firebase Team

Thank you for taking the time to read this article. If you like this article, please like and share it with your friends/colleagues, and stay updated for this kind of post by subscribing to my blog. In case of any question/doubts hit me on any social media platform @burhanrashid52.

Testing in Flutter

Burhanuddin Rashid — Fri, 11 Sep 2020 10:45:33 +0000

If you are struggling to write tests for legacy codebase in a flutter then yesterday I talked about "Testing in Flutter" for legacy codebase at Mobile Z-days.

The more features your flutter app has, the harder it is to test manually. Automated tests help ensure that your app performs correctly before you publish it while retaining your feature and bug-fix velocity.

Writing these tests for your Flutter app can help you create a resilient and bug-free code.

In this talk, we will take about how to do unit, integration, and widget testing in a flutter with live demo while discussing the fact that there are trade-offs between different kinds of testing.

We will also look into multiple Continuous integration (CI) services that are available for flutter to get started, which allows us to run the tests automatically when pushing new code changes.