Remove Duplicate – Kotlin Solution

Problem

Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well.

Example 1:

Input: head = [1,1,2]
Output: [1,2]

Example 2:

Input: head = [1,1,2,3,3]
Output: [1,2,3]


Solution- Kotlin

fun main(args:Array<String>){
    var node1=ListNode(1)
    var node2=ListNode(1)
    var node3=ListNode(2)
//    var node4=ListNode(3)
//    var node5=ListNode(3)
//    node4.next=node5
//    node3.next=node4
    node2.next=node3
    node1.next=node2
    var result = deleteDuplicates(node1)
}



// * Example:
var li = ListNode(5)
var v = li.`val`
//  Definition for singly-linked list.
class ListNode(var `val`: Int) {
    var next: ListNode? = null
}


fun deleteDuplicates(head: ListNode?): ListNode? {

    if (head?.`val`==null) return head

    var result=ListNode(head.`val`)
    var dummy:ListNode=result
    var headNode=head

    while (headNode!=null){
        if(dummy.`val`!=headNode.`val` ){
            dummy.next= ListNode(headNode.`val`)
            dummy=dummy.next!!
        }
        headNode=headNode.next


    }
    return result
}

Square root of x -Sqrt(x) – Kotlin

Problem

Given a non-negative integer x, compute and return the square root of x.

Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.

Note: You are not allowed to use any built-in exponent function or operator, such as pow(x, 0.5) or x ** 0.5.

Example 1:

Input: x = 4
Output: 2

Example 2:

Input: x = 8
Output: 2
Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.

Solution- Kotlin

fun main(args:Array<String>){

        var result = mySqrt(2000000000)
        printResult("Square Root of 2000000000", result.toString())
}


//Using Binary Search
fun mySqrt(x: Int): Int {
    var ans=0
    if(x!=0){
        var start:Long=0
        var end:Long=x.toLong()
        while (start<=end){
            var mid:Long=(start+end)/2

            if(mid*mid<x){
                start=mid+1
                ans=mid.toInt()

            }else if(mid*mid>x){
                end=mid-1
            }else{
                ans=mid.toInt()
                break

            }
        }
    }
    return ans
}

CupertinoActivityIndicator – iOS Styling-Flutter

CupertinoActivityIndicator is the iOS(Cupertino) version of the material circular progress indicator. It animates in a clockwise circle. Flutter possesses in its store a widget to perform this task with ease & perfection Using CupertinoActivityIndicator.

It will look like


Code

CupertinoActivityIndicator(
          animating: true,
          radius: 22,
        ),

Thanks for reading !!


Image Picker In Flutter

Installation

First, add image_picker_gallery_camera as a dependency in your pubspec.yaml file.

dependencies:
  image_picker_gallery_camera: ^0.1.4

Install it

You can install packages from the command line:

with Flutter:


$ flutter pub get

Alternatively, your editor might support flutter pub get.

Now Copy and paste the following example code.

import 'dart:io';

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

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

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Example Image Picker',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Example Image Picker'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key key, this.title}) : super(key: key);
  final String title;

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

class _MyHomePageState extends State<MyHomePage> {
  File _image;

  Future getImage(ImgSource source) async {
    var image = await ImagePickerGC.pickImage(
        context: context,
        source: source,
        cameraIcon: Icon(
          Icons.add,
          color: Colors.red,
        ),//cameraIcon and galleryIcon can change. If no icon provided default icon will be present
    );
    setState(() {
      _image = image;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: SingleChildScrollView(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Container(
                width: 300,
                child: RaisedButton(
                  onPressed: () => getImage(ImgSource.Gallery),
                  color: Colors.blue,
                  child: Text(
                    "From Gallery".toUpperCase(),
                    style: TextStyle(color: Colors.white),
                  ),
                ),
              ),
              Container(
                width: 300,
                child: RaisedButton(
                  onPressed: () => getImage(ImgSource.Camera),
                  color: Colors.deepPurple,
                  child: Text(
                    "From Camera".toUpperCase(),
                    style: TextStyle(color: Colors.white),
                  ),
                ),
              ),
              Container(
                width: 300,
                child: RaisedButton(
                  onPressed: () => getImage(ImgSource.Both),
                  color: Colors.red,
                  child: Text(
                    "Both".toUpperCase(),
                    style: TextStyle(color: Colors.white),
                  ),
                ),
              ),
              _image != null ? Image.file(_image) : Container(),
            ],
          ),
        ),
      ),
    );
  }
}

That’s it!! Please Find the source code Here

Simple SharedPreference Functions – Kotlin

Android provides many ways of storing data of an application. One of these ways is called Shared Preferences. Shared Preferences allow you to save and retrieve data in the form of key, value pair.

Here I share a simple custom SharedPreferences.kt class that can be used for every Android application if needed.

import android.content.Context
import android.content.SharedPreferences
import com.securepreferences.SecurePreferences

/**
 * Created by Sayandh-Kolincodes on 10/05/2018.
 */

class SharedPreference(val context: Context) {
    private val PREFS_NAME = "your_app_preference_name"

    private val sharedPref: SharedPreferences =
        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)

    fun save(KEY_NAME: String, text: String) {

        val editor: SharedPreferences.Editor = sharedPref.edit()

        editor.putString(KEY_NAME, text)

        editor.commit()
    }

    fun save(KEY_NAME: String, value: Int) {
        val editor: SharedPreferences.Editor = sharedPref.edit()

        editor.putInt(KEY_NAME, value)

        editor.commit()
    }

    fun save(KEY_NAME: String, status: Boolean) {

        val editor: SharedPreferences.Editor = sharedPref.edit()

        editor.putBoolean(KEY_NAME, status)

        editor.commit()
    }

    fun getValueString(KEY_NAME: String): String? {

        return sharedPref.getString(KEY_NAME, null)


    }

    fun getValueInt(KEY_NAME: String): Int {

        return sharedPref.getInt(KEY_NAME, 0)
    }

    fun getValueBoolien(KEY_NAME: String, defaultValue: Boolean): Boolean {

        return sharedPref.getBoolean(KEY_NAME, defaultValue)

    }

    fun clearSharedPreference() {

        val editor: SharedPreferences.Editor = sharedPref.edit()

        //sharedPref = PreferenceManager.getDefaultSharedPreferences(context);

        editor.clear()
        editor.commit()
    }

    fun removeValue(KEY_NAME: String) {

        val editor: SharedPreferences.Editor = sharedPref.edit()

        editor.remove(KEY_NAME)
        editor.commit()
    }

}

You can find the Github repo for this class here

Room Database with Kotlin

Room is a persistence library, part of the Android Jetpack.
The Room is now considered as a better approach for data storing than SQLiteDatabase.
The Room persistence library provides an abstraction layer over SQLite to allow for more robust database access while harnessing the full power of SQLite.

Why Room?

  • Compile-time verification of SQL queries.
  • You need to use lots of boilerplate code to convert between SQL queries and Java/Kotlin data objects. But, Room maps our database objects to Java Object without boilerplate code.
  • Room is built to work with Live data and RxJava

Room has 3 main components

  1. Entity: Represents table within the database. We can create a table in room database using @Entity annotation
  2. Dao: Contains all the methods used for accessing data from the database.
  3. Database: Contains the database holder and serves as the main access point for the underlying connection to your app’s persisted, relational data.

Implementation

To add Room database add the below lines into your app-level build.gradle file

implementation "androidx.room:room-runtime:2.2.4"
kapt "androidx.room:room-compiler:2.2.4"
implementation "androidx.room:room-ktx:2.2.4"

Don’t forget to add apply plugin: ‘kotlin-kapt’ in top your app-level build.gradle file

Creating Model Class

Room creates a table for each model class annotated with @Entity, the fields in the class correspond to a column in the table. Therefore each entity class tends to be a small model class contains no logic.

We are going to create a small class User represents a model for the data in the database.

Create a model class as shown below.

package com.kotlincodes.roomdatabasekotlin.model

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "users")
data class UserModel (
    @PrimaryKey(autoGenerate = true)
    var id:Int,
    var name:String,
    var mobile:String,
    var age:Int
)

Creating DAOs (Data Access Object)

DAOs contain all methods that are used to access data from database.

To create a DAO we need to create an interface annotated with @Dao

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
import androidx.room.Update
import com.kotlincodes.roomdatabasekotlin.model.UserModel

@Dao
interface UserDao {

    @Insert
    fun insert(user:UserModel)

    @Update
    fun update(user:UserModel)

    @Update
    fun delete(user:UserModel)

    @Query("SELECT * FROM USERS")
    fun getAllUsers():List<UserModel>

    @Query("SELECT * FROM USERS WHERE id==:id")
    fun getUserWithId(id:Int):UserModel
}

Creating Database

To create a database we need to define an abstract class that extends RoomDatabase. This class is annotated with @Database, lists the entities contained in the database, and the DAOs which access them.

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.kotlincodes.roomdatabasekotlin.model.UserModel


@Database(entities = [UserModel::class], version =1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun users():UserDao


    companion object {
        private var INSTANCE: AppDatabase? = null
        fun getAppDatabase(context: Context): AppDatabase? {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java, "room-kotlin-database"
                ).build()
            }
            return INSTANCE
        }

        fun destroyInstance() {
            INSTANCE = null
        }
    }
}

Now we are ready to access the database using Room.

Make sure that you are not performing any database operations on the main thread. We need to execute all database operations in a separate thread otherwise the application will crash.

Initialize

val locaDb= AppDatabase.getAppDatabase(this)!!

Insert

locaDb.users().insert(user)

Update

locaDb.users().update(user)

Delete

locaDb.users().update(user)

That’s it!! I have created a repo with a small project with Room database operations Here

Bluetooth Printer In Android

1 Open Android Studio.
 2 Go to File => New => New Project. Write application name . Then, check Include Kotlin Support and click next button.
 3Select minimum SDK you need. However, we have selected 17 as minimum SDK. Then, click next button
 4 Then, select Empty Activity => click next => click finish.
 5 You will get a newly created project successfully if you have followed steps properly.




Main.java

        import java.io.IOException;
        import java.io.OutputStream;
        import java.nio.ByteBuffer;
        import java.util.Set;
        import java.util.UUID;

        import android.app.Activity;
        import android.app.ProgressDialog;
        import android.bluetooth.BluetoothAdapter;
        import android.bluetooth.BluetoothDevice;
        import android.bluetooth.BluetoothSocket;
        import android.content.Intent;
        import android.os.Bundle;
        import android.os.Handler;
        import android.os.Message;
        import android.util.Log;
        import android.view.View;
        import android.view.Window;
        import android.view.WindowManager;
        import android.widget.Button;
        import android.widget.Toast;

        public class Main extends Activity implements Runnable {
            protected static final String TAG = "TAG";
            private static final int REQUEST_CONNECT_DEVICE = 1;
            private static final int REQUEST_ENABLE_BT = 2;
            Button mScan, mPrint, mDisc;
            BluetoothAdapter mBluetoothAdapter;
            private UUID applicationUUID = UUID
                    .fromString("00001101-0000-1000-8000-00805F9B34FB");
            private ProgressDialog mBluetoothConnectProgressDialog;
            private BluetoothSocket mBluetoothSocket;
            BluetoothDevice mBluetoothDevice;

            @Override
            public void onCreate(Bundle mSavedInstanceState) {
                super.onCreate(mSavedInstanceState);
                requestWindowFeature(Window.FEATURE_NO_TITLE);
                getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                        WindowManager.LayoutParams.FLAG_FULLSCREEN);
                setContentView(R.layout.main);
                mScan = (Button) findViewById(R.id.Scan);
                mScan.setOnClickListener(new View.OnClickListener() {
                    public void onClick(View mView) {
                        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
                        if (mBluetoothAdapter == null) {
                            Toast.makeText(Main.this, "Message1", 2000).show();
                        } else {
                            if (!mBluetoothAdapter.isEnabled()) {
                                Intent enableBtIntent = new Intent(
                                        BluetoothAdapter.ACTION_REQUEST_ENABLE);
                                startActivityForResult(enableBtIntent,
                                        REQUEST_ENABLE_BT);
                            } else {
                                ListPairedDevices();
                                Intent connectIntent = new Intent(Main.this,
                                        DeviceListActivity.class);
                                startActivityForResult(connectIntent,
                                        REQUEST_CONNECT_DEVICE);
                            }
                        }
                    }
                });

                mPrint = (Button) findViewById(R.id.mPrint);
                mPrint.setOnClickListener(new View.OnClickListener() {
                    public void onClick(View mView) {
                        Thread t = new Thread() {
                            public void run() {
                                try {
                                    OutputStream os = mBluetoothSocket
                                            .getOutputStream();
                                    String BILL = "";

                                    BILL = "\nInvoice No: 00000000000000000 " + "    "
                                            + "04-08-2011\n";
                                    BILL = BILL
                                            + "-----------------------------------------";
                                    BILL = BILL + "\n\n";
                                    BILL = BILL + "Total Qty:" + "      " + "1.0\n";
                                    BILL = BILL + "Total Value:" + "     "
                                            + "80000.0\n";
                                    BILL = BILL
                                            + "-----------------------------------------\n";
                                    os.write(BILL.getBytes());
                                        //This is printer specific code you can comment ==== > Start

                                    // Setting height
                                    int gs = 29;
                                    os.write(intToByteArray(gs));
                                    int h = 104;
                                    os.write(intToByteArray(h));
                                    int n = 162;
                                    os.write(intToByteArray(n));

                                    // Setting Width
                                    int gs_width = 29;
                                    os.write(intToByteArray(gs_width));
                                    int w = 119;
                                    os.write(intToByteArray(w));
                                    int n_width = 2;
                                    os.write(intToByteArray(n_width));

                                    // Print BarCode
                                    int gs1 = 29;
                                    os.write(intToByteArray(gs1));
                                    int k = 107;
                                    os.write(intToByteArray(k));
                                    int m = 73;
                                    os.write(intToByteArray(m));

                                    String barCodeVal = "ASDFC028060000005";// "HELLO12345678912345012";
                                    System.out.println("Barcode Length : "
                                            + barCodeVal.length());
                                    int n1 = barCodeVal.length();
                                    os.write(intToByteArray(n1));

                                    for (int i = 0; i < barCodeVal.length(); i++) {
                                        os.write((barCodeVal.charAt(i) + "").getBytes());
                                    }
       //printer specific code you can comment ==== > End
                                } catch (Exception e) {
                                    Log.e("Main", "Exe ", e);
                                }
                            }
                        };
                        t.start();
                    }
                });

                mDisc = (Button) findViewById(R.id.dis);
                mDisc.setOnClickListener(new View.OnClickListener() {
                    public void onClick(View mView) {
                        if (mBluetoothAdapter != null)
                            mBluetoothAdapter.disable();
                    }
                });

            }// onCreate

            @Override
            protected void onDestroy() {
                // TODO Auto-generated method stub
                super.onDestroy();
                try {
                    if (mBluetoothSocket != null)
                        mBluetoothSocket.close();
                } catch (Exception e) {
                    Log.e("Tag", "Exe ", e);
                }
            }

            @Override
            public void onBackPressed() {
                try {
                    if (mBluetoothSocket != null)
                        mBluetoothSocket.close();
                } catch (Exception e) {
                    Log.e("Tag", "Exe ", e);
                }
                setResult(RESULT_CANCELED);
                finish();
            }

            public void onActivityResult(int mRequestCode, int mResultCode,
                    Intent mDataIntent) {
                super.onActivityResult(mRequestCode, mResultCode, mDataIntent);

                switch (mRequestCode) {
                case REQUEST_CONNECT_DEVICE:
                    if (mResultCode == Activity.RESULT_OK) {
                        Bundle mExtra = mDataIntent.getExtras();
                        String mDeviceAddress = mExtra.getString("DeviceAddress");
                        Log.v(TAG, "Coming incoming address " + mDeviceAddress);
                        mBluetoothDevice = mBluetoothAdapter
                                .getRemoteDevice(mDeviceAddress);
                        mBluetoothConnectProgressDialog = ProgressDialog.show(this,
                                "Connecting...", mBluetoothDevice.getName() + " : "
                                        + mBluetoothDevice.getAddress(), true, false);
                        Thread mBlutoothConnectThread = new Thread(this);
                        mBlutoothConnectThread.start();
                        // pairToDevice(mBluetoothDevice); This method is replaced by
                        // progress dialog with thread
                    }
                    break;

                case REQUEST_ENABLE_BT:
                    if (mResultCode == Activity.RESULT_OK) {
                        ListPairedDevices();
                        Intent connectIntent = new Intent(Main.this,
                                DeviceListActivity.class);
                        startActivityForResult(connectIntent, REQUEST_CONNECT_DEVICE);
                    } else {
                        Toast.makeText(Main.this, "Message", 2000).show();
                    }
                    break;
                }
            }

            private void ListPairedDevices() {
                Set<BluetoothDevice> mPairedDevices = mBluetoothAdapter
                        .getBondedDevices();
                if (mPairedDevices.size() > 0) {
                    for (BluetoothDevice mDevice : mPairedDevices) {
                        Log.v(TAG, "PairedDevices: " + mDevice.getName() + "  "
                                + mDevice.getAddress());
                    }
                }
            }

            public void run() {
                try {
                    mBluetoothSocket = mBluetoothDevice
                            .createRfcommSocketToServiceRecord(applicationUUID);
                    mBluetoothAdapter.cancelDiscovery();
                    mBluetoothSocket.connect();
                    mHandler.sendEmptyMessage(0);
                } catch (IOException eConnectException) {
                    Log.d(TAG, "CouldNotConnectToSocket", eConnectException);
                    closeSocket(mBluetoothSocket);
                    return;
                }
            }

            private void closeSocket(BluetoothSocket nOpenSocket) {
                try {
                    nOpenSocket.close();
                    Log.d(TAG, "SocketClosed");
                } catch (IOException ex) {
                    Log.d(TAG, "CouldNotCloseSocket");
                }
            }

            private Handler mHandler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    mBluetoothConnectProgressDialog.dismiss();
                    Toast.makeText(Main.this, "DeviceConnected", 5000).show();
                }
            };

            public static byte intToByteArray(int value) {
                byte[] b = ByteBuffer.allocate(4).putInt(value).array();

                for (int k = 0; k < b.length; k++) {
                    System.out.println("Selva  [" + k + "] = " + "0x"
                            + UnicodeFormatter.byteToHex(b[k]));
                }

                return b[3];
            }

            public byte[] sel(int val) {
                ByteBuffer buffer = ByteBuffer.allocate(2);
                buffer.putInt(val);
                buffer.flip();
                return buffer.array();
            }

        }

UnicodeFormatter.java

  import java.io.*;

    public class UnicodeFormatter {

        static public String byteToHex(byte b) {
                // Returns hex String representation of byte b
                char hexDigit[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                        'a', 'b', 'c', 'd', 'e', 'f' };
                char[] array = { hexDigit[(b >> 4) & 0x0f], hexDigit[b & 0x0f] };
                return new String(array);
        }

        static public String charToHex(char c) {
                // Returns hex String representation of char c
                byte hi = (byte) (c >>> 8);
                byte lo = (byte) (c & 0xff);
                return byteToHex(hi) + byteToHex(lo);
        }

    } // class

DeviceListActivity.java

 import java.util.Set; 
          import android.app.Activity; 
          import android.bluetooth.BluetoothAdapter; 
          import android.bluetooth.BluetoothDevice; 
          import android.content.Intent; 
          import android.os.Bundle; 
          import android.util.Log; 
          import android.view.View; 
          import android.view.Window; 
          import android.widget.AdapterView; 
          import android.widget.ArrayAdapter; 
          import android.widget.ListView; 
          import android.widget.TextView; 
          import android.widget.AdapterView.OnItemClickListener; 

    public class DeviceListActivity extends Activity 
    { 
    protected static final String TAG = "TAG"; 
    private BluetoothAdapter mBluetoothAdapter; 
    private ArrayAdapter<String> mPairedDevicesArrayAdapter; 

    @Override 
    protected void onCreate(Bundle mSavedInstanceState) 
    { 
        super.onCreate(mSavedInstanceState); 
        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS); 
        setContentView(R.layout.device_list); 

        setResult(Activity.RESULT_CANCELED); 
        mPairedDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name); 

        ListView mPairedListView = (ListView) findViewById(R.id.paired_devices); 
        mPairedListView.setAdapter(mPairedDevicesArrayAdapter); 
        mPairedListView.setOnItemClickListener(mDeviceClickListener); 

        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); 
        Set<BluetoothDevice> mPairedDevices = mBluetoothAdapter.getBondedDevices(); 

        if (mPairedDevices.size() > 0) 
        { 
            findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE); 
            for (BluetoothDevice mDevice : mPairedDevices) 
            { 
                mPairedDevicesArrayAdapter.add(mDevice.getName() + "\n" + mDevice.getAddress()); 
            } 
        } 
        else 
        { 
            String mNoDevices = "None Paired";//getResources().getText(R.string.none_paired).toString(); 
            mPairedDevicesArrayAdapter.add(mNoDevices); 
        } 
    } 

    @Override 
    protected void onDestroy() 
    { 
        super.onDestroy(); 
        if (mBluetoothAdapter != null) 
        { 
            mBluetoothAdapter.cancelDiscovery(); 
        } 
    } 

    private OnItemClickListener mDeviceClickListener = new OnItemClickListener() 
    { 
        public void onItemClick(AdapterView<?> mAdapterView, View mView, int mPosition, long mLong) 
        { 
            mBluetoothAdapter.cancelDiscovery(); 
            String mDeviceInfo = ((TextView) mView).getText().toString(); 
            String mDeviceAddress = mDeviceInfo.substring(mDeviceInfo.length() - 17); 
            Log.v(TAG, "Device_Address " + mDeviceAddress); 

            Bundle mBundle = new Bundle(); 
            mBundle.putString("DeviceAddress", mDeviceAddress); 
            Intent mBackIntent = new Intent(); 
            mBackIntent.putExtras(mBundle); 
            setResult(Activity.RESULT_OK, mBackIntent); 
            finish(); 
        } 
    }; 

     } 

main.xml

<?xml version="1.0" encoding="utf-8"?>
        <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent">
        <TextView android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />
        <Button android:text="Scan" 
        android:id="@+id/Scan"
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content"></Button>
        <Button android:text="Print"
        android:id="@+id/mPrint"
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content"></Button>
        <Button android:text="Dissable"
        android:id="@+id/dis"
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content"></Button>
        </LinearLayout>

device_name.xml

 <?xml version="1.0" encoding="utf-8"?> 
    <TextView xmlns:android="http://schemas.android.com/apk/res/android" 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:textSize="18sp"
    android:padding="5dip" /> 

device_list.xml

    <?xml version="1.0" encoding="utf-8"?> 
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
    android:orientation="vertical"
    android:layout_width="fill_parent" 
    android:layout_height="fill_parent"> 
    <TextView android:id="@+id/title_paired_devices" 
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" 
    android:text="My Text"
    android:visibility="gone" 
    android:background="#666" 
    android:textColor="#fff" 
    android:paddingLeft="5dip" /> 
    <ListView android:id="@+id/paired_devices" 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:stackFromBottom="true" 
    android:layout_weight="1" /> 
    </LinearLayout>

Manifest


  <uses-permission android:name="android.permission.BLUETOOTH" />
  <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

Edittext Text ChangeListener Kotlin

Action whenever the text is changed in the EditText View.

Application to implement a listener
TextWatcher object, for EditText to trigger an action on text change.

Create a new Project in Kotlin

Message can display outside of our application normal UI

1 Open Android Studio.
2 Go to File => New => New Project. Write application name . Then, check Include Kotlin Support and click next button.
3Select minimum SDK you need. However, we have selected 17 as minimum SDK. Then, click next button
4 Then, select Empty Activity => click next => click finish.
5 You will get a newly created project successfully if you have followed steps properly.

Use the below code to Implement a Edittext with Kotlin

MainActivity.kt

import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.text.Editable
import android.text.TextWatcher
import kotlinx.android.synthetic.main.activity_main.*

class MainActivity : AppCompatActivity() {

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

        editTextSample.addTextChangedListener(object : TextWatcher {

            override fun afterTextChanged(s: Editable) {}

            override fun beforeTextChanged(s: CharSequence, start: Int,
                                           count: Int, after: Int) {
            }

            override fun onTextChanged(s: CharSequence, start: Int,
                                       before: Int, count: Int) {
                tvSample.setText("Text is : "+s)
            }
        })
    }
}


main_activity.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"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      tools:context=".MainActivity">

    <LinearLayout
            android:layout_marginTop="20dp"
            android:orientation="vertical"
            android:padding="10sp"
            android:gravity="center_horizontal"
            android:layout_width="match_parent"
            android:layout_height="match_parent">
            android:layout_height="wrap_content" />

        <EditText
                android:id="@+id/editTextSample"
                android:textSize="20sp"
                android:layout_marginTop="50dp"
                android:hint="Enter Text ..."
                android:layout_width="match_parent"
                android:layout_height="wrap_content"/>



        <TextView
                android:id="@+id/tvSample"
                android:layout_marginTop="20dp"
                android:textColor="@color/colorPrimary"
                android:textStyle="bold"
                android:textSize="16dp"
                android:layout_width="wrap_content"
                  android:layout_height="wrap_content"/>

    </LinearLayout>

</android.support.constraint.ConstraintLayout>

Notifications in Kotlin Oreo (8+)

Create a new Project in Kotlin

Message can display outside of our application normal UI

1 Open Android Studio.
2 Go to File => New => New Project. Write application name . Then, check Include Kotlin Support and click next button.
3Select minimum SDK you need. However, we have selected 17 as minimum SDK. Then, click next button
4 Then, select Empty Activity => click next => click finish.
5 You will get a newly created project successfully if you have followed steps properly.

added line in the build.gradle (Module: app) dependencies:

implementation 'com.android.support:appcompat-v7:26.1.0'

Use the below code to Implement a Notification with Kotlin

 MainActivity.k
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.*
import kotlinx.android.synthetic.main.activity_main.*
import android.widget.RadioGroup
import android.widget.Toast
import android.app.NotificationManager
import android.support.v4.app.NotificationCompat
import android.os.Build
import android.app.NotificationChannel
import android.content.Context
import android.support.annotation.RequiresApi
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
   val button:Button=findViewById(R.id.button);
        button.setOnClickListener()

        {

            issueNotification()

        }
    }


    @RequiresApi(api = Build.VERSION_CODES.O)
    fun makeNotificationChannel(id: String, name: String, importance: Int) {
        val channel = NotificationChannel(id, name, importance)
        channel.setShowBadge(true) // set false to disable badges, Oreo exclusive

        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        notificationManager.createNotificationChannel(channel)
    }


    fun issueNotification() {

        // make the channel. The method has been discussed before.
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            makeNotificationChannel("CHANNEL_1", "Example channel", NotificationManager.IMPORTANCE_DEFAULT)
        }
        // the check ensures that the channel will only be made
        // if the device is running Android 8+

        val notification = NotificationCompat.Builder(this, "CHANNEL_1")
        // the second parameter is the channel id.
        // it should be the same as passed to the makeNotificationChannel() method

        notification
            .setSmallIcon(R.mipmap.ic_launcher) // can use any other icon
            .setContentTitle("Notification!")
            .setContentText("This is an Oreo notification!")
            .setNumber(3) // this shows a number in the notification dots

        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        notificationManager.notify(1, notification.build())
        // it is better to not use 0 as notification id, so used 1.
    }


}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/root_layout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
 <Button

            android:id="@+id/button"
            android:layout_gravity="center"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="15dp"
            android:text="click"
    />
</LinearLayout>