DEV Community: Nasir Ahmed Momin

Flutter: Scroll Content on Keypad appears

Nasir Ahmed Momin — Sun, 19 Jul 2020 06:43:43 +0000

In the beginning for my Flutter journey, I struggled with scrolling the UI when Keypad appears on screen. Later I found out that it is pretty simple enough, I just have to use one single widget.

SingleChildScrollView()

Below is entire gist code

Linked list implementation in Swift

Nasir Ahmed Momin — Sun, 19 Jan 2020 05:01:46 +0000

Linked list according to Wikipedia:
It's a linear collection of data elements, whose order is not given by their physical placement in memory. Instead, each element points to the next. It is a data structure consisting of a collection of nodes that together represent a sequence.

Types of a linked list.

Singly.
Doubly.
Circular.
And many more.

Operations that we are going to perform.

Add a node from left/right.
Remove Node from left/right.
Size of the list.
Search data in the list.

Here we 'll see only a Singly list.

Let's define the structure for List

struct Node<T> {
   var data: T?
   var next: Node<T>?

   init(_ data: T) {
       self.data = data
   }
}

As soon as to define this structure, you 'll hit with compilation error.

Due to the nature of struct this issue obvious, as the compiler must know the size of struct in compile time. In this case, struct refers to itself which means there no definite size.
To resolve it, just change from struct (value type) to class (reference type).

class Node<T>{

Here we are using a generic type called <T> so that we can hold any type of data in the list.

Define an enum as direction for node manipulation.

enum ListDirection {
    case left
    case right
}

Define a structure for SinglyLinkedList & functions to implement as shown below.

struct SinglyLinkedList {

    // If nil, then there is NO node in list sequence.
    var firstNode: Node<T>?

    // Adds data/Item by creating node from specified direction.
    mutating func add(anItem item: T, from d: ListDirection) { }

    // Remove item from from specified direction.
    mutating func remove(from d: ListDirection) -> Node<T>? { }

    // fetch number of nodes available in linked list
    func getListSize() -> Int? { }

    // Search for item/data existance in list, returns true or false
    func search(anItem item: T?) -> Bool { }

    // Displays content of list
    func showListContent() { }
}

Let's start the implementation of those function, the explanation will be available inline.

add(anItem:from:) function

// Adds data/Item by creating node from a specified direction.
mutating func add(anItem item: T, from d: ListDirection) {

    // Create node by supplied data, to be added in list
    let newNode = Node<T>(item)

    // Validation check for node list does NOT exist, if true then, make new node as firstNode
    if firstNode == nil {
        self.firstNode = newNode
    }
    else {

        // Obtain firstNode reference.
        var tempNode = self.firstNode

        if d == .left { // Validation check for data insertion from Left side.
            // Make tempNode as next sequence for newly created node.
            newNode.next = tempNode

            // Make newNode as first node, so that new data empbed on left side.
            self.firstNode = newNode

        }
        else if d == .right { // Validation check for data insertion from Right side.

            // Note that the first node is never manipulated in this clause.
            // Traverse till it reaches nil
            while tempNode?.next != nil {
                tempNode = tempNode?.next
            }

            // Then insert new node from right side.
            tempNode?.next = newNode
        }
    }
}

Now create an instance of a singly linked list & start adding items in it.

var ll = SinglyLinkedList<Int>()
ll.add(anItem: 10, from: .left)
ll.add(anItem: 20, from: .right)
ll.add(anItem: 30, from: .left)
ll.add(anItem: 40, from: .left)
ll.add(anItem: 50, from: .right)
ll.add(anItem: 60, from: .right)

Once we added items there is no way we can see it in action, for that we required a showListContent() function. Below is the implementation of it.

// Displays content of list
func showListContent() {

    // Visible string to display sequence of data in list
    var visibleNodeSequence: String = ""

    var tempNode = self.firstNode

    // Travese till reaches end of list
    while tempNode != nil {

        if let str = tempNode?.data {
            visibleNodeSequence.append(contentsOf: String(describing:str))
            visibleNodeSequence.append(contentsOf:  tempNode?.next != nil ? " -> " : "")
        }

        // Incrementing by pointing to next node
        tempNode = tempNode?.next
    }

    print(visibleNodeSequence)
}

// Display content of list
ll.showListContent()

On console, you can see output like this.

remove(from:) -> Node<T>? function

// Remove item from from specified direction.
mutating func remove(from d: ListDirection) -> Node<T>? {

    var nodeToBeRemoved: Node<T>?

    // return nil, incase of NO sequence exist
    if self.firstNode == nil {
        return nil
    }

    var nextNode = self.firstNode

    if d == .left {
        // Makes sure firstNode's next node becomes firstNode. so that firstNode from left side can be removed.
        self.firstNode = nextNode?.next
        nodeToBeRemoved = nextNode
    }
    else if d == .right {
        // Maintains a previous node, so that connection for node to be removed is deleted.
        var prevnode: Node<T>? = self.firstNode

        // Traverse till it reaches nil node
        while nextNode?.next != nil {
            // Both points to same node, then next node is incremented to point to next of next
            prevnode = nextNode
            nextNode = nextNode?.next
        }

        // Connection deleting for node to be removed
        prevnode?.next = nil
        nodeToBeRemoved = nextNode
    }

    return nodeToBeRemoved
}

getListSize()->Int? function

// fetch number of nodes available in linked list
func getListSize() -> Int? {

    // Validation check for first node is nil.
    guard firstNode != nil else { return nil }

    var tempNode = firstNode

    // Maintian a counter to loop
    var noOfNodes = 0

    // Traverse till it reaches nil node
    while tempNode != nil {
        // If not nil then increment counter
        noOfNodes += 1
        // Increment node by pointing to next node
        tempNode = tempNode?.next
    }

    return noOfNodes
}

// Get size of linked list
ll.getListSize()

search(anItem:) -> Bool function

// Search for item/data existance in list, returns true or false
func search(anItem item: T?) -> Bool {

    guard firstNode != nil else { return false }

    var tempNode = self.firstNode

    while tempNode != nil {

        if tempNode?.data == item {
            // Once item exist return true.
            return true
        }

        // Increment node by pointing to next node
        tempNode = tempNode?.next
    }

    return false
}

// Searches item 40 in list
ll.search(anItem: 40)

iOS Chat App with XMPP framework

Nasir Ahmed Momin — Sat, 21 Dec 2019 07:50:52 +0000

Wants to build Chat App for iOS?

Lets gets started
XMPP stands for Xtensible Messaging & Presence Protocol.

Things required ?

IM Server (I prefer MongooseIM)
User (Account created)

You can download MongooseIM Package here & Install package
https://www.erlang-solutions.com/resources/download.html

Details for installation can be found here https://mongooseim.readthedocs.io/en/latest/user-guide/Getting-started/

On installation completes launch Terminal & execute following command
$ mongooseimctl start

then Check status
$ mongooseimctl status

When All thats done. You need a user, head down below & create user

$ mongooseimctl register <user> <host> <password>

Eg: $ mongooseimctl register user1 localhost qwerty

You can verify user creation $ mongooseimctl registered_users localhost

Till now server config & user creation completed.

Before jumping into code part, lets understand following things

JID
Stanza & its type.
Stream.
1. JID: is something by which each individual is uniquely identified is XMPP. It does looks like this username@hostname/resource username: is local part hostname: is domain part resource: is resource part which is optional in many cases
2. Stanza: is name of XML tag/piece that sends & received. Basic Stanza's are < message > < presence > & < iq >, details will be mentioned about them, if required in future
3. Stream: is entry point for interprocess communication to start on shared file called Socket, which happens by < stream > tag.

We shall start working on iOS App.
I hope you guys knows how to create Xcode iOS Project & Pod setup.

In Podfile pod 'XMPPFramework'
then run pod install

Create XMPPController.swift file & make a singleton object.

class XMPPController: NSObject {
    static let sharedInstance = XMPPController()
}

Now declare an XMPPStream instance & intilize it in init()

var stream: XMPPStream?
override init() {
  self.stream = XMPPStream()
  super.init()
}

Also declare following vars.

var hostName: String?
var userJID: XMPPJID?
var hostPort: UInt16?
var password: String?

Declare a connect function as below

func connect(withHostName name: String, userJID jid: String, hostPort port: UInt16, password pwd: String) {

    guard let uJID = XMPPJID(string: jid) else {
        return
    } 

    hostName    = name
    userJID     = uJID
    hostPort    = port
    password    = pwd

    // Stream Configuration
    stream?.hostName = name
    stream?.myJID = uJID
    stream?.hostPort = port
    stream?.startTLSPolicy = .allowed

    if stream!.isDisconnected {
        do {
            try stream?.connect(withTimeout: 10)
        }
        catch let e {
            print(e.localizedDescription)
        }
    }
}

Once we reached till here, we have forgot most important thing.
without confirming delegate of stream our XMPPController wont able to receive any callbacks, add following lines in init

self.stream?.addDelegate(self, delegateQueue: DispatchQueue.main)

XMPPStreamDelegate as set of delegate functions among them we will use only couple of, add following code as below

extension XMPPController: XMPPStreamDelegate {
    func xmppStreamDidConnect(_ sender: XMPPStream) {
       print("Stream Connected")
       try! stream?.authenticate(withPassword: password!)
    }

    func xmppStreamDidAuthenticate(_ sender: XMPPStream) {
       print("Stream: Authnticated")
       stream?.send(XMPPPresence())
    }
}

Once xmppStreamDidConnect(:XMPPStream) is connected, we are making sure that authentication should initiate & on authentication xmppStreamDidAuthenticate(:XMPPStream) will receive callback

Entire code is available on github repo
https://github.com/momin96/Mobile-Chat-App