DEV Community: Shah Poran

Unlocking the Power of Sealed Classes and Interfaces in Kotlin

Shah Poran — Thu, 04 May 2023 12:04:37 +0000

Sealed classes and sealed interfaces in Kotlin are powerful features for creating class hierarchies with restricted subtypes. These features enable developers to define a limited and predefined set of subtypes, while also preventing any new subtypes from being created outside of the hierarchy.
Sealed class

sealed class is a class that can only be subclassed in its own file. This means that all subclasses of the sealed class must be defined in the same file as the sealed class itself. Sealed classes are useful for representing restricted class hierarchies, whereas a value can only have a finite set of types.

Sealed classes in Kotlin are useful in a variety of scenarios where you have a limited set of possible data types, and you want to represent them in a type-safe manner. Now I will demonstrate some common and rare use cases for sealed classes.
Representing the result of an operation:

Sealed classes can be used to represent the result of an operation, where the result can either be successful or contain an error. For example, the following code defines a sealed class Result with two subclasses: Success and Error.

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

You can make it generic also

sealed class Result<out T>
data class Success<out T>(val data: T) : Result<T>()
data class Error(val message: String) : Result<Nothing>()

In this above example, the Result class is sealed and has two subclasses: Success and Error. These subclasses can only be defined in the same file as the Result class.

Modeling state in a finite state machine: Sealed classes can be used to model the different states in a finite state machine. For example, the following code defines a sealed class State with two subclasses: Loading and Loaded.

sealed class State
object Loading : State()
data class Loaded(val data: String) : State()

Representing a fixed set of data types: Sealed classes can be used to represent a fixed set of data types, such as different types of shapes. The following code defines a sealed class Shape with three subclasses: Circle, Rectangle, and Triangle.

sealed class Shape
class Circle(val radius: Double) : Shape()
class Rectangle(val width: Double, val height: Double) : Shape()
class Triangle(val base: Double, val height: Double) : Shape()

Implementing the Visitor pattern: Sealed classes can be used to implement the Visitor pattern, which allows you to define operations on a hierarchy of types without modifying their implementation. For example, the following code defines a sealed class Expression with two subclasses: Number and Sum. It also defines an interface Visitor with two methods: visitNumber and visitSum. Each subclass of Expression implements the accept method to call the appropriate method on the Visitor.

sealed class Expression {
    abstract fun accept(visitor: Visitor): Int
}

class Number(val value: Int) : Expression() {
    override fun accept(visitor: Visitor): Int = visitor.visitNumber(this)
}

class Sum(val left: Expression, val right: Expression) : Expression() {
    override fun accept(visitor: Visitor): Int = visitor.visitSum(this)
}

interface Visitor {
    fun visitNumber(number: Number): Int
    fun visitSum(sum: Sum): Int
}

Implementing algebraic data types: Sealed classes can be used to implement algebraic data types, which are types composed of simpler types. The following code defines a sealed class Expr with three subclasses: Value, Add, and Multiply. The Value subclass contains a single Double value, while the Add and Multiply subclasses contain two Expr values.

sealed class Expr {
    abstract fun eval(): Double
}

data class Value(val value: Double) : Expr() {
    override fun eval(): Double = value
}

data class Add(val left: Expr, val right: Expr) : Expr() {
    override fun eval(): Double = left.eval() + right.eval()
}

data class Multiply(val left: Expr, val right: Expr) : Expr() {
    override fun eval(): Double = left.eval() * right.eval()
}

You can read full article from here

Creating a Floating Alert Dialog like google translate with Material Design 3 in android

Shah Poran — Sat, 04 Jun 2022 05:19:07 +0000

I’m going to show you how to create a Floating alert dialog like tap to translate features in the google translate app using a material design 3. The google translate app can open a floating alert dialog wherever you want to select a text. My approach is simple. At first, I will create a translucent theme that actually inheritance from Theme.Material3.DayNight.NoActionBar after that, I will set the theme for the activity which will open when a floating dialog appears on the screen. You can read the full article from here, https://poran-cse.medium.com/creating-a-floating-alert-dialog-like-google-translate-with-material-design-3-in-android-4b5cbab57571

Flutter Overlay loader

Shah Poran — Sat, 14 May 2022 08:50:17 +0000

flutter_overlay_loader

A simple Flutter package for managing loader when
fetching remote data or any long running async task. Flutter overlay loader is easy to use.
You can show loader using only write two lines of code.

Overlay loader without overlaying Appbar

Overlay Loader without overlaying BottomAppBar and also overlaying AppBar

Getting Started

Installing

dependencies:
  flutter_overlay_loader: ^1.0.8

Import

import 'package:flutter_overlay_loader/flutter_overlay_loader.dart';

How To Use

When start network call then call this line of code..

Loader.show(context,progressIndicator:LinearProgressIndicator());

After finished network call then call :

Loader.hide();

You can customize this loader..

Loader.show(context,
  isSafeAreaOverlay: false,
  isBottomBarOverlay: false,
  overlayFromBottom: 80,
  overlayColor: Colors.black26,
  progressIndicator: CircularProgressIndicator(backgroundColor: Colors.red),
  themeData: Theme.of(context)
    .copyWith(colorScheme: ColorScheme.fromSwatch().copyWith(secondary: Colors.green))
);

You can also check loader is showing or not using the property :


 and you can
prevent back pressed like this snippet:



```dart
WillPopScope(
  child: //TODO , 
  onWillPop:()async => !Loader.isShown
)

Finally dispose call hide method on dispose method :

@override
void dispose() {
  Loader.hide();

  super.dispose();
}