HMKCODE

Creating Dynamic and Draggable Points on a Line with Smooth Transitions

Sat, 27 Jul 2024 09:00:00 +0900

Introduction:

In the ever-evolving world of web development, interactive elements enhance user experience by making web pages more engaging and intuitive. One such feature is creating dynamic and draggable points on a line, which can be used in various applications like data visualization, interactive timelines, or educational tools. This blog post delves into how to implement draggable points on a line with smooth transitions to handle overlaps and ensure a seamless user experience.

Explanation:

Creating draggable points on a line involves several steps, including handling mouse events, adjusting positions to prevent overlaps, and ensuring smooth transitions for a polished look. Here’s a breakdown of the key components:

HTML Structure:
- A simple structure with a container for the line and buttons to add new points dynamically.
CSS Styling:
- Basic styles to define the appearance of the points, labels, and line, including transitions for smooth animations.
JavaScript Logic:
- Handling mouse events (mousedown, mousemove, mouseup) to enable dragging.
- Adjusting positions to prevent points from overlapping.
- Smoothly adjusting the vertical lines to avoid label overlaps.

Source Code @ GitHub

CSS | Understanding CSS @keyframes and Animation Timing Functions

Fri, 21 Jul 2023 09:00:00 +0900

CSS animations are a powerful way to add dynamic and engaging elements to your web pages. They allow you to create smooth and visually appealing transitions between different states of an element. Among the various techniques available in CSS animations, @keyframes and animation-timing-function play crucial roles in defining animation behavior.

CSS @keyframes: Defining Animation Steps

The @keyframes rule allows developers to specify the intermediate steps or stages of an animation. With @keyframes, you can define how an element should look at various points during an animation. Let’s look at an example of a simple animation that moves an element from its initial position to the right by 600 pixels:

@keyframes moveforward {
    0% { left: 0px; }
    100% { left: 600px; }    
}

In this example, we’ve defined a @keyframes rule named moveforward. The animation starts with the element positioned at left: 0px, and at the 100% keyframe, the element’s left property is set to 600px. As a result, the element will smoothly move from its initial position to 600 pixels to the right.

Animation Timing Functions: Controlling Animation Pace

The animation-timing-function property determines the pace of an animation over its duration. CSS provides several predefined timing functions, each affecting the way an animation progresses. Here are some commonly used timing functions:

linear: The animation progresses at a constant pace, creating a steady motion.
ease: The animation starts slowly, accelerates in the middle, and then decelerates towards the end, creating a natural look and feel.
ease-in: The animation starts slowly and gradually accelerates.
ease-out: The animation starts quickly and gradually decelerates at the end.
ease-in-out: The animation starts slowly, accelerates in the middle, and then decelerates towards the end, similar to ease.

Additionally, you can use the cubic-bezier function to create custom timing functions. The cubic-bezier function takes four values (P1, P2, P3, P4) between 0 and 1, allowing you to finely tune the animation curve.

Putting it All Together: An Interactive Example

Let’s explore a practical example that combines @keyframes and animation-timing-function. We have an element with the class .animate that will move forward and backward in an infinite loop, demonstrating different timing functions.

<!DOCTYPE html>
<html>

<head>
    <style>
        .animate {
            width: 128px;
            height: 40px;
            color: white;
            font-weight: bold;
            position: relative;
            animation-direction: normal;
            animation-iteration-count: 1;
            animation-delay: 1000ms;
            border: 0px solid white;
        }
        .forward{
            animation: moveforward 8s forwards;
            background-image: url("car.png");
        }
        .backward{
            animation: movebackward 8s forwards;
            background-image: url("car-rtl.png");
        }
       
        .track{
            position: relative;
            width : 728px;
            height : 40px;
            background-color: #444444;
            margin-bottom: 25px;

        }
        .timing-function{
            position: absolute;
            top: -19px;
            left: 0px;
            width: 280px;
            color: #76d1fe;
            font-family: monospace;
            background-color: #333;
            padding: 2px;
            border-radius: 3px 3px 0px 0px;


        }
        .timing-function span{
            color: rgb(233, 169, 85);
        }

        .content {
            width: 728px;
            margin: 0 auto;
            padding: 20px;
            background-color: #333;
            color: #76d1fe;
            font-family: monospace;
            border-radius: 3px;
        }

        .linear {
            animation-timing-function: linear;
        }

        .ease {
            animation-timing-function: ease;
        }

        .ease-in {
            animation-timing-function: ease-in;
        }

        .ease-out {
            animation-timing-function: ease-out;
        }

        .ease-in-out {
            animation-timing-function: ease-in-out;
        }

        .cubic-bezier {
            animation-timing-function: cubic-bezier(0.1, 0.7, 1.0, 0.1);
        }

        @keyframes moveforward {
            0% { left: 0px; }
            100% { left: 600px;}    
        }

        @keyframes movebackward {
            0% { left: 600px; }
            100% { left: 0px;}    
        }
      
    </style>

    <script>
       document.addEventListener('DOMContentLoaded', () => {
        // Get the animated element using its class name
        const animatedElement = document.querySelectorAll('.animate');

        // Add an event listener for the animationend event
        animatedElement.forEach((element) => {
            element.addEventListener('animationend', () => {
                
                console.log('Animation completed!');
                element.classList.toggle('forward');               
                setTimeout(() => {element.classList.toggle('backward');}, 5);
            });
        });
    });
    </script>
</head>

<body>

    <div class="content">    
        <div style="margin-bottom: 40px; display: flex; align-items: center; justify-content: center;">
            <img src="CSS3_logo.png" alt="CSS Logo" width="64px" height="64px" style="display: inline-block;">
            <h1 style="display: inline-block; margin-left: 10px;color:#fff">CSS animation-timing-function</h1>
        </div>
        
        
       

        <div class="track">
            <code class="timing-function">animation-timing-function: <span>linear;</span></code>
            <div class="animate linear forward"></div>
        </div>
        <div class="track">
            <div class="animate ease forward"></div>
            <code class="timing-function">animation-timing-function: <span>ease;</span></code>
        </div>
        <div class="track">
            <div class="animate ease-in forward"></div>
            <code class="timing-function">animation-timing-function: <span>ease-in;</span></code>
        </div>
        <div class="track">
            <div class="animate ease-out forward"></div>
            <code class="timing-function">animation-timing-function: <span>ease-out;</span></code>    
        </div>
        <div class="track">
            <div class="animate ease-in-out forward"></div>
            <code class="timing-function">animation-timing-function: <span>ease-in-out;</span></code>
        </div>    
        <div class="track">
            <div class="animate cubic-bezier forward"></div>
            <code class="timing-function">animation-timing-function: <span>cubic-bezier;</span></code>
        </div>
    </div>
  

</body>

</html>

In this example, we animate a car element using two @keyframes rules: moveforward and movebackward. The animation-timing-function is set for each element to showcase different timing functions.

The result is an interactive demonstration of how each timing function influences the element’s motion, providing a smooth, dynamic, and visually appealing user experience.

Source Code @ GitHub

Java | Nested Classes

Thu, 07 Jul 2022 21:00:00 +0900

Nested class is a class that is defined within another class.

public class OuterClass {
    
    class NestedClass {

    }
}

A nested class is a member of its enclosing class.
Nested class should only serve its enclosing class. If a nested class is needed outside the context of its enclosing class then it should be defined as a top-level class.
There are four kinds of nested classes:
- static member classes
- non-static member classes
- anonymous classes
- local classes

Non-Static Nested Classes “Inner Classes”

Non-static nested classes are called inner classes.
Inner class is associated with an instance of its enclosing class
Inner class has access to members of its enclosing class, even if they are declared private.

public class OuterClass {
    
    private String name = "OuterClass.name";
	private static String NAME = "OuterClass.NAME";

    public class InnerClass {
        public InnerClass(){
            // InnerClass can access non-static "name" and static "NAME" members of OuterClass
    		System.out.println("InnerClass "+name+" "+NAME);
        }
    }
}

public class App {

	public static void main(String[] args) {
		
        // InnerClass is associated with an instance of OuterClass
		OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();	
	}
}

Output:

InnerClass OuterClass.name

Static Nested Classes

Static nested class is associated with its outer class
Static nested classes do not have access to other members of the enclosing class.
Nested class that does not require access to an enclosing instance should be declared static.
A nested class can be declared private, public, protected, or package private. (OuterClass can only be declared public or package private.)

public class OuterClass {
    
    private String name = "OuterClass.name";
	private static String NAME = "OuterClass.NAME";

    static class StaticNestedClass {

        public StaticNestedClass(){
            
            // StaticNestedClass can only access static member "NAME" of OuterClass
    		System.out.println("StaticNestedClass "+NAME);
    	}
    }
}

public class App {

	public static void main(String[] args) {
		
		OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();	
	}
}

Output:

StaticNestedClass OuterClass.NAME

Anonymous Classes

Anonymous class has no name and is not a member of its enclosing class.
Anonymous class is declared and instantiated at the same time.
Anonymous class is commonly used to implement an interface with few methods.

interface SomeInterface {
	
	void doSomething();
}

public class App {

	public static void main(String[] args) {
				
		String name = "App class";

		someMethod(new SomeInterface() {
			@Override
			public void doSomething() {
				System.out.println("Anonymous class inside "+name);
			}			
		});
	}
	
	public static void someMethod(SomeInterface someInterface) {
		someInterface.doSomething();
	}
}

lambda expression can be used instead of an anonymous class expression if the interface contains only one method.

public class App {

	public static void main(String[] args) {
				
		String name = "App class";

		SomeInterface lambda = () -> { System.out.println("Anonymous class inside "+name); };
		someMethod(lambda);
	}
	
	public static void someMethod(SomeInterface someInterface) {
		someInterface.doSomething();
	}
}

Java | How to Enforce Non-Instantiability of a Class?

Thu, 02 Jun 2022 21:00:00 +0900

Interfaces and abstract classes are non-instantiable i.e. we can’t directly create instances out of them. Regular classes are instantiable by default, so how to enforce non-instantiability?

“Enforce the singleton property with private constructor or an enum type” ~ Joshua Block’s, Effective Java

Why Do We Need Non-instantiable Classes?

You may need to have a class that provides static methods and fields e.g. java.lang.Math
Such classes should not be instantiated since their static members are accessible without creating an instance.

public final class MyUtility{

    public static void doSomething(){
        // ....
    }
}

How to Enforce Non-instantiability?

No explicit constructor

Writing a class without an explicit constructor is the first step. However, it is not enough since the compiler will implicitly provide the default constructor.
MyUtility is still instantiable using the default constructor.

public static void main(String[] args) {
    new MyUtility();
}

Not abstract

Making the class abstract is not enough since abstract class can be extended specially that abstract class is usually designed for inheritance.

public abstract class MyUtility {

	 public static void doSomething(){
	        // ....
	 }
}

class MySubUtility extends MyUtility{}

Include a private constructor

private constructor will prevent the creation of new instances even if the class is extended.
One exception is that the private constructor can be called from within the class.

public class MyUtility {

	 private MyUtility() {}
	 
	 public static void doSomething(){
	        // ....
	 }
}

Throw an Error

To prevent the calling of the constructor from within the class, throw an error.

public class MyUtility {

	 private MyUtility() {
         throw new AssertionError();
     }
	 
	 public static void doSomething(){
	        // ....
	 }
}

Java | Overriding equal() Method

Mon, 30 May 2022 21:00:00 +0900

Overriding common methods (equals, hashCode, toString, and clone) of the Object class and Comparable.compareTo() method, should be done according to the general contracts provided in the documentation to ensure proper behaviour of these methods.

Overriding Object Common Methods

Object is the super type for all classes.
All classes inherit the default behaviour of Object methods (equals, hashCode, toString, and clone)

public boolean equals(Object obj)
public int hashCode()
public String toString()
protected Object clone() throws CloneNotSupportedException

However, if you decide to override one of these methods, then there are general contracts or instructions you should follow to ensure proper execution of these methods.

Overriding equals(Object)

Default Implementation

The default behaviour of equals(Object) method is to compare objects references “identity”.

public boolean equals(Object obj) {

	return (this == obj);
}

So, if a class creates a single instance “singleton” or unique instances, then it is better to keep default implementation.
If we need to compare instances of a class based on their values “logical equality”, then overring equals(Object) is necessary.

General Contracts

Overriding equals(Object) method should adhere to the general contract as documented in Object class API.

The equals method implements an equivalence relation on non-null object references:

It is reflexive: for any non-null reference value x, x.equals(x) should return true.

It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.

It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.

It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.

For any non-null reference value x, x.equals(null) should return false.

Reflexive

myObject.equals(myObject) // should return true

Symmetry

myObject.equals(anotherObject) // returns true
anotherObject.equals(myObject) // should return true too!

We can demonstrate how to get this one wrong in the following example

MyString class overrides equals(Object). The method was overridden to handle passed object of type String which works fine. However, String class was NOT implemented to handle an object of type MyString! This implementation is violating symmetry.

public class MyString {

	private final String s;
	
	public MyString(String s) {
		this.s = (s == null? "":s);
	}
	
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof MyString)
			return ((MyString)(obj)).s.equals(this.s);
		else if(obj instanceof String)
			return obj.equals(this.s);
		else
			return false;
	}
}

public static void main(String[] args) {
		
		MyString myString = new MyString("cool!");
		String string = "cool!";
		
		System.out.println(myString.equals(string)); // returns true
		System.out.println(string.equals(myString)); // returns false

	}

MyString class should not accept object of type other than MyString.

@Override
	public boolean equals(Object obj) {
		if(obj instanceof MyString)
			return ((MyString)(obj)).s.equals(this.s);
		else
			return false;
	}

public static void main(String[] args) {
		
		MyString myString = new MyString("cool!");
		String string = "cool!";
		
		System.out.println(myString.equals(string)); // returns false
		System.out.println(string.equals(myString)); // returns false

	}

Transitivity

firstObject.equals(secondObject) // returns true
secondObject.equals(thirdObject) // returns true
firstObject.equals(thirdObject) // must return true

We can demonstrate how to get this one wrong in the following example

We have a class Point with two parameters and overrides equals() method with no violation of general contracts.
ColorPoint is a subclass with one extra color parameter and also overrides equals() method that includes the color paramter in the logic of equality.

public class Point {
	private final int x;
	private final int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override public boolean equals(Object obj) {
		if (!(obj instanceof Point))
			return false;
		
		Point p = (Point)obj;
		return p.x == x && p.y == y;
	}
}

public class ColorPoint extends Point {
	
	private final String color;
	
	public ColorPoint(int x, int y, String color) {
		super(x, y);
		this.color = color;
	}
	
	@Override public boolean equals(Object obj) {
		if (!(obj instanceof ColorPoint))
			return false;
		return super.equals(obj) && ((ColorPoint) obj).color.equals(this.color);
	}
	
}

ColorPoint equals() method violates symmetry!

public static void main(String[] args) {
	
		Point point = new Point(1, 2);
		ColorPoint colorPoint = new ColorPoint(1, 2, "RED");
		
		System.out.println(point.equals(colorPoint)); // true
		System.out.println(colorPoint.equals(point)); // false

	}

To fix the symmetry issue we modify the equal() method as following

@Override 
public boolean equals(Object obj) {
	if (!(obj instanceof Point))
		return false;

	// if obj is Point but not ColorPoint
	if (!(obj instanceof ColorPoint))
		return obj.equals(this);
	
	// if obj is a ColorPoint; do a full comparison
	return super.equals(obj) && ((ColorPoint) obj).color.equals(this.color);
}

public static void main(String[] args) {
	
		Point point = new Point(1, 2);
		ColorPoint colorPoint = new ColorPoint(1, 2, "RED");
		
		System.out.println(point.equals(colorPoint)); // true
		System.out.println(colorPoint.equals(point)); // true

	}

However, this modified version of equals() method violates transitivity!

public static void main(String[] args) {
		
		ColorPoint redPoint = new ColorPoint(1, 2, "RED");
		Point point = new Point(1, 2);
		ColorPoint bluePoint = new ColorPoint(1, 2, "BLUE");
		
		System.out.println(redPoint.equals(point)); // true
		System.out.println(point.equals(bluePoint)); // true
		System.out.println(redPoint.equals(bluePoint)); // false
}

It turns out that this is a fundamental problem in object-oriented languages.

“There is no way to extend an instantiable class and add a value component while preserving the equals contract” ~ Joshua Block’s, Effective Java

The solution for this problem is to use composition instead of inheritance

public class ColorPoint  {
	
	private final Point point;
	private final String color;
	
	public ColorPoint(Point point, String color) {
		this.point = point;
		this.color = color;
	}
	
	@Override 
	public boolean equals(Object obj) {

		if (!(obj instanceof ColorPoint))
			return false;
		
		ColorPoint cp = (ColorPoint) obj;
		return cp.point.equals(this.point) && cp.color.equals(this.color);
	}
	
}

public static void main(String[] args) {
		
		ColorPoint redPoint = new ColorPoint(new Point(1, 2), "RED");
		Point point = new Point(1, 2);
		ColorPoint bluePoint = new ColorPoint(new Point(1, 2), "BLUE");
		
		System.out.println(redPoint.equals(point)); // false
		System.out.println(point.equals(bluePoint)); // false
		System.out.println(redPoint.equals(bluePoint)); // false
}

Consistency

Calling equals() method on two objects should consistently return the same result until one or both of them is modified.
This can be achieved by making the object immutable.

Java | Serialization

Thu, 26 May 2022 21:00:00 +0900

Serialization is the process of converting an object into a stream of bytes which can be deserialized back to a copy of the object. A serialized object can be stored in a file and deserialized later into an object.

Serializable Objects

An object is serializable if it is a sub-type of java.io.Serializable interface or its sub-interface java.io.Externalizable.
Serializable objects can be stored into e.g. a file and restored back into an object by deserializing it.
Serializable objects can be serialized using default Java way or custom way.
Serializable object includes sufficient information to restore the fields in the stream to a compatible version of the class.

public class Universe implements Serializable  {

	private long timestamp;
	
	public Universe() {
		timestamp =  System.currentTimeMillis();
	}
}

Serializing an Object

ObjectOutputStream.writeObject(Object ob) method is used to write an object to OutputStream e.g. FileOutputStream.

public static void serialize(Universe universe) throws Exception {
	    FileOutputStream file = new FileOutputStream("output.txt");
	    ObjectOutputStream out = new ObjectOutputStream(file);
	    out.writeObject(universe);
	    out.close();
	    file.close();
	}

Deserializing an Object

ObjectInputStream.readObject() method is used to read an object from InputStream e.g. FileInputStream.

public static Universe deserialize() throws Exception {
	    FileInputStream file = new FileInputStream("output.txt");
	    ObjectInputStream in = new ObjectInputStream(file);
	    Universe universe = (Universe) in.readObject();
	    in.close();
	    file.close();
	    return universe;
}

Non-serializable Fields

Fields declared as transient or static will not be serialized.

public class Universe implements Serializable  {

	public static Universe INSTANCE; //Non-serializable
	
	private long timestamp;
	private transient long age;  // Non-serializable 
	
	public Universe() {
		timestamp =  System.currentTimeMillis();
	}
}

Optional Methods for Serializable Class

Classes implementing Serializable interface can optionally define the following methods:
- writeObject() to control what is saved and append additional information to the stream.
- readObject() to update the state of the object after it has been restored.
- writeReplace() to replace object to be written to stream with different one.
- readResolve() to replace object read from stream with different object.

Java | Singleton Pattern

Thu, 26 May 2022 21:00:00 +0900

“Enforce the singleton property with private constructor or an enum type” ~ Joshua Block’s, Effective Java

Some objects are required to be singleton such as “builder, facade, state, logging, …etc”. Singleton pattern can be used to enforce the creation of exactly one instance of those objects.

How to Enforce the Creation of a Single Instance?

There are two common way to implement singleton:

1. `private` Constructor with `public static` member

The private constructor ensures that no calls will be allowed from outside the class.
The private constructor can be further protected by throwing an exception if a second instance is requested.
The public member in this way can be either a static field or static method.
- public feild approach is preferable over public factory method.
- public factory method approach can be more flexible e.g. by allowing the return of an instance for each thread if necessary.
1.1 pubic field

public class Universe {

	public static final Universe INSTANCE = new Universe();
	private long timestamp;

	private Universe() {
		timestamp =  System.currentTimeMillis();
	}
	
}

1.2 public static factory method

public class Universe {

	private static final Universe INSTANCE = new Universe();
	private long timestamp;

	private Universe() {
		timestamp =  System.currentTimeMillis();
	}
	
	public static Universe getInstance() {
		return INSTANCE;
	}
}

Dealing with serialization

Maintaining singleton is not guaranteed for classes implementing Serializable.
New instances will be created when serialized instances are deserialized.

public class Universe implements Serializable  {

	public static final Universe INSTANCE = new Universe();
	private long timestamp;
	
	private Universe() {
		timestamp =  System.currentTimeMillis();
	}
}

public class App {
	public static void main(String[] args) throws Exception {
		
		Universe universe = Universe.INSTANCE;
				
		// serialize and deserialize
		Serializer.serialize(universe);
		Universe deserilizedUniverse = Serializer.deserialize();

		System.out.println(deserilizedUniverse == universe); // --> false
	}
}

class Serializer{
	
	public static void serialize(Universe universe) throws Exception {
	    FileOutputStream file = new FileOutputStream("output.txt");
	    ObjectOutputStream out = new ObjectOutputStream(file);
	    out.writeObject(universe);
	    out.close();
	    file.close();
	}
	
	public static Universe deserialize() throws Exception {
	    FileInputStream file = new FileInputStream("output.txt");
	    ObjectInputStream in = new ObjectInputStream(file);
	    Universe universe = (Universe) in.readObject();
	    in.close();
	    file.close();
	    return universe;
	}
}

To overcome this issue we need to add the following
- Declare all instance feilds transient
- Implement readResolve() method
  - readResolve() is called when an object is deserialized.
  - A class implementing the readResolve() method, can directly control the return of the deserialization process.
  - So will use this trick to replace deserialized object with the original “INSTANCE” object.

public class Universe implements Serializable  {

	public static final Universe INSTANCE = new Universe();
	private transient long timestamp;
	
	private Universe() {
		timestamp =  System.currentTimeMillis();
	}

	private Object readResolve() {
		return INSTANCE; //not deserialized one!
	}
}

System.out.println(deserilizedUniverse == universe); // --> true

2. Single Element `enum`

Single-element enum is similar to public field approach.
Single-element enum is thread, serialization and reflection safe approach.

”..a single-element enum type is often the best way to implement a singleton.” ~ Joshua Block’s, Effective Java

public enum Universe {

	INSTANCE(System.currentTimeMillis());
	private long timestamp;

	private Universe(long timestamp) {
		this.timestamp = timestamp;
	}

	public long getTimestamp() {
		return timestamp;
	}
}

public class App {

	public static void main(String[] args) throws Exception {
		
		System.out.println(Universe.INSTANCE.getTimestamp());
	}
}

Java | Builder Pattern for Optional Parameters

Tue, 24 May 2022 21:00:00 +0900

“Consider a builder when faced with many constructor parameters” ~ Joshua Block’s, Effective Java

Classes that have many optional parameters can use builder pattern to create instances of these classes according to Joshua Block’s Effective Java Item-2.

How to Create Instances of Classes with Many Optional Parameters?

For example, we have Mobile.java class that has one required parameter and many optional ones.

public class Mobile {
	
	String brand;  //required
	String model;  
	String color;
	double display;
	double price;
}

To create an instance of this class we can have a constructor that accepts all parameters. While this seems to be a simple solution, it will require the passing of values for parameters that might not needed.

public Mobile(String brand, String model, String color, double display, double price) {
		this.brand = brand;
		this.model = model;
		this.color = color;
		this.display = display;
		this.price = price;
	}

Another way is to write a constructor or “static factory method” for each possible case. However, this way might not be practical and will be faced with the language restriction of not allowing more than one constructor with the same signature.

public Mobile(String brand, String model) {
		this.brand = brand;
		this.model = model;
	}

// not allowed! we already have a constructor with similar signature
public Mobile(String brand, String color) {
		this.brand = brand;
		this.color = color;
	}

A third possible solution is JavaBean in which we call default constructor “that has no parameters” and then set parameters using setter methods. However, since the creation of an instance needs multiple calls we need to ensure thread safety and consistency of passed values.

Mobile mobile = new Mobile();
mobile.setBrand("Apple");
mobile.setSize(5.4);
...

An alternative solution that overcomes all the disadvantages of previous ones is Builder Pattern

Builder Pattern

Builder pattern is an efficient way to create instances of classes that have many optional parameters.
Builder pattern has many advantages over other alternative ways e.g. JavaBeans.
Builder pattern works by creating a builder object with required parameters then setter-like methods are called to set optional parameters. The actual instance is created by calling build() method.

Mobile mobile = new Mobile.Builder("Apple").display(5.4).model("iPhone 13").build();

public class Mobile {
	
	private String brand;  //required
	private String model;  
	private String color;
	private double display;
	private double price;
	
	// getters
	
	private Mobile(Builder builder) {
		// optional paramters only
		this.model = builder.model;
		this.color = builder.color;
		this.display = builder.display;
		this.price = builder.price;
	}

	
	public static class Builder{
		//required
		private String brand;
		
		// optional 
		private String model;  
		private String color;
		private double display;
		private double price;
		
		public Builder(String brand) {
			this.brand = brand;
		}
		
		// optional parameters setters
		public Builder model(String model) {
			this.model = model;
			return this;
		}
		public Builder color(String color) {
			this.color = color;
			return this;
		}
		public Builder display(double display) {
			this.display = display;
			return this;
		}
		public Builder price(double price) {
			this.price = price;
			return this;
		}
		
		// build 
		public Mobile build() {
			return new Mobile(this);
		}
	}
}

Java | Service Provider Interface

Fri, 20 May 2022 21:00:00 +0900

Service provider interface (SPI) enables developers to extend applications functionalities by adding services implementation, e.g. Jar files, to classpath without modifying the application code base.

Service Provider Interface Components

Service: Classes on interfaces that provide access to functionality of feature.

public interface MyService {

	void doSomething();
}

Service Provider Interface (SPI): interfaces or abstract classes that define the set of services that can be provided to the application.

public interface MyServiceProviderInterface {

	MyService getService();
}

Service Provider: implementation of the SPI that provide concrete implementation of the service.

public class MyServiceImpl1 implements MyService{

	@Override
	public void doSomething() {
		System.out.println("MyServiceImpl1");
		
	}
}

public class MyServiceProviderImpl1 implements MyServiceProviderInterface {

	@Override
	public MyService getService() {
		return new MyServiceImpl1();
	}

}

The ServiceLoader Class

The java.util.ServiceLoader class helps you find, load, and use service providers. Providers can be added to classpath or runtime extension directory. The application needs to specify the provider interface to the loader to find it and load it.

public class MyServiceLoader {

    private static final String DEFAULT_PROVIDER = "com.hmkcode.impl.MyServiceProviderImpl1";
    
    public static MyServiceProviderInterface defaultProvider() {
    	return provider(DEFAULT_PROVIDER);
    }
    
    public static MyServiceProviderInterface provider(String providerName) {
        ServiceLoader<MyServiceProviderInterface> loader = 
        		ServiceLoader.load(MyServiceProviderInterface.class);

        Iterator<MyServiceProviderInterface> it = loader.iterator();
        while (it.hasNext()) {
        	MyServiceProviderInterface provider = it.next();
            if (providerName.equals(provider.getClass().getName())) {
                return provider;
            }
        }
        throw new ProviderNotFoundException("provider " + providerName + " not found");
    }
    
}

Example

We have three Java projects:

java-spi-api: api project containing
- MyService.java service interface
- MyServiceProviderInterface.java SPI interface

public interface MyService { 
	void doSomething(); 
}

public interface MyServiceProviderInterface { 
	MyService getService(); 
}

java-spi-impl1: implementation of service provider
- MyServiceImpl1.java: service implementation i.e. implements MyService.java
- MyServiceProviderImpl1.java: service provider implementation.
- com.hmkcode.api.MyServiceProviderInterface: provider configuration file placed under META-INF/services directory.

public class MyServiceImpl1 implements MyService{

	@Override
	public void doSomething() {
		System.out.println("MyServiceImpl1");	
	}
}

public class MyServiceProviderImpl1 implements MyServiceProviderInterface {
	
	@Override
	public MyService getService() {
		return new MyServiceImpl1();
	}
}

java-spi-app: main application
- App.java: main method
- MyServiceLoader.java: service loader that helps find, load and use service providers.

package com.hmkcode.app;

public class App 
{
    public static void main( String[] args )
    {        
        MyServiceLoader.defaultProvider().getService().doSomething();
    }
}

Source Code @ GitHub

Java | Constructors vs Static Factory Methods

Wed, 18 May 2022 21:00:00 +0900

“Consider static factory methods instead of constructors” ~ Joshua Block’s, Effective Java

While using constructors is the default way of creating new objects, using static methods might bring more advantages according to Joshua Block’s Effective Java Item-1.

Using Static Methods Instead of Constructors!

Controlling the way of creating new objects seems to be a best practice to be considered when programming.
One of these ways is static factory method, which is simply a static method returning an instance of a class.
Java API has many examples of classes using static factory methods e.g. String class

public static String valueOf(Object obj) {
  return (obj == null) ? "null" : obj.toString();
}

String str1 = String.valueOf(1);
String str2 = String.valueOf(true);
String str3 = String.valueOf('a');

Some Advantages of using Static Factory Methods

1. Meaningful Names

Unlike constructors, static factory methods can have meaningful names which describe the functionalities. For example, Optional class has static factory method empty() that, as the name conveys, return an empty instance.

public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
}

Also, static factory methods will help to get around the restriction of having multiple constructors with the same signature.

public class User {

	private String name;
	private String address;
	private String type;
	
	public User(String name, String address, String type) {
		
		this.name = name;
		this.address = address;
		this.type = type;
	}
	
	public static User createUserwithDefualtType(String name, String address) {
		return new User(name, address, "Regular");
	}
	
	public static User createUserwithEmptyAddress(String name, String type) {
		return new User(name, "", type);
	}
	
}

2. Instance Controlled Classes

Controlling the creation of new instances is achievable with static factory methods.
Immutable classes can be preconstructed or cached and return them with every invocation without recreating them.
Static factory methods allow classes to be singleton, non-instantiable and to provide logic to be implemented before returning fully-initialized objects e.g. to check for duplicated instances.

public class Connection {
    
    private static volatile Connection instance = null;
    
    private Connection(String host, String address) {...}
    
    public static Connection getSingletonInstance(String host, String address) {
        if (instance == null) {
            synchronized (Connection.class) {
                if (instance == null) {
                    instance = new Connection(host, address);
                }
            }
        }
        return instance;
    }
}

3. Returning Subtypes

Unlike constructors, static factory methods can return subtypes of the return type.

interface Shape {

	public static Shape createRectangle(int width, int height) {
		return new Rectangle(width, height);
	}
	
	public static Shape createSquare(int length) {
		return createRectangle(length, length);
	}
	
	public static Shape createCircle(int radius) {
		return new Circle(radius);
	}
}

public class Rectangle implements Shape {

	private int width;
	private int height;
	
	public Rectangle(int width, int height) {
		this.width = width;
		this.height = height;
	}
}

public class Circle implements Shape {

	private int radius;
	
	public Circle(int radius) {
		this.radius = radius;
	}
	
}

4. Basis of Service Provider Frameworks

Static factory methods do not need the actual implementation of the returned object to exist immediately!
This is clear when using service provider frameworks where actual implementation of a service interface does not need to exist at the compile time.

public interface MyService {
  void doSomething();
}

class MyServiceFactory {
	
  public static MyService getService() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    
		 return (MyService) Class.forName("MyServiceImplemetation").newInstance();

         // MyServiceImplemetation is not written yet! But the code compile
  }
}

public class App {

	public static void main(String[] args) {
		
		MyServiceFactory.getService().doSomething();

        //... 
    }
			
}

class MyServiceImplemetation implements MyService{

	@Override
	public void doSomething() {
		System.out.println("doing something!");
		
	}
	
}

Spring Global Exception Handling Using @ControllerAdvice Annotation

Sat, 27 Feb 2021 21:30:00 +0900

For several reasons, you may want a global solution to handle exceptions thrown by controllers across the whole application. Spring provides a mechanism that enables such functionality using @ControllerAdvice annotation.

Overview

We will build a simple Spring Boot application which includes three classes:

Controller.java : Simple controller responding to GET requests mapped to /ok & /exception.
ControllerAdvisor.java: A class annotated with @ControllerAdvice to handle exceptions.
App.java: Run the application

Dependencies

Spring Boot

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.4.2</version>
</parent>
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>

Complete Maven dependencies is included in pom.xml

Spring MVC Controller

We will build a simple controller which has two services:

First service ok() returns OK
The second service exception() throws an Exception.

Controller.java

@RestController
public class Controller {


	 @RequestMapping("/ok")
	 public @ResponseBody String ok() throws Exception {
	  	return "OK";
	 }

	 @RequestMapping("/exception")
	 public @ResponseBody String exception() throws Exception {
	  	throw new Exception("Error");
	 }
}

If we call /exception, “before implementing @ControllerAdvice” we will see following message

Also, notice that the HTTP status code is 500 Internal Server Error.

@ControllerAdvice

We can handle the previous exception using @ControllerAdvice by defining a new class annotated with this annotation.
Methods of this class can be annotated by @ExceptionHandler which defines a single or a list of exceptions types to be handled.
@ResponseStatus is used to override the response status code to be returned by annotated methods.

@ControllerAdvice
public class ControllerAdvisor {


	@ExceptionHandler(Exception.class)
	@ResponseStatus(HttpStatus.BAD_REQUEST)

	public @ResponseBody String generalException(final Exception exception,
			final HttpServletRequest request) {

		return exception.getMessage()+" while calling: "+request.getRequestURI();

	}
}

Now, when calling the /exception service, @ControllerAdvice class will handle the thrown exception and will set the status code to 400 Bad Request.

Source Code @ GitHub

Java | Simple Jasper Report Example

Sat, 25 Apr 2020 21:00:00 +0900

JasperReports library is an open source reporting library written in Java. The library can export documents in different formats e.g. PDF, HTML, CSV…etc. This post shows a simple example of how to export PDF document using JasperReports.

Environment, Tools & Libraries used in this post

Maven (build tool)
jasperreports 6.10.0
spring core 5.2.3.RELEASE

Overview

In order to generate a report we need to following inputs to be passed to Jasper exporting functions:

Jasper Report Template: Jasper template is an XML .jrxml file that can be created using JasperSoft Studio.
Parameters: This is a Java Map object containing a set of values passed from the application requesting the report. They can be used for runtime configuration or to pass additional custom data that is not part of the data source.
Datasource: JasperReport engines expect an object of type JRDataSource as a data source. There several implementations of JRDataSource that allow to fetch data from different data source types such as databases, XML file, CSV file or Java beans.

In this post will export a PDF file using a List of Java bean Country as a data source. The template we are going to use report.jrxml is created using JasperSoft Studio.

Dependencies

pom.xml

<dependencies>
    <dependency>
      <groupId>net.sf.jasperreports</groupId>
      <artifactId>jasperreports</artifactId>
      <version>6.10.0</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.2.3.RELEASE</version>
    </dependency>

  </dependencies>

Java Bean `Country.java`

We have one simple Java class Country that holds country’s code, name and URL to an image of the contry’s flag.

public class Country {

    private String code;
    private String name;
    private String url;

    public Country(String code, String name, String url) {
        this.code = code;
        this.name = name;
        this.url = url;
    }
    ...
}

Java `App.java`

The App.java class contains the main() method.
The main() method call 3 custom methods
1. getJasperReport() read & compiles .jrxml file.
2. getParameters() returns the set of parameters.
3. getDataSource() builds the data source .

package com.hmkcode;

import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import org.springframework.util.ResourceUtils;

import java.io.*;
import java.util.*;

public class App 
{
    // name and destination of output file e.g. "report.pdf"
    private static String destFileName = "report.pdf";

    public static void main( String[] args ) throws FileNotFoundException, JRException {

        System.out.println( "generating jasper report..." );

        // 1. compile template ".jrxml" file
        JasperReport jasperReport = getJasperReport();

        // 2. parameters "empty"
        Map<String, Object> parameters = getParameters();

        // 3. datasource "java object"
        JRDataSource dataSource = getDataSource();

        JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, 
                parameters, 
                dataSource);
        JasperExportManager.exportReportToPdfFile(jasperPrint, destFileName);

    }

    private static JasperReport getJasperReport() throws FileNotFoundException, JRException {
        File template = ResourceUtils.getFile("classpath:report.jrxml");
        return JasperCompileManager.compileReport(template.getAbsolutePath());
    }
    private static Map<String, Object> getParameters(){
        Map<String, Object> parameters = new HashMap<>();
        parameters.put("createdBy", "hmkcode");
        return parameters;
    }

    private static JRDataSource getDataSource(){

        List<Country> countries = new LinkedList<>();

        countries.add(new Country("IS", "Iceland", 
            "https://i.pinimg.com/originals/72/b4/49/72b44927f220151547493e528a332173.png"));

        // 9 other countries in GITHUB

        return new JRBeanCollectionDataSource(countries);
    }
}

Source Code @ GitHub

Android | Sending & Receiving Simple Data Between Apps

Fri, 20 Dec 2019 21:00:00 +0900

Intent is a messaging object that can be used to start app components such activity within an app or to interact with other apps. Explicit intent is used to launch a specific app component while implicit intent specifies an action that can invoke other apps able to perform the action. Here we will see how to use intent to send and receive simple data between apps.

( 1 ) Sending Text to Other Apps

Using Intents and associated extras we can send data to other apps.
Intent specifies the action to be performed.
ACTION_SEND is used to send data from one activity to another.
Data type should be specified in the intent.
Android system identifies activities that can receive the data.

 fun send(){
    val sendIntent: Intent = Intent().apply {
        action = Intent.ACTION_SEND
        putExtra(Intent.EXTRA_TEXT, "Some text...")
        type = "text/plain"
    }

    val shareIntent = Intent.createChooser(sendIntent, null)
    startActivity(shareIntent)
}

( 2 ) Receiving Text from Other Apps

Your app can also receive data from other apps.
Intent filters inform the system what intents an application component is willing to accept.
Intent filter is defined in app manifest, using the <intent-filter> element.

<intent-filter>
    <action android:name="android.intent.action.SEND" />
    <category android:name="android.intent.category.DEFAULT" />
    <data android:mimeType="text/plain" />
</intent-filter>

To read the content of the received intent in onCreate()

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

    val editText = findViewById<EditText>(R.id.editText)


    if(intent?.action == Intent.ACTION_SEND)
        editText.setText(intent.getStringExtra(Intent.EXTRA_TEXT))
}

Source Code @ GitHub

Kotlin | Function Type, Lambda and Higher-Order Functions

Sun, 15 Dec 2019 21:00:00 +0900

Functions in Kotlin can be stored in variables, passed as arguments to other functions and returned from other functions. However, since Kotlin is statically typed language, functions should have a type. In this post we will see how to declare the type of a function, how to use lambda to define a function and how to define a higher order function.

Function Type

We know that a variable can have an explicit declared type or an implicit inferred type.
The declared or inferred type is the type of the assigned or returned value.

val a:Int = 1 // explicit "Int" type
val b = "ABC"   // inferred "Int" type
val c = SomeClass() // inferred "SomeClass" type

fun sum(a:Int, b:Int) = a + b // inferred return type "Int"

Most often, the declared or inferred type is a class type.
However, the declared or inferred type can also be a function type because in Kotlin, functions have types too!
Unlike class type, function type is defined by its signature i.e. parameters and return type.
Special notation is used to define the type of a function based on its parameters and return types.
A function type is defined by listing the types of the input parameters between parentheses followed by an arrow -> and ended by the return type.
For example, (Int, Int) -> Boolean is a function type representing all functions that take two arguments of type Int and return Boolean.
For example, the function below has a function type (Int, Int) -> Boolean.

fun gt(a: Int, b: Int): Boolean = a > b // function type: (Int,Int) -> Boolean

Function type with now parameters can be written as following () -> A where A is a return type.

fun print(){ println("printing...") } // function type:  () -> Unit

Function type can also specify receiver type e.g. Int.(Int) -> Boolean represents a function that is called on an receiver object of type Int , takes one parameter of type Int and returns Boolean

fun Int.gt(b: Int): Boolean = this > b // function type Int.(Int) -> Boolean

Now, the function type can be used to declare variable type, parameter type or return type.

// variable with function type: (Int, Int) -> Boolean
val f: (Int, Int) -> Boolean = ...

// parameter with function type: (Int, Int)-> Int
fun someFunction(a:Int, f: (Int, Int) -> Int) { ... }

// return function of function type: () -> Unit
fun anotherFunction(): () -> Unit { ... }

`typealias`

To improve code readability, function type can be named using typealias keyword.

typealias someType = (Int, Int) -> Boolean

val f: someType = ... 
// this equavalent  val f: (Int, Int) -> Boolean =

Lambda

Lambda is a literal function which means it is not declared but passed as an expression.
Lambda expression is always surrounded by curly braces {...}
Parameters types are optional if they can be inferred.
Lambda’s body goes after the arrow ->.
Similar to regular function, lambda has a function type.

{a:Int, b:Int -> a + b} // lambda of function type: (Int, Int) -> Int

// Equivalent function 
fun sum(a:Int , b:Int) = a + b 

We can assign lambda to a variable of similar function type:

var sum: (Int, Int) -> Int = {a:Int, b:Int -> a + b} 

Which can be written without parameters types.

val sum: (Int, Int) -> Int = {a , b -> a + b} 

println(sum(2,3)) // call sum

Special Case: Lambda with single parameter

Lambda with single parameter is a special case.
The single parameter can be omitted along with the arrow -> and use it as a reference to the single parameter.
Regular way:

var increment: (Int) -> Int = { a -> a + 1 } 

Special case, single parameter is referenced as it

var increment: (Int) -> Int = { it + 1 } 

Where is `return` in lambda?

By default, the last expression of a lambda is implicitly returned.

 val sum: (Int, Int) -> Int = {a , b -> 
        println("a = $a")
        println("b = $b")
        a + b // last expression is returned
    }

Anonymous Functions

Anonymous function is also a literal function which means it is not declared but passed as an expression.
Anonymous function is a regular function without a name.
Similar to regular functions, anonymous functions have function type.

var sum: (Int, Int) -> Int = fun(x: Int, y: Int): Int = x + y

println(sum(2,3)) // call sum

Creating & Calling Instances of a Function Type

Similar to class type, we can create instances of a given function type.
There are serval ways to create an instance of a function type.
For example, to create instances of (Int, Int) -> Int we can use one of the following ways:
Lambda

val sum: (Int, Int) -> Int = {a , b -> a + b} 

Anonymous function

var sum: (Int, Int) -> Int = fun(x: Int, y: Int): Int = x + y

Callable Reference

fun sum(a: Int, b:Int) = a + b // top-level function

val sum: (Int, Int) -> Int = ::sum

class SomeClass{
fun sum(a: Int, b:Int) = a + b // member function
}

val sum: (Int, Int) -> Int = SomeClass()::sum

Implementing function type

class SumFunctionType: (Int, Int) -> Int {
override operator fun invoke(a: Int, b:Int) = a + b
} 

val sum: (Int, Int) -> Int = SumFunctionType()

Calling an instance of a function type

Instances of a function type created using one of the ways above can be invoked using invoke(a, b, ...) function.
Or directly passing the parameter (a, b, ...)
For receiver type, the receiver should be the first argument.

val sum: (Int, Int) -> Int = {a , b -> a + b} 

sum(2,3) // 5
sum.invoke(2,3) // 5

{a:Int, b:Int -> a + b}.invoke(2,3) // 5
{a:Int, b:Int -> a > b}(2,3) // 5

val f: Int.(Int) -> Int = { b -> this + b}
f.invoke(2,3) //5
f(2,3) // 5
2.f(3) //5

| Higher-Order Functions

Higher-order functions can take functions as parameters or return a function.
The type of the parameter accepting the function or the return type is declared using function type.

//  Higher-Order Function
fun higherOrderSum(a:Int, b:Int, f: (Int, Int) -> Int): Int{
    return f(a,b)
}

typealias someType = (Int, Int) -> Int

fun main() { 	
    val lambdaSum: someType = {a , b -> a + b}     
	println(higherOrderSum(2, 3, lambdaSum)) // 5
}

Android | Handling Click Events Kotlin's Way

Tue, 10 Dec 2019 21:00:00 +0900

Listening to a button clicks is a common task in application development. A listener is set to listen and act upon click events. OnClickListener is an interface used to listen to click events of a button or any other components of type View.

View & Click Listener

View is the basic building block for UI components.
Views can register or set listeners that will be notified when an event happens to the view.
Components of type View can set click listener that get notified on click event.
setOnClickListener(OnClickListener l) is used to set the click listener.
Click listener is an instance of type OnClickListener.

View.java

 public void setOnClickListener(OnClickListener l) { .... }

OnClickListener is an interface with a single abstract method “SAM”.

public interface OnClickListener {
        void onClick(View v);
}

So, we need to pass an instance of type OnClickListener to setOnClickListener() function.
We can achieve this in the following ways.

( 1 ) The simplest old way, implement OnClickListener interface

The simplest way to create an instance of type OnClickListener is by implementing it.
Our activity can implement the interface OnClickListener and override onClick().

// 1. extend View.OnClickListener
class MainActivity : AppCompatActivity(), View.OnClickListener {

    private lateinit var textView:TextView

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

        val button = findViewById<Button>(R.id.button)
        textView = findViewById<TextView>(R.id.textView)

        // 2. pass this as instance of OnClickListener
        button.setOnClickListener(this)

    }

    // 3. override onClick()
    override fun onClick(v: View?) {
        textView.setText("Clicked!")
    }
}

( 2 ) Use object expression

Use object expression to create an instance from an anonymous class implementing OnClickListener.

class MainActivity : AppCompatActivity() {

    private lateinit var textView:TextView

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

        val button = findViewById<Button>(R.id.button)
        textView = findViewById<TextView>(R.id.textView)

        // create an instance from anonymous class
        button.setOnClickListener{
            object: View.OnClickListener{
                override fun onClick(v: View?) {
                    textView.setText("Clicked!")
                }

            }
        }

    }
}

( 3 ) Lambda

Since OnClickListener is an interface with a single abstract function, we can use lambda.
The onClick() function takes a parameter of type View and returns void or Unit for Kotlin.
So, the function type of the lambda should be (View) -> Unit

class MainActivity : AppCompatActivity() {

    private lateinit var textView:TextView

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

        val button = findViewById<Button>(R.id.button)
        textView = findViewById<TextView>(R.id.textView)

        // create an instance from anonymous class
       button.setOnClickListener{ v -> textView.setText("Clicked!") }

    }
}

Or, even simpler

button.setOnClickListener{ textView.setText("Clicked!") }

Java | Converting HTML to PDF using iText

Thu, 05 Dec 2019 21:00:00 +0900

Creating a PDF file from HTML can be done using iText Java library. iText has an add-on that enables converting HTML to PDF document. This post shows how to use iText to convert HTML to PDF.

“When using iText PDF in a closed source environment, you will need to purchase an iText PDF commercial license.”

Environment, Tools & Libraries used in this post

Maven (build tool)
iText 7.1.9
pdfHTML iText PDF Add-On 2.1.6

Depenedenceis

We need to add iText core library and pdfHTML add-on to our project dependencies.

pom.xml

<dependencies>
    <!-- iText Core -->
    <dependency>
        <groupId>com.itextpdf</groupId>
        <artifactId>itext7-core</artifactId>
        <version>7.1.9</version>
        <type>pom</type>
    </dependency>

    <!-- iText pdfHTML add-on -->
    <dependency>
	    <groupId>com.itextpdf</groupId>
	    <artifactId>html2pdf</artifactId>
	    <version>2.1.6</version>
	</dependency>
</dependencies>

`HtmlConverter` Class

HtmlConverter class is the main class to convert HTML to PDF.
HtmlConverter class has three main methods with different inputs and return types:
- convertToDocument(): returns Document instance.
- convertToElements(): returns a list of iText IElement instances.
- convertToPdf(): this method converts HTML to PDF.

convertToPdf() Method

We will use convertToPdf() method from HtmlConverter class to convert HTML to PDF.
convertToPdf() has different variations that takes HTML as String, File or InputStream & writes the PDF content to File, OutputStream or existing PdfDocument.
In this post we will use the following variations of the convertToPdf()
- convertToPdf(String html, OutputStream pdfStream)
- convertToPdf(InputStream htmlStream, OutputStream pdfStream)

Converting HTML String to PDF

The simplest example is converting a String of HTML to PDF.

package com.hmkcode;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import com.itextpdf.html2pdf.HtmlConverter;

public class App 
{
	public static final String HTML = "<h1>Hello</h1>"
			+ "<p>This was created using iText</p>"
			+ "<a href='hmkcode.com'>hmkcode.com</a>";
	
	
    public static void main( String[] args ) throws FileNotFoundException, IOException  
    {
    	HtmlConverter.convertToPdf(HTML, new FileOutputStream("string-to-pdf.pdf"));
    	
        System.out.println( "PDF Created!" );
    }
}

Output: The code above will create a PDF file string-to-pdf.pdf

Converting HTML File to PDF

We can convert HTML file to PDF using the same method convertToPdf() that takes HTML as InputStream and write the PDF content into OutputStream.
The HTML file can contain CSS file and images. However, they need to be in the same location of the HTML file. If CSS and images are located in different directories, we need to use ConverterProperties to set the base URL.

index.html

<html>
	<head>
		<title>HTML to PDF</title>
		<link href="style.css" rel="stylesheet" type="text/css" />
	</head>
	<body>
		<h1>HTML to PDF</h1>
		<p>
            <span class="itext">itext</span> 7.1.9 
            <span class="description"> converting HTML to PDF</span>
		</p>
		<table>
		  <tr>
				<th class="label">Title</th>
				<td>iText - Java HTML to PDF</td>
			</tr>
			<tr>
				<th>URL</th>
				<td>http://hmkcode.com/itext-html-to-pdf-using-java</td>
			</tr>
		</table>
	</body>
</html>

package com.hmkcode;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import com.itextpdf.html2pdf.HtmlConverter;

public class App 
{
	
    public static void main( String[] args ) throws FileNotFoundException, IOException  
    {
    	HtmlConverter.convertToPdf(new FileInputStream("index.html"), 
            new FileOutputStream("index-to-pdf.pdf"));

        System.out.println( "PDF Created!" );
    }
}

Output: The code above will create a PDF file string-to-index.pdf

Source Code @ GitHub

Kotlin | Backing Fields

Sat, 30 Nov 2019 21:00:00 +0900

Kotlin auto-generates a field referencing a class property within its accessors "get() or set()". This field is called a backing field and it will be generated if a property uses the default accessors implementation or if one of the accessors references it through field identifier.

Class Properties

val & var variables defined within the body of a class are called calss properties.

class SomeClass{
    val id:Int = 2  // property "id" of type Int
    var name:String = "" // property "name" of type String
}

Class properties are accessible using properties names and dot notation on instances of the class.
Properties declared as val are read-only i.e. have get().
Properties declared as var are mutable i.e. have get() and set().

val someClass:SomeClass = SomeClass() // create an instance of class SomeClass
println(someClass.id) // getting value of id = 2
someClass.name = "SomeName" // setting value of name
println(someClass.name) // SomeName // getting value of name

So, where are those get() and set() defined?

Auto-Generated `get()` & `set()`

Kotlin, implicitly generates accessors function i.e. get() & set() with default implementation for declared properties.
The default implementation of get() returns property value, while default implementation of set(value) assigns the passed value to the property.
get() & set() can be explicitly defined as shown below.

class SomeClass{
    val id:Int = 2  // property "id" of type Int
        get():Int { ... }

    var name:String = "" // property "name" of type String
        get():String { ... }
        set(value):Unit { ... }
}

So, how does get() return the property value?

This will generate `StackOverflowError`!

We may think that, get() returns the value of a property by simply using the property name e.g. get(){ return id }.
Actually, this implementation will generate a StackOverflowError because we are making a recursive call to to the property.

class SomeClass{
    val id:Int = 2  // property "id" of type Int
        get():Int { return id } // recursive call StackOverflowError

    var name:String = "" // property "name" of type String
        get():String { return name } // recursive call StackOverflowError
        set(value):Unit { name = value } // recursive call StackOverflowError
}

So, how do get() & set() refer to a property?

Backing `field`

To avoid recursive call, Kotlin provides a backing field that will help you refer to a property within its get() & set() functions.
field identifier can only be used in the accessors of the property.

class SomeClass{
    val id:Int = 2  // property "id" of type Int
        get():Int = field // default implementation

    var name:String = "" // property "name" of type String
        get():String = field  // default implementation
        set(value):Unit { field = value }  // default implementation
}

Kotlin provides a backing field automatically if it is used in the accessors i.e. if we override the default implementation of the accessors with a custom implementation that does not use backing field kotlin will NOT generate it.

val text:String = "ABCDEF"
val isEmpty: Boolean
get() = text.length == 0 // there will be no backing field

Properties without Backing Fields

Backing fields are not available for properties in the following cases:
1. Properties declared in interfaces.
2. Properties annotated with inline modifier.
3. Extension properties

// 1. interface property
interface SomeInterface{
    var ID:Int 
    	get() = 3 // field is not allowed for inteface property
    	set(value){ } // field is not allowed for inteface property
    	
}

// 2. inline property
class SomeClass{
    inline var id:Int
    	get() = 3 // field is not allowed for inline property
    	set(value){ } // field is not allowed for inline property
}

// 3. extension property
val SomeClass.name:String
	get() = "SomeName" // field is not allowed for extension property

Kotlin | Delegation Design Pattern

Mon, 11 Nov 2019 21:00:00 +0900

Inheritance is a common solution for code reusability. Extending class implementation will allow subclasses to inherit implemented members e.g. functions and properties. Delegation design pattern, however, is an alternative solution to inheritance. Delegation pattern uses object composition to achieve code reusability. Kotlin provides native support for this pattern where a class can delegate implementation to a specified object. In this post we will explain delegation design pattern and see it in action usign Kotlin

Overview

We have an interface Mode which has one function display() and one String property color:String.
We initially have two classes implementing Mode interface namely DarkMode and LightMode.

interface Mode{
    val color:String
    fun display()
}

class DarkMode(override val color:String) : Mode{    
    override fun display(){
        println("Displayig dark mode...")
    }
}
class LightMode(override val color:String) : Mode {
    override fun display() { 
        println("Displayig light mode...") 
    }
}

We wanted to derive a custom mode from each implemented mode. Each custom mode reuse display() function from its parent mode.
We can achieve this goal using one of the following solutions:
- Extending initially implemented modes using inheritance.
- Delegating implementation using delegation pattern.

1 | Extending Modes Using Inheritance

If we want to extend existing dark and light modes, the trivial solution is inheritance.
Inheritance allow subclasses to reuse the implementation from the extended classes DarkMode & LightMode.
So, we will create two new subclasses MyCustomDarkMode & MyCustomLightMode each extending one of the implemented modes.

interface Mode{
    val color:String
    fun display()
}

open class DarkMode(override val color:String) : Mode{    
    override fun display(){
        println("Dark Mode..."+color)
    }
}
open class LightMode(override val color:String) : Mode {
    override fun display() { 
        println("Light Mode..."+color) 
    }
}

class MyCustomDarkMode(override val color:String): DarkMode(color)
class MyCustomLightMode(override val color:String): LightMode(color)

fun main() {
    MyCustomDarkMode("CUSTOM_DARK_BLUE").display()
}

Now, each new custom mode can reuse the implementation of its parent mode.
However, notice that in Kotlin parent modes should be open class in order to be extendable.
Also, a drawback of inheritance is that we need to create a separate custom mode for each parent mode.

2 | Using Delegation Pattern

“Delegation pattern is an object-oriented design pattern that allows object composition to achieve the same code reuse as inheritance.”

Using delegation, we can achieve code reusability using object composition.
We can create one custom mode that reuses display() function of each initial mode.
The custom mode class will implement the interface Mode as well as taking a parameter of type Mode in its constructor.

interface Mode{
    val color:String
    fun display()
}

class DarkMode(override val color:String) : Mode{    
    override fun display(){
        println("Dark Mode..."+color)
    }
}
class LightMode(override val color:String) : Mode {
    override fun display() { 
        println("Light Mode..."+color) 
    }
}

class MyCustomMode(val mode: Mode): Mode{
    override val color:String = mode.color
    override fun display() { 
        mode.display()
    }
}

Now, the custom mode can reuse display() function of both modes DarkMode & LightMode.

fun main() {
    MyCustomMode(DarkMode("CUSTOM_DARK_GRAY")).display()
    MyCustomMode(LightMode("CUSTOM_LIGHT_GRAY")).display()
}

/* output:
Dark Mode...CUSTOM_DARK_GRAY
Light Mode...CUSTOM_LIGHT_GRAY
*/

Kotlin Native Support for Delegation Pattern

Kotlin natively support delegation pattern.
Kotlin provides by keyword to specify the delegate object which our custom mode will be delegating to.
We can achieve the same result of the code above using by keyword.

class MyCustomMode(val mode: Mode): Mode by mode

fun main() {
    MyCustomMode(DarkMode("CUSTOM_DARK_GRAY")).display()
    MyCustomMode(LightMode("CUSTOM_LIGHT_GRAY")).display()
}

/* output:
Dark Mode...CUSTOM_DARK_GRAY
Light Mode...CUSTOM_LIGHT_GRAY
*/

Backpropagation Step by Step

Sun, 03 Nov 2019 21:00:00 +0900

If you are building your own neural network, you will definitely need to understand how to train it. Backpropagation is a commonly used technique for training neural network. There are many resources explaining the technique, but this post will explain backpropagation with concrete example in a very detailed colorful steps.

You can see visualization of the forward pass and backpropagation here. You can build your neural network using netflow.js

Overview

In this post, we will build a neural network with three layers:

Input layer with two inputs neurons
One hidden layer with two neurons
Output layer with a single neuron

Weights, weights, weights

Neural network training is about finding weights that minimize prediction error. We usually start our training with a set of randomly generated weights.Then, backpropagation is used to update the weights in an attempt to correctly map arbitrary inputs to outputs.

Our initial weights will be as following: w1 = 0.11, w2 = 0.21, w3 = 0.12, w4 = 0.08, w5 = 0.14 and w6 = 0.15

Dataset

Our dataset has one sample with two inputs and one output.

Our single sample is as following inputs=[2, 3] and output=[1].

Forward Pass

We will use given weights and inputs to predict the output. Inputs are multiplied by weights; the results are then passed forward to next layer.

Calculating Error

Now, it’s time to find out how our network performed by calculating the difference between the actual output and predicted one. It’s clear that our network output, or prediction, is not even close to actual output. We can calculate the difference or the error as following.

Reducing Error

Our main goal of the training is to reduce the error or the difference between prediction and actual output. Since actual output is constant, “not changing”, the only way to reduce the error is to change prediction value. The question now is, how to change prediction value?

By decomposing prediction into its basic elements we can find that weights are the variable elements affecting prediction value. In other words, in order to change prediction value, we need to change weights values.

The question now is how to change\update the weights value so that the error is reduced?
The answer is Backpropagation!

Backpropagation

Backpropagation, short for “backward propagation of errors”, is a mechanism used to update the weights using gradient descent. It calculates the gradient of the error function with respect to the neural network’s weights. The calculation proceeds backwards through the network.

Gradient descent is an iterative optimization algorithm for finding the minimum of a function; in our case we want to minimize th error function. To find a local minimum of a function using gradient descent, one takes steps proportional to the negative of the gradient of the function at the current point.

For example, to update w6, we take the current w6 and subtract the partial derivative of error function with respect to w6. Optionally, we multiply the derivative of the error function by a selected number to make sure that the new updated weight is minimizing the error function; this number is called learning rate.

The derivation of the error function is evaluated by applying the chain rule as following

So to update w6 we can apply the following formula

Similarly, we can derive the update formula for w5 and any other weights existing between the output and the hidden layer.

However, when moving backward to update w1, w2, w3 and w4 existing between input and hidden layer, the partial derivative for the error function with respect to w1, for example, will be as following.

We can find the update formula for the remaining weights w2, w3 and w4 in the same way.

In summary, the update formulas for all weights will be as following:

We can rewrite the update formulas in matrices as following

Backward Pass

Using derived formulas we can find the new weights.

Learning rate: is a hyperparameter which means that we need to manually guess its value.

Now, using the new weights we will repeat the forward passed

We can notice that the prediction 0.26 is a little bit closer to actual output than the previously predicted one 0.191. We can repeat the same process of backward and forward pass until error is close or equal to zero.

Backpropagation Visualization

You can see visualization of the forward pass and backpropagation here.

You can build your neural network using netflow.js

Android | Monitor Network Connectivity Using ConnectivityManager.NetworkCallback

Mon, 07 Oct 2019 21:00:00 +0900

ConnectivityManager class can be used to answer queries about network connectivity status. It can also notifiy applications when network connectivity status changes using ConnectivityManager.NetworkCallback.

Environment & Tools

Tools used in this post

Android Studio 3.5
Google Pixel 3
Kotlin 1.3.50

ConnectivityManager

ConnectivityManager class is the starting point to query about networ connectivity status. It can also notifiy applications when network connectivity changes.

An instance of ConnectivityManager class can give us access to an instance of NetworkInfo class which can be used to check current active network.

NetworkInfo is deprecated in API 29

NetworkInfo class holds details about the current active default network. Using NetworkInfo.isConnected() we can check the network connectivity status before initiating network traffic. However, NetworkInfo was deprecated in API level 29.

Developers should instead use ConnectivityManager.NetworkCallback API to monitor connectivity changes.

ConnectivityManager.NetworkCallback

Checking network connectivity and getting notifications about network changes can be achieved by registering ConnectivityManager.NetworkCallback. Interested applications should extend this class and override the wanted methods such as .onAvailable(Network) & .onLost(Network).

val cm:ConnectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val builder: NetworkRequest.Builder = NetworkRequest.Builder()

 cm.registerNetworkCallback(
            builder.build(),
            object : ConnectivityManager.NetworkCallback() {

                override fun onAvailable(network: Network) {                   
                        Log.i("MainActivity", "onAvailable!")

                        // check if NetworkCapabilities has TRANSPORT_WIFI
                        val isWifi:Boolean = cm.getNetworkCapabilities(network).hasTransport(
                            NetworkCapabilities.TRANSPORT_WIFI)

                        // doSomething()                
                }

                override fun onLost(network: Network) {
                    
                        Log.i("MainActivity", "onLost!")
                        
                        // doSomething                  
                }
            }
        )

Source Code @ GitHub

Android | Send JSON Content to the Cloud Using HttpUrlConnection & Kotlin Coroutine

Sat, 05 Oct 2019 21:00:00 +0900

Sending data to the cloud is a common task in mobile applications. Here we will consume an open REST service to practice sending data in JSON format to a cloud server. We will use HttpURLConnection to make an HTTP POST request to the server. Then, we can verify that our request is successful by going to hmkcode-api.appspot.com/links.html page.

Objectives

How to send HTTP POST request to the cloud with JSON content.
How to check network connection?
How to use kotlin coroutine to perform network operations on a separate thread?

Environment, Tools & Library

used in this post

Android Studio 3.5.1
HttpURLConnection client.
REST service http://hmkcode-api.appspot.com/rest/link/add to post data.
https://hmkcode-api.appspot.com/links.html to view our stored data.

About the app

We are going to build a sample app that stores links info in the cloud. The app takes three inputs from the user link title, url and optional tags. When the user click send, the app will build a JSON object holding the three inputs, add the built JSON object to the POST request body and finally execute the POST request.

( 1 ) Create new Android Project

Create new android application keep default options.

Application Name: post-json
Package Name: com.hmkcode
Language: Kotlin
Minimum SDK: API 19: Android 4.4 (KitKat)

( 2 ) Add Permissions

Add the following two lines to the AndroidMainifest.xml file

   <uses-permission android:name="android.permission.INTERNET" />
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

( 3 ) Design App Layout

Add the following views to activity_main.xml.
TextView for displaying network connection info.
Three EditText for title, URL & tags account.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout ...>
    <TextView
        android:id="@+id/tvIsConnected"
        ... />

    <com.google.android.material.textfield.TextInputLayout
        ...>
        <com.google.android.material.textfield.TextInputEditText
            android:id="@+id/etTitle"
            ...
            android:hint="Title..."/>
    </com.google.android.material.textfield.TextInputLayout>

    <com.google.android.material.textfield.TextInputLayout
       ...>
        <com.google.android.material.textfield.TextInputEditText
            android:id="@+id/etUrl"
            ...
            android:hint="example.com"/>
    </com.google.android.material.textfield.TextInputLayout>

    <com.google.android.material.textfield.TextInputLayout
        ...>
        <com.google.android.material.textfield.TextInputEditText
            android:id="@+id/etTags"
            ...
            android:hint="tag1;tag2;..."/>
    </com.google.android.material.textfield.TextInputLayout>

    <Button
        android:id="@+id/btnSend"
        android:text="Send"
        ...
        android:onClick="send"/>

    <TextView
        android:id="@+id/tvResult"
       .../>
</LinearLayout>

Dependencies

You need to include the following dependencies to build.gradle

build.gradle (Module: post-json)

dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'com.google.android.material:material:1.1.0-beta01'
    implementation 'androidx.core:core-ktx:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    // Coroutine
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2"
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha05"
}

( 4 ) Send JSON to Server

MainActivity.kt is the only class where we need to code the following:

a. Check network connectivity.
b. Build httpPost() function with IO dispatcher.
c. Build send() function to launch httpPost() in lifecycleScope coroutine scope.

a. Check network connectivity

Before making network operation check notwork connectivity status.
To check network connectivity use getActiveNetworkInfo() & isConnected().

private fun checkNetworkConnection(): Boolean {
    val connMgr = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    val networkInfo = connMgr.activeNetworkInfo
    val isConnected: Boolean = if(networkInfo != null) networkInfo.isConnected() else false
    if (networkInfo != null && isConnected) {
        // show "Connected" & type of network "WIFI or MOBILE"
        tvIsConnected.text = "Connected " + networkInfo.typeName
        // change background color to red
        tvIsConnected.setBackgroundColor(-0x8333da)
    } else {
        // show "Not Connected"
        tvIsConnected.text = "Not Connected"
        // change background color to green
        tvIsConnected.setBackgroundColor(-0x10000)
    }
    return isConnected
}

b. Build `httpPost()` function with IO dispatcher.

Create httpPost(String url) method
httpPost() method does the following:
1. Use withContext(Dispatcher.IO){} to run code on IO thread.
2. Creates HttpURLConnection
3. Builds JSONObject
4. Adds JSON content to POST request body
5. executes the POST request
6. returns response message

Throws(IOException::class, JSONException::class)
    private suspend fun httpPost(myUrl: String): String {

        val result = withContext(Dispatchers.IO) {
            val url = URL(myUrl)
            // 1. create HttpURLConnection
            val conn = url.openConnection() as HttpsURLConnection
            conn.requestMethod = "POST"
            conn.setRequestProperty("Content-Type", "application/json; charset=utf-8")

            // 2. build JSON object
            val jsonObject = buidJsonObject()

            // 3. add JSON content to POST request body
            setPostRequestContent(conn, jsonObject)

            // 4. make POST request to the given URL
            conn.connect()

            // 5. return response message
            conn.responseMessage + ""
        }
        return result
    }

}
	

c. Build `send()` function to launch `httpPost()` in `lifecycleScope` coroutine scope.

Launch coroutine using activity lifecycleScope.
Show the result on the tvResult

 public fun send(view:View) {
        Toast.makeText(this, "Clicked", Toast.LENGTH_SHORT).show()
        // clear text result
        tvResult.setText("")

        if (checkNetworkConnection())
            lifecycleScope.launch {
                val result = httpPost("https://hmkcode-api.appspot.com/rest/link/add")
                tvResult.setText(result)
            }
        else
            Toast.makeText(this, "Not Connected!", Toast.LENGTH_SHORT).show()

    }

MainActivity.java complete code

package com.hmkcode
import android.content.Context
import android.net.ConnectivityManager
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.view.View
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.json.JSONException
import org.json.JSONObject
import java.io.BufferedWriter
import java.io.IOException
import java.io.OutputStreamWriter
import java.net.HttpURLConnection
import java.net.URL
import javax.net.ssl.HttpsURLConnection

class MainActivity : AppCompatActivity() {

    lateinit var tvIsConnected: TextView
    lateinit var etTitle: EditText
    lateinit var etUrl: EditText
    lateinit var etTags: EditText
    lateinit var tvResult: TextView

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

        tvIsConnected = findViewById<TextView>(R.id.tvIsConnected)
        etTitle = findViewById<EditText>(R.id.etTitle)
        etUrl = findViewById<EditText>(R.id.etUrl)
        etTags = findViewById<EditText>(R.id.etTags)
        tvResult = findViewById<TextView>(R.id.tvResult)
        checkNetworkConnection()
    }

    public fun send(view:View) {
        Toast.makeText(this, "Clicked", Toast.LENGTH_SHORT).show()
        // clear text result
        tvResult.setText("")

        if (checkNetworkConnection())
            lifecycleScope.launch {
                val result = httpPost("https://hmkcode-api.appspot.com/rest/link/add")
                tvResult.setText(result)
            }
        else
            Toast.makeText(this, "Not Connected!", Toast.LENGTH_SHORT).show()

    }

    @Throws(IOException::class, JSONException::class)
    private suspend fun httpPost(myUrl: String): String {

        val result = withContext(Dispatchers.IO) {
            val url = URL(myUrl)
            // 1. create HttpURLConnection
            val conn = url.openConnection() as HttpsURLConnection
            conn.requestMethod = "POST"
            conn.setRequestProperty("Content-Type", "application/json; charset=utf-8")

            // 2. build JSON object
            val jsonObject = buidJsonObject()

            // 3. add JSON content to POST request body
            setPostRequestContent(conn, jsonObject)

            // 4. make POST request to the given URL
            conn.connect()

            // 5. return response message
            conn.responseMessage + ""
        }
        return result
    }

    private fun checkNetworkConnection(): Boolean {
        val connMgr = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

        val networkInfo = connMgr.activeNetworkInfo
        val isConnected: Boolean = if(networkInfo != null) networkInfo.isConnected() else false
        if (networkInfo != null && isConnected) {
            // show "Connected" & type of network "WIFI or MOBILE"
            tvIsConnected.text = "Connected " + networkInfo.typeName
            // change background color to red
            tvIsConnected.setBackgroundColor(-0x8333da)
        } else {
            // show "Not Connected"
            tvIsConnected.text = "Not Connected"
            // change background color to green
            tvIsConnected.setBackgroundColor(-0x10000)
        }
        return isConnected
    }

    @Throws(JSONException::class)
    private fun buidJsonObject(): JSONObject {

        val jsonObject = JSONObject()
        jsonObject.accumulate("title", etTitle.getText().toString())
        jsonObject.accumulate("url", etUrl.getText().toString())
        jsonObject.accumulate("tags", etTags.getText().toString())

        return jsonObject
    }

    @Throws(IOException::class)
    private fun setPostRequestContent(conn: HttpURLConnection, jsonObject: JSONObject) {

        val os = conn.outputStream
        val writer = BufferedWriter(OutputStreamWriter(os, "UTF-8"))
        writer.write(jsonObject.toString())
        Log.i(MainActivity::class.java.toString(), jsonObject.toString())
        writer.flush()
        writer.close()
        os.close()
    }
}

(5) Run & Check

Run the app
Enter title, URL & tags.
Click Send
Visit http://hmkcode-api.appspot.com/link.html to check

Source Code @ GitHub

Android | Using Kotlin Coroutine to Perform HTTP Request using HttpUrlConnection

Thu, 03 Oct 2019 21:00:00 +0900

Long-running task such as CPU intensive work, writing a file to disk or network request should NOT run on the main thread. Android, for example, will throw a NetworkOnMainThreadException if you try to perform an HTTP reqeust on the main thread. To resolve this issue, we can use Kotlin coroutine to perform long-running task on a separate thread. This post shows how to perform a non-blocking HTTP reqest using HttpUrlConnection and Kotlin coroutine.

Objectives

What is coroutine?
Why using coroutine?
How to use coroutine to perform network reqeust?

Environment & Tools

Tools used in this post

Android Studio 3.5
Google Pixel 3
Kotlin 1.3.50
http://hmkcode-api.appspot.com/rest/api/hello/[NAME] this URL will return simple string “Hello, [NAME]”

What is Coroutine?

Coroutine is a feature of Kotlin that enables you to write asynchronous sequential code to manage long-running task in background threads.

For example, coroutine will allow you to write sequential code to make an HTTP request.

Why Using Coroutine?

Long-running tasks such as CPU intensive work, network requests, and disk IO should not run on main thread. Running such tasks on main thread may block UI interactions. However, running network request on the main thread is prevented by Android SDK. Android will throw an exception if we try to make an HTTP request on the main thread.

How to use coroutine to perform network reqeust?

In a previous post Connecting to the Network Using HttpUrlConnection, I explained how to perform HTTP GET reqeust using HttpUrlConnection and AsyncTask on an Android app. Here we will replace AsyncTask with coroutine to perform the same task.

HTTP GET Request

The simplest example for network operation is HTTP GET request.
We create a new URL object by passing url string to the constructor.
The URL object is used to establish an HttpURLConnection.
Then, we execute the operation and receive the response as InputStream.
Finally, we use helper method to convert InputStream to string.

private fun httpGet(myURL: String?): String {

    val inputStream:InputStream
    val result:String

    // create URL
    val url:URL = URL(myURL)

    // create HttpURLConnection
    val conn:HttpURLConnection = url.openConnection() as HttpURLConnection

    // make GET request to the given URL
    conn.connect()

    // receive response as inputStream
    inputStream = conn.inputStream

    // convert inputstream to string
    if(inputStream != null)
        result = convertInputStreamToString(inputStream)
    else
        result = "Did not work!"
    
    return result
}

Perform Network Operations on a Separate Thread Using AsyncTask

Network operation should always run on a seperate thread to avoid UI freeze.
The AsyncTask class provides one of the simplest ways to create separate thread from the UI thread.
Create an inner class extending AsyncTask.
Override doInBackground() & onPostExecute.

inner class HTTPAsyncTask : AsyncTask<String, Void, String>() {
    override fun doInBackground(vararg urls: String?): String {
        return HttpGet(urls[0])
    }
    override fun onPostExecute(result: String?) {
        tvResult.setText(result)
    }
}

Now, we can execute the HTTP request as following

HTTPAsyncTask().execute("http://hmkcode-api.appspot.com/rest/api/hello/Android")

Perform Network Operations on a Separate Thread Using Coroutine

Meet `suspend`

suspend is a reserved keyword in Kotlin that makes a function available to coroutines. Function marked with suspend suspends execution until the result is returned. While waiting for the result, it unblocks the thread that it’s running on so other functions or coroutines can run.

private suspend fun httpGet(myURL: String?): String? {...}

The suspend keyword doesn’t specify the thread code runs on. Suspend functions may run on a background thread or the main thread.

Dispatcher

Dispatcher controls which thread runs a coroutine.
There are three dispatcher Default, IO & Main

We will run our suspend function on IO thread using withContext(Dispatchers.IO)

private suspend fun httpGet(myURL: String?): String? {

        val result = withContext(Dispatchers.IO) {
           
           // HTTP GET request code... 

        }
        return result
    }

Coroutine Scope

Coroutines run inside a CoroutineScope
A scope controls the lifetime of coroutines.
We can use GlobalScope to launch our coroutine.

GlobalScope is a good default for launching work in background, however it is not recommend using GlobalScope.

We will launch the coroutine using GlobalScope

GlobalScope.launch(Dispatchers.Main) {
                val result = httpGet("http://hmkcode-api.appspot.com/rest/api/hello/Android")
                tvResult.setText(result)
            }

We can replace GlobalScope with LifecycleScope.
LifecycleScope is one of the three built-in coroutine scopes in the architecture components contained in the KTX extensions.

Add the dependency below to use this scope.

 implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha05"

Now, you can use ‘lifecycleScope’ to launch the coroutine

 lifecycleScope.launch {
                val result = httpGet("http://hmkcode-api.appspot.com/rest/api/hello/Android")
                tvResult.setText(result)
            }

Source Code @ GitHub

Android | Connecting to the Network Using HttpUrlConnection

Fri, 27 Sep 2019 21:00:00 +0900

One common task for most Android apps is connecting to the Internet. Most network-connected Android apps use HTTP to send and receive data. This article shows you how to write a simple application that connects to the Internet, send HTTP GET request & display the response.

Objectives

How to send HTTP GET request to a web server and display the response?
How to check network connection?
How to use AsyncTask to perform network operations on a separate thread?

Environment & Tools

Tools used in this post

Android Studio 3.5
Google Pixel 3
Kotlin
http://hmkcode-api.appspot.com/rest/api/hello/[NAME] this URL will return simple string “Hello, [NAME]”

About this Sample App

We will build an app that send HTTP GET request and display the response.

( 1 ) Create new Android Project

Project Name: android-http
Package Name: com.hmkcode.http
Minimum SDK: API 19: Android 4.4 (KitKat)

( 2 ) Add Permissions

Add the following two lines to the AndroidMainifest.xml file

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Starting with Android 9 (API level 28), cleartext support is disabled by default.

cleartext traffic

<application
        ...
        android:usesCleartextTraffic="true"
        ...
</application>

( 2 ) Design App Layout

Add two TextView to activity_main.xml .
First TextView for displaying network connection info.
Second TextView to display message from server.

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

    <TextView
        android:id="@+id/tvIsConnected"
        .../>

    <TextView
        android:id="@+id/tvResult"
        .../>
</LinearLayout>

( 3 ) Check the Network Connection

Before making any network operation you need to check if you are connected or not.
To check whether a network connection is available use getActiveNetworkInfo() and isConnected().

private fun checkNetworkConnection(): Boolean {
    val cm:ConnectivityManager =
        getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    val networkInfo:NetworkInfo? = cm.activeNetworkInfo
    val isConnected: Boolean = if(networkInfo != null) networkInfo.isConnected() else false

    if(isConnected){
        tvIsConnected.setText("Connected "+networkInfo?.typeName)
        tvIsConnected.setBackgroundColor(0xFF7CCC26.toInt())

    }else{
        tvIsConnected.setText("Not Connected!")
        tvIsConnected.setBackgroundColor(0xFFFF0000.toInt())
    }
    return isConnected;
}

( 4 ) Perform HTTP GET Request

The simplest example for network operation is HTTP GET request.
We create a new URL object by passing url string to the constructor.
The URL object is used to establish an HttpURLConnection.
Then, we execute the operation and receive the response as InputStream.
Finally, we use helper method to convert InputStream to string.

private fun HttpGet(myURL: String?): String {

    val inputStream:InputStream
    val result:String

    // create URL
    val url:URL = URL(myURL)

    // create HttpURLConnection
    val conn:HttpURLConnection = url.openConnection() as HttpURLConnection

    // make GET request to the given URL
    conn.connect()

    // receive response as inputStream
    inputStream = conn.inputStream

    // convert inputstream to string
    if(inputStream != null)
        result = convertInputStreamToString(inputStream)
    else
        result = "Did not work!"
    
    return result
}

( 5 ) Perform Network Operations on a Separate Thread

Network operation should always run on a seperate thread to avoid UI freeze.
The AsyncTask class provides one of the simplest ways to create separate thread from the UI thread.
Create an inner class extending AsyncTask.
Override doInBackground() & onPostExecute.

inner class HTTPAsyncTask : AsyncTask<String, Void, String>() {
    override fun doInBackground(vararg urls: String?): String {
        return HttpGet(urls[0])
    }
    override fun onPostExecute(result: String?) {
        tvResult.setText(result)
    }
}

( 6 ) Convert the InputStream to a String

We will use a helper method to convert InputStream byte into String

private fun convertInputStreamToString(inputStream: InputStream): String {
    val bufferedReader:BufferedReader? = BufferedReader(InputStreamReader(inputStream))
    var line:String? = bufferedReader?.readLine()
    var result:String = ""

    while (line != null) {
        result += line
        line = bufferedReader?.readLine()
    }

    inputStream.close()
    return result
}

Source Code @ GitHub

Android | RecyclerView Using Support Library ListAdapter

Thu, 06 Sep 2018 21:30:00 +0900

ListAdapter for RecyclerView has been introduced in Revision 27.1.0 Release of Support Library. ListAdapter uses DiffUtil under the hood to compute list diffs on a background thread. This will help RecyclerView animate changes automatically with less work on the UI thread.

Environment, Tools & Library

Android Studio 3.1.4
Android Support Library com.android.support:recyclerview-v7:28.0.0
Java 1.8+ for Lambda experssions support

Overview

We will build an app that displays a list of hard-coded instances of class Link in a RecyclerView. We will use ListAdapterinstead of the usual RecyclerView.Adapter as shown in a previous post Create a List with RecyclerView. To display items on RecyclerView you need to the following:

RecyclerView widget added to the activity layout.
A class extending DiffUtil.ItemCallback
A class extending ListAdapter.
A class extending RecyclerView.ViewHolder.
Layout for RecyclerView items.

Files we need for this app are shown in the image below.

( 1 ) Create new Android Project

Create new android application keep default options. This app is targeting API 19 or later

( 2 ) Add the Support Library

Add the v7 Support Library to gradle build file

build.gradle

dependencies {
    implementation 'com.android.support:recyclerview-v7:28.0.0'
}

( 3 ) Add RecyclerView to Layout

Add RecyclerView to the activity layout.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/forcast_list"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

( 4 ) Extend DiffUtil.ItemCallback

DiffUtil is a utility class that can calculate the difference between two lists and output a list of update operations that converts the first list into the second one. DiffUtil.Callback is a Callback class used by DiffUtil while calculating the diff between two lists. DiffUtil.Callback serves two roles - list indexing, and item diffing. ItemCallback handles just the second of these, which allows separation of code that indexes into an array or List from the presentation-layer and content specific diffing code.

We need an instance of DiffUtil.ItemCallback to be passed into ListAdapter constructor.

ListAdapter(ItemCallback diffCallback)

LinkDiffCallback.java

package com.hmkcode.utils;

import android.support.v7.util.DiffUtil;
import com.hmkcode.models.Link;

public class LinkDiffCallback extends DiffUtil.ItemCallback<Link> {
    @Override
    public boolean areItemsTheSame(Link oldItem, Link newItem) {
        return oldItem.getUrl().equals(newItem.getUrl());
    }

    @Override
    public boolean areContentsTheSame(Link oldItem, Link newItem) {
        return oldItem.getUrl().equals(newItem.getUrl());
    }
}

( 5 ) Functional Interface

This interface is not needed for the implementation of the RecyclerView. It just serves as a bridge in passing click event from ListAdapter to MainActivity to update the list of links List<Link> links;.

It is annotated with @FunctionalInterface to take advantage of lambda expression.

package com.hmkcode.listeners;

import com.hmkcode.models.Link;

@FunctionalInterface
public interface MyItemClickListener {
    public void onClick(Link link);
}

( 6 ) Extending ListAdapter & RecyclerView.ViewHolder

MyListAdapter calss extends ListAdapter<Link, MyListAdapter.MyViewHolder>
Define constructor MyListAdapter(ItemCallback, MyItemClickListener)
Override onCreateViewHolder() to inflate layout item_layout & return object of type MyViewHolder.
Override onBindViewHolder() to bind returned MyViewHolder with item i.e. Link returned by getItem(position) .
Define inner class MyViewHolder that extends RecyclerView.ViewHolder

package com.hmkcode.adapters;

import android.support.annotation.NonNull;
import android.support.v7.recyclerview.extensions.ListAdapter;
import android.support.v7.util.DiffUtil;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.hmkcode.R;
import com.hmkcode.listeners.MyItemClickListener;
import com.hmkcode.models.Link;

public class MyListAdapter extends ListAdapter<Link, MyListAdapter.MyViewHolder> {

    MyItemClickListener myItemClickListener;
    public MyListAdapter(@NonNull DiffUtil.ItemCallback diffCallback,
                         MyItemClickListener myItemClickListener) {
        super(diffCallback);
        this.myItemClickListener = myItemClickListener;
    }

    @NonNull
    @Override
    public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View itemLayoutView = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_layout, null);

        return new MyViewHolder(itemLayoutView);
    }

    @Override
    public void onBindViewHolder(@NonNull MyViewHolder myViewHolder, int position) {
        myViewHolder.bind(getItem(position));
    }
    
    // inner class
    public class MyViewHolder extends RecyclerView.ViewHolder {

        private View itemLayoutView;
        private TextView itemTitle;
        private TextView itemUrl;
        private ImageView itemIcon;

        public MyViewHolder(View itemLayoutView) {
            super(itemLayoutView);
            this.itemLayoutView = itemLayoutView;
            this.itemTitle = itemLayoutView.findViewById(R.id.item_title);
            this.itemUrl = itemLayoutView.findViewById(R.id.item_url);
            this.itemIcon = itemLayoutView.findViewById(R.id.item_icon);
        }
        public void bind(Link link){
            this.itemIcon.setImageResource(link.getIcon());
            this.itemTitle.setText(link.getTitle());
            this.itemUrl.setText(link.getUrl());

            this.itemLayoutView.setOnClickListener(
                    v -> myItemClickListener.onClick(link));

        }

    }
}

( 7 ) MainActivity

Obtain a handle to the RecycleView object
Set layout manager using setLayoutManager()

You can use a standard layout managers (such as LinearLayoutManager or GridLayoutManager), or implement your own.

Create an adapter of type MyListAdapter

listAdapter = new MyListAdapter(new LinkDiffCallback(), link -> updateList(link));

First argument is instance of LinkDiffCallback Second argument is lambda expression which is a cooler way of passing argument of type MyItemClickListener. You can use anonymous class to accomplish the same result.

Attach an adapter for the data to be displayed setAdapter(listAdapter).
Call listAdapter.submitList(getListData());

MainActivity.java

package com.hmkcode.activities;

import ...

public class MainActivity extends AppCompatActivity {

    private RecyclerView recyclerView;
    private List<Link> links;
    private ListAdapter listAdapter;

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

        // layout manager
        RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(this);
        recyclerView.setLayoutManager(layoutManager);

        recyclerView.setClickable(true);

        // list adapter
        links = getListData();

        listAdapter = new MyListAdapter(new LinkDiffCallback(),
                link -> updateList(link));

        recyclerView.setAdapter(listAdapter);

        listAdapter.submitList(getListData());

    }

    private void updateList(Link link){
        boolean removed = links.remove(link);
        listAdapter.submitList(new LinkedList(links));
    }

    //generate a list of Link
    private List<Link> getListData(){...}
}

Source Code @ GitHub

Android | Creating Swipe Views with Tabs

Wed, 05 Sep 2018 21:00:00 +0900

You can navigate between sibling screens using horizontal finger gesture. This post shows you how to build swipe views and how to add tabs to action bar offering users a familiar interfaces.

Objectives

Building an app with horizontal navigation between sibling screens “fragments”.
Adding tabs to action bar for navigating between and identifying sibling screens in your app.

Environment, Tools & Library

Android Studio 3.1.4
Design Support Library com.android.support:design:27.1.1

( 1 ) Create new Android Project

Create new android application keep default options. This app is targeting API 19 or later

( 2 ) Build Swipe Views

To create swipe views use ViewPager widget.
Extends FragmentPagerAdapter to hold child views .
Create two fragments to be used as child views.

2.1 Add a element to your XML layout

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <android.support.v4.view.ViewPager
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/viewPager"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</android.support.constraint.ConstraintLayout>

2.2 Create two fragments

Create two fragment FirstFragment.java & SecondFragment.java

FirstFragment.java

package com.hmkcode.fragments;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.hmkcode.R;

public class FirstFragment extends Fragment {
    
    public FirstFragment() {}

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    public View onCreateView(LayoutInflater inflater,
                             ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_first, container, false);
    }
}

SecondFragment.java

package com.hmkcode.fragments;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.hmkcode.R;

public class SecondFragment extends Fragment {

    public SecondFragment() {}

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    public View onCreateView(LayoutInflater inflater,
                             ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_second, container, false);
    }
}

fragment_first.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="First Fragment"
        android:gravity="center"/>

</android.support.constraint.ConstraintLayout>

fragment_second.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    
    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Second Fragment"
        android:gravity="center"/>

</android.support.constraint.ConstraintLayout>

2.3 Extends `FragmentPagerAdapter` to hold child views

Adapter is a container for child views which needs to be hooked to ViewPager layout.
There are two types of PagerAdapter 1.FragmentPagerAdapter for fixed small number of pages. 2.FragmentStatePagerAdapter for undetermined number of pages. It destroys fragments as the user navigates to other pages, minimizing memory usage.

MyFragmentPagerAdapter.java

package com.hmkcode.adapters;

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentPagerAdapter;
import com.hmkcode.fragments.FirstFragment;
import com.hmkcode.fragments.SecondFragment;

public class MyFragmentPagerAdapter extends FragmentPagerAdapter {


    public MyFragmentPagerAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        switch (position) {
            case 0:
                return new FirstFragment();
            case 1:
                return new SecondFragment();
            default:
                return null;
        }
    }

    @Override
    public int getCount() {
        return 2;
    }
}

Put it all together!

MainActivity.java

package com.hmkcode;

import android.support.v7.app.AppCompatActivity;
import android.support.v4.view.ViewPager;
import android.os.Bundle;
import com.hmkcode.adapters.MyFragmentPagerAdapter;

public class MainActivity extends AppCompatActivity {

    MyFragmentPagerAdapter myFragmentPagerAdapter;
    ViewPager viewPager;

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

        viewPager = (ViewPager) findViewById(R.id.viewPager);

        setPagerAdapter();
    }

    private void setPagerAdapter(){
        myFragmentPagerAdapter = new MyFragmentPagerAdapter(getSupportFragmentManager());
        viewPager.setAdapter(myFragmentPagerAdapter);
    }

}

( 3 ) Adding Tabs

While you can swipe between screens using horizontal finger gesture, android also offers tabs to switch between screens.

To create swipe views use TabLayout widget.
Attached pager adapter to tablayout using setupWithViewPager() method.

gradel.build (app)

implementation ‘com.android.support:design:27.1.1’

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <android.support.v4.view.ViewPager
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/viewPager"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <android.support.design.widget.TabLayout
        android:id="@+id/tabLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:tabMode="fixed"
        app:tabGravity="fill"/>

</android.support.constraint.ConstraintLayout>

MainActivity.java

package com.hmkcode;

import android.support.v7.app.AppCompatActivity;
import android.support.design.widget.TabLayout;
import android.support.v4.view.ViewPager;
import android.os.Bundle;
import com.hmkcode.adapters.MyFragmentPagerAdapter;

public class MainActivity extends AppCompatActivity {

    MyFragmentPagerAdapter myFragmentPagerAdapter;
    ViewPager viewPager;
    TabLayout tabLayout;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        viewPager = (ViewPager) findViewById(R.id.viewPager);
        tabLayout = (TabLayout) findViewById(R.id.tabLayout);

        setPagerAdapter();
        setTabLayout();

    }

    private void setPagerAdapter(){
        myFragmentPagerAdapter = new MyFragmentPagerAdapter(getSupportFragmentManager());
        viewPager.setAdapter(myFragmentPagerAdapter);
    }

    private void setTabLayout() {
        tabLayout.setupWithViewPager(viewPager);

        tabLayout.getTabAt(0).setText("First");
        tabLayout.getTabAt(1).setText("Second");
    }
}

Source Code @ GitHub

Android | How to Center Views & Content Horizontally and Vertically?

Fri, 31 Aug 2018 10:00:00 +0900

How to center a view or its content e.g. TextView or Button horizontally and vertically? layout_gravity can be used to position a view in the center of its parent. While gravity attribute is used to position view’s content e.g. “text” in the center of the view.

( 1 ) Center Views Horizontally

Place target views in a <LinearLayout>
Set LinearLayout attribute android:orientation="vertical""
Set views attribute android:layout_gravity="center"

<?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:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:layout_margin="10dp">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:padding="5dp"
        android:text="TextView"
        android:layout_gravity="center"
        android:background="#333"
        android:textColor="#fff"
        />

    <Button
        androida:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:text="Button"/>

</LinearLayout>

( 2 ) Center Views Vertically

Place target views in a <LinearLayout>
Set LinearLayout attribute android:orientation="horizontal""
Set views attribute android:layout_gravity="center"

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    android:layout_margin="10dp">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:padding="5dp"
        android:text="TextView"
        android:layout_gravity="center"
        android:background="#333"
        android:textColor="#fff"
        />

    <Button
        androida:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:text="Button"/>

</LinearLayout>

( 3 ) Center Views Horizontally & Vertically

Place a <LinearLayout> with vertical orientation within a parent <LinearLayout> with horizontal orientation
Set views & child <LinearLayout> attribute android:layout_gravity="center"

<?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:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    android:layout_margin="10dp">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:layout_gravity="center">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:padding="5dp"
            android:text="TextView"
            android:layout_gravity="center"
            android:background="#333"
            android:textColor="#fff"
            />

        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:text="Button"/>

    </LinearLayout>

</LinearLayout>

( 4 ) Center Text Horizontally

Set view attribute android:gravity="center_horizontal"

<?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:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:layout_margin="10dp">
    
    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="5dp"
        android:text="TextView"
        android:gravity="center_horizontal"
        android:background="#333"
        android:textColor="#fff" />
    
</LinearLayout>

( 5 ) Center Text Horizontally & Vertically

Set view attribute android:gravity="center_horizontal"

<?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:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:layout_margin="10dp">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:padding="5dp"
        android:text="TextView"
        android:gravity="center"
        android:background="#333"
        android:textColor="#fff" />

</LinearLayout>

Algorithms for Finding all Possible Combinations of k Elements in an Array with Java Implementation

Thu, 30 Aug 2018 19:00:00 +0900

Given an array of size N e.g. e={'A','B','C','D','E'} N=5, we want to find all possible combinations of k elements in that array. For example, if k=3 then one possible combination is {'A','B','C'}. Here we have three different algorithms for finding k-combinations of an array.

Forward-Backward Algorithm

Here we have two arrays and two main indices r & i:

Array e which is the elements array.
Array pointers which is an array for holding indices for selected element.
Index i for pointing to current selected element in array e.
Index r for pointing to current position in pointers array.
The algorithm will move forward by incrementing i & r as long as they do not exceed arrays length.
If r reaches the last position of pointers array a combination is printed.
If both indices reach the last poisition of their pointing arrays the algorith will step backward by reducing r value r-- and set i with the value of i = pointer[r]+1.

public static void combination(Object[]  elements, int k){

	// get the length of the array
	// e.g. for {'A','B','C','D'} => N = 4 
	int N = elements.length;
	
	if(k > N){
		System.out.println("Invalid input, K > N");
		return;
	}
		
	// init combination index array
	int pointers[] = new int[k];
	

	int r = 0; // index for combination array
	int i = 0; // index for elements array
	
	while(r >= 0){
	
		// forward step if i < (N + (r-K))
		if(i <= (N + (r - k))){
			pointers[r] = i;
				
			// if combination array is full print and increment i;
			if(r == k-1){
				print(pointers, elements);
				i++;				
			}
			else{
				// if combination is not full yet, select next element
				i = pointers[r]+1;
				r++;										
			}				
		}
		
		// backward step
		else{
			r--;
			if(r >= 0)
				i = pointers[r]+1;
			
		}			
	}
}

Shifting Algorithm

This algorithm is more intuitive than the first one.
We virtually split the elements array into two types of elements, k elements that can be selected and N-k elements that will be ignored.
In each iteration we select N-k non-ignored elements.
After each iteration we shift the positions of ignored elements as shown in the image below.

public static void combination(Object[]  e, int k){

	int[] ignore = new int[e.length-k]; // --> [0][0]
	int[] combination = new int[k]; // --> [][][]
	
	// set initial ignored elements 
	//(last k elements will be ignored)
	for(int w = 0; w < ignore.length; w++)
		ignore[w] = e.length - k +(w+1);
	
	int i = 0, r = 0, g = 0;
	
	boolean terminate = false;
	while(!terminate){   
		
		// selecting N-k non-ignored elements
		while(i < e.length && r < k){
    			
    		if(i != ignore[g]){
    			combination[r] = i;
    			r++; i++;
    		}
    		else{	    			
    			if(g != ignore.length-1)
    				g++;	    			
    			i++;
    		}
    	}
    	print(combination, e);
    	i = 0; r = 0; g = 0;

    	terminate = true;
    	
    	// shifting ignored indices
    	for(int w = 0 ; w < ignore.length; w++){
    		if(ignore[w] > w){	    			
    			ignore[w]--;
    			
    			if(w > 0)
    				ignore[w-1] = ignore[w]-1;
    			terminate = false;
    			break;	    			
    		}
    	}
	}    		
}

Recursive Algorithm

Recursive algorithm has shorter steps.
In each call to the function we pass List of elements, k and an accumulated combination.
Then we have four conditions:
1. if elements.length < k then stop
2. if k == 1 then add each element to the accumulated combination
3. if elements.length == k then add all elements to the accumulated combination.
4. if elements.length > k then for each element e make a recursive call passing sub list of the elements list, k-1 and add element e to accumulated combination.
It works as shown below

public static void combination(List<String> e, int k, String accumulated){

	// 1. stop
	if(e.size() < k)
		return;
	
	// 2. add each element in e to accumulated
	if(k == 1)
		for(String s:e)
			print(accumulated+s);
	
	// 3. add all elements in e to accumulated
	else if(e.size() == k){
		for(String s:e)
			accumulated+=s;
		print(accumulated);
	}
	
	// 4. for each element, call combination
	else if(e.size() > k)
		for(int i = 0 ; i < e.size() ; i++)
			combination(e.subList(i+1, e.size()), k-1, accumulated+e.get(i));
	
}

Source Code @ GitHub

Android | Create a List with RecyclerView

Wed, 22 Aug 2018 21:30:00 +0900

Creating a scrollable list of elements is a common pattern in mobile application. Using RecyclerView we can list a large data sets or frequently changing one. RecyclerView is an advanced and flexible version of ListView, addressing serveral issues with existing listing views. Here we will build two identical versions of an application with RecyclerView one is written in Java and the other one in Kotlin.

Environment, Tools & Library

Android Studio 3.1.1
Android Support Library com.android.support:recyclerview-v7:28.0.0

Overview

We will build two versions of a simple app (one in Java and one in Kotlin) that displays a list of hard-coded instances of class Link in a RecyclerView. To display items on RecyclerView you need to the following:

RecyclerView widget added to the activity layout.
A class extending RecyclerView.Adapter.
A class extending RecyclerView.ViewHolder.
Layout for RecyclerView items.

Files we need for this app are shown in the image below.

( 1 ) Create new Android Project

Create new android application keep default options. This app is targeting API 19 or later

( 2 ) Add the Support Library

Add the v7 Support Library to gradle build file

build.gradle

dependencies {
    implementation 'com.android.support:recyclerview-v7:28.0.0'
}

( 3 ) Add RecyclerView to Layout

Add RecyclerView to the activity layout.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/forcast_list"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

( 4 ) MainActivity

Obtain a handle to the RecycleView object
Set layout manager using setLayoutManager()

You can use a standard layout managers (such as LinearLayoutManager or GridLayoutManager), or implement your own.

Attach an adapter for the data to be displayed setAdapter().

MainActivity.java

package com.hmkcode.activities;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import com.hmkcode.R;
import com.hmkcode.adapters.MyAdapter;
import com.hmkcode.model.Link;

import java.util.LinkedList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private RecyclerView recyclerView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        recyclerView = findViewById(R.id.recyclerView);

        // layout manager
        RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(this);
        recyclerView.setLayoutManager(layoutManager);

        // adapter
        RecyclerView.Adapter adapter = new MyAdapter(getListData());
        recyclerView.setAdapter(adapter);

    }

    //generate a list of Link
    private static List<Link> getListData(){...}
}

MainActivity.kt

package com.hmkcode.activities

import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.support.v7.widget.LinearLayoutManager
import android.support.v7.widget.RecyclerView
import com.hmkcode.R
import com.hmkcode.adapters.MyAdapter
import com.hmkcode.model.Link
import java.util.*

class MainActivity : AppCompatActivity() {

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

        val recyclerView = findViewById<RecyclerView>(R.id.recyclerView)

        // layout manager
        val layoutManager:RecyclerView.LayoutManager  = LinearLayoutManager(this)
        recyclerView.layoutManager = layoutManager;

        // adapter
        val adapter:RecyclerView.Adapter<MyAdapter.MyViewHolder> = MyAdapter(getListData())
        recyclerView.adapter = adapter;
    }

    //generate a list of Link
    private fun getListData(): List<Link> {...}
}

( 5 ) Extending RecyclerView ViewHolder & Adapter

View holder objects represent views in the RecyclerView
Each view holder object is an instance of a class extending RecyclerView.ViewHolder
Each view holder displays a single item with a view.
View hodler objects are managed by adapter
Adapter is created by extending RecyclerView.Adapter
Adapter creates view hoders as needed by calling onCreateViewHolder() which returns instance of a class created by extending RecyclerView.ViewHolder.
Adapter also binds the view holders to their data using onBindViewHolder().

MyAdapter.java

package com.hmkcode.adapters;

import android.support.annotation.NonNull;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;

import com.hmkcode.R;
import com.hmkcode.model.Link;

import java.util.List;

public class MyAdapter extends RecyclerView.Adapter<MyAdapter.MyViewHolder> {

    private List<Link> links;

    // constructor
    public MyAdapter(List<Link> links){
        this.links = links;
    }

    @NonNull
    @Override
    public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {

        // inflate item_layout
        View itemLayoutView = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_layout, null);

        MyViewHolder vh = new MyViewHolder(itemLayoutView);
        return vh;
    }

    @Override
    public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
        holder.itemIcon.setImageResource(links.get(position).getIcon());
        holder.itemTitle.setText(links.get(position).getTitle());
        holder.itemUrl.setText(links.get(position).getUrl());
    }

    @Override
    public int getItemCount() {
        if(links != null)
            return links.size();
        else
            return 0;
    }

    // inner static class
    public static class MyViewHolder extends RecyclerView.ViewHolder {

        public TextView itemTitle;
        public TextView itemUrl;
        public ImageView itemIcon;

        public MyViewHolder(View itemLayoutView) {
            super(itemLayoutView);
            itemTitle = itemLayoutView.findViewById(R.id.item_title);
            itemUrl = itemLayoutView.findViewById(R.id.item_url);
            itemIcon = itemLayoutView.findViewById(R.id.item_icon);
        }
    }
}

MyAdapter.kt

package com.hmkcode.adapters

import android.support.v7.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import com.hmkcode.R
import com.hmkcode.model.Link

class MyAdapter(private val links:List<Link>): 
    RecyclerView.Adapter<MyAdapter.MyViewHolder>() {

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int):
            MyViewHolder {

        val itemLayoutView:View =  LayoutInflater.from(parent.context)
                                    .inflate(R.layout.item_layout, null)

        val vh:MyViewHolder = MyViewHolder(itemLayoutView)
        return vh
    }

    override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
        holder.itemIcon.setImageResource(links[position].icon)
        holder.itemTitle.text = links[position].title
        holder.itemUrl.text = links[position].url
    }

    override fun getItemCount(): Int {
        return links?.size ?: 0
    }

    class MyViewHolder(itemLayoutView: View):
        RecyclerView.ViewHolder(itemLayoutView) {

        val itemTitle = itemLayoutView.findViewById<TextView>(R.id.item_title)
        val itemUrl = itemLayoutView.findViewById<TextView>(R.id.item_url)
        val itemIcon = itemLayoutView.findViewById<ImageView>(R.id.item_icon)
    }
}

( 6 ) RecyclerView Element Layout

Below is the layout for RecyclerView items.
The layout displays ImageView on the left and two TextView below each other to the right of the ImageView

item_layout.xml

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:padding="5dp">

    <RelativeLayout
        ...
        android:background="@drawable/item_border">

        <!-- icon -->
        <ImageView
            android:id="@+id/item_icon"
            .../>

        <!-- title -->
        <TextView
            android:id="@+id/item_title"
            .../>

        <TextView
            android:id="@+id/item_url"
            ... />

    </RelativeLayout>

</LinearLayout>

Source Code @ GitHub

Java | Servlet Sending & Receiving JSON Using jQuery.ajax()

Fri, 17 Aug 2018 19:00:00 +0900

A complete working Java project showing how to use jQuery ajax function to send an HTTP POST request with JSON content in the request body to the backend and how to receive and parse JSON in the frontend using jQuery. In the backend a Java servlet is running to receive POST request, read the JSON content, map it to Java object, add the received content to a list and again send the complete list to the fontend in JSON format.

Objectives

How to send jQuery.ajax() POST request with data in JSON format?
How to receive JSON data in Java servlet, parse it and map it into Java objects?
How to send data back to the client in JSON format?

Overview

We will build a simple Java servlet using @WebServlet. The servlet recieves POST request, reads JSON content, maps it into Article Java object using Jackson and finally sends a list of received articles in the response body to the frontend in JSON format. In the frontend we will have a single HTML file and JS file with a single function sendPost that sends HTTP POST request and recieves JSON contnet on success.

JSONServlet.java: Java servlet that receives POST request with JSON content and send back JSON content in response body. Article.java: Java class for creating an object holding article’s title, url, tags and categories. index.html: HTML file for entering article info to be sent and displaying articles list received from backend. myfunctions.js: JS file with one function sendPost for sending ajax POST request with article info in JSON format and receiving a list of articles from the backend in JSON format. pom.xml: Maven pom.xml file listing dependencies and plugin used for this project.

Dependencies

Jackson <version>2.9.6</version>
Jetty plugin for running the project.

<dependencies>
	<dependency>
		<groupId>javax.servlet</groupId>
		<artifactId>javax.servlet-api</artifactId>
		<version>3.1.0</version>
		<scope>provided</scope>
	</dependency>
	
	<!-- Jackson -->
	<dependency>
		<groupId>com.fasterxml.jackson.core</groupId>
		<artifactId>jackson-core</artifactId>
		<version>2.9.6</version>
	</dependency>
	<dependency>
		<groupId>com.fasterxml.jackson.core</groupId>
		<artifactId>jackson-databind</artifactId>
		<version>2.9.6</version>
	</dependency>
	<dependency>
		<groupId>com.fasterxml.jackson.core</groupId>
		<artifactId>jackson-annotations</artifactId>
		<version>2.9.6</version>
	</dependency>
</dependencies>


<plugins>
	<plugin>
		<groupId>org.eclipse.jetty</groupId>
		<artifactId>jetty-maven-plugin</artifactId>
		<version>9.4.11.v20180605</version>	
	</plugin>
</plugins>

Backend

JSONServlet.java

Use servlet annotations @WebServlet("/jsonservlet")
Extends HttpServlet
Override doPost()
1. get received JSON data from request
2. initiate jackson mapper
3. Convert received JSON to Article
4. Set response type to JSON
5. Add article to List<Article>
6. Send List<Article> as JSON to client

package com.hmkcode;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.hmkcode.vo.Article;

@WebServlet("/jsonservlet")
public class JSONServlet extends HttpServlet {
	
	private static final long serialVersionUID = 1L;

	// This will store all received articles
	List<Article> articles = new LinkedList<Article>();
	
	/***************************************************
	 * URL: /jsonservlet
	 * doPost(): receives JSON data, parse it, map it and send back as JSON
	 ****************************************************/
	protected void doPost(HttpServletRequest request, HttpServletResponse response)
	        throws ServletException, IOException{
	    
		// 1. get received JSON data from request
		BufferedReader br = 
		new BufferedReader(new InputStreamReader(request.getInputStream()));
		
		String json = "";
		if(br != null){
			json = br.readLine();
			System.out.println(json);
		}
		
		// 2. initiate jackson mapper
		ObjectMapper mapper = new ObjectMapper();
    	
		// 3. Convert received JSON to Article
		Article article = mapper.readValue(json, Article.class);

		// 4. Set response type to JSON
		response.setContentType("application/json");		    
    	
		// 5. Add article to List<Article>
		articles.add(article);

		// 6. Send List<Article> as JSON to client
		mapper.writeValue(response.getOutputStream(), articles);
	}
}

Article.java

package com.hmkcode.vo;

import java.util.LinkedList;
import java.util.List;

public class Article {

	private String title;
	private String url;
	private List<String> categories;
	private List<String> tags;
	
	//setters & getters
}

Frontend

index.html

<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
<title>Java Servlet JSON</title>
<script src="js/jquery.1.9.1.min.js"></script>

<!-- bootstrap just to have good looking page -->
<link href="bootstrap/css/bootstrap.css" type="text/css" rel="stylesheet" />

<!-- we code these -->
<script src="js/myfunctions.js"></script>


</head>

<body>

	<h1 style="text-align:center">Java Servlet Send & Receive JSON<br></h1> 
	
	<!-- article inputs -->
	<div class="article" style="margin:10px;">
		<div class="input-prepend">
			<span class="add-on">Title</span>
			<input class="span4" id="title" name="title" 
				type="text" placeholder="Article Title...">
		</div>		
		<br/>
		
		<div class="input-prepend">
			<span class="add-on">URL</span>
			<input class="span4" id="url" name="url" 
				type="text" placeholder="http://...">
		</div>		
		<br/>
		
		<div class="input-prepend">
			<span class="add-on">Categories</span>
			<input class="span2" id="categories" name="categories" 
				type="text" placeholder="category1;category2;...">
		</div>
		<br/>
		
		<div class="input-prepend">
			<span class="add-on">Tags</span>
			<input class="span2" id="tags" name="tags"
				type="text" placeholder="tag1;tag2;...">
		</div>
		<p>
			<button class="btn btn-primary" 
				type="button" onclick="sendAjax()">Add</button>
		</p>
	</div>
	
	<!-- display all articles -->
	<div style="width:700px;padding:20px;S">
		<h5 style="text-align:center">
			<i style="color:#ccc"><small>Articles</small></i>
		</h5>
	
		<table id="added-articles" class="table">
			<tr>
				<th>Title</th>
				<th>Categories</th>
				<th>Tags</th>
			</tr>
		</table>
	</div>
</body> 
</html>

myfunctions.js

function sendAjax() {
 
	// get inputs
	var article = new Object();
	article.title = $('#title').val();
	article.url = $('#url').val();
	article.categories = $('#categories').val().split(";");
	article.tags = $('#tags').val().split(";");
	
	$.ajax({
		url: "jsonservlet",
		type: 'POST',
		dataType: 'json',
		data: JSON.stringify(article),
		contentType: 'application/json',
		mimeType: 'application/json',
		
		success: function (data) {
        	$("tr:has(td)").remove();

        	$.each(data, function (index, article) {
            	
                var td_categories = $("<td/>");
                $.each(article.categories, function (i, tag) {
                	var span = $("<span class='label label-info' 
						style='margin:4px;padding:4px' />");
						
                	span.text(tag);
                	td_categories.append(span);
                });
                
                var td_tags = $("<td/>");
                $.each(article.tags, function (i, tag) {
                	var span = $("<span class='label' 
						style='margin:4px;padding:4px' />");
                	span.text(tag);
                	td_tags.append(span);
                });
                
                $("#added-articles").append($('<tr/>')
                	.append($('<td/>')
				.html("<a href='"+article.url+"'>"+article.title+"</a>"))
                	.append(td_categories)
                	.append(td_tags)
                );
            
                
            }); 
        },
		error:function(data,status,er) {
			alert("error: "+data+" status: "+status+" er:"+er);
		}
	});
}

Run

Clone the repoistory from github and use maven to run the project.

	java-servlet-json>mvn jetty:run

Source Code @ GitHub

Spring MVC Test Using MockMVC

Sat, 04 Aug 2018 21:30:00 +0900

The goal of Spring MVC Test is to provide an effective way for testing controllers. Spring MVC Test allows performing requests and generating responses without the need for running in a Servlet container. It uses the DispatcherServlet to provide full Spring MVC runtime behavior and provides support for loading actual Spring configuration with the TestContext framework in addition to a standalone mode in which controllers may be instantiated manually and tested one at a time.

Overview

We will build a simple Spring MVC controller that returns JSON content when receiving GET request. In order to build the service we need the following Java classes and XML files:

Controller.java : Simple Spring MVC controller responding to GET request mapped to /rest/api/get.
Link.java: Simple Java model class.
rest-servlet: Spring XML configuration file.
web.xml: Defining DispatcherServlet.
index.html: HTML file with one link calling REST service.
TestController: Test class for testing our controller.
rest-servlet-test.xml: Spring Configration for testing.
pom.xml: Maven pom.xml file listing dependencies and plugin used for this project.

Dependencies

To develop, run and test the service you need the following libraries:

Spring Framework

<spring.version>5.0.8.RELEASE</spring.version>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>${spring.version}</version>
</dependency>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>${spring.version}</version>
</dependency>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	<version>${spring.version}</version>
</dependency>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-web</artifactId>
	<version>${spring.version}</version>
</dependency>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>${spring.version}</version>
</dependency>

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-expression</artifactId>
	<version>${spring.version}</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring.version}</version>
    <scope>test</scope>
</dependency>

jUnit

<junit.version>4.12</junit.version>

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>${junit.version}</version>
	<scope>test</scope>
</dependency>

hamcrest && jsonpath

Hamcrest and JSON path will be used to assert JSON results

<dependency>
	<groupId>org.hamcrest</groupId>
	<artifactId>hamcrest-library</artifactId>
	<version>1.3</version>
	<scope>test</scope>
</dependency>
<dependency>
	<groupId>com.jayway.jsonpath</groupId>
	<artifactId>json-path</artifactId>
	<version>2.2.0</version>
	<scope>test</scope>
</dependency>

Complete Maven dependencies is included in pom.xml

Spring MVC Controller

We will build a simple controller that returns JSON. The service will return a single Link object in json format.

Controller.java

package com.hmkcode.controllers;


import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.hmkcode.model.Link;

@RestController
@RequestMapping("api")
public class Controller {
	
	@RequestMapping(value = "/get", method = RequestMethod.GET)
	public @ResponseBody Link get(){
		System.out.println("Get!");
		
		Link link = new Link();
		link.setTitle("HMKCODE BLOG!");
		link.setUrl("hmkcode.com");
		
		return link;
		
	}
}

Link.java

package com.hmkcode.model;

public class Link {

	private String title;
	private String url;

	// setters & getters
}

rest-servlet.xml web.xml index.html

Spring MVC Test

TestController.java

@RunWith(SpringJUnit4ClassRunner.class) will run Spring test.
@ContextConfiguration loads the context configuration in rest-servlet-test.xml.
@WebAppConfiguration will load the web application context

package com.hmkcode.test;

import javax.servlet.ServletContext;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockServletContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "/rest-servlet-test.xml")
@WebAppConfiguration
public class TestController {

	@Autowired
	private WebApplicationContext wac;
	
	private MockMvc mockMvc;
	@Before
	public void setup() throws Exception {
	    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
	}
	
	@Test
	public void configTest() {
	    ServletContext servletContext = wac.getServletContext();
	     
	    Assert.assertNotNull(servletContext);
	    Assert.assertTrue(servletContext instanceof MockServletContext);
	    Assert.assertNotNull(wac.getBean("controller"));
	}
	
	@Test
	public void test() throws Exception{
		 this.mockMvc.perform(get("/api/get"))
		 	.andExpect(status().isOk())
		 	.andDo(print());
		 
	}
}

Source Code @ GitHub

Gradle for Java

Sun, 22 Jul 2018 18:43:00 +0900

This post is a quick Gradle tutorial for Java developers. It shows how to use Gradle to build, test and run Java desktop and web application.

Table of Content

What is Gradle?
Gradle Installation
First Gradle Project
Gradle Fundamentals
Gradle & Java Projects
Building Java Application
Building Java Web Application

What is Gradle?

Gradle is an open-source build tool that helps developers automating building tasks.
Gradle allows you to write scripts in Groovy or Kotlin to define tasks to be executed on your code.
Tasks such as compiling, testing or creating jar file can be automated using Gradle.
Gradle can be used to define dependencies or jar files in case of Java to run your code.
Gradle has a core Java plugin that includes many tasks needed for Java development.
In the case of web application, Gradle can run your web application using plugin server.
Gradle is your best friend!

Gradle Installation

Gradle can be installed on Linux, macOS, or Windows.
Gradle requires only a Java JDK version 7 or higher.
Download the latest release. 4.9 is the latest as of now!
Follow installation steps.
Verifying installation by running gradle -v in command line window.

C:\>gradle -v

------------------------------------------------------------
Gradle 4.9
------------------------------------------------------------

Build time:   2018-07-16 08:14:03 UTC
Revision:     efcf8c1cf533b03c70f394f270f46a174c738efc

Kotlin DSL:   0.18.4
Kotlin:       1.2.41
Groovy:       2.4.12
Ant:          Apache Ant(TM) version 1.9.11 compiled on March 23 2018
JVM:          1.8.0_71 (Oracle Corporation 25.71-b15)
OS:           Windows 8.1 6.3 amd64

First Gradle Project

Create a new directory e.g. C:\Gradle>first-gradle-project
Open command line window and go to the dirctory created in the previous step.
Type gradle init

C:\Gradle\first-gradle-project>gradle init
Starting a Gradle Daemon, 1 incompatible and 1 stopped Daemons could not be reused, 
use --status for details

BUILD SUCCESSFUL in 11s
2 actionable tasks: 2 executed

Gradle will create new files and sub directories within the parent directory.
build.gradle this is the main file where we write scripts in Groovy or Kotlin for Gradle to execute.
Open build.gralde file in a text editor and type the following script.

task hello{
	println "Hello, World!"
}

Open command prompt, go to the project location and type gradle hello

C:\Gradle\first-gradle-project>gradle hello
Hello, World!

Gradle Fundamentals

Everything in Gradle sits on top of two basic concepts: projects and tasks.
Every Gradle build is made up of one or more projects.
A project represents a thing to be built e.g. JAR file or to be done e.g. deploying to production.
A Task represents a single atomic piece of work for a build, such as compiling classes or generating javadoc.
Gradle describes its build using build file build.gradle.
Gradle build file is located in the root folder of the project.
Build file defines projects, tasks, plugins, dependencies…ect.
Gradle uses plugins to extend its core functionality.
For example, the ability to compile Java code is added by a plugin.
Gradle has built-in support for dependency management for declaring, resolving and using dependencies required by the project.

Gradle & Java Projects

While Gradle can be used with other languages we will focus on using Gradle with Java projects.
Gradle is a build tool automating the creation of Jar/War build.
Gradle helps automating a wide variety of tasks such as compiling Java classes, packaging binary code & running Junit tests.
Gradle allows you to declare dependencies and repositories of Jar files needed for your Java project to compile or run.

Building Java Application

1. Create new directory

Create a new directory e.g. gradle-java-app
Go to the directory

C:\gradle-projects>mkdir gradle-java-app

C:\gradle-projects>cd gradle-java-app

C:\gradle-projects\gradle-java-app>

2. `init` java-application

To create new Java application call gradle init --type java-application

C:\gradle-projects\gradle-java-app>gradle init --type java-application

Starting a Gradle Daemon

BUILD SUCCESSFUL in 8s
2 actionable tasks: 2 executed

Gradle will create src folder with two sub-folders main and test
build.gradle will apply java and application plugin, point to guava lib in dependencies and to jcenter() repository.

plugins {
    id 'java'
    id 'application'
}

mainClassName = 'App'

dependencies {
    compile 'com.google.guava:guava:23.0'
    testCompile 'junit:junit:4.12'
}

repositories {
    jcenter()
}

App.java has main method that print Hello, World! when executed.

public class App {
    public String getGreeting() {
        return "Hello world.";
    }

    public static void main(String[] args) {
        System.out.println(new App().getGreeting());
    }
}

3. `build` Java Applicaiton

To build Java application call gradle build task.
build task depends on 6 other tasks such as compileJava task.

C:\gradle-projects\gradle-java-app>gradle build

BUILD SUCCESSFUL in 0s
7 actionable tasks: 7 up-to-date

To see all executed tasks call --console=plain build

4. `run` Java Application

build.gradle is pointing to the main class mainClassName = 'App'.
To run main class call gradle run

C:\gradle-projects\gradle-java-app>gradle run

> Task :run
Hello world.

BUILD SUCCESSFUL in 0s
2 actionable tasks: 1 executed, 1 up-to-date

Building Java Web Application

1. Create new directory

Create a new directory e.g. gradle-java-web-app
Go to the directory

C:\gradle-projects>mkdir gradle-java-web-app

C:\gradle-projects>cd gradle-java-web-app

C:\gradle-projects\gradle-java-web-app>

2. `init` java-application

So far, there is no init type for java web application, so we will use java-appliation as a starter.
While gradle init --type java-application will not create java web application, it will help creating src and build.gradle file.

C:\gradle-projects\gradle-java-web-app>gradle init --type java-application

BUILD SUCCESSFUL in 0s
2 actionable tasks: 2 executed

Change the content of build.gradle to be as following
- use the war plugin
- and add servlet-api to dependencies

plugins {
    id 'war'  
}

repositories {
    jcenter()
}

dependencies {
    providedCompile 'javax.servlet:javax.servlet-api:3.1.0' 
    testCompile 'junit:junit:4.12'
}

3. Create a servlet class

Under /scr/main/java/com/hmkcode/ create a Java class HelloServlet.java

package com.hmkcode;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name = "HelloServlet", urlPatterns = {"hello"}, loadOnStartup = 1) 
public class HelloServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        response.getWriter().print("Hello, World!");  
    }

}

4. Add .html file

Add an index page to the root of the application by creating the file index.html.

<html>
<head>
  <title>Java Web App</title>
</head>
<body>
<p>Say<a href="hello">Hello</a></p> 

</body>
</html>

5. Add the gretty plugin and run the app

Gretty plugin makes it easy to run or test webapps

build.gradle

plugins {
    id 'war'
    id 'org.gretty' version '2.2.0' 
}

6. Run the web app

Use gradle appRun to run the web app.

C:\gradle-projects\gradle-java-web-app>gradle appRun

Open your web browser and type http://localhost:8080/gradle-java-web-app/

Spring MVC Excel View Resolver

Tue, 20 Feb 2018 23:30:00 +0900

The V in MVC is about viewing the data, or "model", requested through the controller. Spring MVC can render retrieved data into views of different format such as PDF, JSP or Excel. Spring framework view resolvers e.g. InternalResourceViewResolver, XmlViewResolver, ResourceBundleViewResolver and a few others enable you to render model into views. This post shows you how to render model into Excel view using XmlViewResolver.

Overview

We will build a REST service using Spring MVC that returns Excel “.xlsx” document. In order to build the service we need the following Java classes and XML files:

Controller.java: Java class that receives mapped HTTP request.
Link.java: Simple Java class to be used as model object holding links data.
ExcelXlsxView: Java class extending AbstractXlsxView and generating the actual Excel document.
view.xml: XML file containing Excel view class configuration.
rest-servlet.xml: Spring XML configuration file containing configuration of controllers and view resolvers.

Dependencies

To develop and run the service you need the following libraries:

Spring core, context, beans, expression, webmvc, web.
Apache common logging
Apache POI
Apache POI OOXML

Complete Maven dependencies is included in pom.xml

Project Structure

`Controller.java`

package com.hmkcode.controllers;

import java.util.LinkedList;
import java.util.List;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import com.hmkcode.model.Link;

@RestController
public class Controller {
	
	@RequestMapping(value = "/viewExcel", method = RequestMethod.GET)
	public ModelAndView getExcel(){
		System.out.println("getExcel!");
		
		List<Link> links = new LinkedList<Link>();
		links.add(new Link("Android", "android.com"));
		links.add(new Link("Spring", "spring.io"));
		links.add(new Link("Firebase", "firebase.com"));
		
		return new ModelAndView("ExcelXlsxView", "model", links);
	}

}

`ExcelXlsxView.java`

package com.hmkcode.view;

import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.web.servlet.view.document.AbstractXlsxView;
import com.hmkcode.model.Link;

public class ExcelXlsxView extends AbstractXlsxView {

	@Override
	protected void buildExcelDocument(Map<String, Object> model, 
			Workbook workbook, 
			HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		
		@SuppressWarnings("unchecked")
		List<Link> links = (List<Link>) model.get("model");
	         
        // create a new Excel sheet
        Sheet sheet = workbook.createSheet("Sheet");

        int i = 0;
        Row row = null;
        for(Link link:links){
        	row = sheet.createRow(i++);
        	row.createCell(0).setCellValue(link.getTitle());
        	row.createCell(1).setCellValue(link.getUrl());
        }
	}
}

`Link.java`

package com.hmkcode.model;

public class Link {

	private String title;
	private String url;
	
	public Link(String title, String url){
		this.title = title;
		this.url = url;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	@Override
	public String toString() {
		return "Link [title=" + title + ", url=" + url + "]";
	}
}

`views.xml`

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
     
    <bean id="ExcelXlsxView" class="com.hmkcode.view.ExcelXlsxView" />
     
</beans>

`rest-servlet.xml`

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

	<context:component-scan base-package="com.hmkcode.controllers" />


    <bean id="ExcelXlsxView" class="org.springframework.web.servlet.view.XmlViewResolver">
        <property name="order" value="1"/>
        <property name="location" value="/WEB-INF/views.xml"/>
    </bean>
    
</beans>

Running the Service

pom.xml includes jetty server as a plug-in. To run the service type the following command

>mvn jetty:run

Output

The service response will contain an Excel document “.xlsx”. The content of the document will be as shown below.

Source Code @ GitHub

Android | TextInputLayout

Fri, 29 May 2015 18:43:00 +0900

EditText , has a hint attribute that will show text inside the EditText telling the user what to enter in this text field. That hint text disappears due to the user inputting text. However, TextInputLayout , "a layout wrapping an EditText", shows hint as floating label when the hint is hidden due to the user inputting text. TextInputLayout is part of Design Support library.

Environment & Tools

Windows 7
Eclipse ADT
Nexus 5
Android Support Library, revision 22.2.0 or higher

About this Sample App

The code below is for a dummy app that will show how TextInputLayout will work on your screen.

( 1 ) Create new Android Project

Application Name: InputTextLayout
Project Name: android-input-text-layout
Package Name: com.hmkcode.inputtextlayout

( 2 ) Add TextInputLayotu to Layout XML

TextInputLayout will wrap EditText view.
EditText hint attribute should not be empty.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.hmkcode.inputtextlayout.MainActivity" >

    
     <android.support.design.widget.TextInputLayout
        android:id="@+id/til"
      	android:layout_width="fill_parent"
      	android:layout_height="wrap_content">
       	<EditText
        	android:id="@+id/textDialog"
        	android:layout_width="fill_parent"
        	android:layout_height="wrap_content"
        	android:hint="First Name"/>
  	</android.support.design.widget.TextInputLayout>
  
  	<android.support.design.widget.TextInputLayout
    	android:id="@+id/til2"
      	android:layout_width="fill_parent"
      	android:layout_height="wrap_content"
      	android:layout_below="@+id/til">
       	
       	<EditText
      	  	android:id="@+id/textDialog2"
        	android:layout_width="fill_parent"
        	android:layout_height="wrap_content"
        	android:hint="Last Name"/>
  	</android.support.design.widget.TextInputLayout>

</RelativeLayout>

Note: This sample app was created in Eclipse ADT. You may need to go over the below steps to resolve some issues.

Make sure you have Android Support Library, revision 22.2.0 or higher.
TextInputLayout is part of Design Support Library.
You need to import <android-sdk>/extras/android/support/design.
You need to import <android-sdk>/extras/android/support/v7/appcompat.
After importing design library, you need to edit project.proerties file as following:

# Project target.
target=android-21
android.library.reference.1=../v7/appcompat
android.library=true

In your app project, [reference design library project] (https://developer.android.com/tools/projects/projects-eclipse.html#ReferencingLibraryProject).

HMKCODE

Creating Dynamic and Draggable Points on a Line with Smooth Transitions

Introduction:

Explanation:

Source Code @ GitHub

CSS | Understanding CSS @keyframes and Animation Timing Functions

CSS @keyframes: Defining Animation Steps

Animation Timing Functions: Controlling Animation Pace

Putting it All Together: An Interactive Example

Source Code @ GitHub

Java | Nested Classes

Non-Static Nested Classes “Inner Classes”

Static Nested Classes

Anonymous Classes

Java | How to Enforce Non-Instantiability of a Class?

Why Do We Need Non-instantiable Classes?

How to Enforce Non-instantiability?

Java | Overriding equal() Method

Overriding Object Common Methods

Overriding equals(Object)

Default Implementation

General Contracts

Java | Serialization

Serializable Objects

Serializing an Object

Deserializing an Object

Non-serializable Fields

Optional Methods for Serializable Class

Java | Singleton Pattern

How to Enforce the Creation of a Single Instance?

1. private Constructor with public static member

Dealing with serialization

2. Single Element enum

Java | Builder Pattern for Optional Parameters

How to Create Instances of Classes with Many Optional Parameters?

Builder Pattern

Java | Service Provider Interface

Service Provider Interface Components

The ServiceLoader Class

Example

Source Code @ GitHub

Java | Constructors vs Static Factory Methods

Using Static Methods Instead of Constructors!

Some Advantages of using Static Factory Methods

1. Meaningful Names

2. Instance Controlled Classes

3. Returning Subtypes

4. Basis of Service Provider Frameworks

Spring Global Exception Handling Using @ControllerAdvice Annotation

Overview

Dependencies

Spring MVC Controller

@ControllerAdvice

Source Code @ GitHub

Java | Simple Jasper Report Example

Environment, Tools & Libraries used in this post

Overview

Dependencies

Java Bean Country.java

Java App.java

Source Code @ GitHub

Android | Sending & Receiving Simple Data Between Apps

( 1 ) Sending Text to Other Apps

( 2 ) Receiving Text from Other Apps

Source Code @ GitHub

Kotlin | Function Type, Lambda and Higher-Order Functions

Function Type

typealias

Lambda

Special Case: Lambda with single parameter

Where is return in lambda?

Anonymous Functions

Creating & Calling Instances of a Function Type

Calling an instance of a function type

| Higher-Order Functions

Android | Handling Click Events Kotlin's Way

View & Click Listener

( 1 ) The simplest old way, implement OnClickListener interface

( 2 ) Use object expression

( 3 ) Lambda

1. `private` Constructor with `public static` member

2. Single Element `enum`

Java Bean `Country.java`

Java `App.java`

`typealias`

Where is `return` in lambda?

`HtmlConverter` Class

Auto-Generated `get()` & `set()`

This will generate `StackOverflowError`!

Backing `field`

b. Build `httpPost()` function with IO dispatcher.

c. Build `send()` function to launch `httpPost()` in `lifecycleScope` coroutine scope.

Meet `suspend`