RSS Feed

Indie Devlog #00

Sat, 03 Jan 2026 10:00:00 GMT

This June marks 12 years since I built my first app. I have lost count of how many products I have worked on since then. Well into the triple digits, if I were to guess. Which is why it is surprising that I have never published a "serious" product of my own.

Being tied to a never-ending stream of projects was the main reason. But I want to change that this year. With the help of AI-assisted development and a much-needed sabbatical from professional work, I finally have the opportunity.

So, what will I build? Beyond my backlog of ideas and requests collected over the years from friends and family, I will use the time-tested method of scratching your own itch. As a regular premium user of at least a dozen products, from fitness and nutrition to reading and expense tracking, you naturally spot friction and long-standing issues. The details are a bit fuzzy, but the core theme would be to reduce friction and make the user experience more delightful.

I will be documenting the journey here and hope to collect feedback and share something valuable along the way. And lastly, a very happy new year.

For suggestions and queries, just contact me{:target="_blank"}.

Git Worktrees: Work on Multiple Flutter Branches Simultaneously

Sat, 16 Aug 2025 10:00:00 GMT

The context-switching tax

You're knee-deep in a new feature – state management wired up, widgets looking good, tests passing. Then Slack pings: "Production bug. Needs a hotfix NOW."

You know the drill:

git stash
git checkout main
git checkout -b hotfix/critical-issue
# fix the bug, test it, push it
git checkout feature/new-feature
git stash pop
# pray your IDE catches up

By the time you're back, your IDE is re-indexing, the emulator needs a fresh run, and you've lost your train of thought. The context switch costs 15 minutes minimum.

Worktrees: multiple branches, zero stashing

Git worktrees let you check out different branches in separate directories from the same repo. No stashing, no branch switching, no waiting for IDE re-indexing.

Here's the setup:

# Your main working directory
~/Code/my_app/

# Create a worktree for the hotfix in a parallel directory
git worktree add ../my_app-hotfix main

Now you have:

~/Code/my_app/          # Your feature branch (untouched)
~/Code/my_app-hotfix/   # Fresh main branch checkout

Open the hotfix directory in a new IDE window, fix the bug, commit, push. Your feature branch keeps running in the original window. Zero interruption.

Real-world Flutter scenarios

Scenario 1: Code review while working

PM needs you to review a PR but you're mid-refactor with uncommitted changes everywhere.

git worktree add ../my_app-review feature/teammate-pr

Open it, review the code, run the app, leave comments. Your main work stays untouched.

Scenario 2: Compare behavior across branches

"This button worked on main but broke on my branch."

git worktree add ../my_app-main main

Run both apps side-by-side. Instant comparison. No guessing, no stashing.

Scenario 3: Long-running experiments

You want to try a new architecture pattern but don't want to commit to it yet.

git worktree add ../my_app-experiment -b experiment/new-arch

Work on it for days. If it works, merge it. If not, delete the worktree. Your main branch never saw the chaos.

Commands you'll actually use

# Create a new worktree from an existing branch
git worktree add <path> <branch>

# Create a worktree with a new branch
git worktree add <path> -b <new-branch>

# List all worktrees
git worktree list

# Remove a worktree when you're done
git worktree remove <path>
# or just delete the directory and run
git worktree prune

Things to know

Shared commits: All worktrees share the same repository. A commit in one worktree is visible in all others after a git fetch.
One branch per worktree: You can't check out the same branch in multiple worktrees. Git prevents this to avoid conflicts.
IDE quirks: VS Code and Android Studio handle worktrees fine – just open each as a separate window. IntelliJ IDEA might complain about duplicate projects; ignore it.
pub get runs independently: Each worktree needs its own flutter pub get. They don't share build or .dart_tool folders.

Clean-up

When you're done with a worktree:

git worktree remove ../my_app-hotfix

Or just delete the folder and prune:

rm -rf ../my_app-hotfix
git worktree prune

Why this matters

Before worktrees I avoided urgent fixes because the mental overhead of stashing and switching was too high. Now I keep 2-3 worktrees active:

my_app – main feature work
my_app-hotfix – quick fixes and reviews
my_app-experiment – risky ideas

I bounce between them instantly. No stashing. No waiting. No lost context.

If you frequently switch branches or need to compare behavior across branches, worktrees are a game-changer. Try it once and you won't go back.

For suggestions and queries, just contact me{:target="_blank"}.

Automatically Trigger Dart Test Runs On File Changes

Thu, 26 Jun 2025 07:00:00 GMT

Jest has us spoiled

In the JavaScript world I run jest --watch and forget about it. Change a file and the tests rerun before I can switch windows. It makes TDD painless.

Flutter? Crickets

flutter test is fine but it has no built-in watcher. I searched for plug-ins, flags, secret env vars – nothing. There are a handful of community tools but most are abandoned.

Remember the `spec` package?

For a while spec wrapped the test runner and watched your files. Sadly it stopped working after the Dart 3 upgrade and the repo has been dormant.

I even tried Nodemon

nodemon --exec "flutter test" --ext dart almost works, until it doesn't. It gets confused by generated files, spams multiple runs and never exits cleanly on Ctrl-C. After the third flaky loop I gave up.

Enter `fswatch`

fswatch is a tiny cross-platform file watcher written in C. Homebrew users can grab it with:

brew install fswatch

Then add a shell alias. I dropped this in my ~/.zshrc:

alias dtest='fswatch -or lib test | xargs -n1 -I{} flutter test'

Breakdown:

fswatch -or lib test – recursively watch the lib and test folders and emit one event (-o) each time something changes.
xargs -n1 -I{} flutter test – for every event run one flutter test run.

Open a new terminal tab, run dtest, start coding and watch the green ticks fly. Zero config, instant feedback.

That's it. No more manual flutter test spam, no flaky wrappers. Just a simple watcher that does one job and does it well.

For suggestions and queries, just contact me{:target="_blank"}.

Lazy Loading Libraries in Dart

Sun, 21 May 2023 08:25:00 GMT

When it comes to building large scale applications, efficient use of resources is one of the most important considerations. This includes not only memory usage but also network bandwidth, disk space, and CPU cycles. One way of achieving this is through lazy loading.

Lazy loading refers to loading code or resources only when they are actually needed. This approach can greatly reduce the size and complexity of an application by loading only the necessary parts, thus improving startup time, reducing network bandwidth, and reducing memory usage.

In Dart, the deferred keyword is used to implement lazy loading of libraries. This keyword allows you to specify that a library should be loaded only when needed, rather than being loaded when the application starts up.

How to Use Deferred Loading in Dart

To use deferred loading in Dart, you need to follow a few simple steps.

Declare the library as deferred
import 'package:deferred_library/deferred_library.dart' deferred as deferred_library;
Use the library when needed
someFunction() async { await deferred_library.loadLibrary(); deferred_library.someFunctionInLibrary(); }
In this example, the loadLibrary method is called before accessing any function defined in the deferred_library. This method loads the library if it has not already been loaded. Once the library is loaded, any function or variable defined in it can be used normally.

Advantages of Using Deferred Loading

Using deferred loading in your Dart application provides several advantages:

Reduced application loading time: By loading only the necessary code when it is actually needed, the application startup time can be greatly reduced.
Reduced memory usage: If a library is not used frequently, it is wasteful to keep it in memory all the time. Deferred loading ensures that the library is loaded only when needed, thus reducing memory usage.
Better network bandwidth usage: If the library is loaded lazily, the initial download size of the application can be reduced, resulting in faster downloads and better network bandwidth usage.

Conclusion

Lazy loading is a crucial technique for optimizing resource usage in large-scale applications. Dart has a built-in capability to load libraries lazily using the deferred keyword. This allows you to load only the necessary parts of the application, thus reducing memory usage, network bandwidth, and startup time. By using this technique judiciously, you can greatly improve the performance of your Dart application.

For suggestions and queries, just contact me{:target="_blank"}.

Building a ChatGPT App using Flutter

Sun, 05 Mar 2023 06:49:00 GMT

Flutter is a state-of-the-art cross-platform mobile development framework owned by Google that allows developers to create visually stunning, high-performance native applications for iOS, Android, and web. On the other hand, ChatGPT is an AI model that utilizes the power of GPT to generate human-like responses to chat messages.

In this tutorial, we'll be putting both technologies together to create a ChatGPT application using Flutter. We'll be utilizing the Dart programming language and Flutter's widgets to communicate with ChatGPT and display the chat interface.

Prerequisites

Before we start building our application, you'll need to set up your development environment. Here are the necessary prerequisites:

Flutter SDK installed on your machine.
An IDE, such as Android Studio, IntelliJ IDEA, or Visual Studio Code.
A working knowledge of Flutter and Dart.

Setting up the Application

Create a new project in your IDE of choice.
Add the http package and the flutter_dotenv package to your pubspec.yaml file using the dependencies property.

dependencies:
  flutter:
    sdk: flutter
  http: ^0.12.2
  flutter_dotenv: ^4.0.0

Create a .env file in your project's root directory and add your ChatGPT API key.

OPENAI_API_KEY=<YOUR_API_KEY>

Import the necessary packages in your main.dart file.

import 'dart:convert';
import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;
import 'package:flutter_dotenv/flutter_dotenv.dart';

Create a ChatPage class that will display the chat interface and handle the user's input.

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

  @override
  ChatPageState createState() => ChatPageState();
}

class ChatPageState extends State<ChatPage> {
  // Map of messages and whether they were sent by the user
  final _messages = <String, bool>{};
  final _textEditingController = TextEditingController();

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('ChatGPT Demo'),
      ),
      body: Column(
        children: [
          Expanded(
            child: ListView.builder(
              itemBuilder: (context, index) {
                var isUserMessage = _messages.values.elementAt(index);
                return Row(
                  mainAxisAlignment: isUserMessage
                      ? MainAxisAlignment.end
                      : MainAxisAlignment.start,
                  children: [
                    Flexible(
                      child: Container(
                        alignment: isUserMessage
                            ? Alignment.centerRight
                            : Alignment.centerLeft,
                        padding: const EdgeInsets.all(16),
                        margin: EdgeInsets.only(
                          top: 4,
                          bottom: 4,
                          left: isUserMessage ? 40 : 4,
                          right: !isUserMessage ? 40 : 4,
                        ),
                        decoration: BoxDecoration(
                          borderRadius: BorderRadius.circular(8),
                          color: isUserMessage ? Colors.blue : Colors.grey,
                        ),
                        child: Text(_messages.keys.elementAt(index)),
                      ),
                    ),
                  ],
                );
              },
              itemCount: _messages.length,
            ),
          ),
          TextField(
            controller: _textEditingController,
            onSubmitted: _sendMessage,
            decoration: InputDecoration(
              hintText: 'Type your message',
              contentPadding: const EdgeInsets.all(8),
              suffixIcon: IconButton(
                icon: const Icon(Icons.send),
                onPressed: () => _sendMessage(_textEditingController.text),
              ),
            ),
          ),
        ],
      ),
    );
  }

  void _sendMessage(String message) async {
    setState(() {
      _messages[message] = true;
      _messages["..."] = false;
    });

    // Send API request to ChatGPT
    final response = await http.post(
      Uri.parse('https://api.openai.com/v1/chat/completions'),
      headers: {
        'Authorization': 'Bearer $openAiKey',
        'Content-Type': 'application/json',
      },
      body: jsonEncode(<String, dynamic>{
        'model': 'gpt-3.5-turbo',
        "messages": [
          {"role": "user", "content": message}
        ]
      }),
    );

    if (response.statusCode == 200) {
      final json = jsonDecode(response.body);
      setState(() {
        _messages.remove("...");
        _messages[json['choices'][0]['message']['content']] = false;
      });
    } else {
      print('Request failed with status: ${response.statusCode}.');
    }

    // Clear text field
    _textEditingController.clear();
  }
}

Modify your main.dart file to display the ChatPage when the app starts.

final openAiKey = dotenv.env['OPENAI_API_KEY'];

void main() async {
  await dotenv.load();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'ChatGPT Demo',
      home: ChatPage(),
    );
  }
}

That's it! You now have a fully functional ChatGPT application built with Flutter. Launch your app and start chatting with ChatGPT.

For suggestions and queries, just contact me{:target="_blank"}.

Build Modern Command Line Interfaces (CLI) with Python

Sun, 29 Jan 2023 00:33:00 GMT

When it comes to command-line interfaces (CLI), they are often viewed as dull and unengaging. However, CLI wizards offer a fun and interactive way for users to interact with the CLI. In this post, we'll take a deep dive into how to create a beautiful CLI wizard using PyInquirer.

What is PyInquirer?

PyInquirer is an interactive CLI prompt library that allows you to build interactive command-line interfaces. The library provides intuitive prompts with various controls and widgets, such as dropdowns, checkboxes, text input, and more. The library is built on top of the prompt-toolkit library for Python.

How to Install PyInquirer

To install PyInquirer, open your terminal and run the following command:

pip install PyInquirer

Creating a CLI Wizard with PyInquirer

To create a CLI wizard using PyInquirer, you need to first define the questions to ask the user. In PyInquirer, these questions are referred to as prompts. The library supports various types of prompts, including input prompts, list prompts, checkbox prompts, and more.

Here's an example of a simple CLI wizard using PyInquirer:

from PyInquirer import prompt

questions = [
    {
        'type': 'input',
        'name': 'name',
        'message': 'What is your name?'
    },
    {
        'type': 'checkbox',
        'message': 'Select toppings',
        'name': 'toppings',
        'choices': [
            {'name': 'Pepperoni'},
            {'name': 'Mushroom'},
            {'name': 'Onion'},
            {'name': 'Tomato'},
            {'name': 'Extra cheese'},
        ],
        'validate': lambda answer: 'You must choose at least one topping.' \
            if len(answer) == 0 else True
    }
]

answers = prompt(questions)
print(answers)

In this example, we define two prompts: one for the user's name and another for the pizza toppings they want. The prompts are defined using a Python dictionary, with each prompt having a name, type, and message.

We use the prompt method to display the prompts and get the user's answers. The method returns a dictionary containing the answers provided by the user.

Customizing the Look of the CLI Wizard

pyinquirer provides several customization options that allow you to tweak the look and feel of the CLI wizard. You can change the color of the prompts, change the borders, add headers and footers, and more.

Here's an example of a custom CLI wizard using pyinquirer:

from PyInquirer import prompt, style_from_dict, Token

style = style_from_dict({
    Token.Separator: '#cc5454',
    Token.QuestionMark: '#7f7fff bold',
    Token.Selected: '#5F819D',  # default
    Token.Pointer: '#5F819D bold',
    Token.Instruction: '',  # default
    Token.Answer: '#5F819D bold',
    Token.Question: '',
})

questions = [
    {
        'type': 'list',
        'name': 'theme',
        'message': 'What do you want to do?',
        'choices': [
            'Create a new project',
            'Help',
            'Exit',
        ],
        'default': 'Create a new project',
        'filter': lambda val: val.lower()
    },
    {
        'type': 'input',
        'name': 'project_name',
        'message': 'Project name:',
        'validate': lambda answer: 'You must enter a project name.' \
            if len(answer) == 0 else True
    },
]

answers = prompt(questions, style=style)
print(answers)

In this example, we define a custom style for the CLI wizard using a Python dictionary. We then pass the style to the prompt method to apply it to the prompts.

Conclusion

Creating interactive CLI wizards is a great way to engage users and provide a more enjoyable experience when using the CLI. pyinquirer is an easy-to-use library that allows you to create beautiful and functional CLI wizards in Python. With pyinquirer, you can customize the prompts to fit your needs, and with a little creativity, you can create a unique CLI wizard that stands out.

For suggestions and queries, just contact me{:target="_blank"}.

Securing Sensitive Data using Gradle Files

Mon, 02 Jan 2023 05:09:00 GMT

When developing an Android application, it's important to keep sensitive data such as API keys secure. One technique for doing this is to store the data in an external gradle file.

Storing Secrets in a Properties File

A Properties object can be used to load key-value pairs from a file. This allows you to store sensitive data such as API keys and passwords in a separate file that can be excluded from version control.

Here's an example of how to load secrets from a secrets.properties file:

def secretsPropertiesFile = rootProject.file("secrets.properties")
def secretProperties = new Properties()

if (secretsPropertiesFile.exists()) {
    secretProperties.load(new FileInputStream(secretsPropertiesFile))
}

Using Environment Variables

If the secrets.properties file does not exist, you can use environment variables as a fallback. This is useful when building your application on a continuous integration server where you may not have access to the secrets.properties file.

Here’s an example of how to read an environment variable named API_KEY and set it as a property:

if (!secretsPropertiesFile.exists()) {
    secretProperties.setProperty("API_KEY", "${System.getenv('API_KEY')}")
}

Setting Build Config Fields

Once you have loaded your secrets into a Properties object, you can use them to set build config fields. This allows you to access the values at runtime using the generated BuildConfig class.

Here’s an example of how to set two build config fields for API_BASE_URL and API_KEY, using values from the previously loaded properties:

android {
    defaultConfig {
        buildConfigField "String", "API_BASE_URL", "\"${secretProperties['API_BASE_URL']}\""
        buildConfigField "String", "API_KEY", "\"${secretProperties['API_KEY']}\""
    }
}

Storing sensitive data in a separate properties file or using environment variables are effective techniques for keeping your data secure. By setting build config fields with these values, you can easily access them at runtime while keeping them out of version control.

For suggestions and queries, just contact me{:target="_blank"}.

Flutter Plugin Development

Sat, 22 Oct 2022 02:06:00 GMT

One of the great things about Flutter is its extensibility through plugins. Even though I have been developing Flutter apps for about 4 years now, my first experience with building Flutter plugins was just last month. In this tutorial, lets walk you through the process of creating your own Flutter plugin.

What is a Flutter Plugin?

A Flutter plugin is a package that adds new functionality to the Flutter framework. Plugins can access platform-specific APIs (such as camera or location services) and expose them to Dart code in a way that's easy to use.

Getting Started

To get started with creating your own Flutter plugin, you'll need to have the following installed on your computer:

The latest version of Flutter
A text editor (such as VS Code)
A terminal or command prompt

Once you have these installed, open up your terminal or command prompt and navigate to the directory where you want to create your new plugin.

Creating a New Plugin

To create a new Flutter plugin, run the following command:

flutter create --template=plugin my_plugin

This will create a new directory called my_plugin with all the necessary files for creating a Flutter plugin.

Adding Platform-Specific Code

One of the main reasons for creating a Flutter plugin is to access platform-specific APIs. To do this, you'll need to add some native code (either Java/Kotlin for Android or Objective-C/Swift for iOS) to your plugin.

For example, let's say we want our plugin to access the device's camera. On Android, we would add some Java code like this:

// my_plugin/android/src/main/java/com/example/my_plugin/MyPlugin.java
package com.example.my_plugin;

import androidx.annotation.NonNull;
import io.flutter.embedding.engine.plugins.FlutterPlugin;
import io.flutter.plugin.common.MethodChannel;

public class MyPlugin implements FlutterPlugin {
  private static final String CHANNEL = "my_plugin";

  @Override
  public void onAttachedToEngine(@NonNull FlutterPluginBinding flutterPluginBinding) {
    MethodChannel channel = new MethodChannel(flutterPluginBinding.getBinaryMessenger(), CHANNEL);
    channel.setMethodCallHandler(
      (call, result) -> {
        if (call.method.equals("getCamera")) {
          // TODO: Access camera here
        } else {
          result.notImplemented();
        }
      }
    );
  }

  @Override
  public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) {}
}

On iOS, we would add some Objective-C code like this

// my_plugin/ios/Classes/SwiftMyPlugin.swift
import Foundation
import UIKit

public class SwiftMyPlugin: NSObject {
    public static func register(with registrar: FlutterPluginRegistrar) {
        let channel = FlutterMethodChannel(name: "my_plugin", binaryMessenger: registrar.messenger())
        let instance = SwiftMyPlugin()
        registrar.addMethodCallDelegate(instance, channel: channel)
    }

    public func handle(_ call: FlutterMethodCall,
                       result: @escaping (Any?) -> Void) {
        if call.method == "getCamera" {
            // TODO: Access camera here
            result(nil)
        } else {
            result(FlutterMethodNotImplemented)
        }
    }
}

Once you’ve added your platform-specific code, you can expose it to Dart by adding some Dart code like this:

// my_plugin/lib/my_plugin.dart
import 'dart:async';

import 'package:flutter/services.dart';

class MyPlugin {
  static const MethodChannel _channel =
      const MethodChannel('my_plugin');

static Future<String> get camera async {
    final String version = await _channel.invokeMethod('getCamera');
    return version;
  }
}

Testing Your Plugin

To test your plugin, you can create an example app within your my_plugin directory by running the following command:

cd example/
flutter run

This will launch an example app that uses your newly created plugin. You can then test out any functionality that you’ve added.

Publishing Your Plugin

Once you’re happy with your plugin and have tested it thoroughly, it’s time to publish it so others can use it! To do this, follow these steps:

Update the pubspec.yaml file in your my_plugin directory with information about your plugin (such as its name and description).
Run flutter packages pub publish from within your my_plugin directory.
Follow the prompts to publish your package.

Congratulations! You’ve now created and published your very own Flutter plugin!

Conclusion

In this tutorial, we walked through the process of creating a Flutter plugin from scratch. We covered everything from setting up our development environment to adding platform-specific code and publishing our finished product. We hope this tutorial has been helpful in getting you started with creating your own plugins for use in future projects

For suggestions and queries, just contact me{:target="_blank"}.

Generate ASCII Art with Python

Fri, 08 Jul 2022 12:37:00 GMT

ASCII art is a form of art that was popularized in the early days of computing, where characters from the ASCII character set are used to create images. It’s a fun and creative way to use programming to create something visually interesting.

In this post, we will explore how to generate ASCII art using Python.

Setting Up the Environment

Before we start generating ASCII art, we need to set up our environment. We will be using a Python library called art which provides functionality for creating ASCII art.

To install art, simply run the following command in your terminal:

pip install art

Generating ASCII Art

Once we have art installed, we can start generating ASCII art. The library provides a variety of styles and fonts to choose from, and we can also create our own custom fonts.

Here’s a simple example that generates ASCII art of the word “Python” using the “slant” font:

from art import text2art

art = text2art("Python", font='slant')
print(art)

This code will generate the following ASCII art:

    _____       _     ____        _    
   / ___/____  (_)___/ / / ___    (_)___
   \__ \/ __ \/ / __  / / / _ \  / / __ \
  ___/ / / / / / /_/ / /_/  __/ / / /_/ /
 /____/_/ /_/_/\__,_/\__,_/\___(_)_/\____/

Creating Custom Fonts

One of the really cool things about the art library is that we can create our own custom fonts. This allows us to create ASCII art that is unique and personalized.

Here’s an example of how to create a custom font:

from art import tprint, font_creator

font = font_creator("myfont",
                r"""
 ___________________________________________________
/ This is my custom font. It includes all letters   \
| of the alphabet as well as some special characters. |
\ Enjoy!                                             /
 ---------------------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
""")

tprint("Hello, World!", font='myfont')

This code will create a custom font that includes all letters of the alphabet as well as some special characters. We can then use this font to generate ASCII art using the tprint function.

For suggestions and queries, just contact me{:target="_blank"}.

Clutterfree Flutter Architecture

Fri, 19 Feb 2021 04:42:00 GMT

Flutter is a modern and popular framework for building mobile applications. While its easy-to-learn syntax and fast development time make it a great choice for developing mobile apps, many developers struggle with finding the right architecture that fits their needs. To help solve this problem, we will be discussing a clutter-free architecture setup using a combination of popular libraries such as Bloc, Chopper, Auto Route, Injectable, Freezed, and Screen Util.

We will start by building a simple vanilla Flutter application that has basic functionality such as displaying a list of items and navigating to a detail page.

I will be skipping some of the non-essential code to keep things concise.

import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Clutterfree Flutter',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: HomePage(),
    );
  }
}

class HomePage extends StatefulWidget {
  @override
  _HomePageState createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  List<String> words = [];

  @override
  void initState() {
    super.initState();
    fetchWords();
  }

  void fetchWords() async {
    var response = await http.get('https://random-word-api.herokuapp.com/word?number=10');
    if (response.statusCode == 200) {
      setState(() {
        words = json.decode(response.body);
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Clutterfree Flutter'),
      ),
      body: ListView.builder(
        itemCount: words.length,
        itemBuilder: (context, index) {
          return ListTile(
            title: Text(words[index]),
            onTap: () {
              Navigator.push(
                context,
                MaterialPageRoute(
                  builder: (context) => DetailPage(word: words[index]),
                ),
              );
            },
          );
        },
      ),
    );
  }
}

class DetailPage extends StatelessWidget {
  final String word;

  DetailPage({this.word});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(word),
      ),
      body: Center(
        child: Text(word),
      ),
    );
  }
}

With this code, we have a basic two-page Flutter application that makes API calls and displays a list of data on the first page and the details of a selected item on the second page. However, as the application grows in complexity and size, it becomes increasingly difficult to maintain the codebase, especially when it comes to state management and API calls.

Write Code Not Boilerplate

This is where Flutter libraries such as Bloc, Chopper, Auto Route, Injectable, Freezed, and Screen Util come in. These libraries are designed to help you write scalable, maintainable, and efficient Flutter applications. Let's take a look at how we can refactor our previous application to make use of these libraries.

Freezed

Freezed is a code generation library for Dart that provides a set of annotations and code generators to make it easy to create immutable classes and data structures. Freezed makes it simple to create classes that are easy to understand and test, and that can be used throughout your application without having to worry about mutability.

BLoC

The Bloc library provides a powerful and flexible pattern for state management. With Freezed, we can easily generate data classes for our application's state, which helps to reduce boilerplate code and ensures that our data model remains in sync with our state. The generated data classes also allow us to easily add new properties and update existing ones, ensuring that our data model remains up-to-date.

First, we need to create a BLoC that will handle the logic for retrieving and updating the data. To do this, we'll create a new class WordBloc that extends Bloc:

import 'package:flutter/material.dart';
import 'package:injectable/injectable.dart';
import 'package:freezed_annotation/freezed_annotation.dart';
import 'package:bloc/bloc.dart';
import 'word_repository.dart';

part 'word_event.dart';
part 'word_state.dart';

@injectable
class WordBloc extends Bloc<WordEvent, WordState> {
  final WordRepository _wordRepository;

  WordBloc(this._wordRepository) : super(WordState.initial());

  @override
  Stream<WordState> mapEventToState(WordEvent event) async* {
    if (event is FetchWords) {
      yield WordState.loading();
      try {
        final words = await _wordRepository.getWords();
        yield WordState.loaded(words: words);
      } catch (e) {
        yield WordState.error(errorMessage: e.toString());
      }
    }
  }
}

@freezed
abstract class WordEvent with _$WordEvent {
  const factory WordEvent.fetchWords() = FetchWords;
}

@freezed
abstract class WordState with _$WordState {
  const factory WordState.initial() = WordInitial;
  const factory WordState.loading() = WordLoading;
  const factory WordState.loaded({List<String> words}) = WordLoaded;
  const factory WordState.error({String errorMessage}) = WordError;
}

Injectable

Injectable provides a simple and flexible way to manage dependencies in our Flutter application. With Injectable, we can easily manage the lifecycle of our dependencies and provide the required instances to the parts of our application that need them. This can greatly simplify the process of writing tests and making changes to our application.

Chopper

The Chopper library simplifies the process of making API calls and allows us to easily add and manage our API endpoints. This can be particularly useful when working on a large-scale application, where the number of API endpoints can become difficult to manage. Chopper also provides support for request and response interception, making it easy to add global error handling and logging.

Let's rewrite the data layer of this app using Chopper for networking and Freezed for data models.

import 'package:chopper/chopper.dart';
import 'package:clutterfree_flutter/data/models/word.dart';
import 'package:injectable/injectable.dart';

part 'word_repository.chopper.dart';

@ChopperApi(baseUrl: 'https://random-word-api.herokuapp.com')
abstract class WordRepository extends ChopperService {
  @Get(path: 'word?number=10')
  Future<Response<List<Word>>> getWords();

  static WordRepository create() {
    final client = ChopperClient(
      baseUrl: 'https://random-word-api.herokuapp.com',
      services: [
        _$WordRepository(),
      ],
      converter: JsonConverter(),
    );
    return _$WordRepository(client);
  }
}

@freezed
abstract class Word with _$Word {
  const factory Word({String word}) = _Word;

  factory Word.fromJson(Map<String, dynamic> json) => _$WordFromJson(json);
}

@injectable
class ProductionWordRepository extends WordRepository {
  final ChopperClient chopperClient;

  ProductionWordRepository(this.chopperClient) : super(chopperClient);
}

Auto Route

Auto Route makes it easy to navigate between pages in our application and reduces the amount of boilerplate code required to manage navigation. With AutoRoute, we can define routes in a declarative way, reducing the risk of bugs and making it easier to maintain our application.

You can use the generateRoute function from the AutoRouter class to define the routes using the AutoRoute library. Here's an example of how you can define the routes for your app:

import 'package:auto_route/auto_route.dart';
import 'package:flutter/material.dart';
import 'package:injectable/injectable.dart';
import 'package:clutterfree_flutter/ui/views/home_page.dart';
import 'package:clutterfree_flutter/ui/views/detail_page.dart';

@Injectable(as: Router)
class $Router extends RouterBase {
  @override
  Widget generateRoute(RouteSettings settings) {
    switch (settings.name) {
      case Routes.homePage:
        return MaterialPageRoute<dynamic>(
          builder: (_) => HomePage(),
        );
      case Routes.detailPage:
        var word = settings.arguments as String;
        return MaterialPageRoute<dynamic>(
          builder: (_) => DetailPage(word: word),
        );
      default:
        return MaterialPageRoute<dynamic>(
          builder: (_) => Scaffold(
            body: Center(
              child: Text('No route defined for ${settings.name}'),
            ),
          ),
        );
    }
  }
}

class Routes {
  static const String homePage = '/';
  static const String detailPage = '/detail';
}

Screen Util

Finally, the Screen Util library makes it easy to build responsive user interfaces in Flutter. With ScreenUtil, we can easily adjust the size and position of our UI elements based on the size of the screen, ensuring that our application looks great on all devices.

Let's rewrite the UI and bind all the components together. We will be using Screen Util for scaling and AutoRoute for routing.

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:screenutils/screenutils.dart';
import 'package:clutterfree_flutter/word_bloc.dart';
import 'package:clutterfree_flutter/models/word.dart';
import 'package:clutterfree_flutter/word_repository.dart';

class HomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocProvider<WordBloc>(
      create: (context) => WordBloc(WordRepository()),
      child: Scaffold(
        appBar: AppBar(
          title: Text('Clutterfree Flutter'),
        ),
        body: BlocBuilder<WordBloc, WordState>(
          builder: (context, state) {
            return state.when(
              initial: () => Center(
                child: CircularProgressIndicator(),
              ),
              loading: () => Center(
                child: CircularProgressIndicator(),
              ),
              loaded: (words) {
                return ListView.builder(
                  itemCount: words.length,
                  itemBuilder: (context, index) {
                    return ListTile(
                      title: Text(words[index].word, style: TextStyle(fontSize: 20.sp)),
                      onTap: () {
                        Navigator.pushNamed(context, 'word_detail', arguments: words[index].word);
                      },
                    );
                  },
                );
              },
              error: () => Center(
                child: Text('Error Occurred', style: TextStyle(fontSize: 20.sp)),
              ),
            );
          },
        ),
      ),
    );
  }
}

class DetailPage extends StatelessWidget {
  final String word;

  DetailPage({this.word});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(word),
      ),
      body: Center(
        child: Text(word, style: TextStyle(fontSize: 30.sp)),
      ),
    );
  }
}

In conclusion, by using these libraries, we can build clean, scalable and maintainable Flutter applications that are easier to develop, test, and maintain. By using a combination of Bloc, Freezed, Chopper, AutoRoute, Injectable and ScreenUtil, we can take advantage of the latest and greatest in Flutter development and ensure that our applications are ready for the future.

For suggestions and queries, just contact me.

Automatic JSON to Dart Conversion in Flutter

Wed, 13 May 2020 12:33:00 GMT

Flutter is a popular mobile app development framework that allows developers to build beautiful and high-performance apps for iOS and Android from a single codebase. One of the common tasks when building apps with Flutter is working with JSON data.

JSON (JavaScript Object Notation) is a lightweight data interchange format that is easy for humans to read and write and easy for machines to parse and generate. It’s commonly used for transmitting data between a server and a web application.

In Flutter, you can use the dart:convert library to convert JSON data into Dart objects. However, manually writing the code to convert JSON data into Dart objects can be tedious and error-prone.

Fortunately, there are several tools available that can automatically generate the Dart code for you. These tools take a JSON object as input and generate the corresponding Dart classes with all the necessary methods for encoding and decoding the JSON data.

One such tool is json_serializable, which generates code using source_gen and build_runner. To use json_serializable in your Flutter project, you need to add it as a dependency in your pubspec.yaml file:

dependencies:
  json_annotation: ^4.0.1

dev_dependencies:
  build_runner: ^2.0.6
  json_serializable: ^4.1.3

Then run flutter pub get to install the dependencies.

Next, you need to create a model class for your JSON data and annotate it with @JsonSerializable():

import 'package:json_annotation/json_annotation.dart';

part 'user.g.dart';

@JsonSerializable()
class User {
  final String name;
  final String email;

  User(this.name, this.email);

  factory User.fromJson(Map<String, dynamic> json) => _$UserFromJson(json);
  Map<String, dynamic> toJson() =>_$UserToJson(this);
}

Finally, run flutter pub run build_runner build to generate the necessary code.

Another option is json_to_dart, an online tool that generates Dart classes from JSON input. To use json_to_dart, simply paste your JSON data into the input field on their website and click “Generate”. The tool will then generate the corresponding Dart classes for you.

Using these tools can save you time and reduce errors when working with JSON data in your Flutter app.

In conclusion, automatic JSON to Dart conversion in Flutter can make your development process faster and more efficient. By using tools like json_serializable or json_to_dart, you can easily convert your JSON data into usable Dart objects without having to write any additional code. This saves time and reduces errors, allowing you to focus on building great apps with Flutter.

For suggestions and queries, just contact me{:target="_blank"}.

Painless UI Testing with Kaspresso

Sat, 14 Mar 2020 11:00:00 GMT

A few months ago I wrote a blog post under a similar title{:target="_blank"} about better Unit Testing for Kotlin with Kotest{:target="_blank"} (formerly KotlinTest). The focus of that post was to demonstrate a more organized, boilerplate free and self-documenting TDD/BDD friendly testing framework for Kotlin.

I have been using Kotest for about a year now and it is safe to say that it has encouraged me to test more of my code. While frameworks like Kotest and Spek provide a good alternative for unit testing, the UI part still feels lacking. Most of us still use Espresso for writing UI tests that, even with its super clean API, feel very repetitive and verbose. For some time, I worked around this by extracting the repetitive code for reuse. It wasn't very clean.

Caffeine Overflow

Part of my dev-wishlist was to someday establish this perfect loop of TDD flow with Android where all the features start with a failing UI test, followed by multiple unit tests to satisfy the business logic. At the end of which we have a solid well-tested and self-documented feature. So I started searching for other options which lead me to several frameworks, most of which were named after a coffee.

One of the great finds was Kakao{:target="_blank"} by Agoda, it provides a more readable and reusable DSL on top of Espresso. The idea is to encapsulate the UI in Screen interfaces which can then be reused. Here is an example of what a form UI would look like:

	class FormScreen : Screen<FormScreen>() {
	val phone = KView { withId(R.id.phone) }
	val email = KEditText { withId(R.id.email) }
	val submit = KButton { withId(R.id.submit) }
	}

view raw FormScreen.kt hosted with ❤ by GitHub

The resulting tests are reduced to a combination of actions and assertions inside the screen:

	onScreen<FormScreen> {
	phone {
	hasText("971201771")
	}
	button {
	click()
	}
	}

view raw FormTest.kt hosted with ❤ by GitHub

But Wait, There's More!

Kakao seemed like a pretty reasonable solution until I stumbled upon Kaspresso{:target="_blank"}. It combines Espresso and UI Automator into single DSL based API. For the Espresso part, it just wraps around Kakao with some added features such as improved logging, built-in screenshots, ADB command execution, runtime permissions management and more.

Grade Calculator 2.0

What could be a better example than to revisit the grade calculator we built in the previous post? Let's add some UI and this time build in a purely Test-Driven style.

Installation

Let's create a simple Android project with an empty Activity. Then add the following test dependencies:

	testImplementation 'junit:junit:4.13'
	implementation 'androidx.test:core:1.2.0'
	androidTestImplementation 'androidx.test.ext:junit:1.1.1'
	testImplementation 'io.kotlintest:kotlintest-runner-junit5:3.1.7'
	testImplementation 'io.mockk:mockk:1.9.3'
	androidTestImplementation 'com.kaspersky.android-components:kaspresso:1.1.0'

view raw TestDeps.gradle hosted with ❤ by GitHub

If you set up your project using the Android Studio wizard, then most of these dependencies should already be present. The only dependencies that we must add manually are Kotest, Mockk, and Kaspresso.

Kotest and Mockk are the same as last time for unit testing and mocking, while Kaspresso will be used for UI tests.

Adding The UI Test

Let's add a UI test for the happy path of our calculator without touching the activity first:

	import androidx.test.rule.ActivityTestRule
	import com.kaspersky.kaspresso.testcases.api.testcase.TestCase
	import com.zuhaibahmad.kaspressotestingdemo.screens.GradeCalculatorScreen
	import org.junit.Rule
	import org.junit.Test

	class GradeCalculatorUiTest : TestCase() {

	@Rule
	@JvmField
	var rule = ActivityTestRule(GradeCalculatorActivity::class.java, false, false)

	val screen = GradeCalculatorScreen()

	@Test
	fun onCorrectScoreSubmit_shouldDisplayCorrectGrade() = before {
	// No-op
	}.after {
	// No-op
	}.run {
	screen {
	step("Open grade calculator screen") {
	rule.launchActivity(null)
	}

	step("Submit obtained marks") {
	inputMarks.replaceText("90")
	buttonSubmit.click()
	}

	step("Verify the displayed grade is correct") {
	labelGrade.hasText("Your Grade is: A")
	}
	}
	}
	}

view raw GradeCalculatorUiTestStep1.kt hosted with ❤ by GitHub

If we try to run this test, it will fail because we have not added the GradeCalculatorScreen yet. This test serves as a blueprint of what we want to achieve for the happy path of grade calculation. Let's break down each step:

TestCase - The first thing you might have noticed is that the test class extends TestCase, which is a base class provided by Kaspresso that gives access to most of its features.
Activity Test Rule - Next, we create an activity test rule for the grade activity. This part is the same as normal Instrumentation tests.
GradeCalculatorScreen Instance - This instance of the screen will be used in the Kaspresso DSL.
Test Body - For the test body, you might notice the chain of 3 separate blocks. You can use the block syntax instead of the expression body, but then it will add an extra indent to all the code inside the block which I do not like very much.
Before-After-Run - The before and after blocks are interceptors for anything you might want to do before or after the test respectively. For example, before can be used for mocking and after can be used to release resources.
Steps - Finally, the run block is where actual testing happens
- Every step is described with a step block. This part is optional, you can skip the steps if you want and directly write the encapsulating code. However, it is very helpful since not only it provides a comment on what is happening but this information also gets printed in the logs.
- In the first step, we launch the activity, this can be done directly with the test rule though.
- In the next two steps, we perform some actions on the GradeCalculatorScreen and then verify their results. Note that all the methods come from the library, we only provide view bindings in the Screen implementations.

Implementing The Kaspresso Screen

At this point, we cannot even compile the application due to missing classes. Let's provide an implementation for our GradeCalculatorScreen.

	import com.agoda.kakao.edit.KEditText
	import com.agoda.kakao.screen.Screen
	import com.agoda.kakao.text.KButton
	import com.agoda.kakao.text.KTextView
	import com.zuhaibahmad.kaspressotestingdemo.R

	class GradeCalculatorScreen: Screen<GradeCalculatorScreen>() {
	val inputMarks = KEditText { withId(R.id.etMarks) }
	val buttonSubmit = KButton { withId(R.id.btSubmit) }
	val labelGrade = KTextView { withId(R.id.tvGrade) }
	}

view raw GradeCalculatorScreen.kt hosted with ❤ by GitHub

As explained earlier, the screen class just binds the UI elements and organizes them into one place. Since we do not have these elements in the layout XML, the project won't compile unless we add them too. So here's a simple layout for it:

	<?xml version="1.0" encoding="utf-8"?>
	<androidx.constraintlayout.widget.ConstraintLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	xmlns:app="http://schemas.android.com/apk/res-auto"
	xmlns:tools="http://schemas.android.com/tools"
	android:layout_width="match_parent"
	android:layout_height="match_parent"
	android:padding="16dp"
	tools:context=".GradeCalculatorActivity">

	<androidx.appcompat.widget.AppCompatEditText
	android:id="@+id/etMarks"
	android:layout_width="0dp"
	android:layout_height="wrap_content"
	android:gravity="center"
	android:hint="@string/hint_enter_your_marks"
	app:layout_constraintBottom_toBottomOf="parent"
	app:layout_constraintLeft_toLeftOf="parent"
	app:layout_constraintRight_toRightOf="parent"
	app:layout_constraintTop_toTopOf="parent" />

	<androidx.appcompat.widget.AppCompatTextView
	android:id="@+id/tvGrade"
	android:layout_width="0dp"
	android:layout_height="wrap_content"
	android:gravity="center"
	android:textAppearance="@style/TextAppearance.AppCompat.Large"
	android:textColor="@color/colorAccent"
	app:layout_constraintEnd_toEndOf="parent"
	app:layout_constraintStart_toStartOf="parent"
	app:layout_constraintTop_toBottomOf="@id/etMarks"
	tools:text="Your Grade Is: A" />

	<androidx.appcompat.widget.AppCompatButton
	android:id="@+id/btSubmit"
	android:layout_width="0dp"
	android:layout_height="wrap_content"
	android:text="@string/submit"
	app:layout_constraintBottom_toBottomOf="parent"
	app:layout_constraintEnd_toEndOf="parent"
	app:layout_constraintStart_toStartOf="parent" />

	</androidx.constraintlayout.widget.ConstraintLayout>

view raw activity_grade_calculator.xml hosted with ❤ by GitHub

Now, the test will compile but the test will fail because we have not provided any business logic yet.

Adding The Business Logic

The next step is to provide the business logic to calculate the grade.

Since there is nothing new about this part, I will just copy the tests and resulting logic from the previous post. You can read the Kotest post{:target="_blank"} to understand better.

Create a GradeCalculatorSpec class inside the test package and add the specs for grade calculation:

	class GradeCalculatorSpec : BehaviorSpec({

	Given("a grade calculator") {
	val calculator = spyk(GradeCalculator())

	every { calculator.totalMarks } returns 100
	val total = calculator.totalMarks

	When("obtained marks are 90 or above") {
	val grade = calculator.getGrade(93, total)

	Then("grade is A") {
	grade.shouldBe("A")
	}
	}
	When("obtained marks are between 80 and 89") {
	val grade = calculator.getGrade(88, total)

	Then("grade is B") {
	grade.shouldBe("B")
	}
	}
	When("obtained marks are between 70 and 79") {
	val grade = calculator.getGrade(78, total)

	Then("grade is C") {
	grade.shouldBe("C")
	}
	}
	When("obtained marks are between 60 and 69") {
	val grade = calculator.getGrade(68, total)

	Then("grade is D") {
	grade.shouldBe("D")
	}
	}
	When("obtained marks are below 60") {
	val grade = calculator.getGrade(59, total)
	Then("grade is F") {
	grade.shouldBe("F")
	}
	}
	}
	})

view raw GradeCalculatorSpec.kt hosted with ❤ by GitHub

Once all the tests are passing, the resulting implementation would look something like this:

	class GradeCalculator {

	var totalMarks = 0

	fun getGrade(obtainedMarks: Int, totalMarks: Int): String {
	val percentage = getPercentage(obtainedMarks, totalMarks)
	return when {
	percentage >= 90 -> "A"
	percentage in 80..89 -> "B"
	percentage in 70..79 -> "C"
	percentage in 60..69 -> "D"
	else -> "F"
	}
	}

	private fun getPercentage(obtainedMarks: Int, totalMarks: Int): Int {
	return (obtainedMarks / totalMarks.toFloat() * 100).roundToInt()
	}
	}

view raw GradeCalculator.kt hosted with ❤ by GitHub

Binding It All Together

The final step is to bind the GradeCalculator with the UI. Let's add a click listener to the button and use the user input to calculate the grade.

	class GradeCalculatorActivity : AppCompatActivity() {

	companion object {
	private const val TOTAL_MARKS = 100
	}

	private val gradeCalculator = GradeCalculator()

	override fun onCreate(savedInstanceState: Bundle?) {
	super.onCreate(savedInstanceState)
	setContentView(R.layout.activity_grade_calculator)
	btSubmit.setOnClickListener {
	val inputMarks = etMarks.text.toString().toInt()
	val grade = gradeCalculator.getGrade(inputMarks, TOTAL_MARKS)
	tvGrade.text = "Your Grade is: $grade"
	}
	}
	}

view raw GradeCalculatorActivity.kt hosted with ❤ by GitHub

If all goes well, all tests should be passing now. Also, if you look at the logcat output, it will have a complete summary of all test steps.

Bonus: If there was no issue with permission, it should have also captured the screenshots for each step automagically! Look inside the gallery for them.

Here's the pidcat output of my tests:

	KASPRESSO I ---------------------------------------------------------------------------
	I BEFORE TEST SECTION
	I ---------------------------------------------------------------------------
	I ---------------------------------------------------------------------------
	I TEST SECTION
	I ---------------------------------------------------------------------------
	I ___________________________________________________________________________
	I TEST STEP: "1. Open grade calculator screen" in GradeCalculatorUiTest
	ActivityTestRule W getActivityIntent() returned null using default: Intent(Intent.ACTION_MAIN)
	ActivityThread W handleWindowVisibility: no activity for token android.os.BinderProxy@efc119d
	LifecycleMonitor D Lifecycle status change: com.zuhaibahmad.kaspressotestingdemo.GradeCalculatorActivity@76bf15e in: PRE_ON_CREATE
	D running callback: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	D callback completes: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	essotestingdem W Accessing hidden method Landroid/graphics/drawable/Drawable;->getOpticalInsets()Landroid/graphics/Insets; (light greylist, linking)
	W Accessing hidden field Landroid/graphics/Insets;->left:I (light greylist, linking)
	W Accessing hidden field Landroid/graphics/Insets;->right:I (light greylist, linking)
	W Accessing hidden field Landroid/graphics/Insets;->top:I (light greylist, linking)
	W Accessing hidden field Landroid/graphics/Insets;->bottom:I (light greylist, linking)
	W Accessing hidden method Landroid/view/View;->getAccessibilityDelegate()Landroid/view/View$AccessibilityDelegate; (light greylist, linking)
	W Accessing hidden method Landroid/view/View;->computeFitSystemWindows(Landroid/graphics/Rect;Landroid/graphics/Rect;)Z (light greylist, reflect
	ion)
	W Accessing hidden method Landroid/view/ViewGroup;->makeOptionalFitsSystemWindows()V (light greylist, reflection)
	W Accessing hidden method Landroid/widget/TextView;->getTextDirectionHeuristic()Landroid/text/TextDirectionHeuristic; (light greylist, linking)
	LifecycleMonitor D Lifecycle status change: com.zuhaibahmad.kaspressotestingdemo.GradeCalculatorActivity@76bf15e in: CREATED
	D running callback: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	D callback completes: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	D Lifecycle status change: com.zuhaibahmad.kaspressotestingdemo.GradeCalculatorActivity@76bf15e in: STARTED
	D running callback: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	D callback completes: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	D Lifecycle status change: com.zuhaibahmad.kaspressotestingdemo.GradeCalculatorActivity@76bf15e in: RESUMED
	D running callback: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	D callback completes: com.kaspersky.kaspresso.device.languages.LanguageImpl$lifecycleCallback$1@934993f
	OpenGLRenderer D HWUI GL Pipeline
	HostConnection D HostConnection::get() New Host Connection established 0xe8b21370, tid 6867
	D HostComposition ext ANDROID_EMU_CHECKSUM_HELPER_v1 ANDROID_EMU_dma_v1 ANDROID_EMU_YUV420_888_to_NV21 ANDROID_EMU_YUV_Cache ANDROID_EMU_async_u
	nmap_buffer GL_OES_vertex_array_object GL_KHR_texture_compression_astc_ldr ANDROID_EMU_gles_max_version_2
	ConfigStore I android::hardware::configstore::V1_0::ISurfaceFlingerConfigs::hasWideColorDisplay retrieved: 0
	I android::hardware::configstore::V1_0::ISurfaceFlingerConfigs::hasHDRDisplay retrieved: 0
	OpenGLRenderer I Initialized EGL, version 1.4
	D Swap behavior 1
	W Failed to choose config with EGL_SWAP_BEHAVIOR_PRESERVED, retrying without...
	D Swap behavior 0
	eglCodecCommon D setVertexArrayObject: set vao to 0 (0) 0 0
	EGL_emulation D eglCreateContext: 0xe8b05420: maj 2 min 0 rcv 2
	D eglMakeCurrent: 0xe8b05420: ver 2 0 (tinfo 0xe8b03790)
	HostConnection D createUnique: call
	D HostConnection::get() New Host Connection established 0xe8b215f0, tid 6867
	D HostComposition ext ANDROID_EMU_CHECKSUM_HELPER_v1 ANDROID_EMU_dma_v1 ANDROID_EMU_YUV420_888_to_NV21 ANDROID_EMU_YUV_Cache ANDROID_EMU_async_u
	nmap_buffer GL_OES_vertex_array_object GL_KHR_texture_compression_astc_ldr ANDROID_EMU_gles_max_version_2
	eglCodecCommon E GoldfishAddressSpaceHostMemoryAllocator: ioctl_ping failed for device_type=5, ret=-1
	EGL_emulation D eglMakeCurrent: 0xe8b05420: ver 2 0 (tinfo 0xe8b03790)
	AssistStructure I Flattened final assist data: 2688 bytes, containing 1 windows, 9 views
	KASPRESSO I TEST STEP: "1. Open grade calculator screen" in GradeCalculatorUiTest SUCCEED. It took 0 minutes, 0 seconds and 339 millis.
	I ___________________________________________________________________________
	KASPRESSO I ___________________________________________________________________________
	I TEST STEP: "2. Submit obtained marks" in GradeCalculatorUiTest
	essotestingdem W Accessing hidden method Landroid/os/MessageQueue;->next()Landroid/os/Message; (light greylist, reflection)
	W Accessing hidden field Landroid/os/MessageQueue;->mMessages:Landroid/os/Message; (light greylist, reflection)
	W Accessing hidden method Landroid/os/Message;->recycleUnchecked()V (light greylist, reflection)
	W Accessing hidden method Landroid/view/WindowManagerGlobal;->getInstance()Landroid/view/WindowManagerGlobal; (light greylist, reflection)
	W Accessing hidden field Landroid/view/WindowManagerGlobal;->mViews:Ljava/util/ArrayList; (light greylist, reflection)
	W Accessing hidden field Landroid/view/WindowManagerGlobal;->mParams:Ljava/util/ArrayList; (light greylist, reflection)
	ViewInteraction I Performing 'replace text(90)' action on view (with id: com.zuhaibahmad.kaspressotestingdemo:id/etMarks)
	KASPRESSO I replace text(90) on AppCompatEditText(id=etMarks;hint=Enter Your Marks;)
	essotestingdem W Accessing hidden method Landroid/view/ViewConfiguration;->getDoubleTapMinTime()I (light greylist, reflection)
	ViewInteraction I Performing 'single click' action on view (with id: com.zuhaibahmad.kaspressotestingdemo:id/btSubmit)
	KASPRESSO I single click on AppCompatButton(id=btSubmit;text=Submit;)
	I TEST STEP: "2. Submit obtained marks" in GradeCalculatorUiTest SUCCEED. It took 0 minutes, 0 seconds and 315 millis.
	I ___________________________________________________________________________
	KASPRESSO I ___________________________________________________________________________
	I TEST STEP: "3. Verify the displayed grade is correct" in GradeCalculatorUiTest
	ViewInteraction I Checking 'com.kaspersky.kaspresso.proxy.ViewAssertionProxy@d4df345' assertion on view (with id: com.zuhaibahmad.kaspressotestingdemo:id/tvGrad
	e)
	KASPRESSO I Check with text: is "Your Grade is: A" on AppCompatTextView(id=tvGrade;text=Your Grade is: A;)
	I TEST STEP: "3. Verify the displayed grade is correct" in GradeCalculatorUiTest SUCCEED. It took 0 minutes, 0 seconds and 5 millis.
	I ___________________________________________________________________________
	KASPRESSO I ---------------------------------------------------------------------------
	I AFTER TEST SECTION
	I ---------------------------------------------------------------------------
	I ---------------------------------------------------------------------------
	I TEST PASSED
	I ---------------------------------------------------------------------------

view raw TestOutput.txt hosted with ❤ by GitHub

Using Kaspresso, you can also handle runtime permissions, change device state, execute ADB commands right from your code. The flexibility it provides for writing tests in truly amazing.

Conclusion

This is a very basic example that does not handle any edge cases. However, I hope it was enough to give you a taste of test-driven development with Android.

We started with a crude idea without any implementation details in mind and used tests to shape our logic. There are a couple of benefits to this approach:

We ended up with a minimum workable solution with 100% code coverage
As every part of our logic is backed by Unit and UI tests, the tests themselves serve as a documentation for the features.
Since both the architecture and the logic is shaped by the tests themselves, it is quite easy to freely refactor the code further without worrying about regression bugs.

You can find complete source code for this post here{:target="_blank"}

For suggestions and queries, just contact me{:target="_blank"}.

Painless Unit Testing with Kotlintest & Mockk

Sat, 07 Sep 2019 11:00:00 GMT

Testing is hard and not everyone likes to spend their time writing unit tests when they could be building shiny new features.

While almost every developer understands the value of testing their code, most of us fall prey of laziness in the face of approaching deadlines and prospect of more exciting work.

In this post, let's understand why unit tests serve as the backbone of successful products and learn a new way of writing tests that is much simpler, intuitive and appealing.

Why Testing Matters

Since I mostly work with Android applications. I'll let you in on a little secret. More than half of the code bases you will come across will have little to no tests. Not just the crappy ones, but sometimes products with thousands of users.

This is often due to the complex and dull nature of old school JUnit based testing. Not only the process is quite boring, it also requires a lot of repetitive boilerplate code to be written for even the most simplest scenarios, making testing a very time consuming process.

Obviously, when you are in a rush to take the product out as soon as possible, testing becomes least desirable practice.

More often than not, the end result is that project becomes unmaintainable within a year. I have seen organizations rewriting already published products only because the code base has become unmaintainable due to spaghetti code that is rotten with bugs.

Obviously this is not a desirable situation. Testing your code for bugs and architectural flaws from the beginning solidifies your product to be manageable in the longer run.

"If you can not measure it, you can not improve it." - Lord Kelvin

Testing As You Go

Laying the foundations of your project with extensive testing is not a new idea. Behavior Driven Development has been around for decades.

The practice is to turns feature specifications (or user stories) into a set of unit tests and then writing code that satisfies those specs via passing tests.

This results in co-development of both your features and their tests side by side. Coupled with a Continuous Integration solution, this setup almost guarantees that you will never have any regression bugs.

Specification Based Testing In Practice

Cucumber is the most widely used BDD testing framework right now. It provides a plain language parser called Gherkin which can be used to write tests in plain English that non-programmers can also understand. The framework turns these specifications into acceptance tests which also serves as the documentation for each feature. Here is what a test written in Gherkin looks like:

Feature: Calculator
As a user
I want to use a calculator to add numbers
So that I don't need to add myself

Scenario: Add two numbers -2 & 3
Given I have a calculator
When I add -2 and 3
Then the result should be 1

Scenario: Add two numbers 10 & 15
Given I have a calculator
When I add 10 and 15
Then the result should be 25

Neat! Isn't it? This spec results in unit tests that run with Cucumber. Since this post is not about Cucumber, I won't go into the implementation details. You can visit this tutorial{:target="_blank"} for full tutorial on BDD style testing with Cucumber. I used the same article to borrow the above example.

Some other popular BDD frameworks include Lettuce{:target="_blank"}, Jasmine{:target="_blank"}, SpecFlow{:target="_blank"}, Spek{:target="_blank"}, Behat{:target="_blank"}, Jdave{:target="_blank"} and Jbehave{:target="_blank"}

Problems with JUnit

JUnit is a industry standard at this point for all things Java. It has ruled the Java development for decades now and it works. But since it was built for Java, it brings with it most of the common pitfalls of Java based technologies that feel backwards, specially in the world of modern programming languages like Kotlin, JavaScript and Python.

Having said that, writing all styles of tests are entirely possible with JUnit. Mockito provides a BDD style extension in its core library that allows you to do similar Give, When, Then style testing within JUnit test cases.

Let's take a look at some of the problems associated with it and why I believe vanilla JUnit is not a good combination for a powerful language like Kotlin:

Code Repetition

Like everything in Java, JUnit is also quite verbose. This results in too much repetition of similar contents with slight change of logic to test different scenarios.

How many time have you had a test for a HAS and a HAS-NOT condition with all the same contents except for a boolean? For example, a testAccessWhenHasToken and then testAccessWhenNoToken.

Of course, you can stuff in all your assertions in one test at the cost of readability. However, a good test is supposed to be granular i.e. targeting one case per test.

Also, your test code is guaranteed to grow as your project gets bigger and at some point your test code will surpass your application code. If you want to look at examples of this, try looking into the source code of any popular open source projects such as RxJava, Retrofit, OkHttp, Picasso etc. Almost all of them have 1.5x to 2x more test code compared to their business logic.

Lack Of Contextual Information

If you are like me, then one of the first things that you may have done while switching to Kotlin was to change your long JUnit test names like fun onTouchOutside_shouldDismissDialogAndResumeStreaming() with back tick notation. While a big improvement, it gave us a license to go wild with it in our attempts to provide more contextual information about each test case. So now our test case has evolved into something like this: fun `on touch outside, dismiss dialog and resume streaming the paused song` ()

The real issue here is that these names are not enough to provide full context about the test. Unless you are willing to write entire paragraph to define the pre and post conditions for the scenario.

Another problem here is with the organization of test cases. Most of the test cases have some shared code that can be logically structured into a hierarchy. However, because JUnit only allows you to write tests in the form of class methods. So you end up writing more tests, more code but with less context about overall theme of the current group of tests.

A Better Way To Write Tests

The reason behind giving you a taste of Cucumber BDD was to show what it would be like to have such idiomatic tests.

Let's define a set of specification that we want to build and test. We will be using two libraries Kotlintest and Mockk to help us write tests.

Feature

Let's build a grade calculator that tells you your grade based on the marks you obtained. Here are the rules for grading:

When obtained marks are 90 or above, then grade is A.
When obtained marks are between 80 and 89, then grade is B
When obtained marks are between 70 and 79, then grade is C
When obtained marks are between 60 and 69, then grade is D
When obtained marks are below 60, then grade is F

Installation

First, create an empty Kotlin or Android project and add the following two dependencies:

testImplementation 'io.kotlintest:kotlintest-runner-junit5:3.3.2'
testImplementation 'io.mockk:mockk:1.9.3.kotlin12'

The first dependency is Kotlintest which is a testing library built on top of JUnit. It takes advantage of Kotlin's DSL capabilities to support various type of testing styles.

Mockk is a Kotlin-based mocking library with a very clean syntax that blends really well with Kotlintest's specs. It also provides much more flexible API and much wider set of feature compared to Mockito or Powermock.

Implementation

Let's start by creating an empty GradeCalculator class and converting our specifications into a Spec.

class GradeCalculatorSpec : BehaviorSpec({

  Given("a grade calculator") {
    val calculator = spyk(GradeCalculator())

    every { calculator.totalMarks } returns 100
    val total = calculator.totalMarks

    When("obtained marks are 90 or above") {
      Then("grade is A") {}
    }
    When("obtained marks are between 80-89") {
      Then("grade is B") {}
    }
    When("obtained marks are between 70-79") {
      Then("grade is C") {}
    }
    When("obtained marks are between 60-69") {
      Then("grade is D") {}
    }
    When("obtained marks are below 60") {
      Then("grade is F") {}
    }
  }
})

This does not quite look like our traditional JUnit test. So let's break it down and understand bit by bit:

BehaviorSpec - We are extending something called a BehaviorSpec which is basically a Spec written in BDD style (remember the Give, When, Then from Cucumber?). There are dozens of different other Spec styles available in Kotlintest.
Spyk - You may notice that I wrapped the GradeCalculator object with a spyk method. If you have used Mockito before than the concept is the same. Basically, a spy is a wrapper that lets you mock some methods and variables of the object while using the actual values for the rest. I did it to demonstrate the use of Mockk here.
Every/Returns - Similar to Mockito's when/then style, this construct is used by Mockk to to prepare mock values. All we are saying is to return a mock value whenever anyone in this code block asks for this value. The value we are mocking is total marks which are going to help calculate the grade.
When/Then - Finally, there are a bunch of Then blocks nested inside When blocks with some description. The When block is nothing but a way to organize tests in a logical fashion while each Then serves as the actual test where the assertion happens. So you can have a test with just a Then statement but then there's no point of using it.

Next, lets add some functionality to the GradeCalculator class.

class GradeCalculator {

  var totalMarks = 0

  fun getGrade(obtainedMarks: Int, totalMarks: Int): String {
    val percentage = getPercentage(obtainedMarks, totalMarks)
    return when {
      percentage >= 90 -> "A"
      percentage in 80..89 -> "B"
      percentage in 70..79 -> "C"
      percentage in 60..69 -> "D"
    else -> "F"
    }
  }

  private fun getPercentage(obtained: Int, total: Int): Int {
    return  (obtained / total.toFloat() * 100).roundToInt()
  }
}

Here I added a totalMarks field which we mock in our test. This value is used in the getPercentage method to calculate the percentage between total and obtained marks.

Finally, the getGrade calculates the grade by comparing the calculated percentage with different ranges.

You can build this class in a TDD fashion by running the tests first and adding the functionality to make the failing tests pass one by one. I believe the end result would still be somewhat similar.

In the end, lets add some assertions to test the specifications we just wrote. The final implementation would look something like this:

package com.zuhaibahmad.bddtestingtutorial

import io.kotlintest.shouldBe
import io.kotlintest.specs.BehaviorSpec
import io.mockk.every
import io.mockk.spyk

class GradeCalculatorSpec : BehaviorSpec({

  Given("a grade calculator") {
    val calculator = spyk(GradeCalculator())

    every { calculator.totalMarks } returns 100
    val total = calculator.totalMarks

    When("obtained marks are 90 or above") {
      val grade = calculator.getGrade(93, total)

      Then("grade is A") {
        grade.shouldBe("A")
      }
    }
    When("obtained marks are between 80 and 89") {
      val grade = calculator.getGrade(88, total)

      Then("grade is B") {
        grade.shouldBe("B")
      }
    }
    When("obtained marks are between 70 and 79") {
      val grade = calculator.getGrade(78, total)

      Then("grade is C") {
        grade.shouldBe("C")
      }
    }
    When("obtained marks are between 60 and 69") {
      val grade = calculator.getGrade(68, total)

      Then("grade is D") {
        grade.shouldBe("D")
      }
    }
    When("obtained marks are below 60") {
      val grade = calculator.getGrade(59, total)

      Then("grade is F") {
        grade.shouldBe("F")
      }
    }
  }
})

Conclusion

I discussed above that JUnit tests lack contextual information and proper grouping of co-related tests. You can see how every test in the spec has a hierarchy which can be used to compose complex cases.

Furthermore, for this particular style of testing, kotlintest provides an additional And block to allow you to create even more complex tests without loosing contextual information. For example, you may want to construct a test like this:

When("user list is fetched from API") {
  And("the internet is NOT available"){
    Then("Test something"){
      // Some assertions
    }
  }
  And("the internet is available"){
    Then("Test something"){
      // Some assertions
    }
  }
}

Finally, not just the tests are well organized, the test results in Android Studio have that nested style too. Here's the result of our tests in the IDE:

You can find complete source code for this post here{:target="_blank"}

For suggestions and queries, just contact me{:target="_blank"}.

Inter-Process Communication in Android - Lessons & Learnings

Sun, 28 Apr 2019 11:00:00 GMT

Recently, I was tasked with building a solution for OTA (Over-the-Air) updates for one of our products at SodaLabs{:target="_blank"}. Now for those of you who are not familiar with the concept, here's a definition by TechTarget{:target="_blank"}:

An over-the-air update is the wireless delivery of new software or data to mobile devices. Wireless carriers and original equipment manufacturers (OEMs) typically use over-the-air (OTA) updates to deploy firmware and configure phones for use on their networks. The initialization of a newly purchased phone, for example, requires an over-the-air update. With the rise of smartphones, tablets and internet of things (IoT) devices, carriers and manufacturers have also turned to over-the-air updates for deploying new operating systems (OSs) to these devices.

Basically, the updates you receive for your Android, iOS, Windows, Mac or Linux devices are distributed through the mechanism known as OTA programming.

Going the Sandbox Way

We had a couple of choices around how to build this OTA client, but in the end we decided to build it as a completely separate project. The reason was that both the main product and OTA client were equally complex solutions and we didn't want to make it more complex by adding the OTA as part of the main project.

The OTA would essentially be just a service that runs as a background process and communicate with the main application (the product whose updates this OTA was supposed to manage) via AIDL i.e. the IPC mechanism used by Android.

This was the first time I was going to be working with IPC in general. So unsurprisingly, there was a lot of frustration, learning and fixing through trial and error involved.

My goal in this post is to write about the basics and share some insights from my experience so that you can avoid the confusions that I had to face.

Inter-Process Communication

Let's start by understand what Inter-Process communication is. Inter-Process Communication or IPC in short, is a mechanism that allows multiple independent processes to communicate and exchange data.

This communication is often achieved through the use of some shared interfaces defined through Interface Description Language (IDL). What it does is basically establish a set of rules that all the interested processes follow. These shared interfaces serves as a common language that all the parties use to communicate with each other.

How IPC Works In Android

All the applications in Android runs in its own process in a sandbox environment. Which means that each application is independent of others. This isolation helps improve the performance of overall system and in achieving better security through different levels of permissions and access privileges.

Android has its own version of IDL called Android Interface Definition Language (AIDL), which has very much a Java-esque syntax. You basically start by defining an interface (or multiple based on your use case) and then implement the interface in your application and in the client application that wishes to communicate our app.

Understanding The Architecture

One important thing to understand is that IPC communication in Android is also client-server based. Which means that one application has to act as the server while others can interact with it using the interface it exposes.

Generally that Server application is the one you are writing and which you wish to be controlled from outside sources. Following are the components and steps involved:

An AIDL interface: You define an interface in your server application containing the API that you want to expose to your clients.
Implementation of AIDL interface: Rebuilding your project will generate a java interface from your AIDL file, which you can then use to write a concrete implementation of it.
Expose the interface to the clients: Now that you have a concrete implementation of your AIDL interface, it is time to expose it to your clients by binding it with a Service. This Service can be invoked by external applications and then used a communication channel.
Exchanging data via IPC: On Android, one process cannot normally access the memory of another process. So to talk, they need to decompose their objects into primitives that the operating system can understand, and marshall the objects across that boundary for you. This means that you can only exchange primitive type data through IPC in the most basic from.
Writing the parcelable implementations: Since in most real-world applications you cannot live off just the primitives. Android also provides a mechanism to exchange your Objects through IPC with the use of Parcelables.

These are the 5 main steps required to implement the IPC capabilities in an application. However, admittedly they are not simple and bound to give you a lot of trouble. Let's look at the implementation now.

Off To The Code

Let's build a very basic application that let's you perform addition. To demonstrate the use of data exchange with both primitives and objects, instead of returning a simple integer value for result, we will return a made-up Result object.

Start by creating a simple project with two modules, one serving as a Client while the other as the Server. You can find the link to the complete code at the end of post.

The AIDL Interface

Now that you have a basic setup, let's first define our very simple AIDL interface in which we want to expose a single method called performAddition which takes 2 integer values and returns a made-up Result object.

// IAddition.aidl
package com.zuhaibahmad.aidldemo;

import com.zuhaibahmad.aidldemo.Result;
// Declare any non-default types here with import statements

interface IAddition {
  Result performAddition(int numOne, int numTwo);
}

Now as I mentioned above, since we are using a custom object, we need to define a simple AIDL implementation for it as well.

// Result.aidl
package com.zuhaibahmad.aidldemo;

parcelable Result;

Build the project and if no errors occur, then you should be able to find a java implementation of of your AIDL interface.

Once successful, make sure to copy both of your AIDL files to the client project as well.

Implementation Of The AIDL Interface

Next step is to provide concrete implementation of the AIDL interfaces. For the Result object, all you need is a parcelable POJO for it. However! You need to write it the old school java way.

I know you love Kotlin and must be thinking of using parcelize or at least take advantage of the simpler Kotlin code for data classes, but for some reason Kotlin based parcelables don't work at the time of this writing.

So here's your implementation for Result class in pure java style:

Make sure to copy this class into client's source code as well since it is needed by client to interpret the Result AIDL interface.

package com.zuhaibahmad.aidldemo;

import android.os.Parcel;
import android.os.Parcelable;

public class Result implements Parcelable {
private int numOne;
private int numTwo;
private int result;

  public Result() {}

  public Result(int numOne, int numTwo, int result) {
    this.numOne = numOne;
    this.numTwo = numTwo;
    this.result = result;
  }

  public int getNumOne() {
    return numOne;
  }

  public void setNumOne(int numOne) {
    this.numOne = numOne;
  }

  public int getNumTwo() {
    return numTwo;
  }

  public void setNumTwo(int numTwo) {
    this.numTwo = numTwo;
  }

  public int getResult() {
    return result;
  }

  public void setResult(int numResult) {
    this.result = numResult;
  }

  @Override
  public String toString() {
    return numOne + " + " + numTwo + " = " + result;
  }

    @Override
  public int describeContents() {
    return 0;
  }

  @Override
  public void writeToParcel(Parcel parcel, int i) {
    parcel.writeInt(numOne);
    parcel.writeInt(numTwo);
    parcel.writeInt(result);
  }

  public static final Parcelable.Creator<Result> CREATOR = new Parcelable.Creator<Result>(){

    @Override
    public Result createFromParcel(Parcel parcel) {
      Result res=new Result();
      res.numOne = parcel.readInt();
      res.numTwo = parcel.readInt();
      res.result = parcel.readInt();
      return res;
    }

    @Override
    public Result[] newArray(int size) {
      return new Result[size];
    }
  };
}

Anyways, let's now provide the implementation for our IAddition AIDL interface in the server application:

package com.zuhaibahmad.aidldemo

import android.app.Service
import android.content.Intent
import android.os.IBinder
import android.util.Log

class AdditionService : Service() {

  override fun onBind(intent: Intent?): IBinder? {
    Log.e("server", "Binding Service")
    return object : IAddition.Stub() {
      override fun performAddition(numOne: Int, numTwo: Int): Result {
        return Result(numOne, numTwo, numOne + numTwo)
      }
    }
  }
}

While we are at it, let's also register this service in our manifest file. With that our server application will be ready:

<service
  android:name=".AdditionService"
  android:enabled="true"
  android:exported="true" >
  <intent-filter>
    <action
      android:name="com.zuhaibahmad.aidldemo.AdditionService"
    />
  </intent-filter>
</service>

Hooking The Service To The Client

Last step is to bind the AdditionService in the server application to the client app and starting it remotely. I have a very basic activity with the following UI for client app:

Let's implement the activity now:

package com.zuhaibahmad.aidldemo

import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.Bundle
import android.os.IBinder
import android.support.v7.app.AppCompatActivity
import android.util.Log
import kotlinx.android.synthetic.main.activity_main.btEquals
import kotlinx.android.synthetic.main.activity_main.etNumOne
import kotlinx.android.synthetic.main.activity_main.etNumTwo
import kotlinx.android.synthetic.main.activity_main.tvResult

class MainActivity : AppCompatActivity(), ServiceConnection {

  private var isBound: Boolean = false
  private var iRemoteService: IAddition? = null

  // Called when the connection with the service is established
  override fun onServiceConnected(
    className: ComponentName,
    service: IBinder
  ) {
    // Following the example above for an AIDL interface,
    // this gets an instance of the IRemoteInterface,
    // which we can use to call on the service
    Log.e("client", "Service connected!")
    iRemoteService = IAddition.Stub.asInterface(service)
    isBound = true
  }

  // Called when the connection with the service disconnects
  override fun onServiceDisconnected(className: ComponentName) {
    Log.e("client", "Service disconnected!")
    iRemoteService = null
  }

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    bindService()

    btEquals.setOnClickListener {
      onPerformAddition()
    }
  }

  private fun onPerformAddition() {
    val numOne = etNumOne.text.toString().toInt()
    val numTwo = etNumTwo.text.toString().toInt()

    tvResult.text = if (isBound) {
      val result = iRemoteService?.performAddition(numOne, numTwo)
      result.toString()
    } else {
      "Service not bound!"
    }
  }

  override fun onDestroy() {
    unbindService()
    super.onDestroy()
  }

  private fun bindService() {
    Log.e("client", "Attempting to bind service")
    val serviceIntent = Intent()
    serviceIntent.setClassName(PACKAGE_NAME, SERVICE_NAME)
    serviceIntent.action = ACTION_REMOTE_BIND
    bindService(serviceIntent, this, Context.BIND_AUTO_CREATE)
  }

  private fun unbindService() {
    if (isBound) {
      // Detach our existing connection.
      unbindService(this)
      isBound = false
    }
  }

  companion object {
    @JvmStatic
    val PACKAGE_NAME: String = "com.zuhaibahmad.aidldemo"

    @JvmStatic
    val SERVICE_NAME: String = "com.zuhaibahmad.aidldemo.AdditionService"

    @JvmStatic
    val ACTION_REMOTE_BIND = "$SERVICE_NAME-remote-bind"
  }
}

If all goes well, you should be able to compute your additions through the server app using AIDL interfaces.

Things To Remember

In the end, as you may have realized that this mechanism is not very robust and prone to error. So here are few tips from what I learnt working with Android's IPC about the things that could easily go wrong and make you waste a lot of time.

Be very careful about the intent that you use to trigger the service, a minor typo will lead to service never starting.
On the same note, if you face a situation at the start where you are not getting the results, verify your service bindings first before diving into debugging. It could just be a faulty service binding and will save you a lot of effort.
Remember that ONLY primitive types are allowed, so always make sure that you are not accidentally accepting or returning a non-primitive object.
One of the biggest pain was with threading, I never realized that thread would affect IPC as well. Basically, calls made from the local process are executed in the same thread that is making the call. If this is your main UI thread, that thread continues to execute in the AIDL interface. So be very careful if you are using RxJava or any other async mechanism.
Remember, Kotlin classes does not work for parcelable implementations with AIDL. At least not at the time of this writing, and what's worse is that it does not give you any error.

Helpful Resources

This awesome post by DevArea{:target="_blank"}.
Detailed guide about IPC in Android on Official Android Resources{:target="_blank"}.
Also, this Medium Article{:target="_blank"}.

You can find complete source code for this post here{:target="_blank"}

For suggestions and queries, just contact me{:target="_blank"}.

Pythonic Imports in Kotlin

Sat, 01 Dec 2018 16:00:00 GMT

If you have been working with Kotlin for some time now, you might have encountered issues with name conflicts with Kotlin's reserved keywords. A common example is with the popular mocking library Mockito, where the when method which is now used by Kotlin for its switch-like construct. So you end up doing something like this:

`when`(messenger.getMessage()).thenReturn("Hello World!")

Another scenario is when you want to name the imported class or extension function something more meaningful and readable. Which can be acheived to some extent with the use of a typealias. However, there's a better solution available right into the Kotlin standard library.

Pythonic Way of Handling Imports

One the most flexible things I find in Python is the ability to name the imported classes almost anything you want, just like a variable. So you would simply import a class with a name that suits your style e.g.

import matplotlib.pyplot as plt

Now, you can use plt as a variable throughout your script.

Kotlin's Import-As Alias

I wished to have this for Android development after I ran into some ambiguity issues with a recent project. Upon some searching, I was surprized to find that Kotlin had this feature all along. Just like Python, you can simply add imports with an as keyword.

Let's look at how our Mockito problem is resolved now:

import org.mockito.Mockito.`when` as whenever

You can now use whenever in place of the less pleasant 'when' througout the class.

whenever(messenger.getMessage()).thenReturn("Hello World!")

So that was it. Another reason to love Kotlin (and Python as well)! ;)

For suggestions and queries, just contact me{:target="_blank"}.

Parcelize: Boilerplate Free Parcelization With Kotlin

Mon, 20 Aug 2018 12:25:00 GMT

Serialization is the process of converting an object into a stream of bytes for ease of use for different I/O operations. Examples include writing to a database, memory or a file. In context of Android, the most common usecase is to pass an object around Activities and Fragments.

The main idea is to be able to preserve the state of the object in the most primitive way and be able recreated it when needed. The reverse process is called Deserialization.

Java Serialization & Android

The way our old boy Java used to handle serialization was very simple - You would only need to implement a marker interface i.e. java.io.Serializable and objects of that class would be automagically serializable.

public class Foo implements Serializable {
  private int data;
}

This looks perfect, let's leave it here and use this awesome interface everywhere.

But wait! This oversimplification comes at a big cost. The process involves reflection and creation of tonnes of helper objects behind the scenes. Which results in excessive garbage collection and poor performance.

In order to solve this problem, Android came with its own mechanism - Parcelable. Although it is more robust, it sacrifices the simplicity of Serialzable to acheive that. This results in more boilerplate code but which is completely reflection free.

They key to acheiving that, is that we have to explicitly define the serialization process using the writeToParcel method. Here's what your ordinary parcelable class with a single field looks like:

public class Foo implements Parcelable {
  private int data;

  public int describeContents() {
    return 0;
  }

  public void writeToParcel(Parcel out, int flags) {
    out.writeInt(data);
  }

  public static final Parcelable.Creator<Foo> CREATOR
    = new Parcelable.Creator<Foo>() {

    public Foo createFromParcel(Parcel in) {
      return new Foo(in);
    }

    public Foo[] newArray(int size) {
      return new Foo[size];
    }
  };

  private Foo(Parcel in) {
    data = in.readInt();
  }
}

We have been using this for years now, but if you have been using something like Parceler or if you are used to minimal Kotlin code now, then your reaction would probably be something like:

Kotlin To The Rescue (Again?!)

The release of Kotlin 1.1.4 added experimental support for generating Android Parcelable implementations using the @Parcelize annotation. It brings back the simplicity of Serializable but without reflection. It instead uses annotation processing to acheive that.

Setup

Since it is an experimental feature right now, you will need to enable the support for it by adding the following snippet to your gradle file:

androidExtensions {
  experimental = true
}

Also, add apply plugin: ‘kotlin-android-extensions’ to your gradle file if it isn't there already.

Usage

The process of making any class parcelable involves adding only two things - a @Parcelize annotation and marking the class with Parcelable implementation.

Here's what our Foo class would look like:

@Parcelize
data class Foo (val data: Int) : Parcelable

And that was it! When combined with data classes, we ended up with even simpler code than Java's Serializable.

For suggestions and queries, just contact me{:target="_blank"}.

Why Reactive Should Be Default for Mobile

Sat, 04 Aug 2018 01:10:00 GMT

In the early days of software, the way code was written was pretty straight forward. You would start at a single entry point in the program (typically a main function), execute the instructions sequentially and end the program gracefully. It was simple and easy to conceptualize.

Due to the linear control flow, it was not only easier to manage the state of the program but also to test and debug it because all the possible outcomes were predictable. The success of this imperative approach contributed to the way programming mindset established in the years to come. Today, most of us like to think in imperative fashion regardless of the platform or technology we work with.

Imperative Approach Fails With Modern Systems

“All modern systems are asynchronous.”

This may seem misleading at first but if you think about it, almost every system today requires us to code in non-blocking fashion. What I mean by non-blocking is that, you need to eliminate waiting periods from the system as much as you can. For example, it’s not ideal to display a loading indicator to the user while a network request is being processed. Although many still follow this pattern but from user experience standpoint, this is a recipe for disaster.

“Nobody likes to wait and they’ll leave if they are not served instantly.”

The situation worsens with mobile platforms where the OS itself is a source of a countless external changes. You could just flip your device and it’ll break your app unless you have added 3x more code than required just to handle a rotation scenario. What is surprising though, is that almost all of these popular mobile platforms were not designed to be reactive despite them being asynchronous by nature.

Reactive Programming

Hmmm… So what exactly is Reactive Programming? Let’s take some help from Wikipedia:

“In computing, reactive programming is a declarative programming paradigm concerned with data streams and the propagation of change.”

Never mind! So, consider you have a program in which we have a Button and Label. They are defined as classes, like any other thing in an object oriented system. All this program does is updates the Label’s text to “Clicked!” when the Button is clicked. So we can say that the Button can somehow affect the text inside the Label, right?

So the case is simple, Button can be clicked and Label can be updated, both can be defined as a function in their respective classes. Now, here’s a question! If you were to code this interaction, where would you put the logic for updating the label when the button is clicked? Is it inside the Button itself or the Label?

Let’s say you go with the button, which btw is how we normally do it, then in this case you’ll need a reference of Label inside your button which you can update whenever the button is clicked. This essentially is Proactive way of programming. We basically delegated all the responsibility of state-management to the Button and let the Label stay passive i.e. don’t care about what is going on outside. Just follow the instructions when interacted.

The class Button would look something like this:

class Button (val label: Label) {
  public fun onClick() {
    label.setText("Clicked!")
  }
}

The alternative to this approach is Reactive programming. We basically just invert the roles so that the state owner has the ability to change itself, letting the Button call for change and Label react to it.

In this case, the Button class would be similar to this (notice how there's absolutely no trace of label or any outside dependency):

class Button {

  interface ClickListener {
    fun doOnClick()
  }

  var listener: ClickListener? = null

  public fun onClick() {
    listener?.doOnClick()
  }

  public fun addOnClickListener(l: ClickListener) {
    listener = l
  }
}

While the Label will carry all the code for state its management along with list of all the registered clients.

class Label (val buttons: MutableList<Button>) {

  private var text = ""

  init {
    buttons.forEach {
      it.addOnClickListener {
        this.setText("Clicked!")
      }
    }
  }

  private fun setText(text: String) {
    this.text = text
  }
}

But why reactive? What changes with this approach?

First, the Inversion of Control i.e. Label class is now completely responsible of managing its own state and can easily hide away all the implementation details from outside world.

Second but related, is that now we have only one source of change. What I mean by that is how previously we had to make setText method public and all the clients could call it whenever they wanted, which means increased complexity. Now we have a hidden setText method that is called from only one place i.e. inside Button's doOnClick callback and you can attach as many clients to it as you want using the addOnClickListener callback. This leads to Separation of Concern and simplified codebase.

Reactive Extensions

As described in the previous section, Callbacks are key enablers of reactive programming. However, this way of doing things can lead to a very uncomfortable situation known as Callback Hell. Reactive Extensions (abbreviated as RX) is a framework that helps address such issues.

The basic building blocks of the library are Observable, Observers and Operators. If you are familiar with the Observer Pattern, this is essentially the same pattern with some enhancements. You make things Observable and let some other things Observe these observables, during the process where Observable produces some data and the Observable receives it, you apply some Operators to mold the data in the form you like to have at the receiving end.

To learn more about the framework, checkout this talk by Kaushik Gopal or the guide by André Staltz.

Mobile & RX Movement

Now that we know about Reactive Programming and its helper framework. The question is how that solve problems associated with mobile platform that I mentioned at the start of this post?

Instead of giving long explanations of my own, I’d rather direct you to this awesome talk by Jake Wharton where he discusses these problems in context of Android and their solution with use of RxJava.

The crux is basically don’t hate yourself, go async and let the world handle their own problems instead of making your code rely on outside changes in proactive fashion.

Conclusion

State management is hard, especially on mobile platforms. While ideally SDKs should themself be reactively designed, we shouldn’t let that be a source of unreliability in our applications. Thanks to RX movement, we have reactive extensions port for almost every well known language. In context of Android specifically, the rise of Kotlin has provided a great opportunity to finally start writing our applications in functional and reactive manner.

Image Source - ReactiveX{:target="_blank"}.
For suggestions and queries, just contact me{:target="_blank"}.

Kotlin: Java on steroids or something more?

Sat, 28 Oct 2017 01:10:00 GMT

The first time I heard about Kotlin was back in 2015 and my initial reaction was like "Meh! Just another heck into Android ecosystem that would lead to disasters. I'll pass!". I waited and waited for the hype to die down -- but it never did.

The popularity of Kotlin kept on increasing. There was something about Kotlin, there was something that's lacking in Java, I just didn't knew what it was and being a Java fanboy I never bothered investigating. Whatever the case was, everyone was going crazy over it. So finally the prayers were answered and Google made Kotlin an Official language for Android{:target="_blank"} at the Google I/O '17{:target="_blank"}.

Background

The reason for my immediate disapproval was because of the huge number of half-baked platforms and tools emerging for Android during that period. Every single one of them was following the same pattern. They all started out with a bang, did some impressive demos, showed great promise, made it look like everything is going to change, eventually hit technical barriers and then disappeared forever or almost died.

They were hyped not because there was something groundbreaking about them but because there were actual problems with Java and people were desperately looking for alternatives. Anyone coming from Python, Swift or Javascript background could see the huge gap between Java and other modern programming languages.

While there were lambdas, optional types, easier asynchronous processing mechanisms and loads of other useful features in others; Java developers were still fighting Null Pointer Exceptions and writing tons of boilerplate crap everyday.

Kotlin To The Rescue

Right after the acceptance from Google and built-in support for it in Android Studio 3, I started taking interest in it. Boy I was wrong about Kotlin! Just this single demo by Hadi Hariri{:target="_blank"} done at the Google I/O was enough to convert me. Learning curve is lean for anyone familiar with Java so it took roughly 2 days to grasp the core concepts and starting to write first production application.

Now I was having a good time with it (already a fan btw!), the codebase was very concise, boilerplate free and readable - in fact pretty much self-explanatory. However, still I couldn't come up with an expression to explain that magic. Sure there were thousands of technical arguments in its favor but it was not something you'd tell your manager when trying to convince them to use it. Then recently while watching this talk on RxJS{:target="_blank"} it clicked!

Programming should be more about "what".

One of the reasons why Python is so popular in scientific and research domains is because it is doing exactly that. It enables them to focus on solving problems instead of tangling into platform specific low level details.

On the other hand we are still focusing too much on 'How' rather than 'What' to do. A developer should be concerned with completing the task at hand with few lines of code instead of fighting the issues and barriers put in their path by the platform itself.

Alright, enough ranting about Java! Let's take a look at what Kotlin has to offer that makes it different.

Bringing Good Of All Worlds

After having a taste of Python, Javascript and a little bit of Swift, it was easy to identify the source of inspiration for many features (Yes, I know Kotlin is older than Swift and they didn't copy). However, even after using it for a few months, I believe there are still a lot of undiscovered bits that are yet to be explored. So for brevity's sake, I'll be focusing only on the major features.

Type Safety

The selling point for JetBrains{:target="_blank"} has been "NPE Free Language" for the most part and why wouldn't it be? We're all familiar with null pointer exception jokes made on Java developers.

Specially on Android it is quite annoying when the entire application just blows up in your face due to a sudden NPE and then as a developer you'll have to spend a lot of time going back to the same state where you were before.

.. and GOD Help you if they show up in the production code.

In Kotlin, the syntax is different for references that can hold null and those that can not. For example, a regular variable of type String can not hold null:

var a: String = "abc"
a = null // This leads to compile time error

The syntax to allow nulls is to add a trailing question mark after the type declaration e.g. String?:

var b: String? = "abc"
b = null // Acceptable

Now, if you call a method or access a property on a, it's guaranteed not to cause an NPE, so you can safely say:

val l = a.length

But if you want to access the same property on b, that would not be safe, and the compiler reports an error:

val l = b.length // error: variable 'b' can't be null

It doesn't stop at this, type safe calls allows you to eliminate if (someValue != null) blocks for nullable types with simple ?. operator which essentially means execute this only when the value is not null.

val listWithNulls: List<String?> = listOf("A", null)
for (item in listWithNulls) {
  item?.let { println(it) } // prints A and ignores null
}

You can also apply an alternate logic for null case using elvis operator which is equivalent to the else block that follows the if not null block. The syntax for it is ?:, so your conditional code will look something like this:

val l = b?.length ?: -1

This is just an overview, it'll take at least an entire post to cover all of the type system. You can read more about it on the Kotlin's official documentation{:target="_blank"}

Data Classes

This one is my personal favorite so far. How much code do you have to write for a data class? And how much more do you have to add if you need to add equals(), hashCode(), clone() and toString() functionality? This is your average data class declaring fields and providing that additional functionality along with getters and setters:

public class Customer {
  private String name;
  private String email;
  private String company;

  public Customer(String name) {
    this(name, "", "");
  }

  public Customer(String name, String email) {
    this(name, email, "");
  }

  public Customer(String name, String email, String company) {
    this.name = name;
    this.email = email;
    this.company = company;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }

  public String getCompany() {
    return company;
  }

  public void setCompany(String company) {
    this.company = company;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Customer c = (Customer) o;

    if (name != null ? !name.equals(c.name) : c.name != null)
      return false;
    if (email != null ? !email.equals(c.email) : c.email != null)
      return false;
    return company != null
      ? company.equals(c.company)
      : c.company == null;
  }

  @Override
  public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + (email != null ? email.hashCode() : 0);
    result = 31 * result + (company != null ? company.hashCode() : 0);
    return result;
  }

  @Override
  public String toString() {
    return "Customer{" +
    "name='" + name + '\'' +
    ", email='" + email + '\'' +
    ", company='" + company + '\'' +
    '}';
  }
}

That's nearly 80 lines for a simple POJO! Even if the IDE generates them for us, it is every difficult to maintain in the longer run. Now let's look at what the Kotlin equivalent of this would look like:

data class Customer(var name: String, var email: String = "", var company: String = "")

Yes, that's it! A single line that provide you a fully functional data object with equals(), hashCode(), clone() and toString() functionality baked right into it. So now your entire package of data classes can be combined into a single Kotlin file.

More Intuitive Flow Control

There are if-else statements and there are switch statements, then there are Python-like if-else constructs and then there's Kotlin's when construct.

A when improves the traditional switch operator with more readable syntax and increased flexibility for different cases. It can be used both as a statement and as an expression. Following is an example:

when (x) {
  in 1..10 -> print("x is in the range")
  in validNumbers -> print("x is valid")
  !in 10..20 -> print("x is outside the range")
  is String -> print("x is not a number!")
  else -> print("wtf are you feeding me?")
}

On a side note, just like the when operator, the if-else statements also return values in Kotlin.

For looping, we can use in operator instead of less meaningful : from Java:

for (item in array) {
  print(item)
}

Alternatively, you can use the withIndex library function:

for ((index, value) in array.withIndex()) {
  println("the element at $index is $value")
}

Smart Casting

We often write instanceof checks before processing a variable e.g. if (x instanceof String) doSomething(). In Kotlin, the compiler is smart enough to cast objects when it is certain about type changes. The most common use case of this feature is when you have to use a value after checking it's type:

if (u is User) {
  print(u.email)
}

If you were to write same snippet in Java, you'd have to either cast u once again in the print statement or either store the casted value for future use. In this instance, Kotlin can keep track of type and let you use it freely without caring about the type.

Oh! and by the way is and as are also operators in Kotlin.

readability += 1

Extension Functions

Here's a scenario, you need a way to check if user is connected to the Internet. You'd find a snippet and then eventually end up storing that in some sort of Utils class. Now this Utils class has one more habitant along with GOD-knows-how-many other helper methods that are completely unrelated to each other and you carry this file with you in every project and making calls to it for all sorts of functionality. Sounds familiar?

What if you could simply define that functionality in a class that is related to it? Without needing to inherit from it (in case it is a final class)? So you can have that functionality in, say Context class and then you can simply call your isConnected() method from your activities as if it is part of them? This is exactly what extension functions are for.

To declare an extension function, we need to prefix its name with a receiver type, i.e. the type being extended. So our isConnected() function will look something like this:

fun Context.isConnected(): Boolean {
  // some logic to check if device is connected to the Internet
}

and then you can use this from inside any descendant of Context class as if it is part of standard library while still keeping it in some sort of Extensions or Utils file.

Improved Lambdas

We all love lambdas, right? They provide clean and concise logical units that can be passed around as a plug-in functionality. While Java is catching up, they're still not up to the mark when it comes to multi-method lambdas and storing them as expressions.

val sum = { x: Int, y: Int -> x + y }

This is a simple lambda expression that takes two integer type values and returns their sum. There's a lot of flexibility to them as well, for example, you can omit the method parentheses if the lambda is the only or last argument of a method.

Higher-Order Functions

Higher-Order Functions, something we always wanted in Java. If you are unfamiliar with the concept, it is simply a function that can accept other functions as parameters or returns a function.

This is something that can eat a lot of your boilerplate code if used smartly. For example, let's build upon our existing isConnected() function and create a function that accepts a block of code and executes it only when connected to Internet. This is a fairly common use case, so you may want to make that an extension function too.

fun Context.doIfNetworkConnected(operation: () -> Unit) {
  if (isConnected()) {
    operation()
  } else {
    // Notify user about no connection
    displayAlert("Please connect to a network!")
  }
}

When combined with extension functions and lambdas, Higher-Order functions can make your trivial tasks such as checking for the Internet or closing the database after its usage so simple that you can forget about their existence.

Destructuring Declarations

I found this a very impressive feature in Python that sadly lacked in Java. What destructuring declarations do is simply chop down an object into a number of variables so you wont have to fetch each of its members individually and assign them to variables.

val (name, email, password) = user

When combined with Data Classes, this also paves way for functions that can return multiple values. Something we always wished to have in Java.

For example, let's say we want return status and message from an HTTP response, all we have to do is declare a Data Class and return those two items as it's members. At the other end, we can simply break them.

data class Response(val status: Int, val message: String)

fun handleHttpResponse(r:HttpResponse): Response {
  return Response(r.status, r.message)
}

// Now, to use this function:
val (status, message) = handleHttpResponse(someHttpResponse)

Default and Named Parameters

I think most of you would agree that if we had default parameters in Java, it could've saved us from writing countless overloaded methods. We typically write one methods that covers all the possible parameters and then write other variations for it that doesn't do much else but delegate the call to the original method after providing an implementation for missing (or newly added) parameters.

Kotlin solves this problem. Here's an example of extension function for AppCompatActivity that displays a Snackbar with short duration when the duration is not provided.

fun AppCompatActivity.showMessage(
  container: ViewGroup,
  message: String,
  length: Int = Snackbar.LENGTH_SHORT
) = Snackbar.make(container, message, length).show()

Not only we can give default values to parameters but also use them with their name, so we can call them independent of their order of declaration. For example, I can call my showMessage() function in any of the given orders:

showMessage(container = c, message = "Hello!", length = Snackbar.LENGTH_LONG)
// or
showMessage(message = "Hello!", container = c, length = Snackbar.LENGTH_LONG)
// or
showMessage(message = "Hello!", length = Snackbar.LENGTH_LONG, container = c)

100% Java Interoperability

Last but most importantly, Kotlin is 100% interoperable with Java{:target="_blank"}, which means you can use both languages side by side inside the same project and call code from each other without any special treatment.

Important to mention that Android Studio 3 ships with a Java-to-Kotlin converter, that converts your Java classes with single click of a button. Save it for the time when you completely fall in love with it and decide to convert your existing codebase to Kotlin. ;)

Conclusion

I tried to keep this post as concise as possible and skipped a lot of handy feature such as Ranges{:target="_blank"}, Properties{:target="_blank"}, Operator Overloading{:target="_blank"}, Type Inference{:target="_blank"}, String Interpolation{:target="_blank"} etc in doing so. However, I believe only those discussed will be enough to make you realize how much productivity and ease of use Kotlin can bring to your everyday development. Happy learning! :)

References

Official Kotlin Reference{:target="_blank"}
Android Developers Blog{:target="_blank"}

Image Source - Wikimedia{:target="_blank"}.
For suggestions and queries, just contact me{:target="_blank"}.

DevLog 02: Automating Wish Lists | Smarter Shopping with Price Monitoring

Sun, 06 Aug 2017 01:10:00 GMT

Remember when Mark Zuckerberg unveiled his AI assistant during the Christmas break last December? Everyone (including me) was super excited and many people got specially interested in automation related stuff. That's when I wrote the first post of this series pledging to work on a small scale automation projects and writing about them along the way.

Well.. as expected, life happened and all the crazy ideas along with all the excitement got lost somewhere in the abyss of procrastinated projects. Only recently, I found time (and motivation) to start the project once again and made the first "actual" automation script.

Problem

Online shopping has made life a lot easier for us couch potatoes around the world. We lay around half-dead, scroll few pages on online stores and summon the products we want at our doorsteps. I, however, am among those cheapskates who wait for the sales seasons for the fulfilment of their wish-lists.

Seemingly, these stores know about the existence of our species too. Many times, a lot of our desired items doesn't observe any discounts even in the sales seasons. Even when this isn't the case, impatience goes hands-in-hand with laziness anyway.

"Life is too short to wait for sales seasons" - Cheapo McCheapAss

Frustrated with not being able to buy an item for months, I came up with this idea of a script that could sit silently at my system and monitor the prices for the items I need in the background and notify me whenever the prices go below the specified baseline.

With little googling, I found some useful tools for data scraping with Python (didn't had any prior experience of Python programing before this) which made things very straight forward. The basic recipe consists of following steps:

Define a structured list of items along with your desired baseline prices.
Write a web scraper for the chosen online store to fetch the search results.
Match the prices for scraped items against those in the wish-list.
Display windows notifications and write the "ready to buy" items to an Excel file along with the product links.
Schedule the script to run at windows start up.

Through the rest of the post I'll be demonstrating the procedure. As prerequisites, you'll need Python along with pip package manager installed on your system. I'd highly recommend using Anaconda as your default Python as it has almost all of the required modules pre-installed. To keep things simple, I'll limit the code to just a single online store, but hopefully, with little Python knowledge you can expand the script to work with as many store as you want.

After starting to learn just a week ago, I consider myself absolutely noob at Python right now. So if you see something stupid in the code, please feel free to correct me because I only managed to write a "working" system with the limited knowledge I have.

Step 01 : Defining The Wish-List

JSON is now a go-to format for structured data representation. We'll be using it to define our so called "wish-list". Every item in the list will consist of following 3 attributes:

description: A common description for the product that you can find on most of the stores for the specific product. Since the search results on websites usually contains a lot of irrelevant stuff along with the required items. This description will help us identify the similar items from search results.
name: This will be our search term that we will send along with the search query.
baseline_price: This will be the price at which we want to be notified about this item.

I have allowed the K notation as a shorthand for baseline_price prices in the JSON, so we can optionally specify prices as 1K, 5K etc. instead of whole numbers

The wishlist.json file will look something like this:

{
"items": [
{
"description": "Sapphire Radeon R9 270x",
"name": "Sapphire R9",
"baseline_price": "12K"
}, {
"description": "Gigabyte LGA 1151 Z170",
"name": "Gigabyte Z170",
"baseline_price": "13200"
}
]
}

Now, once the system is setup, all you have to do is manage this file to get notifications for desired items.

Step 02 : Writing The Web Scraper

Web Scrapers are programs used to extract large amounts of data from websites whereby the data is extracted and saved to a local file in your computer or to a database in a structured format.

Our simple scraper will send request with our search queries to the specified websites and then pick the target HTML attributes from the returned results. You will have to examine the source of websites you want to scrap before writing the code for them. Most of them represent data in a structured way with consistent Ids and classes. Once the target tags have been picked, all you need to do is extracting the their values and parse them to relevant data structures.

To make things easier, Python has a brilliant and easy to use library for data scraping called Beautiful Soup. We will be using it to write our scraper.


class AmazonScraper: # Declare search URL and class names to picked
BASE_URL = 'https://www.amazon.com/s/ref=nb_sb_noss/' \
 '134-4639554-0290304?url=search-alias%3Daps&' \
 'field-keywords={}'
PRODUCT_TITLE_CLASS = "a-link-normal s-access-detail-page " \
 "s-color-twister-title-link " \
 "a-text-normal"
PRODUCT_BRAND_CLASS = "a-size-small a-color-secondary"
PRODUCT_PRICE_CLASS = "a-size-base a-color-base"

    def search_item(self, product):
        # Read the page contents
        query = urllib.parse.quote(product.name)
        url = self.BASE_URL.format(query)
        # Get structured data using beautiful soup
        data = bSoup(requests.get(url).text, "html.parser")

        # Find all the item containers
        containers = data.findAll(
            "div", {"class", "a-fixed-left-grid-col a-col-right"}
        )

        # Get item information for each item in container
        if len(containers) > 0:
            for item in containers:
                title_div = item.find(
                    "a", {"class", self.PRODUCT_TITLE_CLASS}
                )
                price_div = item.find(
                    "span", {"class", self.PRODUCT_PRICE_CLASS}
                )
                brand_div = item.findAll(
                    "span", {"class", self.PRODUCT_BRAND_CLASS}
                )[1]

                title = title_div.text
                brand = brand_div.text
                price = self.extract_price(price_div)
                link = title_div["href"]

                # Display Windows Notification and write the product
                # details to a csv file when the Price picked form
                # the search result is less than or equal to our
                # baseline price for the item and the product's
                # descriptions has a similarity rate of more than 45%
                price = math.floor(float(price))
                baseline_price = float(product.baseline_price)
                if baseline_price >= price > 0:
                    prompt = "\"" + title.replace(",", "|") + \
                             "\" is now available in " + \
                             str(price) + " at Amazon (Baseline:" + \
                             " " + product.baseline_price + ")"
                    details = get_details(brand, price, title, link)
                    if is_similar(title, product.description):
                        print_similarity(title, product.description)
                        display_windows_notification(brand, prompt)
                        write_to_csv(details)

    @staticmethod
    def extract_price(price_div):
        if price_div is None:
            return 0
        # Remove all the symobls received with the price text
        price = re.sub(r'[–|-||]', "", price_div.text).strip()
        price = price.replace("$", "")
        # Convert USD to PKR
        price = float(price) * 100
        return math.floor(price)

Step 03 : Run Scrapper for each Product in Wish-List

Once the main component of our system i.e. scraper is in place. We need to set up a routine that could read from our wishlist.json file and parse its contents into data models. These model object will then be passed to our scrapper for further processing.

In the procedure, we'll also be creating a available_wishlist_products.csv file that will carry all the latest ready-to-purchase items.

class Product:
def **init**(self, product):
self.description = product["description"]
self.name = product["name"]
self.baseline_price = product["baseline_price"] # Allowed number representation in 'K' format # (e.g. 3K, 10K etc) in json. Here while parsing, # convert the prices with K notation to numeric value
has_k = str(self.baseline_price).lower().**contains**("k")
price = self.baseline_price[:-1]
price = int(price) \* 1000
self.baseline_price = price if has_k else self.baseline_price

# Read all the items from the wishlist.json

with open('wishlist.json') as data_file:
items = json.load(data_file)

# Create csv file to write available items to

filename = "available_wishlist_products.csv"
f = open(filename, "w")
headers = "Date, Title, Brand, Price, Link\n"
f.write(headers)
f.close()

# Parse JSON into Product objects and pass them to scraper for search

scraper = AmazonScraper()
for i in items["items"]:
p = Product(i)
scraper.search_item(p)
time.sleep(5)

Step 04 : Writing The Utility Functions

You might have noticed calls to many unknown functions in the script we have written so far (e.g. print_similarity, display_windows_notification, write_to_csv). In the last part of the script, we'll be writing these utility functions.

Get Item Details

This utility function will prepare the data for writing to csv file by reformatting the text and generating a coma separated string from them.


def get_details(brand, price, title, link):
details = title.replace(",", "|") + ", " + \
 brand.replace(",", "|") + ", " + \
 str(math.floor(float(price))) + ", " + \
 link
return details

Write Details To CSV File

As the name suggests, this function will open our output file and write the contents of available items to it along with the date.

Notice that this time we open the file with a parameter (for appending) unlike in the main routine where we recreate the file every time with a w flag.

def write_to_csv(details):
file = open("available_wishlist_products.csv", "a")
time = strftime("%a, %d %b %Y", gmtime())
details = time.replace(",", " ") + ", " + details + "\n"
file.write(details)
file.close()
print("\nProduct Details: ")
print(details)

Check Similarity Between The Product Descriptions

Since search results often bring a lot of irrelevant results, it is important that we check for the resemblance between the descriptions of our define product and the item received from search results. I have set a threshold of 45% for similarity in descriptions to make an item qualify as legitimate result.

Now as you may have guessed, checking for alikeness between two set of texts seems a very difficult task. Thankfully, Python comes to rescue once again with its difflib.


def is_similar(a, b):
similarity_percent = SequenceMatcher(None, a, b).ratio() \* 100
return similarity_percent > 45

This function is pretty much useless but helps debug when ran from console. You can omit it from your code if you don't want to print results to the console.

def print_similarity(a, b):
similarity_percent = SequenceMatcher(None, a, b).ratio() \* 100
print("Similarity % between " + b + " and " + a + ": " +
str(similarity_percent))

Displaying Windows Notifications

The last part is to display Windows toast notifications for new available items. If you were using Anaconda, this will be the only module that you'll have to install yourself:


pip install win10toast

We're simply creating an instance of ToastNotifier and supplying it a title and message to display along with option icon path and a duration.

def display_windows_notification(title, msg):
print(msg)
notification = ToastNotifier()
notification.show_toast(
title, msg, icon_path=ICON_PATH, duration=30
)

That was all the code required, only thing left is the scheduling of this task. The final will look like this:


import time
import json
import math
import re
import urllib.parse
from time import strftime, gmtime
import requests
from bs4 import BeautifulSoup as bSoup
from win10toast import ToastNotifier
from difflib import SequenceMatcher

# Path to icon file to display with the notifications

ICON_PATH = "<Path to .ico File>"

class AmazonScraper: # Declare search URL and class names to picked
BASE_URL = 'https://www.amazon.com/s/ref=nb_sb_noss/' \
 '134-4639554-0290304?url=search-alias%3Daps&' \
 'field-keywords={}'
PRODUCT_TITLE_CLASS = "a-link-normal s-access-detail-page " \
 "s-color-twister-title-link " \
 "a-text-normal"
PRODUCT_BRAND_CLASS = "a-size-small a-color-secondary"
PRODUCT_PRICE_CLASS = "a-size-base a-color-base"

    def search_item(self, product):
        # Read the page contents
        query = urllib.parse.quote(product.name)
        url = self.BASE_URL.format(query)
        # Get structured data using beautiful soup
        data = bSoup(requests.get(url).text, "html.parser")

        # Find all the item containers
        containers = data.findAll(
            "div", {"class", "a-fixed-left-grid-col a-col-right"}
        )

        # Get item information for each item in container
        if len(containers) > 0:
            for item in containers:
                title_div = item.find(
                    "a", {"class", self.PRODUCT_TITLE_CLASS}
                )
                price_div = item.find(
                    "span", {"class", self.PRODUCT_PRICE_CLASS}
                )
                brand_div = item.findAll(
                    "span", {"class", self.PRODUCT_BRAND_CLASS}
                )[1]

                title = title_div.text
                brand = brand_div.text
                price = self.extract_price(price_div)
                link = title_div["href"]

                # Display Windows Notification and write the product
                # details to a csv file when the Price picked form
                # the search result is less than or equal to our
                # baseline price for the item and the product's
                # descriptions has a similarity rate of more than 45%
                price = math.floor(float(price))
                baseline_price = float(product.baseline_price)
                if baseline_price >= price > 0:
                    prompt = "\"" + title.replace(",", "|") + \
                             "\" is now available in " + \
                             str(price) + " at Amazon (Baseline:" + \
                             " " + product.baseline_price + ")"
                    details = get_details(brand, price, title, link)
                    if is_similar(title, product.description):
                        print_similarity(title, product.description)
                        display_windows_notification(brand, prompt)
                        write_to_csv(details)

    @staticmethod
    def extract_price(price_div):
        if price_div is None:
            return 0
        price = re.sub(r'[–|-||]', "", price_div.text).strip()
        price = price.replace("$", "")
        # Convert USD to PKR
        price = float(price) * 100
        return math.floor(price)

class Product:
def **init**(self, product):
self.description = product["description"]
self.name = product["name"]
self.baseline_price = product["baseline_price"] # Allowed number representation in 'K' format # (e.g. 3K, 10K etc) in json. Here while parsing, # convert the prices with K notation to numeric value
has_k = str(self.baseline_price).lower().**contains**("k")
price = self.baseline_price[:-1]
price = int(price) \* 1000
self.baseline_price = price if has_k else self.baseline_price

def get_details(brand, price, title, link):
details = title.replace(",", "|") + ", " + \
 brand.replace(",", "|") + ", " + \
 str(math.floor(float(price))) + ", " + \
 link
return details

def write_to_csv(details):
file = open("available_wishlist_products.csv", "a")
time = strftime("%a, %d %b %Y", gmtime())
details = time.replace(",", " ") + ", " + details + "\n"
file.write(details)
file.close()
print("\nProduct Details: ")
print(details)

def is_similar(a, b):
similarity_percent = SequenceMatcher(None, a, b).ratio() \* 100
return similarity_percent > 45

def print_similarity(a, b):
similarity_percent = SequenceMatcher(None, a, b).ratio() \* 100
print("Similarity % between " + b + " and " + a + ": " +
str(similarity_percent))

def display_windows_notification(title, msg):
print(msg)
notification = ToastNotifier()
notification.show_toast(
title, msg, icon_path=ICON_PATH, duration=30
)

# Read all the items from the wishlist.json

with open('wishlist.json') as data_file:
items = json.load(data_file)

# Create csv file to write available items to

filename = "available_wishlist_products.csv"
f = open(filename, "w")
headers = "Date, Title, Brand, Price, Link\n"
f.write(headers)
f.close()

# Parse JSON into Product objects and pass them to scraper for search

scraper = AmazonScraper()
for i in items["items"]:
p = Product(i)
scraper.search_item(p) # IMPORTANT: Delay each request by 5 seconds # so Amazon wont suspect our bot
time.sleep(5)

Step 05 : Scheduling Auto Execution Of The Script

Our system is now up and running, you can run it using Python from command line now. However, what's the fun in it if you have to run it yourself every time?

In this final step, we'll set up our script to run at every windows start up.

Open a text editor and write the following cmd commands.

cd /d "<Path To Your Script Folder>"
start pythonw "<Script Name>.py"

Save the file with .bat extension. Try running the file and see if the program gets executed.
Create a shortcut of this file and copy it to C:\Documents and Settings\[User Name]\Start Menu\Programs\Startup if you are running older version of windows or otherwise to C:\Users\[User Name]\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup if your are running Windows 10.

That's all! Your script is now ready to execute at every windows start up. For a quick test, try signing out of your windows and sign in again.

Conclusion

In less than 150 lines of code, we created a very sophisticated price monitoring system that is easy to use and scale. Since starting to write this post, I've already expanded the script to work with 4 different local and international stores.

While this is small system brings a lot of value, there are still some limitations to it. For example, the scrapper for NewEgg worked for a day or two before the website identified the scraper and placed a "captcha" between the results. Even this is not a dead-end, with the power of Python's text and image recognition libraries, these small barriers can be overcome with just a few lines of code. However, this means consistent maintenance and upgrading in order to keep the system working.

Source Code for this project is available at GitHub repository{:target="_blank"}.
For suggestions and queries, just contact me{:target="_blank"}.

Going Clean With MVP | A Guide To Model-View-Presenter On Android

Sun, 21 May 2017 03:10:00 GMT

Let's face it! All of us wrote tons and tons of code inside MainActivity.java, many still do...

Writing code that "works" is fine and acceptable as you start working with a new language or framework. After all, the whole point is to get the work done, right? Not exactly!

We all start from the same place where every "hello world" marks an accomplishment. However, as you grow as an experienced developer, you start to realize that object-oriented programming is more than just writing the code that works.

Almost every project requires some level of testing and maintenance throughout its lifecycle. This makes it a strict requirement to write modular code that is easy to read, modify, test and maintain for future collaborators.

Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. - John Woods

Obviously, our "I love MainActivity" guy won't find this an easy task. Why? Because when you write every single piece of code in the class where it is needed. You end up with a codebase which of course, gets the job done, but makes it almost impossible to test and maintain in the longer run.

Model-View-Presenter

MVP is an architectural pattern that attempts to decouple the business logic from the views by providing simpler activities with all the important work behind separate presentation layers. This results in a highly readable, maintainable and most importantly testable code.

Some might argue that MVP is not an architectural pattern per se as it is only responsible for managing the presentation of the data. However, we leave the debate here and move on to the "why?" aspect.

Need for MVP?

Android activities are cluttered with closely coupled components where everything is structured in a "throw the code on the wall" manner. This makes it an intrinsic problem for android code to be hard to test and extend. Anyone who went through the pain of learning android application testing can tell you that in the beginning it almost feels impossible to test android activities due to unmockable (is this even a word?) SDK components and lifecycle management complexities.

When you separate the business logic away from the activity in a separate presentation layer, it automatically makes it trivial to mock and test your code the way you would test any other java class.

The other difficulty apart from code testing is the maintenance of existing codebase. If you are reading this post and understand what I have said so far, I am assuming that you are at that point where you are familiar with the SOLID{:target="blank"} principles of object oriented design by Robert C. Martin a.k.a Uncle Bob{:target="blank"}. The last part of the five principles refers to the Dependency Inversion Principle (DIP) which encourages the programmers to write code in a way that it depends upon abstractions instead of the concrete implementations.

The way MVP is implemented nowadays (or at least they way I learned to) is through Contract interfaces that describes the responsibilities of Views and the Presenters, making the maintenance of code as simple as adding a new method to the interface and its implementation in the corresponding class. Note that this decoupling also allows us for interchangeable views for the same business logic.

Now let's put a full-stop to the theoretical stuff and explore the implementation details of Model, View and Presenter by building a very basic hello world MVP app.

Before we go ahead, it's important that you understand that there is no "ultimate" or "best" way of implementing MVP. Most people use their own implementations with some modifications, which is completely acceptable as long as the end goal is achieved. Which is to structure your code to decouple the implementation logic from the presentation layer. The way I'm doing it is only the way I like it, if you find another variation of it, don't confuse and use the style that suits you.

The Model

Model is an interface responsible for managing data. Model’s responsibilities include using APIs, caching data, managing databases and so on. The model can also be an interface that communicates with other modules in charge of these responsibilities.

For the sake of simplicity, I'm not using any model classes in this example but I hope you got the idea.

The View

Do not confuse this with your XML views. Views in MVP are simply the components responsible for managing the user interface. This includes all the UI manipulation operations such as setting text to some TextView, toggling visibility of Views, displaying animations etc. Basically, everything that has to do with the User Interface, goes into this place.

Keep your views as dumb as possible.

The idea is to keep your Presenters unaware of "how" to present data to the user. All they have is a View instance that takes this data as input and performs the presentation tasks. So if you were to display an error to the user in case he forgets to fill a field in the form, all your presenter has to do is call the view.displayError(errorMessage) method on the View instance.

Now realize that the Presenter doesn't know what happens next, whether the error is displayed as a Toast, or as a Dialog or a Snackbar or what color is the message etc. The View on the other hand does not know anything about the data it is provided and its origins, it is only interested in accepting the supplied data and manipulate the UI accordingly. This makes it very easy to mock Views while testing your business logic so you can focus on the stuff that is important.

The way I like to define my Views is through a View interface which resides inside the Contract Interface for that particular activity.

interface View extends BaseView<Presenter> {

    void displayMessage(String text);

    void displayResult(int result);

}

Now all I have to do is create a new class and make it implement this interface and we have a candidate that can serve as View for our activity. I guess you might have guessed that we can provide multiple implementations of View as well for different use cases.


public class MainActivity extends AppCompatActivity implements ContractMain.View{

    @BindView(R.id.toolbar)
    Toolbar mToolbar;
    @BindView(R.id.container)
    CoordinatorLayout mContainer;
    @BindView(R.id.numberOneEditText)
    EditText mNumberOneEditText;
    @BindView(R.id.numberTwoEditText)
    EditText mNumberTwoEditText;
    @BindView(R.id.resultTextView)
    TextView mResultTextView;

    private ContractMain.Presenter mPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        setSupportActionBar(mToolbar);

        mPresenter = new MainPresenter(this, this);
        mPresenter.start();
    }

    @Override
    public void displayMessage(String text) {
        Snackbar.make(mContainer, text, Snackbar.LENGTH_LONG).show();
    }

    @Override
    public void setPresenter(ContractMain.Presenter presenter) {
        mPresenter = presenter;
    }

    @Override
    public ContractMain.Presenter getPresenter() {
        return mPresenter;
    }

    @OnClick(R.id.addButton)
    public void onAddButtonClicked() {
        String numberOne = mNumberOneEditText.getText().toString();
        String numberTwo = mNumberTwoEditText.getText().toString();

        mPresenter.performAddition(numberOne, numberTwo);
    }

    @Override
    public void displayResult(int result) {
        mResultTextView.setText(String.valueOf(result));
    }

}

The Presenter

Think of the presenters as the Boss here. Similar to how you used to manage everything from your activity in the I Love MainActivity era, Presenters now handles all the management tasks and keeps your activities/fragments less busy. So instead of throwing your DatabaseHandler, ApiHandler, PeanutButterMaker and instances of whatnot in the activity class and make it look like a huge pile of crappy code, you just provide it with the Presenter instance and place all the other important stuff inside your Presenter.

Now just like the Views, presenters are also defined through a child interface inside the contract interface of the activity that owns it.

interface Presenter extends BasePresenter {

    void performAddition(String numberOne, String numberTwo);

    boolean isEmptyInput(String numOne, String numTwo);

}

Now all I need to do is to make my activity/fragment implement this interface and provide implementations for the defined operations.


class MainPresenter implements ContractMain.Presenter {

    private final ContractMain.View mView;
    private final Context mContext;

    MainPresenter(ContractMain.View view, Context context) {
        mView = view;
        mContext = context;
    }

    @Override
    public void start() {
        // Do your initialization work here
    }

    @Override
    public void performAddition(String numberOne, String numberTwo) {

        if (isEmptyInput(numberOne, numberTwo)) {
            // Display error message if any of the inputs is empty
            mView.displayMessage(mContext.getString(R.string.error_empty_input));
        } else {
            // Compute and pass the result to view for display
            final int firstNumber = Integer.parseInt(numberOne);
            final int secondNumber = Integer.parseInt(numberTwo);

            final int result = firstNumber + secondNumber;
            mView.displayResult(result);
        }
    }

    @Override
    public boolean isEmptyInput(String numOne, String numTwo) {
        return numOne == null || numOne.length() == 0 ||
            numTwo == null || numTwo.length() == 0;
    }

}

Outcome

So you might be wondering what did we achieve apart from dividing our activity into 3 pieces?

The first benefit of using this approach is that we achieved a more modular and scalable architecture. If you were to add subtract functionality to this activity, all you would do is define a new method void performSubtraction(String numberOne, String numberTwo) in the Presenter interface and provide its implementation. Your contracts are the documentation for your code itself.

The second and most important change is that our activity is now fully testable. You could simply mock the View and test all the application logic using your Presenter. Below are a couple of tests for the activity we implemented earlier. I'm using Mockito for mocking dependencies.

@RunWith(MockitoJUnitRunner.class)
public class MainTest {

    private static final String EMPTY_INPUT_ERROR_MESSAGE
        = "Please Provide Both Numbers!";

    @Mock
    private ContractMain.View mView;
    @Mock
    private Context mContext;

    private ContractMain.Presenter mPresenter;

    @Before
    public void setUp() throws Exception {
        mPresenter = new MainPresenter(mView, mContext);
    }

    @Test
    public void performAddition_shouldReturnResult() {
        final String numberOne = String.valueOf(2);
        final String numberTwo = String.valueOf(3);

        mPresenter.performAddition(numberOne, numberTwo);

        verify(mView).displayResult(5);
    }

    @Test
    public void performAddition_shouldDisplayErrorMessage() {
        final String numberOne = String.valueOf(2);
        final String numberTwo = null;
        // Mock error string because our mock context
        // wouldn't be able to return it
        when(mContext.getString(R.string.error_empty_input))
            .thenReturn(EMPTY_INPUT_ERROR_MESSAGE);

        mPresenter.performAddition(numberOne, numberTwo);

        verify(mView).displayMessage(EMPTY_INPUT_ERROR_MESSAGE);
    }

}

Conclusion

At this point, it may make sense to your or it won't, but sooner or later, you'll realize that you need some level of modularization in your code if it requires proper testing and be able to remain maintainable for long-term. If not MVP, you might go with one of the several other architectural patterns that are available. For me, MVP makes more sense than any other in the context of Android.

_{Image rights belong to macoscope.}

Source Code is available at GitHub repository{:target="blank"}.
For suggestions and queries, just contact me{:target="blank"}.

ActiveAndroid Testing with Robolectric

Sun, 19 Feb 2017 04:42:00 GMT

Testing has been painful for android developers from day one. The problem lies probably in the way the foundations of the android system has been laid. Over the years, many significant improvements have been made yet Android remains one of the most hard-to-test platforms to date.

Due to the fact that Android is open-sourced and has a HUGE community of skilled and creative developers. They left no stone unturned in their attempts to make things better. From new libraries and strategies for testing to the varying styles of organizing and architecting the code (e.g. MVP{:target="_blank"} and Clean{:target="_blank"} architecture). We have seen attempts made to tackle the problem from every possible angle.

Robolectric{:target="_blank"} was one of the revolutionizing tools that paved way for TDD{:target="_blank"} on Android. It helps you run most of the tests that requires an Android Device or emulator (Services, Database, UI etc) locally on JVM{:target="_blank"} in a matter of seconds.

Another brilliant (and popular these days) library that made lives easier was the ActiveAndroid{:target="_blank"} ORM{:target="_blank"} that removes all the boilerplate code required to even write the simplest databases in Android while using traditional SQLite{:target="_blank"}. However, testing remains as troublesome as it is with the old lad that we are upgrading from.

Luckily, ActiveAndroid comes in with a partial support form temporary in-memory databases which combined with the power of Robolectric, makes testing no different from your everyday unit tests. In this post, we'll learn to integrate both libraries to setup a testing environment for our database.

Adding Dependencies
Writing A Simple App
Testing with Robolectric

Adding Dependencies

Before we begin, we need to include Robolectric and ActiveAndroid to our project along with some other necessary libraries. Add the following dependencies to your app/build.gradle file:

// Support libraries
compile 'com.android.support:design:25.1.0'
compile 'com.android.support:appcompat-v7:25.1.0'
// Active Android
compile 'com.michaelpardo:activeandroid:3.1.0-SNAPSHOT'
// JUnit
testCompile 'junit:junit:4.12'
// Robolectric
testCompile 'org.robolectric:robolectric:3.2.2'

Writing A Simple App

We'll start by writing a very simple application that would allow us to save and retrieve information to and from our ActiveAndroid database.

MainActivity.java


public class MainActivity extends AppCompatActivity
implements View.OnClickListener {

    private LinearLayout mContainer;
    private EditText mNameEditText;
    private EditText mEmailEditText;
    private EditText mContactEditText;
    private Button mSaveButton;
    private Button mRetrieveButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mContainer = (LinearLayout) findViewById(R.id.LLContainer);
        mNameEditText = (EditText) findViewById(R.id.ETName);
        mEmailEditText = (EditText) findViewById(R.id.ETEmail);
        mContactEditText = (EditText) findViewById(R.id.ETContact);
        mSaveButton = (Button) findViewById(R.id.BTSave);
        mRetrieveButton = (Button) findViewById(R.id.BTRetrieve);

        mSaveButton.setOnClickListener(this);
        mRetrieveButton.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        int id = v.getId();

        String name = mNameEditText.getText().toString();
        String email = mEmailEditText.getText().toString();
        String contact = mContactEditText.getText().toString();

        if (id == R.id.BTSave) {
            // Validate input
            if (isEmpty(name) || isEmpty(email) || isEmpty(contact)){
                showSnackBar("Please Fill All Fields Before Saving");
                return;
            }

            // Save to database
            boolean isSuccessful = DatabaseUtils.getInstance()
                    .saveToDatabase(name, email, contact);

            // Notify user regarding operation success
            String message = isSuccessful ? "Saved Successfully"
                : "Error While Saving Item";
            showSnackBar(message);

        } else if (id == R.id.BTRetrieve) {
            // Validate input
            if (isEmpty(name) && isEmpty(email) && isEmpty(contact)){
                showSnackBar("Please Fill At Least One Field " +
                    "Before Retrieving From Database");
                return;
            }

            // Retrieve from database
            Item item = DatabaseUtils.getInstance()
                    .retrieveFromDatabase(name, email, contact);

            // Notify user about error in case of failure
            if (item == null) {
                showSnackBar("Error While Retrieving Item" +
                    " From Database");
                return;
            }

            // Display item data in relevant fields
            mNameEditText.setText(item.getName());
            mEmailEditText.setText(item.getEmail());
            mContactEditText.setText(item.getContact());

        } else {
            showSnackBar("Invalid Action!");
        }
    }

    private void showSnackBar(String message) {
        Snackbar.make(mContainer, message, Snackbar.LENGTH_SHORT)
            .show();
    }

}

activity_main.xml


<?xml version="1.0" encoding="utf-8"?>

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/LLContainer"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:gravity="center"
        android:orientation="vertical">

        <android.support.design.widget.TextInputLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <EditText
                android:id="@+id/ETName"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:ems="10"
                android:hint="Name"
                android:inputType="textPersonName"/>
        </android.support.design.widget.TextInputLayout>

        <android.support.design.widget.TextInputLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <EditText
                android:id="@+id/ETEmail"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:ems="10"
                android:hint="Email"
                android:inputType="textEmailAddress"/>
        </android.support.design.widget.TextInputLayout>

        <android.support.design.widget.TextInputLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <EditText
                android:id="@+id/ETContact"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:ems="10"
                android:hint="Contact Number"
                android:inputType="phone"/>
        </android.support.design.widget.TextInputLayout>
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:id="@+id/BTSave"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_margin="4dp"
            android:layout_weight=".5"
            android:background="@color/colorPrimary"
            android:text="Save Contact"
            android:textColor="@android:color/white"/>

        <Button
            android:id="@+id/BTRetrieve"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_margin="4dp"
            android:layout_weight=".5"
            android:background="@color/colorPrimary"
            android:text="Retrieve Contact"
            android:textColor="@android:color/white"/>
    </LinearLayout>

</LinearLayout>

Item.java


/\*\*

- Created by Zuhaib Ahmad on 2/7/2017.
- <p>
- Java POJO representing database model
  \*/
  public class Item extends Model {

      public static final String KEY_CONTACT = "contact";
      public static final String KEY_EMAIL = "email";
      public static final String KEY_NAME = "name";

      @Column(name = KEY_NAME)
      private String name;
      @Column(name = KEY_EMAIL)
      private String email;
      @Column(name = KEY_CONTACT)
      private String contact;

      public Item() {
          super();
      }

      public Item(String name, String email, String contact) {
          super();
          this.name = name;
          this.email = email;
          this.contact = contact;
      }

      public String getName() {
          return name;
      }

      public void setName(String name) {
          this.name = name;
      }

      public String getEmail() {
          return email;
      }

      public void setEmail(String email) {
          this.email = email;
      }

      public String getContact() {
          return contact;
      }

      public void setContact(String contact) {
          this.contact = contact;
      }

  }

DatabaseUtils.java

/\*\*

- Created by Zuhaib Ahmad on 1/28/2017.
- <p>
- Utility class to handle database operations
  \*/
  public class DatabaseUtils {

      private static DatabaseUtils instance;

      private DatabaseUtils() {
      }

      /**
       * Gets singleton instance.
       *
       * @return the instance
       */
      public static DatabaseUtils getInstance() {
          if (instance == null) {
              instance = new DatabaseUtils();
          }

          return instance;
      }

      /**
       * Retrieves {@link Item} object from database
       *
       * @param name    The name of contact
       * @param email   The email of contact
       * @param contact The number of contact
       * @return The retrieved item
       */
      public Item retrieveFromDatabase(String name, String email,
          String contact) {
          // Use first non-null parameter for conditional check
          String whereClause = "";
          String key = "";

          if (!isEmpty(name)) {
              whereClause = name;
              key = Item.KEY_NAME;
          } else if (!isEmpty(email)) {
              whereClause = email;
              key = Item.KEY_EMAIL;
          } else if (!isEmpty(contact)) {
              whereClause = contact;
              key = Item.KEY_CONTACT;
          }

          // Query the database and return the fetched item
          return new Select()
                  .from(Item.class)
                  .where(key + " =?", whereClause)
                  .executeSingle();
      }

      /**
       * Saves {@link Item} to database
       *
       * @param name    The name of contact
       * @param email   The email of contact
       * @param contact The number of contact
       * @return The operation success status
       */
      public boolean saveToDatabase(String name, String email,
          String contact) {
          // Create database item object out of provided parameters
          Item item = new Item(name, email, contact);

          // Save to database and get the id of saved item
          Long id = item.save();

          // Mark operation as successful if returned id is non-zero
          return id > 0;
      }

  }

Application.java


/\*\*

- Created by Zuhaib on 1/22/2016.
- <p>
- Application class for global management and data access
  \*/
  public class Application extends android.app.Application {

      @Override
      public void onCreate() {
          super.onCreate();
          // Create Active Android configurations
          Configuration.Builder configuration =
              new Configuration.Builder(this);
          configuration.addModelClasses(Item.class);
          // Initialize ActiveAndroid DB
          ActiveAndroid.initialize(configuration.create());
      }

  }

Testing with Robolectric

Before writing tests for our database, we will need to configure our temporary database. To achieve this, we will be writing an alternate version of our Application.java class which will replace the original in our tests.

TestApplication.java

/\*\*

- Created by Zuhaib Ahmad on 1/20/2017.
- <p>
- Application subclass to be used in Tests
  \*/

public class TestApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        // Create configurations for a temporary mock database
        Configuration.Builder configuration =
            new Configuration.Builder(this).setDatabaseName(null);
        configuration.addModelClasses(Item.class);
        // Initialize ActiveAndroid DB
        ActiveAndroid.initialize(configuration.create());
    }

    @Override
    public void onTerminate() {
        // Dispose temporary database on termination
        ActiveAndroid.dispose();
        super.onTerminate();
    }

}

Notice the setDatabaseName(null) while building configurations. It allows us to create an anonymous temporary database which we dispose on termination of application.

DatabaseUtilsTest.java


/\*\*

- Created by Zuhaib Ahmad on 2/7/2017.
- <p>
- Tests fro database utils
  \*/
  @RunWith(RobolectricTestRunner.class)
  @Config(
  constants = BuildConfig.class,
  // Run with TestApplication instead of actual
  application = TestApplication.class,
  // Test against Lollipop
  sdk = 21
  )
  public class DatabaseUtilsTest {

      private DatabaseUtils mInstance;

      @Before
      public void setUp() throws Exception {
          ShadowLog.stream = System.out;

          mInstance = DatabaseUtils.getInstance();
      }

      @Test
      public void retrieveFromDatabase() throws Exception {
          String name = "Test Retrieve Item";
          String email = "Retrieve@abc.com";
          String contact = "12345";
          Item testItem = new Item(name, email, contact);
          testItem.save();

          // Fetch with name
          Item item1 = mInstance
              .retrieveFromDatabase(name, null, null);
          assertNotNull(item1);
          assertEquals(testItem, item1);

          // Fetch with email
          Item item2 = mInstance
              .retrieveFromDatabase(null, email, null);
          assertNotNull(item2);
          assertEquals(testItem, item2);

          // Fetch with contact
          Item item3 = mInstance
              .retrieveFromDatabase(null, null, contact);
          assertNotNull(item3);
          assertEquals(testItem, item3);

          testItem.delete();
      }

      @Test
      public void saveToDatabase() throws Exception {
          String name = "Test Save Item";
          String email = "Save@abc.com";
          String contact = "67890";

          // Create test object from test parameters
          Item testItem = new Item(name, email, contact);

          // Save test parameters
          boolean isSuccessful = mInstance
              .saveToDatabase(name, email, contact);

          // Check if successfully saved
          assertTrue(isSuccessful);

          // Check if saved item is equal to test object
          Item savedItem = mInstance
              .retrieveFromDatabase(name, null, null);
          assertEquals(testItem.getName(), savedItem.getName());
          assertEquals(testItem.getEmail(), savedItem.getEmail());
          assertEquals(testItem.getContact(), savedItem.getContact());
      }

  }

Run the tests and hopefully you'll see green lights. That's it, you can now locally test your databases just as you would unit test any other part of your application. You can find complete source code of the application here{:target="_blank"}

DevLog 01: Making A Smarter PC | Automating The Download Management

Sun, 08 Jan 2017 04:10:00 GMT

Everyone was hyped up after Mark Zuckerberg unveiled his AI assistant during the Christmas break last December. Almost everyone thought of building or at least owning something similar to Jarvis. I have been a fan of AI and IoT for a long time now but after closely following several impressive automation projects last year such as Amazon's Go and Echo, I got pretty much obsessed with the idea of machines doing stuff for or on behalf of you (sounds cool right?)

So this year I decided to build a small automation system for my personal use. Something simple that would not only be fun but could also help me in everyday life. For this purpose, I compiled a list of do-able tasks that can be done (or already exist) with the help of some programming. My initial plan is to write small scripts for each separate task and then integrate them into once piece of software once I have a collection. Starting with this post, I'll be going through each item on that list in the order of lowest to highest difficulty. Obviously, I might not be able to achieve everything on that list but still it's worth a try and I'll be documenting my progress in these DevLogs.

Problem

I'm a huge fan of Flash and Arrow and desperately wait every week for new episodes. However, the problem is that there's no CW TV (the channel that broadcasts them) in my country, so the only option left for me is via torrents. Not a problem! Right? Nope!

Then I face another problem. When you are in a place where the "unlimited" connection gives a download speed of ~200Kbps, choosing between doing your work or putting something on download becomes a matter of trading off one thing for another. My solution (and surely for most of the people living with a shitty connection) is to put your stuff on download at night before going to bed and leave the system turned on.

Now this strategy works pretty well but for a forgetful soul of a software engineer, this too is a task that must go into the to-do list in order to avoid the chances of being brushed off my head. So the first item I picked from my list was to make my computer do most of the downloading work for me while I sleep at night. To make the task more helpful, I expanded the scope to not only torrents but also Steam and IDM. The process is straight forward:

Make the computer turn on by itself at a specific time (from sleep or hibernation).
Start necessary programs.
Continue pending downloads.
Go back to sleep/shutdown at some specific time in the morning.

So I started my research and what I found surprising was that you don't need to write any code to accomplish this. In the next steps I'll try to demonstrate how I did it for my system:

Please note that this is only the way I achieved my desired results, there might be much more ways to build even smarter, more complex and efficient systems.

Step 01 : Enabling Wake Timers

Before you set up your computer for timed wake up and shutdown, make sure you have the Wake Timers enabled. Wake Timers allows Windows to wake up on timed events. By default, they are disabled on Windows 7 and above. To enable them, following the instruction below.

Right-click the battery icon and click Power Options or go to Control Panel and select Power Options.

{:refdef: style="text-align: center;"} {: refdef}
Click on the Change Plan Settings link of your active plan.

{:refdef: style="text-align: center;"} {: refdef}
In next window, click Change Advanced Power Settings link.

{:refdef: style="text-align: center;"} {: refdef}
Under the Advanced Settings window, expand Sleep option and then expand Allow Wake Timers option. Under Plugged In, change Disable to Enable.

{:refdef: style="text-align: center;"} {: refdef}

Step 02 : Scheduling Wake Up Tasks

The Task scheduler is a powerful yet underestimated feature that comes with Windows OS. It enables you to automatically perform routine tasks on your computer based on whatever criteria you have set. We'll be using Task Scheduler to configure our computer for the automatic wake up and shutdown on specific times. Let's first set up timed wake up.

Open up Task Scheduler by typing in task Scheduler in your Windows Start Menu search bar.

{:refdef: style="text-align: center;"} {: refdef}
Now, let's create our first task. Click on Action ➜ Create Task.

{:refdef: style="text-align: center;"} {: refdef}
In the general tab, give your task appropriate name and description

{:refdef: style="text-align: center;"} {: refdef}
Next, in the triggers tab let's create a trigger for our task. Click the New button and set up the time and repeat frequency for your task. Make sure you mark the Enable checkbox before pressing OK.

{:refdef: style="text-align: center;"} {: refdef}
This step is optional if you have your software already set to start on windows startup. Create a new action by clicking New and then add programs that you want to run when this task is launched.

{:refdef: style="text-align: center;"} {: refdef}
Finally, the most important step. Mark the "Wake the computer to run this task" in order to allow your task to wake up your computer on its own. You can also tweak some other settings such as running the task only if the internet is available. This is obviously optional but essential if you don't want your computer to stay open doing nothing in case of no internet connectivity.

{:refdef: style="text-align: center;"} {: refdef}

Your computer is now set to wake up at your specified time. If you want to test this out, simply edit the time trigger and assign it a value close to your current time. Once created, simply sleep/hibernate your computer and wait for the magic to happen.

Step 03 : Auto Computer Hibernate/Shutdown

In the beginning of the post I said you would not need to write any code for this -- well maybe, I lied. However, I promise it's nothing more than a single line which essentially is the Windows shutdown command for shutting down your computer. So please bear with me and follow these simple steps.

Open up any text editor of your choice and place the following line into it:

shutdown /s

If you want to put the computer to sleep instead, simply replace the /s with /h

Then simply save the file with whatever file name you wish to give it but be sure to give it an extension of .bat e.g. shutdown.bat
That's it, if you double click this file, your computer will shutdown (or sleep depending on which parameter use used).

Step 04 : Scheduling Shutdown Task

Now, the final step is to setup the second part of scheduling i.e. turning the PC off at a specific time. To set this up, follow the same procedure and specify the schedule you want your computer to shutdown/sleep. Make sure in the step 5 you include the script we just created in the programs that are to be launched with this task.

You're all set to test your system. However, one last step for me was to configure Internet Download Manager to automatically launch scheduled downloading task few minutes after my system wakes up. For uTorrent, only launching it was enough since it can automatically resume pending downloads.

Step 05 : Setting Up IDM For Scheduled Downloading

In order to run the scheduled downloading on IDM after your system wakes up. You have to make sure that IDM is registered either as the startup launch item or in the actions tab of your wake up task. This is to make sure that your IDM is running when it's time for the scheduled downloading to kick in. Now let's set up our scheduler.

Open IDM and open scheduler by clicking Download ➜ Scheduler.

{:refdef: style="text-align: center;"} {: refdef}
Next select your main download queue or any custom queue that you want to be resumed

{:refdef: style="text-align: center;"} {: refdef}
Then select one-time downloading and specify the time you want this queue to start. You might have noticed that I've set the time to 5 minutes after my wake-up task. Finally, you can optionally specify the repeat frequency, stop time and download complete action as well. Once done, click apply and then close.

Conclusion

That was it, you have successfully build your own smart download management system that too without any coding. Enjoy your sleep while your computer does the work for you. Make sure your roommates know about this, else some poor souls are going to get spooked or you'll be accused of using the computer all night long.

Speed Up Your Android Development with these 10 Libraries (Part 2)

Sat, 31 Dec 2016 04:42:00 GMT

In the first part of this post{:target="_blank"}, we learnt about ButterKnife{:target="_blank"}, SDP{:target="_blank"}, Joda Time{:target="_blank"}, ActiveAndroid{:target="_blank"} and EventBus{:target="_blank"} libraries to help us speed up our Android development. Now, let's continue from where we left off and explore the remaining libraries in our list.

Volley
Okhttp
Parceler
Android Annotations
Espresso

Volley

Network operations have always been a frustrating task for developers mainly due to the excessive amount of tedious work involved. Without the help of any networking library, to read from even the most basic REST APIs that spits data in JSON format, you will need to setup an HttpURLConnection, InputStream/OutputStream, a JSON parser and you will also have to place all these tasks into an AsyncTask to separate them from UI thread and run asynchronously. That's a lot of work with a lot of boilerplate code, probably more than anything else considering the work we are getting done for the amount of code that we write.

Volley{:target="_blank"} is a HTTP networking library by Google that makes networking tasks easier, helps you get rid of boilerplate and most importantly, it's faster. Some of the key benefits of Volley are:

Automatic scheduling of network requests.
Multiple concurrent network connections.
Support for request prioritization.
Highly flexible and easily customizable.
Comes with debugging and tracing tools.

However, Google advices not to use Volley for large download or streaming operations, since Volley holds all responses in memory during parsing. Another limitation is that the only response types supported are String, Image, JSONObject, and JSONArray also note that there is also no built-in XML support, but due to Volley's flexibility you can build one yourself.

Setup

Setup for Volley is fairly simple, just add this line to your app/build.gradle file and you are good to go:

compile 'com.android.volley:volley:1.0.0'

Usage

Make sure you have android.permission.INTERNET permission in your manifest file. Create a RequestQueue using Volley's convenience method Volley.newRequestQueue:


RequestQueue queue = Volley.newRequestQueue(context);

Specify the URL for request you are making:

final String URL ="http://www.mywebservice.com";

Create a Volley Request.

There are plenty of available request types such as StringRequest, JsonObjectRequest, JsonArrayRequest as well as your custom defined request types.


StringRequest request = new StringRequest(Request.Method.GET, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
// Display first 50 characters of the response string.
Toast.makeText(context, "Response is: "+
response.substring(0,50), Toast.LENGTH_LONG).show();
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// In case of error
Toast.makeText(context, "Error in response!",
Toast.LENGTH_LONG).show();
}
});

Finally, add this request to your Queue:

queue.add(request);

Although this eliminates a lot of excessive work but still involves a fair amount of code and also it isn't very clean. Nonetheless, it gets the job done, it's robust and very useful for small to medium scale projects.

Okhttp

Volley is a fairly easy to use and a complete package which provides support ranging from basic String response to Image loading. However, there are some problems. Quoting this{:target="_blank"} answer on Stackoverflow{:target="_blank"} by CommonsWare{:target="_blank"}:

it is an unsupported, "throw the code over the wall and do an I|O presentation on it" library.

which is to say that all it does is "getting the job done". Which comes at a price of not-so-good-looking code, lack of multipart requests and most of the load being put on the device memory.

OkHttp{:target="_blank"} is a networking library developed by Square for sending and receiving HTTP-based network requests. It is built on top of the Okio{:target="_blank"} library, which tries to be more efficient about reading and writing data than the standard Java I/O libraries by creating a shared memory pool. It also is the underlying library for Retrofit{:target="_blank"} library that provides type safety for consuming REST-based APIs.

Make sure you also check out Retrofit{:target="_blank"} which is another awesome library by Square{:target="_blank"} which competes with Volley. It is a Type-safe HTTP client for Android and Java that turns your HTTP API into a Java interface.

Setup

Add this line to your app/build.gradle file:


compile 'com.squareup.okhttp3:okhttp:3.3.0'

Usage

Again, first step is to make sure you have android.permission.INTERNET permission in your manifest file.

Specify the URL for request you are making:

final String URL ="http://www.mywebservice.com";

Instantiate an OkHttpClient and create a Request object:


OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(URL).build();

To make a synchronous network call, use the Client to create a Call object and use the execute method.

Response response = client.newCall(request).execute();

To make asynchronous calls, also create a Call object but use the enqueue method.


client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
// Do your exception handling here
e.printStackTrace();
}

    @Override
    public void onResponse(Call call, final Response response)
        throws IOException {
        if (!response.isSuccessful()) {
            throw new IOException("Unexpected code " + response);
        } else {
            String text = response.body().string();
            // Display first 50 characters of the response string.
            Toast.makeText(context, "Response is: "+
                text.substring(0,50), Toast.LENGTH_LONG).show();
        }
    }

}

Parceler

Now, that we are done with networking, let's take a look at another headache - creating Parcelable objects. Although creating Parcelable s is faster than using Serializable s, creating Parcelable objects requires creating a lot of boilerplate code in defining data exactly in the sequence that should be serialized and deserialized.

Parceler{:target="_blank"} helps you automate this task. Similar to Butterknife{:target="_blank"} this library generates the necessary wrapper classes for you at compile time automatically, saving you the repetitive steps required for leveraging the performance benefits of Parcelables.

Setup

Using Gradle, add this block to build.gradle at the project-level, it allows code generation libraries like Butterknife and Parceler for annotation processing:

dependencies {
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}

And then in your app/build.gradle file, add the following:


apply plugin: 'com.neenbedankt.android-apt'

...

dependencies {
compile 'org.parceler:parceler-api:1.1.1'
apt 'org.parceler:parceler:1.1.1'
}

Usage

By using Parceler{:target="_blank"} you no longer have to implement the Parcelable interface, the writeToParcel() or createFromParcel() or the public static final CREATOR. You simply annotate a POJO with @Parcel and Parceler does the rest.

@Parcel
public class User {
String name;
int age;

    // Empty constructor required by the Parceler library
    public User() {}

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public String getName() { return name; }

    public int getAge() { return age; }

}

To generated Parcelable from POJO, use the Parcels utility class:


Parcelable wrapped = Parcels.wrap(new Example("John Doe", 22));

To create your POJO from generated Parcelable

User user = Parcels.unwrap(wrapped);
user.getName(); // John Doe
user.getAge(); // 22

There is an Android Studio Plug-in which makes it even easier to generate Parcelables. We will be looking at it in a future post dedicated to Android Studio Plug-ins.

Android Annotations

Android Annotations is a framework that speeds up Android development by replacing most of the repetitive tasks and patterns with java annotations. It takes care of the plumbing, and lets you concentrate on what's really important. By simplifying your code, it facilitates its maintenance.

Setup

Using Gradle, add this block to build.gradle at the project-level:


buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}

And then in your app/build.gradle file, add the following:

apply plugin: 'android-apt'

...

dependencies {
apt "org.androidannotations:androidannotations:4.2.0"
compile "org.androidannotations:androidannotations-api:4.2.0"
}

Usage

Following is an example of a simple MainActivity when used without Android Annotations library and when used with it:

Before


public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(FLAG_FULLSCREEN, FLAG_FULLSCREEN);

        setContentView(R.layout.activity_main);

        TextView msgTextView = (TextView) findViewById(R.id.tv_msg);
        Button hideButton = (Button) findViewById(R.id.btn_hide);
        hideButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                msgTextView.setVisibility(View.INVISIBLE);
            }
        });
    }

}

After

@Fullscreen
@EActivity(R.layout.activity_main)
@WindowFeature(Window.FEATURE_NO_TITLE)
public class MainActivity extends AppCompatActivity {

    @ViewById(R.id.tv_msg)
    TextView mMsgTextView;

    @Click(R.id.btn_hide)
    protected void onHideButtonClick() {
        mMsgTextView.setVisibility(View.INVISIBLE);
    }

}

You can see how clean, concise and readable the code has become after using annotations. There's a lot more to this brilliant library, head over to official documentation{:target="_blank"} to find out more features.

Espresso

So far we have covered different aspects of our development routine and tried to simplify them with the use of 3rd party libraries. This seems to increase overall performance and productivity in our projects but in the end if you cannot test it, it's probably not worth it. Testing{:target="_blank"} has been an integral part of Software Engineering and Android development is no different. In your early days of Android development, you might be testing your applications manually by test driving them every time you added or fixed something. Many might still be doing the same if you have not switched to automated tools yet.

Espresso{:target="_blank"} is part of Android Testing Support Library{:target="_blank"} provided by Google{:target="_blank"}. The basic idea is to get rid of manual testing and let the system do the UI testing for you in matter of seconds. You write intuitive and easy to read tests in the form of each individual action you have to perform in order to get the task done and then finally evaluate the results. All the operations in Espresso follow this simple pattern

Find A View ➜ Perform Some Action(s) ➜ Validate Output

Each of the steps in your test path are more or less exactly written step by step in Espresso and even a person with little or no knowledge about the domain or your project can easily start writing tests for your application. This ease of use makes it one of the best (if not the best) UI testing framework available for Android.

Setup

In the build.gradle file of your Android app module, you must set a dependency reference to the Espresso library:


androidTestCompile
'com.android.support.test.espresso:espresso-core:2.2.2'

Usage

If you are to test the Login screen of your application, you might have to first input email and password in the corresponding fields and then click the Sign In/Log In button. These are 3 separate operations, additionally you might want to first check if Login Form itself is visible. Finally you will check if the application displays a dialog indicating login success in case of successful Login. Let's see how to do this using Espresso.

@RunWith(AndroidJUnit4.class)
public class LoginActivityTest {

    @Test
    public void onLoginSuccess_displaysLoginSuccessDialog() {
    	//Declare our email and password
    	String username = "myusername@gmail.com";
    	String password = "mypassword";

    	// Login success dialog's message
    	String successMsg = "Login Successful";

        // Check if Login form is visible
        onView(withId(R.id.LLLogin)).check(matches(isDisplayed()));
        // Fill details in form
        onView(withId(R.id.ETUsername)).perform(typeText(username));
        onView(withId(R.id.ETPassword)).perform(typeText(password));
        // Click on Login button
        onView(withId(R.id.BTLogin)).perform(click());
        // Check if Login Success dialog is displayed
        onView(withText(successMsg)).check(matches(isDisplayed()));
    }

}

As you can see, this is just an easy to read and easy to write code representation of a real user's actions. You can create all sorts of complex tests by chaining these simple methods together. There are many different types of actions, matchers and other utilities available in Espresso API{:target="_blank"}, to learn more about them, head over to the official Espresso Documentation{:target="_blank"}.

Conclusion

So these were the ten must have libraries in my opinion that every Android developer must start using in order to make their code:

Easy to write
Easy to test
Easy to maintain
Concise and Performant
Highly cohesive and low coupled

and finally improving your overall development speed and productivity, because in the end being a good developer is about working smart, not hard. I hope you have found this article useful. Feel free to provide your valuable feedback.

_{Most of the example code and definitions were adopted from official sources to avoid any errors.}

Speed Up Your Android Development with these 10 Libraries (Part 1)

Sat, 17 Dec 2016 01:08:00 GMT

Introduction

An average developer writes somewhere between few dozen to a couple of hundred lines of code per day. If you are an Android developer, you might be closer to the upper limit. Reason? Boilerplate{:target="_blank"}.. A LOT OF BOILERPLATE!

From findViewById() to writing Adapters and Interfaces for different types of operation, we write loads of boilerplate everyday (at least we juniors do!). Some people still seems surprised about the "10 Lines per Developer per Day" statement from The Mythical Man-Month{:target="_blank"} (a must read book for any software engineer) and some even proudly say that they could beat it by huge margin (impressive!!). What many seems to neglect is the importance of negative code count. You gain more advantage by removing (refactoring) code than by adding new.

If we wish to count lines of code, we should not regard them as "lines produced" but as "lines spent". - Edsger Dijkstra

Now if you apply this theory to Android development, this makes a big difference. What if you were able to remove even half of the boilerplate code from your projects? You might be able to achieve 2x development speed to say the least.

Android community is enormous and they keep improving the eco-system with latest libraries and methodologies. There are actually plenty of libraries already written to boost the development speed. In this post, we will discuss my list of 10 must have libraries that can boost your Android development.

ButterKnife
SDP
Joda Time
ActiveAndroid
EventBus

ButterKnife

findViewById()
setOnClickListener(this)

How many times do you have to write this code in a single project? A year ago, a single Activity (with a complex UI) in one of my projects had about 150 lines of only this code (along with some default value settings). Out of embarrassment, I decided to move this code out from onCreate method to into its own method setComponents() and hide it somewhere near the end of the class. Why? to make it look.. well.. less embarrassing *cough*

Few months back, I got to work on that project again. First of all, I took a fair share of time to laugh at that mess. I ended up replacing most of the UI related boilerplate with ButterKnife{:target="_blank"} and the code count of that particular Activity came down to somewhere around 900 from 1700+. Image what affect this small changed made to the entire project.

Butterknife is a View Injection library that uses annotations to automatically generate common boilerplate code and that too in its own auto-generated classes. This not only saves you a lot of time but also makes your code cleaner and concise.

Setup

Using Gradle, add this block to build.gradle at the project-level:

buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}

And then in your app/build.gradle file, add the following:


apply plugin: 'android-apt'

...

dependencies {
compile 'com.jakewharton:butterknife:8.4.0'
apt 'com.jakewharton:butterknife-compiler:8.4.0'
}

Usage

Eliminate findViewById with @BindView on field declaration:

class ExampleActivity extends Activity {
// Automatically finds each field by the specified ID.
@BindView(R.id.title) TextView title;

@Override public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.simple_activity);
ButterKnife.bind(this);
// Start using your fields...
}
}

Improved Listeners with annotations:


@OnClick(R.id.submit)
public void sayHi(Button button) {
button.setText("Hello!");
}

You can even eliminate resource lookups with resource annotations:

class ExampleActivity extends Activity {
@BindString(R.string.title) String title;
@BindDrawable(R.drawable.graphic) Drawable graphic;
@BindColor(R.color.red) int red;
@BindDimen(R.dimen.spacer) Float spacer;
// ...
}

This is just the tip of an iceberg, there is a lot more to this library. To learn more, head over to the library's page on creator @JakeWharton 's website.

BONUS: There is even an Android Studio plug-in for Butterknife called ButterKnifeZelezny{:target="_blank"}, it automates the binding process with a few clicks, making things lightning fast!

SDP

No # 2 on my list is a real underdog but a true life-saver! Even if you have only written a basic Hello World{:target="_blank"} program so far. You might be well aware of the problems with supporting vast variety of screen sizes associated with Android devices. No matter how many variations you create for your layout, there will always be some devices that will completely destroy your layout.

SDP{:target="_blank"} resolves this problem to some extent by providing a new size unit named sdp (scalable dp). This size unit scales with the screen size hence leading to adaptive layouts. Although this approach is not entirely foolproof and most experienced developers might insist on avoiding it, still I found it very helpful and reliable so far.

Setup

Add the following dependency in your app/build.gradle file:


dependencies {
compile 'com.intuit.sdp:sdp-android:1.0.4'
}

Usage

Not much changes with this library. You only need to develop one layout variation for phones and one for tablets (yes, just two!). The process is exactly the same as your normal layout file, the only difference is that you replace dp with sdp resource values provided by the library in your layout.

<View
android:layout_width="@dimen/\_24sdp"
android:layout_height="wrap_content"
...
/>

To learn more about usage and sample layout, go the project's GitHub repository{:target="_blank"}.

Joda Time

Almost every project require some level of date and time manipulation. The standard date and time classes prior to Java SE 8 are poorly written and broken to some extent. Joda-Time{:target="_blank"} became the de facto standard date and time library for Java due to its extra ordinary capabilities. The design allows for multiple calendar systems (such as Gregorian, Julian, Buddhist, Coptic, Ethiopic and Islamic calendar systems), while still providing a simple API. There is a lot more to it which you can find out at project's GitHub repository{:target="_blank"}.

Setup

Add the following dependency in your app/build.gradle file:


dependencies {
compile 'joda-time:joda-time:2.9.6'
}

Usage

public boolean isAfterPayDay(DateTime datetime) {
if (datetime.getMonthOfYear() == 2) { // February is month 2!!
return datetime.getDayOfMonth() > 26;
}
return datetime.getDayOfMonth() > 28;
}

public Days daysToNewYear(LocalDate fromDate) {
LocalDate newYear = fromDate.plusYears(1).withDayOfYear(1);
return Days.daysBetween(fromDate, newYear);
}

public boolean isRentalOverdue(DateTime datetimeRented) {
Period rentalPeriod = new Period().withDays(2).withHours(12);
return datetimeRented.plus(rentalPeriod).isBeforeNow();
}

public String getBirthMonthText(LocalDate dateOfBirth) {
return dateOfBirth.monthOfYear().getAsText(Locale.ENGLISH);
}

ActiveAndroid

One of the most painful tasks in Android development is setting up an SQLite Database. With all the Keys, Tables, Cursors, Helper and what not, it usually takes an entire package full of classes (filled with boilerplate code for the most part) to be able to produce even the most simplest Databases. ActiveAndroid takes care of all the setup and messy stuff, and all with just a few simple steps of configuration.

So what exactly is ActiveAndroid?

ActiveAndroid is an active record style ORM{:target="_blank"} (object relational mapper). Which allows you to save and retrieve SQLite database records without ever writing a single SQL statement. Each database record is wrapped neatly into a class with methods like save() and delete().

Setup

Add the following dependency in your app/build.gradle file:


repositories {
mavenCentral()
maven {
url "https://oss.sonatype.org/content/repositories/snapshots/"
}
}

compile 'com.michaelpardo:activeandroid:3.1.0-SNAPSHOT'

Next, configure your project by adding some global settings in your AndroidManifest.xml file:

<manifest ...>
<application android:name="com.activeandroid.app.Application"
...>

        ...

        <!--Database name-->
        <meta-data android:name="AA_DB_NAME"
          android:value="Pickrand.db" />
        <!--Database version (default should be 1)-->
        <meta-data android:name="AA_DB_VERSION"
          android:value="5" />

    </application>

</manifest>

Notice also that the application name points to the ActiveAndroid application class. If you are using a custom Application class, just extend com.activeandroid.app.Application instead of android.app.Application.

Even if you are already extending Application class from another library, you can initialize ActiveAndroid in its onCreate method:


public class MyApplication extends SomeLibraryApplication {
@Override
public void onCreate() {
super.onCreate();
ActiveAndroid.initialize(this);
}
}

ActiveAndroid is a very powerful library, and thus its setup process takes a bit longer than others we have seen so far. You might run into few issues in your first attempt as well. For troubleshooting and guides, go to the official documentation{:target="_blank"}.

Usage

Usage of ActiveAndroid is a very broad topic and even a post dedicated to it will not be sufficient to cover all the features. So we leave this to the official wiki{:target="_blank"} where you can learn almost everything about it.

EventBus

You might be used to writing Interfaces for communication between your Activities and Fragments as well as different modules of your project. Now this is a pretty standard way of doing things but as your projects starts to grow, things may get out of hands. As a result, developers often end up with tightly coupling{:target="_blank"} the components of their Application. This results in a code that is less maintainable and hard to test.

EventBus{:target="_blank"} is a popular open-source library that was created to solve this problem using the publisher/subscriber pattern{:target="_blank"}.

EventBus enables central communication to decoupled classes with just a few lines of code resulting in simplification of code, low coupling, high cohesion{:target="_blank"}, and ultimately speeding up your development.

Setup

Add the following dependency in your app/build.gradle file:

compile 'org.greenrobot:eventbus:3.0.0'

Usage

Define events: Events are POJO (plain old Java object) without any specific requirements.


public class LoginEvent {

    public final boolean status;

    public LoginEvent(boolean status) {
        this.status = status;
    }

    public boolean getStatus(){
      return status;
    }

}

Prepare subscribers: Subscribers implement event handling methods that will be called when an event is posted. These are defined with the @Subscribe annotation.

// This method will be called when a LoginEvent is posted
@Subscribe
public void handleLoginEvent(LoginEvent event) {
boolean status = event.getStatus();
if(status) // Show welcome message if status is true
showWelcomeMessage();
else // Otherwise show login fail message
showLoginFailedMessage();
}

Subscribers also need to register themselves to and unregister from the bus.


@Override
public void onStart() {
super.onStart();
// Register subscribers on activity start
EventBus.getDefault().register(this);
}

@Override
public void onStop() {
// Unregister subscribers on activity stop
EventBus.getDefault().unregister(this);
super.onStop();
}

Post Events: Post an event from any part of your code. All currently registered subscribers matching the event type will receive it.

EventBus.getDefault().post(new LoginEvent(isLogin));

These were the first five from the list of libraries to help us speed up our Android development. Find out about the remaining five in the second part{:target="_blank"} of this post.

_{Most of the example code and definitions were adopted from official sources to avoid any errors.}

Build Your Personal Websites with Jekyll & GitHub Pages

Mon, 12 Dec 2016 02:04:00 GMT

Introduction

Having a personal website is a trend these days. It also becomes an important tool if you belong to a profession that requires a showcase for your portfolio items e.g Designer, Developer, Artist etc. Even if you are not one of them, you might still want to spread your ideas through a personal blog. However, most of us never bother trying to get one. Mainly due to one of the following reasons:

Hosting cost a few bucks and paying for a 'not-so-necessary' thing might feel like an overkill to you.
Or may be, you don't know how to build a website (and don't want to pay someone for it).

Well, seems like those are the days of past now. In this post, we'll learn how to setup a fully featured website without any cost using GitHub Pages{:target="_blank"} and Jekyll{:target="_blank"}.

Getting Started with GitHub Pages
- What is GitHub Pages
- Setting up GitHub repo
Setting Up Your Blog/Website
(Optional) Configuring Jekyll For Local Testing
(Optional) Redirect Your Custom Domain To Your Jekyll Site

Getting Started with GitHub Pages

GitHub{:target="_blank"} is a web-based Git repository hosting service. It offers all of the distributed version control{:target="_blank"} and source code management (SCM){:target="_blank"} functionality of Git{:target="_blank"} as well as adding its own features. After it's launch in April 2008, the company continued to make improvements to the existing service as well as introducing new features. GitHub Pages{:target="_blank"} is one of those additions.

What is GitHub Pages

GitHub Pages{:target="_blank"} is designed to host your personal, organization, or project pages directly from a GitHub repository. In order to get started with GitHub Pages, you'll need to set up a GitHub repository. This is where your content will reside and be served from.

Setting up a GitHub Repository

Let's start by creating a new GitHub repository. If you already have a GitHub account, skip to step 4:

First, create a free GitHub account{:target="_blank"}.
Make sure you pick a proper username (even better if you could find your own name available).
Download and install GitHub desktop{:target="_blank"}, especially if you are not comfortable working with CLI{:target="_blank"}.
Now that you have your GitHub account set up. Go to your GitHub account and create a new repository and name it in this format: yourusername.github.io.

{:refdef: style="text-align: center;"} {: refdef}

Next, create a copy of your empty repository in your local GitHub repositories folder. To do this:
- If you are using GitHub desktop, click the Set up in Desktop button on your repository page.
- or if you are using CLI, navigate to the folder where you want to store your project, and clone the new repository:

git clone https://github.com/username/yourusername.github.io

Go to the folder where you have stored your project and create a new file index.html.
Open the file in text editor of your choice and paste the following HTML in it, this is just to indicate that our site is working expectedly.


<html lang="en">
    <head>
        <title>My Website</title>
    </head>
    <body>
        <h1>My Website Hosted by GitHub Pages</h1>
    </body>
</html>

Finally, commit and push changes by:
- If you are using GitHub Desktop, first write a message in summary field and press Commit To Master and then pressing the Sync button.
- Or if you are on CLI, use the following commands

git add --all
git commit -m "Initial commit"
git push -u origin master

Once the changes have been pushed, type in the url yourusername.github.io in your browser and you should see your page.

Congratulations! You've successfully created your website, now is the time give it a pleasing look and feel.

Setting Up Your Blog/Website

Now that your site basic website is up and running, it's time to make it look like an actual website with the help of Jekyll{:target="_blank"}.

What is Jekyll

At this point you might be wondering 'so what is Jekyll anyway?'. It is an awesome blog-aware website generator that is designed for building minimal, static sites to be hosted on GitHub Pages. I recently migrated my personal site from Wordpress to Jekyll and got to admit that I'm loving it.

So how does Jekyll differs from Wordpress?

Firstly, if you have used Wordpress{:target="_blank"}, you can tell that it has it's flaws, plus it's sort of an overkill if you want to put only simple static content. Also, it has been a hot target for hackers in recent years.

Oh! and did I tell you that it's waaaay faster than Wordpress?

Wordpress suffers badly as the load grows on the site. However, Jekyll being static-website-centric, completely ends that problem as static files put very little load on the server.

Another important point for me was Markdown{:target="_blank"} support, if you are like me and hate writing HTML then Jekyll is your friend. Jekyll supports Markdown out of the box, which is a very simple and intuitive text-to-HTML conversion tool. It allows you to write using an easy-to-read, easy-to-write plain text format, then converts it to structurally valid XHTML (or HTML).

Give Your Site Personal Touch With Themes

Just like Wordpress, Jekyll supports customizable themes. You can find plenty of free themes at JekyllThemes.org{:target="_blank"}, Themes.JekyllRC.org{:target="_blank"}, JekyllThemes.io{:target="_blank"} or at this GitHub repository{:target="_blank"}. Our next step will be to apply a theme to our website and then customize it. So go to these sites, play with demo and pick one that you like.

Once you have found the right theme for your website, download the zip file and extract all of its content to your local repository folder.

If the archive contains a top level folder and has all the files in it. Then exclude the folder and copy all contents from it to your repository containing folder.

Finally, once again commit and push your changes and open your browser to see your newly furnished site in action.

Customizing & Testing Your Website

Jekyll themes come with a _config.yml file which contains all the meta data about the website such as title, description, favicon, author info, pages etc. Edit this file with your data e.g.


# Website settings

title: "John Doe"
description: "John's blog powered by Jekyll and GitHub Pages."
keywords: "John,blog,Jekyll,github,gh-pages"
baseurl: "/"
url: "http://www.JohnDoe.com"

# url: "http://127.0.0.1:4000"

# author

author:
name: 'John'
first_name: 'John'
last_name: 'Doe'
email: 'mail@JohnDoe.com'
facebook_username: 'JohnDoe'
github_username: 'JohnDoe'
head_img: 'static/img/landing/JohnDoe.jpg'
desc: 'I am a Software Engineer with 5 year experience. I like
coding, swimming and potato.'

# sections

sections:

- id: 'about-me'
  i18n: 'nav.about_me'
  name: 'About'
  tpl: 'about.html'
  css: ''

- id: 'career'
  i18n: 'nav.career'
  name: 'Career'
  tpl: 'career.html'
  css: 'timeline'

- id: 'skills'
  i18n: 'nav.skills'
  name: 'Skills'
  tpl: 'skills.html'
  css: 'team'

Contents of file may differ based on the theme you choose

Once again commit and push your changes and open your browser to see the changes. That's it! You have your own website up and running totally free of cost. You can continue customizing your theme or learn about writing posts on Jekyll's official documentation{:target="_blank"}.

(Optional) Configuring Jekyll For Local Testing

At this point, you're all set to start customizing and publishing your content, but isn't it tedious to commit and push every time to preview even the slightest of changes?

Confession: I had to push the code over 50 times while customizing my site without knowing there's an easy way. Make sure you don't do something as silly as that.

Well good news is that you can set up a local version of your Jekyll GitHub Pages site to test changes to your site locally. It is highly recommended by GitHub to install Jekyll in order to preview your site and troubleshoot failed Jekyll builds.

Installing Bundler for Ruby

Open Git Bash.
Check whether you have Ruby 2.1.0 or higher installed:

ruby --version
ruby 2.X.X

If you don't have Ruby installed, install Ruby 2.1.0 or higher.
After that, install Bundler:


gem install bundler

Installing Jekyll using Bundler

Check to see if you have a Gemfile in your local Jekyll site repository. If you have a Gemfile, skip to step 4.
If you don't have a Gemfile, open a text editor of your choice, and add these lines to a new file:

source 'https://rubygems.org'
gem 'github-pages', group: :jekyll_plugins

Name the file Gemfile and save it to the root directory of your local Jekyll site repository. Skip to step 5 to install Jekyll.
If you already have a Gemfile, open it in a text editor of your choice, and add these lines:


source 'https://rubygems.org'
gem 'github-pages', group: :jekyll_plugins

Finally, install Jekyll and other dependencies from the GitHub Pages gem:

bundle install

Build your local Jekyll site

Navigate into the root directory of your local Jekyll site repository.
Run your Jekyll site locally:


bundle exec jekyll serve

Preview your local Jekyll site in your web browser at http://localhost:4000.

(Optional) Redirect Your Custom Domain To Your Jekyll Site

If you own a custom domain (say yourusername.com) then you can redirect this existing domain to your GitHub Pages website so it replaces the yourusername.github.io address with this more personal one.

First of all create a new file named CNAME (all caps, without any spaces or extension)
Open this file in a text editor of your choice and add your domain name. e.g.

yourusername.com

Save the file and once again commit and push!
Next, go to your hosting provider and find the Manage DNS section. Add two records there.
Add a A record that points to 192.30.252.153.

{:refdef: style="text-align: center;"} {: refdef}

Add a CNAME record that points to your GitHub Pages site:

{:refdef: style="text-align: center;"} {: refdef}

And that's it, wait for changes to propagate and you'll be able to reach your Jekyll site using your custom domain address.

RSS Feed

Indie Devlog #00

Git Worktrees: Work on Multiple Flutter Branches Simultaneously

The context-switching tax

Worktrees: multiple branches, zero stashing

Real-world Flutter scenarios

Scenario 1: Code review while working

Scenario 2: Compare behavior across branches

Scenario 3: Long-running experiments

Commands you'll actually use

Things to know

Clean-up

Why this matters

Automatically Trigger Dart Test Runs On File Changes

Jest has us spoiled

Flutter? Crickets

Remember the spec package?

I even tried Nodemon

Enter fswatch

Lazy Loading Libraries in Dart

How to Use Deferred Loading in Dart

Advantages of Using Deferred Loading

Conclusion

Building a ChatGPT App using Flutter

Prerequisites

Setting up the Application

Build Modern Command Line Interfaces (CLI) with Python

What is PyInquirer?

How to Install PyInquirer

Creating a CLI Wizard with PyInquirer

Customizing the Look of the CLI Wizard

Conclusion

Securing Sensitive Data using Gradle Files

Storing Secrets in a Properties File

Using Environment Variables

Setting Build Config Fields

Flutter Plugin Development

What is a Flutter Plugin?

Getting Started

Creating a New Plugin

Adding Platform-Specific Code

Testing Your Plugin

Publishing Your Plugin

Conclusion

Generate ASCII Art with Python

Setting Up the Environment

Generating ASCII Art

Creating Custom Fonts

Clutterfree Flutter Architecture

Write Code Not Boilerplate

Freezed

BLoC

Injectable

Chopper

Auto Route

Screen Util

Automatic JSON to Dart Conversion in Flutter

Painless UI Testing with Kaspresso

Caffeine Overflow

But Wait, There's More!

Grade Calculator 2.0

Installation

Adding The UI Test

Implementing The Kaspresso Screen

Adding The Business Logic

Binding It All Together

Conclusion

Painless Unit Testing with Kotlintest & Mockk

Why Testing Matters

Testing As You Go

Specification Based Testing In Practice

Problems with JUnit

Code Repetition

Lack Of Contextual Information

A Better Way To Write Tests

Feature

Installation

Implementation

Conclusion

Inter-Process Communication in Android - Lessons & Learnings

Remember the `spec` package?

Enter `fswatch`