AndroidSketchpad

Src: Medium

class SingleLiveEvent<T> : MutableLiveData<T>() {

    private val pending = AtomicBoolean(false)

    @MainThread
    override fun observe(owner: LifecycleOwner, observer: Observer<T>) {

        if (hasActiveObservers()) {
            //Log.w(TAG, "Multiple observers registered but only one will be notified of changes.")
        }

        // Observe the internal MutableLiveData
        super.observe(owner, Observer<T> { t ->
            if (pending.compareAndSet(true, false)) {
                observer.onChanged(t)
            }
        })
    }

    @MainThread
    override fun setValue(t: T?) {
        pending.set(true)
        super.setValue(t)
    }

    /**
     * Used for cases where T is Void, to make calls cleaner.
     */
    @MainThread
    fun call() {
        value = null
    }

    companion object {
        private const val TAG = "SingleLiveEvent"
    }
}

override fun postValue(value: T) {
    pending.set(true)
    super.postValue(value)
}

enum class Status{
    LOGIN,
    SIGNUP,
    FAILED
}

val observableEvent = SingleLiveEvent<Status>()

fun mockLogin(){
    observableEvent.value = Status.LOGIN
    background()
}

fun mockSignUp(){
        Thread({
            try {
                Thread.sleep(2000) //2 sec wait
            } catch (e:Exception){
                //nothing
            } finally {
                observableEvent.postValue(Status.SIGNUP)
                //do some task from background
                background()
            }
        }).start()
    }

private fun background(){
        val thread = HandlerThread("Background")
        thread.start()

        Handler(thread.looper).post({

            //wait for 2 sec
            Thread({
                try {
                    Thread.sleep(2000) //2 sec wait
                } catch (e:Exception){
                    //nothing
                } finally {
                    observableEvent.postValue(Status.FAILED)
                }
            }).start()
        })
    }

• progress bar
• login button
• signup button

val progressBar:ProgressBar = progressBar
progressBar.gone()

button.setOnClickListener {
    progressBar.vis()
    viewModel.mockLogin()
}

button2.setOnClickListener {
    progressBar.vis()
    viewModel.mockSignUp()
}

viewModel.observableEvent.observe(this, Observer {
    if (it == Status.LOGIN){
        progressBar.gone()
        "Login Successful".showToast()
    } else if (it == Status.SIGNUP) {
        progressBar.gone()
        "Sign up Successful".showToast()
    }

    if (it == Status.FAILED){
        "Job Failed from background thread".showToast()
    }
})

private fun String.showToast(){
    Toast.makeText(context, this, Toast.LENGTH_SHORT).show()
}

Src: Dartlang

• Everything in darts is object and object is an instance of Class.
• Even variable, function and null are object too.
• Type annotation is optional because it is strongly typed. So we can special type or dynamic
• Dart support generic type (for example a list of integers: List
• Top level function is supported, we also used functions that tied to an object or a class. And another cool thing is it supports nested function
• It also supports top-level variable and tied variables. The instance variable, sometimes known as fields or properties.
• Like Java, Dart has no keyword like public, protected, private, If variables start with underscore (_) that consider as package private.
• Dart tools can report only two kinds of problems. The first one is warnings that just indications of your code might not work, but they don’t prevent your program from executing. The second one is errors, it can be either compile-time or run-time and finally, it prevents the code from executing at all

• Tutorial
• Hello word
• Variable
• Data type
• Function
• Operators
• String operation
• Collection
• Control flow statement
• Classes
• Methods
• Enumerated types
• Generics
• Library and visibility
• Asynchrony support

circular queue

• Top position
• Last position

class CircularQueueK(size: Int){
}

private val list:Array<Any> = Array(size,{ i: Int -> i })
private var head = 0
private var tail = 0

• isFull() ->  this will return true if the queue is full, so we don't allow to insert more data.
• isEmpty() -> this will return true if the queue is empty, so we don't allow dequeue the data.

fun isFull() = (tail + 1) % list.size == head
fun isEmpty() = head == tail

fun enqueue(value: Any){
    if (isFull()){
        return
    }

    list[tail] = value
    tail = (tail+1) % list.size
}

fun dequeue():Any{

    var a:Any = ""

    if (!isEmpty()){
        a = list[head]
        head = (head +1) % list.size
    }

    return a
}

head = (head +1) % list.size

fun iterator() = list.withIndex()

fun main(args: Array<String>) {
}

val queue = CircularQueueK(5)

var s = 0

while (!queue.isFull()){
    queue.enqueue(s)
    s++
}

for ((i,v) in queue.iterator()) {
    println("Index:$i and value:$v")
}

Index:0 and value:0
Index:1 and value:1
Index:2 and value:2
Index:3 and value:3
Index:4 and value:4

println("\nGet value1:${queue.dequeue()}")
println("Get value2:${queue.dequeue()}")
println("Get value3:${queue.dequeue()}")

Get value1:0
Get value2:1
Get value3:2

var d = 10
while (!queue.isFull()){
     queue.enqueue(d)
     d++
}

for ((i,v) in queue.iterator()) {
    println("Index:$i and value:$v")
}

Index:0 and value:11
Index:1 and value:12
Index:2 and value:2
Index:3 and value:3
Index:4 and value:10

Src: Wikipedia

• Top position
• Last position

Create an array of Int' and also create 2 variable that mentions above.

var ints = IntArray(10)
var head = 0
var tail = 0

Methods:
enqueue():
insert data in the tail position and increase the tail

fun enqueue(n: Int) {
    ints[tail] = n
    tail += 1
    println("Input:" + n)
}

dequeue():
get data from head position index from the array and increase the head

fun dequeue(): Int {
    val n = ints[head]
    head += 1
    return n
}

Empty check:
if head and tail is same then the stack is empty

val isEmpty: Boolean
        get() = head == tail

Now time for access data:
First, create the main method:

fun main(arg: Array<String>) {
}

enqueue():
just run a for loop from 0 to 10 and insert data

for (i in 0..9) {
     enqueue(i)
}

Output:

Input:0
Input:1
Input:2
Input:3
Input:4
Input:5
Input:6
Input:7
Input:8
Input:9

works fine.
dequeue()
run a while loop until the queue is empty

while (!isEmpty) {
    println("value: " + dequeue())
}

Output:

value: 0
value: 1
value: 2
value: 3
value: 4
value: 5
value: 6
value: 7
value: 8
value: 9

It's work fine.
That's is the basic queue implementation.
You can check this out on Github

Discussion about queue:
The uses of the basic queue are not huge. It has a very limited use.
Because it wastes memory.
For example, if the queue has the capacity of 100. Then at the beginning data inserted from zero, when we access data from one we can get that data from the zero position. After the head is also increased and the tail already increased. Imagine by this way at 99 position data is filled and we access data from the 99 potions. If we want to insert new data into the queue it shows you a warning, "hey! I am full, I can not take any new data". But already the previous position is empty and there is no way to insert new data in the queue. we can use the previous position. But it allocates the memory. This is obviously the waste of memory. see the picture for the more clear concept.

Queue Data structure

To fix this problem we use the circular queue

Circular Queue

In circular queue top position and the last position move around a circle. I will discuss circular queue in the next post.

Until then, stay happy and keep practicing.
Thank you for reading this post. 
Happy coding