Let us look into the OOP side of Kotlin and how to implement the four great pillars of OOP

Pillars of OOP

1. Encapsulation

2. Abstraction

3. Polymorphism

4. Inheritance

Encapsulation

the bundling of data (variables) and methods (functions) that operate on the data into a single unit. Restricts access to some attributes and exposes only necessary attributes for modification

Kotlin provides access modifiers like private, public, internal, and protected to control exposing access to attributes for modification.

class User {
    private var password: String = "secret" // password cannot be directly modified. 

    fun setPassword(newPassword: String) {
        // add any validation here if required, before making any modification
        password = newPassword
    }

    fun getPassword(): String {
       // add any validation here if required, before returning the password value
       return "****"  // Hiding actual password
    }
}

Abstraction

hides implementation details and only exposes relevant functionalities. This allows interacting with objects without needing to understand the complex inner workings.

In Kotlin, abstraction can be achieved in two ways. Abstract class and Interfaces.

Abstract Class

abstract class Vehicle {
    abstract fun start()  // No implementation
}

class Car : Vehicle() {
    override fun start() {
        println("Car is starting...")
    }
}

Interface

interface Clickable {
    fun click()
}

class Button : Clickable {
    override fun click() {
        println("Button clicked!")
    }
}

The major difference between an abstract class and an interface is that an abstract class can have both concrete methods and abstract methods, whereas interfaces cannot have method implementations. If you require to have functions that are not mandatory for the child class to implement or override, you can use an abstract class instead of an interface.

Inheritance

allows a class (child) to inherit the properties and behaviours of another class (parent)

In Kotlin, you can extend a class if it is open.

open class Animal {
    fun eat() {
        println("munch munch munch...")
    }
}

class Dog : Animal() {
    fun bark() = println("Barking...")
}

fun main() {
    val dog = Dog()
    dog.eat()  // Inherited from Animal
    dog.bark()
}

One important thing to notice is that Kotlin does not support multiple inheritance by classes due to the complexity and ambiguity it can introduce. Read Diamond Problem if you want to learn more about the ambiguity. But in Kotlin, you can inherit multiple interfaces.

interface CookingSkill {
    fun makeBeefCurry()
    fun makeChickenTikka()
}

interface BakingSkill {
    fun makeCheeseCake()
}

class Chef : CookingSkill, BakingSkill {
    override fun makeBeefCurry() {
        TODO("Not yet implemented")
    }

    override fun makeChickenTikka() {
        TODO("Not yet implemented")
    }

    override fun makeTiramisu() {
        TODO("Not yet implemented")
    }

}

Polymorphism

allows a single function or method to have multiple behaviors depending on the object calling it.

Kotlin supports both method overriding and method overloading polymorphism.

Method Overriding

In Kotlin, to override a method, it is required to be explicitly mentioned as an open method.

open class Animal {
    open fun makeSound() {
        println("Making sound...")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("Woof...")
    }
}

fun main() {
    val dog = Dog()
    dog.makeSound()
}

Output:

 Woof...

Method Overloading

class SumCalculations {
    fun add(a: Int, b: Int): Int {
        return a + b
    }

    fun add(a: Double, b: Double): Double {
        return a + b
    }
}

fun main() {
    val sumCalculations = SumCalculations()
    val firstOutput = sumCalculations.add(1,2) 
    val secondOutput = sumCalculations.add(1.1,2.2) 
}

Follow for more such posts on Kotlin and Android development.

Breakdown

Now, let's break down our problem into parts. If we need to calculate the distance between two locations, we can use the Haversine Formula to manually calculate the distance or the GeoLocator dependency, which has a built-in function to calculate the distance in units between two points.

But what if we have one location point but the other is a array of location points. How do we calculate whether the provided location point is closer to any of the location points provided. To do that, we need to understand polyline concept.

Polyline

A polyline is a series of connected line segments on a map. It's essentially a path drawn between multiple points. This is commonly used to visualize routes, trails, or any other linear data on a map.

So, a polyline is a line drawn between two latitude-longitude points. A route from point A to point B will have 'n' number of location points and therefore 'n' number of polylines, where 'n' depends on the number of straight lines needed to reach the destination.

Approach

We take pairs of location points and draw polyline between them. And then take the target location point and find a projected location point that falls right on the polyline. Then we will calculate the distance between target location point and the projected point.

Consider the following example. Let us take the first two location points (L0, L1) in the given array and draw polyline between them. We have the target location (current location) somewhere in the top of the polyline.

We can now draw a line from the target location point, perpendicular (or shortest distance) to the polyline to find the projected point that touches the polyline. Now we have the projected point location and target point location. We can easily calculate distance between these two using geolocator.

Code

Taken in consideration that you have already included geo_locator dependency in your package. Lets create two data classes named 'line_segment.dart' and 'location_info.dart'

class LineSegment {
  final LocationInfo start;
  final LocationInfo end;

  LineSegment(this.start, this.end);
}

class LocationInfo {
  final double latitude;
  final double longitude;

  LocationInfo({required this.latitude, this.longitude});  
}

Now, lets create a helper class named 'location_service.dart' with the following function added. The function will take two parameters. One is the user location called point and another is a LineSegment parameter which contains start and end lat long. The function will draw a line between start and end positions and project another line to reach the previously drawn line. This projection will happen in such a way to find the shortest path to reach the previously drawn line. The function will then return the co-ordinates of the projected point.

class LocationService {
  LocationInfo _projectPointOnLineSegment(
      LocationInfo point, LineSegment lineSegment) {
    // Vector from line segment start to point
    final v = LocationInfo(
        latitude: point.latitude - lineSegment.start.latitude,
        longitude: point.longitude - lineSegment.start.longitude);

    // Vector representing the line segment
    final w = LocationInfo(
        latitude: lineSegment.end.latitude - lineSegment.start.latitude,
        longitude: lineSegment.end.longitude - lineSegment.start.longitude);

    // Calculate the projection parameter
    final wLengthSquared = w.latitude * w.latitude + w.longitude * w.longitude;
    final wDotV = w.latitude * v.latitude + w.longitude * v.longitude;
    final t = wDotV / wLengthSquared;

    // Clamp t to the range [0, 1] to ensure the projected point is on the line segment
    final tClamped = t.clamp(0.0, 1.0);

    // Calculate the projected point
    final projectedPoint = LocationInfo(
      latitude: lineSegment.start.latitude + tClamped * w.latitude,
      longitude: lineSegment.start.longitude + tClamped * w.longitude,
    );

    return projectedPoint;
  }
}

Now that we have found out the co-ordinates of a projected point, we can easily calculate the distance between projected point and the user's current location using geo_locator. Add the following functions inside 'location_service.dart'

  double calculateDistanceToRoad(
      LineSegment lineSegment, LocationInfo currentLoc) {

    // finds the co-ordinates of projected point   
    LocationInfo projectLoc =
        _projectPointOnLineSegment(currentLoc, lineSegment);

    // Calculate distance between current location and projection point
    final distanceToProjection =
        calculateDistanceInMeters(currentLoc, projectLoc);
  } 

  double calculateDistanceInMeters(LocationInfo startDes, LocationInfo endDes) {
    return _geoLocator.distanceBetween(startDes.latitude, startDes.longitude,
        endDes.latitude, endDes.longitude);
  }

If you have a use case where you have a large list of polyline points, and want to detect whether the user is in a certain distance from the entire route, you can loop through each co-ordinate pairs to find the distance from user location and validate whether the calculated distance is less than the desired radius.

Thank you for reading!

A typical job interview is a discussion between two liars

Interviews are a headache in general. No matter where you stand in the experience scale, it comes with lot of self doubts, impostor syndromes, preparation burdens and what not. Especially when you are a experienced developer, somehow the companies are expecting us to be well equipped to solve all the world problems.

Not sure about how to solve all world problems, but I am preparing a questionnaire for Senior Android Developers with around 5 years of technical experience. This is for myself and might be useful to you.

Planning to split the article into multiple parts, grouped based on topics. I guess this approach would help us to practice and revise in specific to topics. Feel free to comment suggestions and correct my mistakes if you find any.

Android Core Questions

Explain activity life-cycle

Explain fragment life-cycle

What is context in Android?

• In Android, Context is an important and fundamental class that provides access to various application-specific resources and information about the application environment.

• It's an abstract class provided by the Android framework, and several classes within Android, such as Activities, Services, Application, and Broadcast Receivers, extend or implement the Context class.

• It is used to access app specific resources, Files and database, Location Manager, Audio Manager, retrieve info about app package (version number, package name), view inflation, access theme, initiate service, broadcast, start Activity

What are the different types of Context in Android?

In Android, there are several types of Context available, each serving specific purposes or contexts within an application. These various Context types are differentiated based on their scope and the environment they provide access to:

• Application Context (ApplicationContext):

  1. Obtained via getApplicationContext()

  2. Represents the application's entire life-cycle.

  3. Exists throughout the application's lifetime.

  4. Should be used when an object needs access to application-level resources or global application state. For example, retrieving resources, accessing the application's package information, or using system services.

  5. Be cautious not to store long-lived references to UI components (like Activities or Views) within the Application Context to prevent memory leaks.

• Activity Context (ActivityContext):

  1. Obtained via this or getActivity().

  2. Represents the current state of an Activity.

  3. Exists as long as the activity is alive.

  4. Should be used when working with UI components (Views, Dialogs) or accessing resources that are tied to a particular activity, like inflating layouts or creating intents.

  5. Be careful not to pass the Activity Context beyond the lifetime of the activity (e.g., storing it in long-lived objects) to avoid memory leaks.

• Service Context (ServiceContext):

  1. Obtained via this within a Service.

  2. Represents the context of a running Service.

  3. Exists as long as the service is running.

  4. Used within services for operations like interacting with system services, accessing resources, or managing service-related tasks.

• Broadcast Receiver Context (ReceiverContext):

  1. Obtained via onReceive() method in a Broadcast Receiver.

  2. Represents the context of a broadcast being received.

  3. Exists during the execution of the onReceive() method.

  4. Used within Broadcast Receivers for handling broadcast intents, starting services, etc.

• Content Provider Context (ContentProviderContext):

  1. Obtained via getContext() in a Content Provider.

  2. Represents the context of a Content Provider.

  3. Exists during the execution of Content Provider methods.

  4. Used within Content Providers for accessing and manipulating data through the Content Resolver.

What are Broadcast Receiver?

• Broadcast Receivers in Android are components that facilitate communication between different parts of an application or between different applications.

• They are particularly useful for responding to system-wide broadcast announcements made by the Android system or other applications. Battery Status Change, Network Changes, Push Notifications, Alarm Managers, Background Operations and scheduled tasks, Triggering UI components.

What are intents?

In Android, Intents are a fundamental part of the operating system that enables communication between components such as activities, services, broadcast receivers, and content providers. There are mainly three types of Intents

• Implicit Intent

• Explicit Intent

• Pending Intent

Explain different types of Intents

Explicit Intent : Used to launch components within the same application by explicitly specifying the target component's name (i.e., its class name)

Intent intent = new Intent(CurrentActivity.this, TargetActivity.class); 
startActivity(intent);

Implicit Intent : Used to activate components (like activities, services, or broadcast receivers) without specifying the exact class name of the component to be invoked. (opening a link in browser)

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://www.example.com")); 
startActivity(intent);

Pending Intent : Used in scenarios where an operation needs to be performed at a later time, such as sending a notification or scheduling an alarm, and the operation is triggered from a different context than where it will be executed. Pending Intents are a type of intent that allows you to pass a token representing a future execution of a specified intent.

Intent notificationIntent = new Intent(context, TargetActivity.class); 
PendingIntent pendingIntent = PendingIntent.getActivity(context, requestCode, 
                                    notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);

Is it possible to create activity without UI?

Yes it is possible. You simply need to remove UI initialisation in onCreate method.

What is ANR in android?

• ANR occurs when the user interface thread (main thread or UI thread) of an Android application is blocked for an extended period, typically around 5 seconds or more, causing the app to become unresponsive to user interactions.

• Common causes of ANR include: - Lengthy operations performed on the UI thread, such as long-running computations, network operations, or database queries.

• Deadlocks or race conditions that lead to thread contention, causing the UI thread to halt.

What are crashes in Android?

• Crashes in Android applications occur when the app encounters an unrecoverable error or exception during runtime, leading to the app's termination.

• Null Pointer Exceptions (NPEs), ArrayIndexOutOfBoundsException, or other unchecked exceptions.

How to avoid ANR in Android

• Offload Long-Running Operations from the UI Thread

• Use Loaders or AsyncTasks Carefully

• Avoid Network Operations on the Main Thread

• Optimise Database Access

• Use Handler Threads Wisely

• Use Profiling Tools

What is the purposes of Service in Android?

Android Service is used to perform long running jobs off the UI thread. A typical long running tasks can be periodic downloading of data from internet, saving multiple records into database, perform file I/O, fetching your phone contacts list, etc. For such long running tasks, Service is used to avoid UI lags and makes user experience better.

What is the difference between bound and unbounded service?

• Bound Service – Service which call indefinitely in between activity. An Android component may bind itself to a Service using bindservice (). A bound service would run as long as the other application components are bound to it. As soon as they unbind, the service destroys itself.

• Unbound Service – Service which call at the life span of calling activity. In this case, an application component starts the service, and it would continue to run in the background, even if the original component that initiated it is destroyed. For instance, when started, a service would continue to play music in the background indefinitely.

How can we make the AlarmService run forever even after device reboot?

Once you start an AlarmService, it runs forever until your device restarts. Once your device restart, you have to start the service explicitly to run it forever again. You have to register BroadcastReceiver to handle boot event.

What are the key differences between a service and IntentService in Android?

What is the importance of the AndroidManifest.xml file in an Android application?

The AndroidManifest.xml file is a key component of an Android application. It is an XML file that provides essential information about the application to the Android operating system. Some of the important roles that the AndroidManifest.xml file in the Android SDK plays are:

• Declaring the application's package name: The package name is a unique identifier for the application, and it is used to distinguish it from other applications installed on the device.

• Declaring the application's components: The manifest file declares all the components of the application, including activities, services, broadcast receivers, and content providers. The Android OS uses this information to launch and manage these components.

• Declaring the required permissions: The AndroidManifest.xml file lists all the permissions that the application requires to access system resources or other applications' data. When the application is installed, users are prompted to grant these permissions.

• Declaring the application's minimum and target API levels: The manifest file specifies the application's minimum Android API level required to run and the target API level the application is built for.

• Declaring the application's launch activity: The manifest file specifies which activity should be launched when the application is launched.

How do you handle configuration changes like screen rotations in an Android application?

When a configuration change occurs in an Android application, such as a screen rotation or a language change, the Android system destroys and recreates the activity. This process can lead to loss of data and affect the user experience. To handle configuration changes in an Android platform, you can use one or more of the following techniques:

• Save and restore instance state: The onSaveInstanceState() method of the activity is called before the activity is destroyed. You can use this method to save the current state of the activity, such as the values of UI components or any other important data, in a bundle object. The bundle is then passed to the onCreate() method of the activity when it is recreated, and you can use the values from the bundle to restore the state of the activity.

• Use the ViewModel: ViewModel is a component of the Android Architecture Components library that helps you to manage UI-related data in a life-cycle-conscious way. You can store the data in the ViewModel, and it will survive configuration changes because it is not tied to the activity's life cycle.

• Handle configuration changes manually: You can prevent the activity from being destroyed and recreated on configuration changes by specifying the android:configChanges attribute in the activity tag of the AndroidManifest.xml file. This attribute tells the system to handle the configuration change manually, and the activity's onConfigurationChanged() method will be called instead of the recreated activity.

What dialog boxes are supported on Android?

Android provides several types of dialog boxes that you can use to interact with users and display important information. Here are some commonly used dialog box types supported on Android:

• AlertDialog: AlertDialog is a versatile dialog box that can display a title, message, and optional buttons. It is often used to prompt users for confirmation, display important information, or ask for user input.

• ProgressDialog: ProgressDialog is a dialog box that shows the progress of a long-running operation. It typically displays a spinning progress indicator and an optional message to inform the user about the ongoing task.

• DatePickerDialog: DatePickerDialog allows users to select a date from a calendar. It provides a calendar interface for choosing a specific date and returns the selected date to the application.

• TimePickerDialog: TimePickerDialog allows users to select a time from a clock interface. It provides a clock-like interface for choosing hours and minutes and returns the selected time to the application.

• BottomSheetDialog: BottomSheetDialog is a dialog that slides up from the bottom of the screen, partially covering the content. It is commonly used for displaying additional options or actions related to the current context.

• Custom Dialogs: Android also allows you to create custom dialog boxes by extending the Dialog or DialogFragment class. This gives you full control over the appearance and behavior of the dialog, allowing you to design a dialog that suits your specific needs.

How do you handle background tasks in an Android application?

There are several ways to handle background tasks in an Android application, depending on the nature of the task and the requirements of the application. Here are some commonly used methods:

• Service: A service is a component in the Android system that runs in the background and performs long-running operations, such as playing music, downloading large files, or performing network requests. A service can run indefinitely or be started and stopped on demand.

• IntentService: An IntentService is a type of service that can handle multiple requests on a separate worker thread in a queue. It is suitable for handling long-running tasks in the background, such as downloading large files, and it automatically stops itself when the task is completed.

• JobScheduler: The JobScheduler is a system service introduced in Android 5.0 Lollipop that allows you to schedule background tasks to run at specific times or conditions, such as when the device is idle or connected to a charger. It is suitable for performing periodic or recurring tasks, such as syncing data or sending notifications.

• WorkManager: The WorkManager is a library introduced in Android Jetpack that provides a simple and flexible way to schedule and manage background tasks in your app. It automatically chooses the best implementation based on the device's API level, battery level, and network status.

What is the difference between a service and a broadcast receiver in Android?

A service and a broadcast receiver are components in the Android operating system that perform background tasks but differ in their functions and how they are used.

A service in the Android system runs in the background and performs long-running operations, such as downloading files, playing music, or performing network requests. A service can run indefinitely or be started and stopped on demand. Services can be started in two ways: started services and bound services. A started service runs in the background until it completes its task or is stopped, while a bound service runs only as long as a client is bound to it.

On the other hand, a broadcast receiver is a component in the Android system that listens for system-wide broadcast events, such as the battery level changing, a phone call being received, or a new SMS message being received. When an event occurs, the broadcast receiver is notified and can perform some action in response, such as displaying a notification or starting a service.

In summary, the main difference between a service and a broadcast receiver is that a service is used to perform long-running background tasks. In contrast, a broadcast receiver listens to system-wide broadcast events and performs actions in response to them. Services can be started and stopped on demand, while broadcast receivers always listen to events.

Resources that were helpful:
https://anywhere.epam.com/en/blog/advanced-android-interview-questions-answers
https://stacktips.com/articles/android-service-interview-questions

The above section is only for Android Core related questions. More questionnaire on topics like Kotlin, Async Programming, Jetpack Components, Test driven will be coming up soon. Feel free to comment down if I have missed out any important questions on this topic.

Why do I need a blog?

Yes. I do have hashnode. I can write awesome articles with ease and publish everything into a beautifully pre-designed website. Hashnode is making life easier for me. But who likes it when everything comes easy? Definitely not me.
I wanted to build something completely to my taste. The blog should reflect, who I am and what I do before even someone starts reading my "about" section. I am not just my work. I always wanted to write more about my rants, political opinions, poems, and my 2 cents on random stuff. But I always faced one issue or another with building, structuring, or hosting my blog. So I made some decisions which I really hope work well.

The Decisions

• For my tech articles related to my work, I am still going to utilize hashnode. It creates less friction and thus it will encourage me to write more.

• Previously I was using React to build the front-end components. Now I am migrating the code to NextJS. More on this, later.

• For hosting, I am still going to be using GitHub pages. As it offers free hosting and an SSL (I am not a web dev. So I have no idea how this works)

• I am someone who never liked to use UI helper packages like bootstrap. I always loved to play with CSS components. I am still this guy. So no no for UI components.

What about the backend?

This is where this whole rebuilding of the blog gets interesting. I was on the constant lookout for a perfect CMS that will help me with my requirements. The CMS that satisfies my requirement, comes with high pricing. If it is free, it doesn't have the features that I want. I was exploring strapi.js for some time, and it was pretty great as far as I looked into it. But now, that I have hashnode for my tech blog, all I need to worry about is my personal blog which I update rarely. That is when I learned a bit about MDX

What is MDX?

We all know what Markdown is. Simply put, a text-to-HTML conversion tool. So what is MDX then? MDX lets you embed components directly from your markup. You can add custom view JSX components when rendering your Markdown file. This way, when we fetch a file written in markdown, for each component (heading1, italic, code) we can use individual CSS styling. It provides even more options like passing parameters from the JS component to the MDX for custom .md generation. More on this in later articles.

Where will be the MDX files hosted?

That is something I am yet to decide. I can easily keep the files in the source code. And every time I wanted to add a new article, all I have to do is, add a new file to a folder and push the changes. But I am afraid, this creates friction and I will get too lazy to write anything. So, please let me know if you know of any platform that lets us host MDX files and also provides an option to edit the file right away online. For free, obviously.

Is it open-source and built-in public?

Since I am going to use Github pages for hosting, it is obviously going to be open source. But whether or not I am going to build the whole site in public is based on whether or not I have the energy to write everything about what I did. But I assure you, I will write about the problems I faced or about interesting things I learned in the process.

I got the idea of building a desktop app that helps the user to organize a folder full of images, based on a pattern like, years, months, or even dates. The idea is, to provide the user an option to select a folder that they want to organize, and also an option to select how they want to organize it. Like, as whether it should be collected in a folder based on year or month, or date.

Stuff we gonna use:

Initially, I thought of using flutter to build the desktop app. As flutter promises less memory size and takes short time to load the app when compared to electron apps. But later, I realized electron.js has a wide range of developer support and articles to find what I am looking for. Also, I wanted to widen my knowledge in javascript. So I thought it would be better to start with Electron. So the following are the things we gonna use.

• React app with create-react-app

• Install electron framework into it

• Find a way to access the terminal command to implement our requirement

Info about me, no one asked for

I am an Android developer, who predominantly codes in Kotlin and the native android framework. But occasionally I love to explore other frameworks of different domains. Web development is something I recently started exploring, and it is fun so far. I even managed to create a personal portfolio/blog/a place to brag about myself kinda thing with ReactJS. You can find it here.

When are we gonna start

If you are interested stay pretty close to this space. I have already created a base structure including the react app and electron framework added ready to go. Once it is done, I'll share the repository so that you can clone it and tag along.