A business owner instantly knows the financial state and the business’ needs at a quick glance if the books are well-maintained. Without one, well… the business is adrift, and unable to succeed long-term, even when making recurrent small profits.

With booming businesses entering the digital realm, the role of accounting software has become more and more apparent.

Amid the increasing adoption of Software as a Service (SaaS) for accounting purposes, Tigg stands out as a crucial tool in the Nepali business landscape for financial management.

Tigg app is an easy-to-use accounting software specially designed for restros and wholesale/retail businesses after an in-depth research about the most common pitfalls that SMEs in Nepal face when getting off the ground. With Tigg, you can create tasks on the fly from anywhere, easily manage the data of your customers and products, and seamlessly integrate it with your current system.

From real-time reporting to customizable branding, Tigg’s tailored approach to the nuances of businesses remarkably solves the most frequently-made issues in accounting. In this blog, let’s explore 5 most commonly encountered problems for SMEs in accounting and how Tigg solves it to ensure a smoother voyage toward financial success for its businesses:

1. Document Records

Misplacing documents such as invoices, bills, and receipts can lead to incomplete or inaccurate financial records, which in turn can result in errors in financial reporting and decision-making. This apparently is a common hiccup for businesses, especially during an audit or tax enquiry.

Tigg solves this issue with its robust Document Management feature. With Tigg, you can simply snap pictures of your invoices and bills, and Tigg organizes them neatly in one place. This not only makes record-keeping easy but also ensures quick access to essential documents when needed.

2. User Access Headaches

When businesses use accounting software, they often have multiple team members who need varying levels of access to the system. Inadequate user access controls can compromise the confidentiality of sensitive information, leading to violations and breaches.

Similarly, highly restricted user access can hinder collaboration and workflow efficiency. Managing user permissions can be a headache, especially as your team grows.

Tigg simplifies this with its User Management feature. You can create multiple users with specific permissions, enhancing security and streamlining collaboration by focusing individuals on their designated tasks, all the while providing a tamper-proof activity log for every action taken. User comments and notes can be seamlessly incorporated, enhancing communication and collaboration. And all of this is easily accessible on your dashboard.

3. Real-Time Reporting and Insights

Waiting for accounting and tax reports can hinder a business’s ability to make timely and informed decisions.

TiggApp addresses this challenge by providing up-to-the-minute insights, allowing businesses to stay on top of their finances and make adjustments promptly. Tigg provides Real-Time Reports, offering up-to-the-minute insights. This empowers businesses to make timely adjustments and strategic decisions based on accurate and current financial data.

4. Cloud-Based Accessibility from Anywhere

Traditional accounting software ties you down to a specific location, hindering remote work. Tigg breaks these chains with its Cloud-Based Solution. You can access your financial data from anywhere with an internet connection while enjoying automatic updates, real-time collaboration, and robust security measures, including data encryption and regular backups.

Tigg is a versatile tool that goes beyond traditional accounting software, addressing common mistakes with great features. By streamlining document management, offering customization options, simplifying user management, providing real-time reports, and embracing a cloud-based approach, Tigg becomes a valuable asset for SMEs in Nepal.

5. Customization and Branding

Customising reports and aligning them with a brand image is crucial for a company to present a professional and cohesive image to clients and stakeholders. It allows businesses to maintain consistency in their communication and reinforces their brand identity. Maintaining a consistent brand image is crucial for any business.

Tigg addresses the problem of generic quotes and invoices with extensive customization options, all the while ensuring that your financial information is complete and accurate. You can tailor your quotes and invoices to match your company branding, creating a professional and cohesive image for your clients.

Conclusion

Beyond core accounting, what truly separates Tigg from other software is how it manages all documents, tasks, and contacts. Tigg can manage accounting, restaurants, wholesale, and retail shops using a single cloud-based software.

Developed with non-accountants in mind, Tigg is user-friendly and can be set up within a few hours to a day, depending on your data size. Get the most efficient way to manage accounting & finance for modern businesses with Tigg.

To learn more about Tigg and its services, visit https://www.tiggapp.com/ or shoot us a mail at:

There are different approaches you can do this. How you keep track of your finances mainly depends on the size of your company and its financial complexity. Self-employed individuals or freelancers might opt for manual bookkeeping methods, using a notebook and pen. Small businesses might smell a need for organizing everything into spreadsheets so that it helps with saving time and future reference.

But as your business expands and financial intricacies grow, relying solely on these methods may result in a tangled web of finances. While automating certain processes may initially seem efficient, it could lead to a spaghetti of accounts, requiring frequent manual intervention and rendering the software ineffective. This, in turn, may incur additional costs through hired personnel for data entries, lost time, diminished client trust, and a less reliable financial tracking system overall.

At this point, you might opt for a one-time cost on an on-premise software like Tally, or paying a recurring subscription fee for a SaaS (Software as a Service). In this blog, we’ll dive deeper into the pros and cons of using both traditional software and SaaS for your business, and understand total costs of ownership for what suits your business the best, so that you don’t have to.

1. Cost

Traditional software usually requires a one-time purchase, which can be a significant upfront cost, but there are no recurring fees unless you opt for updates or support. On the other hand, SaaS operates on a subscription model, meaning you pay a recurring fee, often monthly or annually. This can be more manageable for businesses with tight cash flow. SaaS services are scalable, meaning you can increase or decrease your service usage, but you’ll always end up paying only for what you use.

2. Installation Methods

Traditional software needs to be installed on each device that will use it, which can be time-consuming and require technical knowledge. SaaS, however, is cloud-based and accessible via the internet, eliminating the need for installation and making it easier to get up and running.

3. Accessibility and Device Dependency

With traditional software, you’re limited to the device it’s installed on, which can restrict when and where you can access your financial data. SaaS offers more flexibility on this, with the ability to access your data from any device as long as you have a stable internet connection, making it a good option for businesses with remote workers or multiple locations.

4. General vs Tailored

Traditional software may offer a more comprehensive feature set, but it may also include many features you don’t need, making it more complex to use. SaaS providers often offer a range of plans with different features, allowing you to choose the one that best fits your business needs and budget.

5. Security

Both traditional software and SaaS have their own security considerations. With traditional software, your data is stored on your own servers or devices, so you have full control over its security. However, this also means you’re responsible for maintaining that security. SaaS providers store data on the cloud and handle security on their end. Often, the resources employed by SaaS providers use robust security measures, but you’re entrusting your sensitive financial data to a third party.

6. Server Setup

Traditional software requires you to have your own server setup, which can be costly and require ongoing maintenance. SaaS is hosted on the provider’s servers, reducing the need for you to invest in and maintain your own server infrastructure.

7. Compatibility

Traditional software may not always play well with other systems you’re using, which can lead to inefficiencies and frustration. SaaS is typically designed to integrate easily with other popular software, helping to streamline your workflows.

The choice between traditional software and SaaS depends on your specific business needs, budget, and resources. There are multiple accounting software providers but it is difficult to carefully consider what suits your business the best.

Incurred Cost of Ownership over x years for both softwares

That is why we have Tigg. Tigg is the ultimate, all in one business management software, aimed at small and medium businesses (MSMEs) to manage all your business needs such as Accounting, CRM and sales in a single place.

Our cloud-based accounting system is specially designed to target the needs of Nepali SMEs to manage their finances & taxes so that we can give you real-time business intelligence you need to chase growth.

With SaaS’s cloud-based model today, we not only enjoy easily elastic and accessible resources, but don’t have to worry about the huge upfront and maintenance costs either.

But in exchange for relieving these critical pain points, the trade-off has been security and our data privacy.

SaaS companies deal with fabulously large amounts of customer data and that’s why they end up spending loads to safeguard our data within secure walls.

But it’s just as fabulous to see a whole lot of big, fat companies who are practically tripping over themselves to sell this precious data for a quick buck.

Efforts for SaaS Privacy in Nepal

To prevent this, you might’ve heard of privacy guidelines GDPR, HIPAA, CCPA, and regulatory bodies being established who can take matters in their hands while our data rests in the hands of these companies.

Nepal too has made several efforts with the evolving need to safeguard our privacy. Article 29 of our Constitution declares the right to privacy as a “fundamental right.”

And we’ve seen several iterations such as the Individual Privacy Act, 2075, and the Individual Privacy Regulation, 2077 being enacted over the years. According to these, violating anybody’s privacy is a criminal offence whereby the victim can call for a criminal proceeding if their data is found to be collected or disclosed without their consent.

For such heinous criminal offences, the enormous price to pay has been a fine of Rs 30,000 fine, 3 years of prison, or both according to The Privacy Act.

As SaaS providers, it remains our topmost priority to safeguard our customer data with all means possible.

Maintain Data Privacy for Competitive Advantage in SaaS

1. Data and Data Security Compliance

Being compliant effectively builds unfair advantages for companies in the industry. Not only does this reduce the cybersec risks to the company infrastructure, but it also boosts customer loyalty and trust, and therefore, increases the company’s ROI.

Although they sound similar, data security compliance and data compliance are two different things.

Data security compliance primarily deals with how data is protected against breaches, loss, and unauthorized access.

Data compliance, however, covers much more than that. It includes how a company stores, transmits and uses information for their business operations.

Companies invest in both compliances to protect their customers’ data and to maintain industry standards like GDPR and HIPAA. Compliance violations usually end up in costly penalties, fines, and long-term repercussions on a business's reputation.

Cost of Damage due to Compliance Violation

2. PII and Data Masking

PII, or Personally Identifiable Information, includes everything from names and addresses to email addresses, social security numbers, phone numbers, credit card numbers, and employee identification numbers.

Anything that can identify you or access your personal information is PII.

Data masking methods include encryption (securing data with keys), substitution (replacing with similar data), shuffling (random replacement within columns), scrambling (rearranging numerical data), and nulling (replacing with null values for select users) to protect sensitive information while maintaining data utility.

With dynamic data masking, the stored data is masked in real-time, on-the-fly without exposing any personal data thus, ensuring the integrity of the user’s personal info.

Final Thoughts

Adding to these, if a company’s security architecture is compromised, it becomes highly vulnerable to cyber threats.

By integrating these data privacy principles into their business and IT strategies, companies can obtain a competitive advantage and respect customers’ preferences while improving their brand image, customer trust, and market position.

Article Assumes the Reader knows basics of Flutter.

The Problem

Your Designer gives you these buttons and now you gotta implement them in Flutter.

At first glance, you see that it’s 2 different types of buttons :

1. Button with Text
2. Button with Icon and Text

How not to code these components?

There are clearly 2 components but since you’re clever you decide to implement it as a single component and make it reusable as follows :

Button With Text

// ignore_for_file: public_member_api_docs, sort_constructors_first
import 'package:flutter/material.dart';

class CustomButton extends StatelessWidget {
  final String? title;
  final Widget? child;
  final void Function() onTap;
  final Color? color;

  const CustomButton({
    Key? key,
    this.title,
    this.child,
    required this.onTap,
    this.color,
  })  : assert(title != null || child != null),
        super(key: key);

  @override
  Widget build(BuildContext context) {
    return TextButton(
      onPressed: onTap,
      style: TextButton.styleFrom(
        backgroundColor: color ?? const Color(0xff006836),
        shape: RoundedRectangleBorder(
          borderRadius: BorderRadius.circular(6),
        ),
      ),
      child: title != null
          ? Text(
              title!,
              style: const TextStyle(color: Colors.white),
            )
          : child!,
    );
  }
}

Then, you make a new component for the Button With Icon by reusing the old component as :

Button With Icon

class CustomButtonWithIcon extends StatelessWidget {
  final IconData icon;
  final String title;
  final Color? color;
  final void Function() onTap;

  const CustomButtonWithIcon({
    Key? key,
    required this.icon,
    required this.title,
    required this.onTap,
    this.color,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return CustomButton(
      color: color,
      onTap: onTap,
      child: Row(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Icon(icon, color: Colors.white),
          const SizedBox(width: 4),
          Text(
            title,
            style: const TextStyle(color: Colors.white),
          ),
          const SizedBox(width: 4),
          const Icon(
            Icons.chevron_right,
            color: Colors.white,
          ),
        ],
      ),
    );
  }
}

Implementing it this way works but by writing CustomButton and passing it all the parameters, you have essentially duplicated code.

For the small number of parameters, this might not be a problem but for large numbers of parameters (and this will happen specially when working with Flutter) the number of duplications is unreasonable.

So, what to do then?

There is Another Way !!!

This is where the power of Object Oriented Programming comes in.

To remove these duplications we can implement these buttons by using inheritance as follows :

abstract class AppButton extends TextButton {
  AppButton({
    super.key,
    required super.onPressed,
    required super.child,
    Color? color,
  }) : super(
          style: TextButton.styleFrom(
            backgroundColor: color ?? const Color(0xff006836),
            shape: RoundedRectangleBorder(
              borderRadius: BorderRadius.circular(6),
            ),
          ),
        );
}

Button with Text

class CustomButton extends AppButton {
 CustomButton({
 super.key,
 required super.onPressed,
 required String title,
 super.color,
 }) : super(
 child: Text(
 title,
 style: const TextStyle(color: Colors.white),
 ),
 );
}

Button With Icon

class CustomButtonWithIcon extends AppButton {
  CustomButtonWithIcon({
    super.key,
    required super.onPressed,
    required String title,
    required IconData icon,
    super.color,
  }) : super(
          child: Row(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Icon(icon, color: Colors.white),
              const SizedBox(width: 4),
              Text(
                title,
                style: const TextStyle(color: Colors.white),
              ),
              const SizedBox(width: 4),
              const Icon(
                Icons.chevron_right,
                color: Colors.white,
              ),
            ],
          ),
        );
}

All this is made possible because we build UI components in Flutter using Dart classes.

This is just a simple idea.

However,
This idea is very powerful, it’s not only useful for simple and stateless UI components like buttons but it can be used for Stateful Screens. The only difference with implementing such idea with Stateful Screens is that the base abstraction (i.e. The abstract class)
will extend State<T extends StatefulWidget> instead of extending StatelessWidget .

This technique can help reduce a lot of duplicate code and make the code cleaner.

Originally published at https://medium.com on September 6, 2023.

This article only covers text recognition in device without use of any cloud platforms.

Flutter is Google’s Solution for building blazing-fast UIs.

Since Flutter is simply only for UIs all the complex stuff like Text Recognition if done in native platforms. So, all we need to do is call the native APIs.

There are packages in Flutter that help us to call these native APIs.
All we need to do in Flutter is obtain the image and then call the native APIs via the package and pass the image.

This article covers 2 packages to recognize text :
1. google_mlkit_text_recognition
2. flutter_tesseract_ocr

The code for the project can be found here.

GitHub - SushanShakya/text_recognition_flutter

Before we deal with these packages, let’s see how we can get the image for processing.

Obtaining Image

Add the dependency for image_picker :

dependencies:
  flutter:
    sdk: flutter
  ...
  image_picker: ^1.0.0
  ...

We also need to update the minSdkVersion to 21 or higher inside app/build.gradle :

defaultConfig {
  ...
  minSdkVersion 21
  ...
}

Now,
We create a page with a floating button to pick image as follows :

import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';

class Home extends StatefulWidget {
  const Home({super.key});

  @override
  State<Home> createState() => _HomeState();
}

class _HomeState extends State<Home> {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Text Recognition'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () {},
        child: const Icon(Icons.add),
      ),
      body: Container(),
    );
  }
}

When, the user taps on the button we want to show them options to get image from camera or gallery. For this we can create a separate function to render a Alert Dialog as follows :

import 'package:flutter/material.dart';

Widget imagePickAlert({
  void Function()? onCameraPressed,
  void Function()? onGalleryPressed,
}) {
  return AlertDialog(
    title: const Text(
      "Pick a source:",
    ),
    content: Column(
      mainAxisSize: MainAxisSize.min,
      children: [
        ListTile(
          leading: const Icon(Icons.camera_alt),
          title: const Text(
            "Camera",
          ),
          onTap: onCameraPressed,
        ),
        ListTile(
          leading: const Icon(Icons.image),
          title: const Text(
            "Gallery",
          ),
          onTap: onGalleryPressed,
        ),
      ],
    ),
  );
}

Then,
When the floating button is tapped, we can show the dialog as :

...
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          showDialog(
            context: context,
            builder: (context) => imagePickAlert(
              onCameraPressed: () {
                // Pick image from Camera
              },
              onGalleryPressed: () {
                // Pick image from Gallery
              },
            ),
          );
        },
        child: const Icon(Icons.add),
      ),
...

We can get image from camera or gallery by using image_picker package as follows :

import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';

import 'image_widget.dart';

class Home extends StatefulWidget {
  ...
}

class _HomeState extends State<Home> {
  late ImagePicker _picker;

  @override
  void initState() {
    super.initState();
    _picker = ImagePicker();
  }

  Future<String?> obtainImage(ImageSource source) async {
    final file = await _picker.pickImage(source: source);
    return file?.path;
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...
    );
  }
}

Here,
obtainImage() function can be called to get image.
This can be done as follows :

...
showDialog(
  context: context,
  builder: (context) => imagePickAlert(
  onCameraPressed: () async {
    final imgPath = await obtainImage(ImageSource.camera);
    ...
    Navigator.of(context).pop();
  },
  onGalleryPressed: () {
    final imgPath = await obtainImage(ImageSource.gallery);
    ...                
    Navigator.of(context).pop();
  },
 ),
);
...

Now,
We can start working on processing the image as we’re able to get image using image_picker .

For processing image to recognize text we’ll create our own abstraction as :

abstract class ITextRecognizer {
 Future<String> processImage(String imgPath);
}

Using [google_mlkit_text_recognition]

Add dependency for google_mlkit_text_recognition :

dependencies:
  flutter:
    sdk: flutter
  
  ...
  google_mlkit_text_recognition: ^0.8.1
  ...

Now,
We create a MLKitTextRecognizer for recognizing text as :

import 'dart:io';
import 'package:google_mlkit_text_recognition/google_mlkit_text_recognition.dart';
import 'interface/text_recognizer.dart';

class MLKitTextRecognizer extends ITextRecognizer {
  late TextRecognizer recognizer;

  MLKitTextRecognizer() {
    recognizer = TextRecognizer();
  }

  void dispose() {
    recognizer.close();
  }

  @override
  Future<String> processImage(String imgPath) async {
    final image = InputImage.fromFile(File(imgPath));
    final recognized = await recognizer.processImage(image);
    return recognized.text;
  }
}

We can create an instance for it as :

...

class _HomeState extends State<Home> {
  late ImagePicker _picker;
  late ITextRecognizer _recognizer;

  @override
  void initState() {
    super.initState();
    _picker = ImagePicker();
    _recognizer = MLKitTextRecognizer();
  }

  @override
  void dispose() {
    super.dispose();
    if(_recognizer is MLKitTextRecognizer) {
      (_recognizer as MLKitTextRecognizer).dispose();
    }
  }

  Future<String?> obtainImage(ImageSource source) async {
    final file = await _picker.pickImage(source: source);
    return file?.path;
  }


  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...
    );
  }
}

...

We then create a function to process the image as :

....

class _HomeState extends State<Home> {

  ...
  void processImage(String imgPath) async{
    final recognizedText = await _recognizer.processImage(imgPath);
    ...
  }
  ...

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...
    );
  }
}

....

Here,
After we have processed the image, we would like to show it in the UI.
For showing it in our UI we need 2 piece of information :
1. The Image File
2. The Recognized Text

So, we’ll create a data class for it as :

class RecognitionResponse {
  final String imgPath;
  final String recognizedText;

  RecognitionResponse({
    required this.imgPath,
    required this.recognizedText,
  });

  @override
  bool operator ==(covariant RecognitionResponse other) {
    if (identical(this, other)) return true;

    return other.imgPath == imgPath && other.recognizedText == recognizedText;
  }

  @override
  int get hashCode => imgPath.hashCode ^ recognizedText.hashCode;
}

Then, we create a variable of type RecognitionResponse in HomeState as :

class _HomeState extends State<Home> {
  
  ...
  RecognitionResponse? _response;
  ...

  @override
  Widget build(BuildContext context) {
    ...
  }
}

Now,
We can set this variable from processImage() as :

 ...

  void processImage(String imgPath) async{
    final recognizedText = await _recognizer.processImage(imgPath);
    setState(() {
      _response = RecognitionResponse(imgPath: imgPath, recognizedText: recognizedText);
    });
  }

  ...

We will call processImage() when image is selected.

...
showDialog(
  context: context,
  builder: (context) => imagePickAlert(
  onCameraPressed: () async {
    final imgPath = await obtainImage(ImageSource.camera);
    if(imgPath == null) return;
    processImage(imgPath);
    Navigator.of(context).pop();
  },
  onGalleryPressed: () {
    final imgPath = await obtainImage(ImageSource.gallery);
    if(imgPath == null) return;
    processImage(imgPath);
    Navigator.of(context).pop();
  },
 ),
);
...

Finally,
We need to show the image and recognized text in the UI when _response variable is not null.

class _HomeState extends State<Home> {

  ...

  RecognitionResponse? _response;

  ...

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Text Recognition'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          showDialog(
            context: context,
            builder: (context) => imagePickAlert(
              onCameraPressed: () async {
                final imgPath = await obtainImage(ImageSource.camera);
                if (imgPath == null) return;
                processImage(imgPath);
                Navigator.of(context).pop();
              },
              onGalleryPressed: () async {
                final imgPath = await obtainImage(ImageSource.gallery);
                if (imgPath == null) return;
                processImage(imgPath);
                Navigator.of(context).pop();
              },
            ),
          );
        },
        child: const Icon(Icons.add),
      ),
      body: _response == null
          ? const Center(
              child: Text('Pick image to continue'),
            )
          : ListView(
              children: [
                SizedBox(
                  height: MediaQuery.of(context).size.width,
                  width: MediaQuery.of(context).size.width,
                  child: Image.file(File(_response!.imgPath)),
                ),
                Padding(
                    padding: const EdgeInsets.all(16),
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Row(
                          children: [
                            Expanded(
                              child: Text(
                                "Recognized Text",
                                style: Theme.of(context).textTheme.titleLarge,
                              ),
                            ),
                            IconButton(
                              onPressed: () {
                                Clipboard.setData(
                                  ClipboardData(
                                      text: _response!.recognizedText),
                                );
                                ScaffoldMessenger.of(context).showSnackBar(
                                  const SnackBar(
                                    content: Text('Copied to Clipboard'),
                                  ),
                                );
                              },
                              icon: const Icon(Icons.copy),
                            ),
                          ],
                        ),
                        const SizedBox(height: 10),
                        Text(_response!.recognizedText),
                      ],
                    )),
              ],
            ),
    );
  }
}

Ta-da, your app is now able to recognize text from image.

Using [flutter_tesseract_ocr]

Add dependency for flutter_tesseract_ocr as :

dependencies:
  flutter:
    sdk: flutter
  ...
  flutter_tesseract_ocr: ^0.4.23
  ...

Then,
Download the trained data for English language from here.
The file is called eng.traineddata

Once downloaded, copy the file to assets/tessdata as :

Now,
We need to create a configuration file in assets/tessdata_config.json as :

Inside tessdata_config.json we add following content:

{
    "files": [
        "eng.traineddata"
    ]
}

Then, we have to include the asset file into the flutter project by adding entry to pubspec.yaml :

...
  assets:
    - assets/
    - assets/tessdata/
...

Now,
We create TesseractTextRecognizer for recognizing text as :

import 'package:flutter_tesseract_ocr/android_ios.dart';
import 'package:ml_kit_test/recognition/interface/text_recognizer.dart';

class TesseractTextRecognizer extends ITextRecognizer {
 @override
 Future<String> processImage(String imgPath) async {
 final res = await FlutterTesseractOcr.extractText(imgPath, args: {
 "psm": "4",
 "preserve_interword_spaces": "1",
 });
 return res;
 }
}

We can use the same UI as we used for google_mlkit_text_recognition .

The only thing we need to change is the initialization of _recognizer as :

 @override
  void initState() {
    super.initState();
    ...
    _recognizer = TesseractTextRecognizer();
    ...
  }

import 'dart:io';

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:image_picker/image_picker.dart';
import 'package:ml_kit_test/model/recognition_response.dart';
import 'package:ml_kit_test/recognition/interface/text_recognizer.dart';
import 'package:ml_kit_test/recognition/text_recognition_service.dart';

import 'image_widget.dart';

class Home extends StatefulWidget {
  const Home({super.key});

  @override
  State<Home> createState() => _HomeState();
}

class _HomeState extends State<Home> {
  late ImagePicker _picker;
  late ITextRecognizer _recognizer;

  RecognitionResponse? _response;

  @override
  void initState() {
    super.initState();
    _picker = ImagePicker();
    _recognizer = TesseractTextRecognizer();
  }

  @override
  void dispose() {
    super.dispose();
    if (_recognizer is MLKitTextRecognizer) {
      (_recognizer as MLKitTextRecognizer).dispose();
    }
  }

  void processImage(String imgPath) async {
    final recognizedText = await _recognizer.processImage(imgPath);
    setState(() {
      _response =
          RecognitionResponse(imgPath: imgPath, recognizedText: recognizedText);
    });
  }

  Future<String?> obtainImage(ImageSource source) async {
    final file = await _picker.pickImage(source: source);
    return file?.path;
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Text Recognition'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          showDialog(
            context: context,
            builder: (context) => imagePickAlert(
              onCameraPressed: () async {
                final imgPath = await obtainImage(ImageSource.camera);
                if (imgPath == null) return;
                processImage(imgPath);
                Navigator.of(context).pop();
              },
              onGalleryPressed: () async {
                final imgPath = await obtainImage(ImageSource.gallery);
                if (imgPath == null) return;
                processImage(imgPath);
                Navigator.of(context).pop();
              },
            ),
          );
        },
        child: const Icon(Icons.add),
      ),
      body: _response == null
          ? const Center(
              child: Text('Pick image to continue'),
            )
          : ListView(
              children: [
                SizedBox(
                  height: MediaQuery.of(context).size.width,
                  width: MediaQuery.of(context).size.width,
                  child: Image.file(File(_response!.imgPath)),
                ),
                Padding(
                    padding: const EdgeInsets.all(16),
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Row(
                          children: [
                            Expanded(
                              child: Text(
                                "Recognized Text",
                                style: Theme.of(context).textTheme.titleLarge,
                              ),
                            ),
                            IconButton(
                              onPressed: () {
                                Clipboard.setData(
                                  ClipboardData(
                                      text: _response!.recognizedText),
                                );
                                ScaffoldMessenger.of(context).showSnackBar(
                                  const SnackBar(
                                    content: Text('Copied to Clipboard'),
                                  ),
                                );
                              },
                              icon: const Icon(Icons.copy),
                            ),
                          ],
                        ),
                        const SizedBox(height: 10),
                        Text(_response!.recognizedText),
                      ],
                    )),
              ],
            ),
    );
  }
}

Boom,
We can use the same UI but handle image processing using 2 different packages because we created our own abstraction for text recognition.

Originally published at https://medium.com on July 2, 2023.

Article assumes user has some familiarity with git

Consider that we have 2 developers working on 2 different features,
the Git tree in this case will look as follows :

Here,
These 2 developers are working parallelly on 2 different features.
We can think of feature1 and feature2 as being 2 parallel worlds or different timelines of the future.

In fact, the dev branch doesn't have any idea about feature1 or feature2 .

Now,
Let’s say that both feature1 and feature2 are completed at the same time.

In such case,
Developer of feature1 will create a pull request from feature1 to dev .
Developer of feature2 will create a pull request from feature2 to dev .

This point is time is the decisive moment.

dev is our main timeline, we can pick to merge feature1 or feature2 .

Picking feature1

Let’s say we pick to merge feature1 first then our main timeline will be that, our project state was in dev then feature1 was added. The git tree will look like :

Here,
dev now knows that feature1 has happened.
It doesn't know anything about feature2 .

feature2 knows about old dev but doesn't know anything about feature1 being part of dev .

If we want the feature2 branch to know about changes and addition of feature1 to dev then we can rebase feature2 .

Rebasing

The idea of rebasing is simple.
We’ll break the feature2 branch from it's origination point and then attach it somewhere else. Let's look at the tree to understand this :

To break it off it’s base and attach it to the new dev commits, we can use the following command :

(feature2) ~ git rebase dev

(feature2) indicates that we are currently in feature2 branch

This command then breaks off the base of feature2 and attaches it to the dev . We can visualize it as :

Now,
feature2 knows about the existence of feature1 which is merged into dev .

This is one of the powers of rebasing.

When rebasing we might have merge conflicts if feature1 and feature2 branch have changes to the same file. In such case, we resolve the merge conflicts, then add the resolved files as :

(feature2) (rebasing) ~ git add .

Then, we continue with rebasing as :

(feature2) (rebasing) ~ git rebase — continue

If we want to cancel the rebase, we use :

(feature2) (rebasing) ~ git rebase — abort

We can do the similar thing if we wanted to merge feature2 before feature1 .

Originally published at https://medium.com on June 29, 2023.

Article uses BLoC as a state management solution.

To integrate Connect IPS in Flutter we need to use WebView.

Connect IPS is very different from other payment gateways like E-sewa or Khalti because it sends out response as HTML.
So, to work with Connect IPS we need to use WebView in Flutter.

Before we begin integrating Connect IPS we must first establish how our software is going to handle payments. Connect IPS requires an encrypted token to be generated. It is a good idea to generate this token from the backend.
We also want all the params required to start the payment to be generated by the backend and the frontend (i.e The Mobile App) will only send a request to the Connect IPS server to start the payment.

The following will be the flow for the app :

Here,
We’re only interested in Connect IPS payment so, following is the flow we want to focus on :

# Steps to integrate

Step #1

Add the following dependency to pubspec.yaml :

dependencies:
 flutter:
 sdk: flutter
 webview_flutter: ^4.2.0

Step #2

Create a page for Connect IPS payment :

// ignore_for_file: public_member_api_docs, sort_constructors_first
import 'dart:convert';

import 'package:flutter/material.dart';
import 'package:webview_flutter/webview_flutter.dart';

class PaymentView extends StatefulWidget {
  final int purchaseId;

  const PaymentView({
    Key? key,
    required this.purchaseId,
  }) : super(key: key);

  @override
  State<PaymentView> createState() => _PaymentViewState();
}

class _PaymentViewState extends State<PaymentView> {
  late WebViewController controller;

  @override
  void initState() {
    super.initState();
    controller = WebViewController()
      ..setJavaScriptMode(JavaScriptMode.unrestricted)
      ..setBackgroundColor(const Color(0xffffffff))
      ..setNavigationDelegate(
        NavigationDelegate(
          onUrlChange: (value) {
            print('---- URL Change');
            print(value.url);
          },
          onProgress: (int progress) {
            // Update loading bar.
          },
          onPageStarted: (String url) {
            print('------ URL');
            print(url);
          },
          onPageFinished: (String url) {},
          onWebResourceError: (WebResourceError error) {},
          onNavigationRequest: (NavigationRequest request) {
            return NavigationDecision.navigate;
          },
        ),
      );
  }

  void initWebView(String content) {
    final uri = Uri.dataFromString(
      content,
      mimeType: 'text/html',
      encoding: Encoding.getByName('utf-8'),
    );

    controller.loadRequest(uri);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Payment'),
      ),
      body: WebViewWidget(
        controller: controller,
      ),
    );
  }
}

As we can see, a WebView is required because there is no other way to integrate Connect IPS except by using WebView .

Step #3

Create a mechanism to get the required params from the backend.

For this, we will follow the following flow :

The following is the json structure in which the backend will return the params :

{
  "MERCHANTID" : "<merchant-id>",
  "APPID" : "<app-id>",
  "APPNAME" : "<app-name>",
  "TXNID" : "<transaction-id>",
  "TXNDATE" : "<transaction-date>",
  "TXNCRNCY" : "<transaction-currency>",
  "TXNAMT" : "<transaction-amount>",
  "REFERENCEID": "<reference-id>",
  "REMARKS": "<remarks>",
  "PARTICULARS": "<particulars>",
  "TOKEN": "<encrypted-token>",
}

Then,
We will create an HTML string to send request to Connect IPS server to start the payment.

We will create a Cubit for this purpose as :

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import './dio.dart';

part 'connect_ips_payment_state.dart';

class ConnectIpsPaymentCubit extends Cubit<ConnectIpsPaymentState> {
  ConnectIpsPaymentCubit() : super(ConnectIpsPaymentInitial());

  Future<Map<String, dynamic>> _getParams(int purchaseId) async {
    final res = await dio.post('/getParams', dat: {
      "purchaseId": purchaseId,
    });
    return res.data;
  }

  Future<String> _getHtmlString(int purchaseId) async {
    final param = await _getParams(purchaseId);
    return """
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        const form = document.createElement("FORM");
        form.setAttribute("action", "https://uat.connectips.com/connectipswebgw/loginpage");
        form.setAttribute("target", "");
        form.setAttribute("method", "POST");

        const merchantIdElement = document.createElement("INPUT");
        merchantIdElement.setAttribute("name", "MERCHANTID");
        merchantIdElement.setAttribute("value", "${param['MERCHANTID']}");
        merchantIdElement.setAttribute("type", "hidden");
        form.appendChild(merchantIdElement);

        const appId = document.createElement("INPUT");
        appId.setAttribute("name", "APPID");
        appId.setAttribute("value", "${param['APPID']}");
        appId.setAttribute("type", "hidden");
        form.appendChild(appId);

        const appName = document.createElement("INPUT");
        appName.setAttribute("name", "APPNAME");
        appName.setAttribute("value", "${param['APPNAME']}");
        appName.setAttribute("type", "hidden");
        form.appendChild(appName);

        const txnId = document.createElement("INPUT");
        txnId.setAttribute("name", "TXNID");
        txnId.setAttribute("value", "${param['TXNID']}");
        txnId.setAttribute("type", "hidden");
        form.appendChild(txnId);

        const txnDate = document.createElement("INPUT");
        txnDate.setAttribute("name", "TXNDATE");
        txnDate.setAttribute("value", "${param['TXNDATE']}");
        txnDate.setAttribute("type", "hidden");
        form.appendChild(txnDate);

        const txnCurrency = document.createElement("INPUT");
        txnCurrency.setAttribute("name", "TXNCRNCY");
        txnCurrency.setAttribute("value", "${param['TXNCRNCY']}");
        txnCurrency.setAttribute("type", "hidden");
        form.appendChild(txnCurrency);

        const txnAmount = document.createElement("INPUT");
        txnAmount.setAttribute("name", "TXNAMT");
        txnAmount.setAttribute("value", "${param['TXNAMT']}");
        txnAmount.setAttribute("type", "hidden");
        form.appendChild(txnAmount);

        const referenceId = document.createElement("INPUT");
        referenceId.setAttribute("name", "REFERENCEID");
        referenceId.setAttribute("value", "${param['REFERENCEID']}");
        referenceId.setAttribute("type", "hidden");
        form.appendChild(referenceId);

        const remarks = document.createElement("INPUT");
        remarks.setAttribute("name", "REMARKS");
        remarks.setAttribute("value", "${param['REMARKS']}");
        remarks.setAttribute("type", "hidden");
        form.appendChild(remarks);

        const particulars = document.createElement("INPUT");
        particulars.setAttribute("name", "PARTICULARS");
        particulars.setAttribute("value", "${param['PARTICULARS']}");
        particulars.setAttribute("type", "hidden");
        form.appendChild(particulars);

        const token = document.createElement("INPUT");
        token.setAttribute("name", "TOKEN");
        token.setAttribute("value", "${param['TOKEN']}");
        token.setAttribute("type", "hidden");
        form.appendChild(token);

        // console.log(form);

        document.body.appendChild(form);
        form.submit();
    </script>
</body>

</html>
""";
  }

  Future<void> initiate(int purchaseId) async {
    emit(ConnectIpsPaymentLoading());
    try {
      final data = await _getHtmlString();
      emit(ConnectIpsPaymentLoaded(htmlString: data));
    } catch (e) {
      emit(const ConnectIpsPaymentFailed(message: "Failed"));
    }
  }
}

Note :
It is important to create a form in HTML and send the request otherwise it won’t work.

Step #4

Now,
We can use the cubit to start the payment as follows :

// ignore_for_file: public_member_api_docs, sort_constructors_first
import 'dart:convert';

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import './connect_ips_payment_cubit.dart';
import 'package:webview_flutter/webview_flutter.dart';
import './show_error.dart';

class PaymentView extends StatefulWidget {
  final int purchaseId;

  const PaymentView({
    Key? key,
    required this.purchaseId,
  }) : super(key: key);

  @override
  State<PaymentView> createState() => _PaymentViewState();
}

class _PaymentViewState extends State<PaymentView> {
  late ConnectIpsPaymentCubit cubit;
  late WebViewController controller;

  @override
  void initState() {
    super.initState();
    cubit = ConnectIpsPaymentCubit()..initiate(widget.purchaseId);
    controller = WebViewController()
      ..setJavaScriptMode(JavaScriptMode.unrestricted)
      ..setBackgroundColor(const Color(0xffffffff))
      ..setNavigationDelegate(
        NavigationDelegate(
          onUrlChange: (value) {
            print('---- URL Change');
            print(value.url);
          },
          onProgress: (int progress) {
            // Update loading bar.
          },
          onPageStarted: (String url) {
            print('------ URL');
            print(url);
          },
          onPageFinished: (String url) {},
          onWebResourceError: (WebResourceError error) {},
          onNavigationRequest: (NavigationRequest request) {
            return NavigationDecision.navigate;
          },
        ),
      );
  }

  void initWebView(String content) {
    final uri = Uri.dataFromString(
      content,
      mimeType: 'text/html',
      encoding: Encoding.getByName('utf-8'),
    );

    controller.loadRequest(uri);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Payment'),
      ),
      body: BlocConsumer<ConnectIpsPaymentCubit, ConnectIpsPaymentState>(
        bloc: cubit,
        listener: (context, state) {
          if (state is ConnectIpsPaymentFailed) {
            showErrorDialog(context);
            return;
          }
          if (state is ConnectIpsPaymentLoaded) {
            initWebView(state.htmlString);
          }
        },
        builder: (context, state) {
          if (state is ConnectIpsPaymentLoading) {
            return const Center(
              child: CircularProgressIndicator(),
            );
          }
          return WebViewWidget(
            controller: controller,
          );
        },
      ),
    );
  }
}

When the params are loaded then the app will successfully show the login page for Connect IPS to furthur continue the payment.

Originally published at https://medium.com on June 21, 2023.

If you search for managing routes in Flutter, all you get is a list of things you can do which usually always includes the following 3 :

#1 Unnamed Routes

...

Navigator.of(context).push(
  MaterialPageRoute(
    builder: (c) => const HomeView(),
  ),
);

...

#2 Named Routes

...

return MaterialApp(
  title: "Flutter Demo",
  routes: {
    "home": (c) => const HomeView(),
    "hotel": (c) => const HotelView(),
    "hotelDetail": (c) => const HotelDetailView(),
  },
  home: const HomeView(),
);

...

Usage:

Navigator.of(context).pushNamed("home");

#3 onGenerateRoute

...

return MaterialApp(
  title: "Flutter Demo",
  onGenerateRoute: Routes.onGenerateRoutes,
  initialRoute: Routes.home,
);

...

...

class Routes {
  static const String home = "home";
  
  static Route onGenerateRoutes(RouteSettings settings) {
    Widget child;
    
    switch(settings.name) {
      case Routes.home:
        child = const HomeView();
        break;
      default:
        child = Container();
        break;
    }

    return MaterialPageRoute(builder: (c) => child);
  }
}
...

Usage:

...

Navigator.of(context).pushNamed(Routes.home);

...

# The Problem

Let’s say you decided to use the advanced route management technique #3 onGenerateRoute .

Since your app can have a lot of routes, you’ll end up with a Routes class that has a mountain load of cases for the switch statements. Which might look something like this.

This makes it messy.
So, how do we make it clean and a bit more localized to it’s scope?

# The Solution

We can look at another discipline and see how they manage routes.
For example Django manages routes by localizing all URLs for each module to urls.py .

We can learn from this idea.

Here’s how we separate our routes :

First, we’ll store our routes in a Map object like we did in #2 Named Routes .

static Route onGenerateRoutes(RouteSettings settings) {
    var routes = {
      Routes.home: (context, settings) => const HomeView(),
    };
    try {
      final child = routes[settings.name];

      Widget builder(BuildContext c) => child!(c, settings);

      return MaterialPageRoute(
        builder: builder,
      );
    } catch (e) {
      throw const FormatException("--- Route doesn't exist");
    }
  }

Now,
We can refactor this such that we get the routes from another function as follows :

class Routes {
  static const String home = "home";

  static Map<String, RouteType> _resolveRoutes() {
    return {
      Routes.home: (context, settings) => const HomeView(),
    };
  }

  static Route onGenerateRoutes(RouteSettings settings) {
    var routes = _resolveRoutes();
    try {
      final child = routes[settings.name];

      Widget builder(BuildContext c) => child!(c, settings);

      return MaterialPageRoute(
        builder: builder,
      );
    } catch (e) {
      throw const FormatException("--- Route doesn't exist");
    }
  }
}

The _resolveRoutes() function can be refactored such that we have routes separated for each module.

What does that mean?
Well, let’s say you’re making a hotel booking app, then you might have the following pages :

1. Login View
2. Signup View
3. Hotel Listing View
4. Hotel Detail View

Here, Login View and Signup View are authorization routes so, we should group them into one route, Hotel Listing View and Hotel Detail View is associated with the Hotel so, it's a good idea to group them.

This can be done as follows :

static _resolveRoutes() {
  var authRoutes = {
    Routes.login: (c, s) => const LoginView(),
    Routes.signup: (c, s) => const SignupView(),
  };

  var hotelRoutes = {
    Routes.hotel: (c, s) => const HotelView(),
    Routes.hotelDetail: (c, s) => const HotelDetailView(),
  };

  return {
    Routes.home: (context, settings) => const HomeView(),
    ...authRoutes,
    ...hotelRoutes,
  }

Then, we can to a similar type of refactoring as before to get these routes from different files as :

import '../../modules/hotel/gui/views/login_view.dart';
import '../../modules/hotel/gui/views/signup_view.dart';
import 'app_routes.dart';

var authRoutes = {
  Routes.login: (context, settings) => const LoginView(),
  Routes.signup: (context, settings) => const SignupView(),
};

import '../../modules/hotel/gui/views/hotel_detail_view.dart';
import '../../modules/hotel/gui/views/hotel_view.dart';
import 'app_routes.dart';

var hotelRoutes = {
  Routes.hotel: (context, settings) => const HotelView(),
  Routes.hotelDetail: (context, settings) => const HotelDetailView(),
};

import 'package:flutter/material.dart';
import 'package:flutter_generalization/src/modules/hotel/gui/views/home_view.dart';
import 'auth_routes.dart';
import 'hotel_routes.dart';

class Routes {
  static const String home = 'home';
  static const String hotel = 'hotel';
  static const String hotelDetail = 'hotelDetail';
  static const String login = 'login';
  static const String signup = 'signup';

  static Map<String, RouteType> _resolveRoutes() {
    return {
      Routes.home: (context, settings) => const HomeView(),
      ...authRoutes,
      ...hotelRoutes,
    };
  }

  static Route onGenerateRoutes(RouteSettings settings) {
    var routes = _resolveRoutes();
    try {
      final child = routes[settings.name];

      Widget builder(BuildContext c) => child!(c, settings);

      return MaterialPageRoute(
        builder: builder,
      );
    } catch (e) {
      throw const FormatException("--- Route doesn't exist");
    }
  }
}

Then, we can refactor the Routes class by moving all the Route strings to a different file as follows :

class AppRoutes {
 static const String home = 'home';
 static const String hotel = 'hotel';
 static const String hotelDetail = 'hotelDetail';
 static const String login = 'login';
 static const String signup = 'signup';
}

class Routes {
  static Map<String, RouteType> _resolveRoutes() {
    return {
      AppRoutes.home: (context, settings) => const HomeView(),
      ...authRoutes,
      ...hotelRoutes,
      ...packageRoutes,
    };
  }

  static Route onGenerateRoutes(RouteSettings settings) {
    var routes = _resolveRoutes();
    try {
      final child = routes[settings.name];

      Widget builder(BuildContext c) => child!(c, settings);

      return MaterialPageRoute(
        builder: builder,
      );
    } catch (e) {
      throw const FormatException("--- Route doesn't exist");
    }
  }
}

Then,
We also update the files where the routes were defined to use AppRoutes .

import '../../modules/hotel/gui/views/login_view.dart';
import '../../modules/hotel/gui/views/signup_view.dart';
import 'app_routes.dart';

var authRoutes = {
  Routes.login: (context, settings) => const LoginView(),
  Routes.signup: (context, settings) => const SignupView(),
};

import '../../modules/hotel/gui/views/hotel_detail_view.dart';
import '../../modules/hotel/gui/views/hotel_view.dart';
import 'app_routes.dart';

var hotelRoutes = {
  Routes.hotel: (context, settings) => const HotelView(),
  Routes.hotelDetail: (context, settings) => const HotelDetailView(),
};

This is good enough to be used in projects.
But we can take it one step further by adding types to the Map object.

# Adding Types

First, we create a type definition as follows :

import 'package:flutter/material.dart';
typedef RouteType = Widget Function(BuildContext, RouteSettings);

Then, we add the return type for _resolveRoute() function as :

  ...
  
  static Map<String, RouteType> _resolveRoutes() {
    return {
      AppRoutes.home: (context, settings) => const HomeView(),
      ...authRoutes,
      ...hotelRoutes,
    };
  }

...

We should also update the type for authRoutes and hotelRoutes as follows :

Map<String, RouteType> authRoutes = {
 AppRoutes.login: (context, settings) => const LoginView(),
 AppRoutes.signup: (context, settings) => const SignupView(),
};

Map<String, RouteType> hotelRoutes = {
 AppRoutes.hotel: (context, settings) => const HotelView(),
 AppRoutes.hotelDetail: (context, settings) => const HotelDetailView(),
};

Now,
With this, our routes will span into multiple files which is much more manageable.

Now,
Let’s say we wanted to implement a new feature of packages that has routes for Package Listing View and Package Detail View . We can create a new file called package_routes.dart as :

import 'package:flutter_generalization/src/core/routing/route_type.dart';
import 'package:flutter_generalization/src/modules/hotel/gui/views/package_detail_view.dart';
import 'package:flutter_generalization/src/modules/hotel/gui/views/package_listing_view.dart';

import 'app_routes.dart';
Map<String, RouteType> packageRoutes = {
 AppRoutes.packageListing: (context, settings) => const PackageListingView(),
 AppRoutes.packageDetail: (context, settings) => const PackageDetailView(),
};

Then, we can add this route to the _routeResolver() as :

...
  
  static Map<String, RouteType> _resolveRoutes() {
    return {
      AppRoutes.home: (context, settings) => const HomeView(),
      ...authRoutes,
      ...hotelRoutes,
      ...packageRoutes,
    };
  }

...

So,
The next time you want to create a cohesive list of routes, you can create a new folder and create a Map<String, RouteType> and then import it into Routes class and spread the Map inside the return of _resolveRoutes() .

# Animating the Routes

Let’s say that, you wanted your app route animations to be such that all the pages slide from bottom to top.

Achieving this is fairly easy because we have a single entry point that defines the PageRoute . This is done in Routes.onGenerateRoutes() where we’ve returned MaterialPageRoute .

The slide top-to-bottom animation can be achieved by extending PageRouteBuilder :

class SlideRoute extends PageRouteBuilder {
  final Widget Function(BuildContext) builder;
  final Offset? startOffset;
  final Offset? endOffset;
  SlideRoute({
    required this.builder,
    bool fullscreenDialog = false,
    this.startOffset,
    this.endOffset,
  }) : super(
          fullscreenDialog: fullscreenDialog,
          transitionDuration: const Duration(milliseconds: 500),
          pageBuilder: (a, b, c) => builder(a),
        );

  @override
  Widget buildTransitions(BuildContext context, Animation<double> animation,
      Animation<double> secondaryAnimation, Widget child) {
    return SlideTransition(
      position: Tween<Offset>(
        begin: startOffset ?? const Offset(0, 1),
        end: endOffset ?? Offset.zero,
      ).animate(animation),
      child: child,
    );
  }
}

Then,
We can replace MaterialPageRoute as :

class Routes {
  static Map<String, RouteType> _resolveRoutes() {
    return {
      AppRoutes.home: (context, settings) => const HomeView(),
      ...authRoutes,
      ...hotelRoutes,
      ...packageRoutes,
    };
  }

  static Route onGenerateRoutes(RouteSettings settings) {
    print(settings.name);
    var routes = _resolveRoutes();
    try {
      final child = routes[settings.name];

      return SlideRoute(builder: (c) => child!(c, settings));
    } catch (e) {
      throw const FormatException("--- Route doesn't exist");
    }
  }
}

Now,
All the routes in the app will be animated from bottom to top.

# Animating Specific Routes Differently

It is possible that you might only want to animate a particular route such that it slides from bottom to top.

This can be achieved by adding an if statement in onGenerateRoutes as :

...
  static Route onGenerateRoutes(RouteSettings settings) {
    var routes = _resolveRoutes();
    try {
      final child = routes[settings.name];

      Widget builder(BuildContext c) => child!(c, settings);

      if (settings.name == AppRoutes.hotel) {
        return SlideRoute(builder: builder);
      }

      return MaterialPageRoute(builder: builder);
    } catch (e) {
      throw const FormatException("--- Route doesn't exist");
    }
  }
...

# Bonus

The Slide Animation can be configured to slide left to right or right to left and even top to bottom .

To achieve this we just have to pass in the offset.

Animating Left to Right

...
return SlideRoute(
    builder: builder,
    offset: const Offset(-1, 0),
);
...

Animating Right to Left

...
return SlideRoute(
    builder: builder,
    offset: const Offset(1, 0),
);
...

Animating Top to Bottom

...
return SlideRoute(
    builder: builder,
    offset: const Offset(0, -1),
);
...

Animating Bottom to Top

...
return SlideRoute(
    builder: builder,
    offset: const Offset(0, 1),
);
...

Originally published at https://medium.com on June 21, 2023.

This Article uses React Native for Demonstration but the concepts work with any UI framework or simple HTML.

Code can be found at the end of the article.

If you’re a Frontend Developer chances are that you’ve been slowed down by waiting for the API.

What if I told you that your UI doesn’t need to depend upon whatever the API data format looks like?

Let me tell you how it’s done.
Let’s say you have to make a component as follows :

If you observe this Component, you only need 5 different information:
1. Name
2. Phone Number
3. Gender
4. Age
5. Image

However, when backend decides to send data for this component, it might include extra information like id, address, etc.

This component doesn’t care about any other data except the described 5.
So, we can create a Model for those 5 data as :

export default interface UserCardViewMOdel {
 name: string,
 phone: string,
 gender: string,
 age: string,
 image: string,
}

Then,
We can have the component take that data as a prop.

const UserCard = ({data}: {data: UserCardViewModel}) => {
 return (
  ...
   ----- Component UI defined here -----
  ...
 )
}

With this, we have all the data the UserCard component needs in order to render.

The required data can be accessed from the data variable as :

const UserCard = ({data}: {data: UserCardViewModel}) => {
 return (
  ...
        <Text>{data.name}</Text>
  ...
 )
}

Now,
The UserCard component doesn't care about anything that happens with the API. This component is able to render the UI as long as it is given data of type UserCardViewModel .

This makes the component you write reusable across multiple projects as you can copy the component along with it’s View Model when using it. The term View Model comes from MVVM which is for Model, View, View Model .
A Model is a data class that holds the data of your app. A View Model is just a Model but for a View . A View is anything that appears on the screen.

Now,
Let’s say that the data provided by the backend looked as :

export default interface UserResponse {
 firstName: string,
 lastName: string,
 phone: string,
 gender: string,
 dob: string,
 image: string,
}

You’ll realize that the backend data is completely different from what you need in your UI. To make our component render we need the data to be of type UserCardViewModel .

For this, we have to convert UserResponse into UserCardViewModel .

This can be done in various ways.

# The Common Way

One way is to convert it while passing it to the component inside the UI as :

const HomeView = () => {
  let response = useGetResponseSomehow();
  
  return (
      ...
          <UserCard data={{
            name: `${response.firstName} ${response.lastName}`,
            phone: response.phone,
            gender: response.gender,
            age: getAgeFromDob(response.dob),
            image: response.image,
          }} />
      ...
  )
}

This will work, but, you’ve cluttered your UI code with data conversion logic.

So, a better way is to separate out this logic into an adapter.

# The Better Way

You create an adapter as follows :

export const UserCardAdapter = {
 convert(response: UserResponse): UserCardViewModel {
 return {
 name: `${response.firstName} ${response.lastName}`,
 phone: response.phone,
 gender: response.gender,
 age: getAgeFromDob(response.dob),
 image: response.image,
 };
 }
}

We can have the HotelCardAdapter be a Singleton.
Then, use it as :

const HomeView = () => {
  let response = useGetResponseSomehow();
  
  return (
      ...
          <UserCard data={UserCardAdapter.convert(response)} />
      ...
  )
}

This is good.
But, this means that you need to remember to write this .convert() statement for every component.

So, we can take this adapter idea one step further by abstracting it.

# The More Better Way

The abstraction for the adapter can be created as :

export default interface Adapter<T,D> {
 convert(data: T): D;
}

Then,
Every adapter can implement the interface. In our UserCardAdapter example, it will become :

export const UserCardAdapter : Adater<UserResponse, UserCardViewModel> = {
 convert(response: UserResponse): UserCardViewModel {
 return {
 name: `${response.firstName} ${response.lastName}`,
 phone: response.phone,
 gender: response.gender,
 age: getAgeFromDob(response.dob),
 image: response.image,
 };
 }
}

Now,
We can create an adapter component that will call the .convert() as :

const AdaptedComponent = <T,D> ({
 data,
 adapter,
 children,
}: {
 data: T,
 adapter: Adapter<T,D>
 children: (data: D) => JSX.Element
}) => {
 const adaptedData = adapter.convert(data);
 return children(adaptedData);
}
 
export default AdaptedComponent;

Then, this can be used as :

const HomeView = () => {
  let response = useGetResponseSomehow();
  
  return (
      ...
          <AdaptedComponent<UserResponse, UserCardViewModel>
              adapter={UserCardAdapter}
              data={response}
          >
          {
            data => <UserCard data={UserCardAdapter.convert(response)} />
          }
          </AdaptedComponent>
      ...
  )
}

Why is this good even though clearly, I seem to have to write more code than remembering to use .convert() ?

It’s good because we have abstracted the logic of .convert() and all we need to do is wrap our component with <AdaptedComponent /> .

With this, we’ll not have to worry about our API’s data format.
All we need to do is create a Model for our GUI and then adapt the data from API into the GUI.

Originally published at https://medium.com on June 21, 2023.

Article assumes user to have some experience in Object Oriented Programming.
The article uses Dart as a programming language for example.

To understand polymorphism, let’s take an example of a Laptop.

Suppose you have a laptop with USB ports.
What are the things that you can insert into the USB ports ?
The answer is anything that has a USB male connector.

Can it be a mouse ? YES.
Can it be a keyboard ? YES.
Can it be a printer ? YES.

What’s common in these devices ?
They are I/O devices.
They are used for input and output.

Now, programmers realized very quickly that it was of our interest to have our systems (computers) be independent of I/O devices.

Creation of this independence is called polymorphism.

In our example USB was an interface between our laptop and the I/O devices.

Now, how do we do that in code ?

Consider the following example :

Problem

Let’s say that module A calls module B .
We can consider module A to be our laptop and module B to be our keyboard.

In this scenario, the code will look as follows :

Here,
ModuleA knows about ModuleB because the code in module_a.dart explicity has a declaration of ModuleB in relative line number 11.

The following will be the dependency graph :

This means ModuleA is tightly coupled to ModuleB in compile time.
So, if ModuleA has to compile then it must have ModuleB compiled too. That's bad.

Why’s this bad ?
Back in our example, this means that when our laptop was made it will only support a particular kind of keyboard designed for that laptop but we want any keyboard to work with our system.

Solution

To solve this, we create an interface between ModuleA and ModuleB so that ModuleA doesn't need to directly reference ModuleB . This can be done because ModuleA depends upon the function doSomething() present in ModuleB .

Now,
In module_a.dart there is no declaration of ModuleB directly, instead it has a reference to some Interface .

Now, the dependency graph is like :

If we look at interface.dart we'll see that there is no implementation of the method doSomething() but ModuleA is able to call the function doSomething() in relative line number 4, in module_a.dart .

Notice, that ModuleB is no longer referenced in ModuleA anywhere in compile time but we can inject ModuleB into ModuleA at runtime via the constructor.

Why is this good ?
It’s good because, this means that now we can have a ModuleX that implements the Interface which can work with ModuleA .

This gives the developer immense power.

This means that we can change the behavior of ModuleA without ever changing it's source code.

We can inject the dependencies as follows :

Here,
ModuleA accepts ModuleX as well as ModuleB .

But, when we look at the output :

The behavior of ModuleA is different for the same function call.

This is why we like Polymorphism.
It gives the developer immense power.

Originally published at https://medium.com on April 13, 2023.