shaon, Author at Coding Hunt

Implement SqLite Db in your iOS app

April 10, 2020April 10, 2020shaonLeave a comment

Add this in your App Delegate

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        // Initializing db
        _ = DB.shared
        
        return true
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

// Initializing db

_ = DB.shared

return true

}

func applicationWillResignActive(_ application: UIApplication) {
        _ =  DB.shared.closeDB()
}

func applicationWillResignActive(_ application: UIApplication) {

_ = DB.shared.closeDB()

}

//
//  DatabaseManager.swift
//  SalahAndDua
//
//  Created by Ashiq on 9/4/20.
//  Copyright © 2020 LastBlade. All rights reserved.
//

import Foundation
import SQLite3

class DB {
    // Singleton Instance
    static var shared = DB()
    
    private let dbPath = "mydb.sqlite"
    
    private var op : OpaquePointer?
    
    private let calendarTableName = "calendar"
    
    // Calendar table columns
    private let KEY_ID = "_id"
    private let KEY_FAJR = "fajr"
    private let KEY_DHUHR = "dhuhr"
    private let KEY_ASR = "asr"
    private let KEY_MAGHRIB = "maghrib"
    private let KEY_ISHA = "isha"
    private let KEY_SUNRISE = "sunrise"
    private let KEY_SUNSET = "sunset"
    private let KEY_IMASK = "imask"
    private let KEY_MIDNIGHT = "midnight"
    private let KEY_TODAY_DATE_ENGLISH = "today_date_english"
    private let KEY_TODAY_DATE_HIJRI = "today_date_hijri"
    
    init() {
        op = openDatabase()
        createCalendarTable()
    }
    
    private func openDatabase() -> OpaquePointer?
    {
        let fileURL = try! FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
            .appendingPathComponent(dbPath)
        var db: OpaquePointer? = nil
        if sqlite3_open(fileURL.path, &db) != SQLITE_OK {
            print("error opening database")
            return nil
        }
        else {
            print("Successfully opened connection to database at \(dbPath)")
            return db
        }
    }
    
    func createCalendarTable() {
        let createTableString = """
        CREATE TABLE IF NOT EXISTS \(calendarTableName) (
        \(KEY_ID) INTEGER PRIMARY KEY AUTOINCREMENT,
        \(KEY_FAJR) TEXT,
        \(KEY_DHUHR) TEXT,
        \(KEY_ASR) TEXT,
        \(KEY_MAGHRIB) TEXT,
        \(KEY_ISHA) TEXT,
        \(KEY_SUNRISE) TEXT,
        \(KEY_SUNSET) TEXT,
        \(KEY_IMASK) TEXT,
        \(KEY_MIDNIGHT) TEXT,
        \(KEY_TODAY_DATE_ENGLISH) TEXT,
        \(KEY_TODAY_DATE_HIJRI) TEXT
        );
        """
        var createTableStatement: OpaquePointer? = nil
        
        if sqlite3_prepare_v2(op, createTableString, -1, &createTableStatement, nil) == SQLITE_OK
        {
            if sqlite3_step(createTableStatement) == SQLITE_DONE
            {
                print("calendar table created.")
            } else {
                print("calendar table could not be created.")
            }
        } else {
            print("CREATE TABLE statement could not be prepared.")
        }
        sqlite3_finalize(createTableStatement)
    }
    
    func insert(with calendarData : CalendarData) {
        let insertStatementString = """
        
        INSERT INTO \(calendarTableName) (
        
        \(KEY_FAJR),
        \(KEY_DHUHR),
        \(KEY_ASR),
        \(KEY_MAGHRIB),
        \(KEY_ISHA),
        \(KEY_SUNRISE),
        \(KEY_SUNSET),
        \(KEY_IMASK),
        \(KEY_MIDNIGHT),
        \(KEY_TODAY_DATE_ENGLISH),
        \(KEY_TODAY_DATE_HIJRI)
        
        )
        VALUES (?, ?,?, ?,?, ?,?, ?,?, ?,?);
        """
        
        var insertStatement: OpaquePointer?
        
        if sqlite3_prepare_v2(op, insertStatementString, -1, &insertStatement, nil) ==
            SQLITE_OK {
            
            //let id: Int32 = 1
            let fajr: NSString = calendarData.timings.fajr as NSString
            let dhuhr: NSString = calendarData.timings.dhuhr as NSString
            let asr: NSString = calendarData.timings.asr as NSString
            let maghrib: NSString = calendarData.timings.maghrib as NSString
            let isha: NSString = calendarData.timings.isha as NSString
            let sunrise: NSString = calendarData.timings.sunrise as NSString
            let sunset: NSString = calendarData.timings.sunset as NSString
            let imask: NSString = calendarData.timings.imask as NSString
            let midnight: NSString = calendarData.timings.midnight as NSString
            let todayDateEnglish: NSString = calendarData.date.readable as NSString
            let todayDateHijri: NSString = calendarData.date.hijriData.date as NSString
            
            //sqlite3_bind_int(insertStatement, 1, id)
            sqlite3_bind_text(insertStatement, 1, fajr.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 2, dhuhr.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 3, asr.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 4, maghrib.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 5, isha.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 6, sunrise.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 7, sunset.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 8, imask.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 9, midnight.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 10, todayDateEnglish.utf8String, -1, nil)
            sqlite3_bind_text(insertStatement, 11, todayDateHijri.utf8String, -1, nil)
            
            if sqlite3_step(insertStatement) == SQLITE_DONE {
                print("\nSuccessfully inserted row.")
            } else {
                print("\nCould not insert row.")
            }
        } else {
            print("\nINSERT statement is not prepared.")
        }
        
        sqlite3_finalize(insertStatement)
    }
    
    func getCalendarData(withDate date : String) -> CalendarData? {
        var calendarData : CalendarData?
        let queryStatementString = """
        SELECT * FROM \(calendarTableName) where \(KEY_TODAY_DATE_ENGLISH) = '\(date)';
        """
        
        var queryStatement: OpaquePointer?
        
        if sqlite3_prepare_v2(op, queryStatementString, -1, &queryStatement, nil) ==
            SQLITE_OK {
            
            if sqlite3_step(queryStatement) == SQLITE_ROW {
                
                //let id = sqlite3_column_int(queryStatement, 0)
                
                let fajr = String(describing: String(cString: sqlite3_column_text(queryStatement, 1)))
                let dhuhr = String(describing: String(cString: sqlite3_column_text(queryStatement, 2)))
                let asr = String(describing: String(cString: sqlite3_column_text(queryStatement, 3)))
                let maghrib = String(describing: String(cString: sqlite3_column_text(queryStatement, 4)))
                let isha = String(describing: String(cString: sqlite3_column_text(queryStatement, 5)))
                let sunrise = String(describing: String(cString: sqlite3_column_text(queryStatement, 6)))
                let sunset = String(describing: String(cString: sqlite3_column_text(queryStatement, 7)))
                let imask = String(describing: String(cString: sqlite3_column_text(queryStatement, 8)))
                let midnight = String(describing: String(cString: sqlite3_column_text(queryStatement, 9)))
                let todayDateEnglish = String(describing: String(cString: sqlite3_column_text(queryStatement, 10)))
                let todayDateHijri = String(describing: String(cString: sqlite3_column_text(queryStatement, 11)))
                
                let timings = Timings(fajr: fajr, dhuhr: dhuhr, asr: asr, maghrib: maghrib, isha: isha, sunrise: sunrise, sunset: sunset, imask: imask, midnight: midnight)
                
                let dateData = DateData(readable: todayDateEnglish, hijriData: HijriData(date: todayDateHijri))
                
                calendarData = CalendarData(timings: timings, date: dateData)
            } else {
                print("\nQuery returned no results.")
            }
        } else {
            // 6
            let errorMessage = String(cString: sqlite3_errmsg(op))
            print("\nQuery is not prepared \(errorMessage)")
        }
        // 7
        sqlite3_finalize(queryStatement)
        
        return calendarData
    }
   
    
    // Insert a list into database using this method. Change as per your need
    func insertMultiple() {
        let insertStatementString = """
        
        INSERT INTO \(calendarTableName) (
        
        \(KEY_FAJR),
        \(KEY_DHUHR),
        \(KEY_ASR),
        \(KEY_MAGHRIB),
        \(KEY_ISHA),
        \(KEY_SUNRISE),
        \(KEY_SUNSET),
        \(KEY_IMASK),
        \(KEY_MIDNIGHT),
        \(KEY_TODAY_DATE_ENGLISH),
        \(KEY_TODAY_DATE_HIJRI)
        
        )
        VALUES (?, ?,?, ?,?, ?,?, ?,?, ?,?);
        """
        
        var insertStatement: OpaquePointer?
        // 1
        let names: [NSString] = ["Ray", "Chris", "Martha", "Danielle"]
        if sqlite3_prepare_v2(
            op,
            insertStatementString,
            -1,
            &insertStatement,
            nil
            ) == SQLITE_OK {
            print("\n")
            // 2
            for (index, name) in names.enumerated() {
                // 3
                let id = Int32(index + 1)
                sqlite3_bind_int(insertStatement, 1, id)
                sqlite3_bind_text(insertStatement, 2, name.utf8String, -1, nil)
                if sqlite3_step(insertStatement) == SQLITE_DONE {
                    print("Successfully inserted row.")
                } else {
                    print("Could not insert row.")
                }
                // 4
                sqlite3_reset(insertStatement)
            }
            sqlite3_finalize(insertStatement)
        } else {
            print("\nINSERT statement is not prepared.")
        }
    }
    
    // TODO change
    func update() {
        let updateStatementString = "UPDATE Contact SET Name = 'Adam' WHERE Id = 1;"
        
        var updateStatement: OpaquePointer?
        if sqlite3_prepare_v2(op, updateStatementString, -1, &updateStatement, nil) ==
            SQLITE_OK {
            if sqlite3_step(updateStatement) == SQLITE_DONE {
                print("\nSuccessfully updated row.")
            } else {
                print("\nCould not update row.")
            }
        } else {
            print("\nUPDATE statement is not prepared")
        }
        sqlite3_finalize(updateStatement)
    }
    
    // TODO Change
    func delete() {
        let deleteStatementString = "DELETE FROM Contact WHERE Id = 1;"
        
        var deleteStatement: OpaquePointer?
        if sqlite3_prepare_v2(op, deleteStatementString, -1, &deleteStatement, nil) ==
            SQLITE_OK {
            if sqlite3_step(deleteStatement) == SQLITE_DONE {
                print("\nSuccessfully deleted row.")
            } else {
                print("\nCould not delete row.")
            }
        } else {
            print("\nDELETE statement could not be prepared")
        }
        
        sqlite3_finalize(deleteStatement)
    }
    
    func closeDB() {
        sqlite3_close(op)
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

// DatabaseManager.swift

// SalahAndDua

// Created by Ashiq on 9/4/20.

import Foundation

import SQLite3

class DB {

// Singleton Instance

static var shared = DB()

private let dbPath = "mydb.sqlite"

private var op : OpaquePointer?

private let calendarTableName = "calendar"

// Calendar table columns

private let KEY_ID = "_id"

private let KEY_FAJR = "fajr"

private let KEY_DHUHR = "dhuhr"

private let KEY_ASR = "asr"

private let KEY_MAGHRIB = "maghrib"

private let KEY_ISHA = "isha"

private let KEY_SUNRISE = "sunrise"

private let KEY_SUNSET = "sunset"

private let KEY_IMASK = "imask"

private let KEY_MIDNIGHT = "midnight"

private let KEY_TODAY_DATE_ENGLISH = "today_date_english"

private let KEY_TODAY_DATE_HIJRI = "today_date_hijri"

init() {

op = openDatabase()

createCalendarTable()

}

private func openDatabase() -> OpaquePointer?

{

let fileURL = try! FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)

.appendingPathComponent(dbPath)

var db: OpaquePointer? = nil

if sqlite3_open(fileURL.path, &db) != SQLITE_OK {

print("error opening database")

return nil

}

else {

print("Successfully opened connection to database at \(dbPath)")

return db

}

func createCalendarTable() {

let createTableString = """

CREATE TABLE IF NOT EXISTS \(calendarTableName) (

\(KEY_ID) INTEGER PRIMARY KEY AUTOINCREMENT,

\(KEY_FAJR) TEXT,

\(KEY_DHUHR) TEXT,

\(KEY_ASR) TEXT,

\(KEY_MAGHRIB) TEXT,

\(KEY_ISHA) TEXT,

\(KEY_SUNRISE) TEXT,

\(KEY_SUNSET) TEXT,

\(KEY_IMASK) TEXT,

\(KEY_MIDNIGHT) TEXT,

\(KEY_TODAY_DATE_ENGLISH) TEXT,

\(KEY_TODAY_DATE_HIJRI) TEXT

);

"""

var createTableStatement: OpaquePointer? = nil

if sqlite3_prepare_v2(op, createTableString, -1, &createTableStatement, nil) == SQLITE_OK

{

if sqlite3_step(createTableStatement) == SQLITE_DONE

{

print("calendar table created.")

} else {

print("calendar table could not be created.")

}

} else {

print("CREATE TABLE statement could not be prepared.")

}

sqlite3_finalize(createTableStatement)

}

func insert(with calendarData : CalendarData) {

let insertStatementString = """

INSERT INTO \(calendarTableName) (

\(KEY_FAJR),

\(KEY_DHUHR),

\(KEY_ASR),

\(KEY_MAGHRIB),

\(KEY_ISHA),

\(KEY_SUNRISE),

\(KEY_SUNSET),

\(KEY_IMASK),

\(KEY_MIDNIGHT),

\(KEY_TODAY_DATE_ENGLISH),

\(KEY_TODAY_DATE_HIJRI)

)

VALUES (?, ?,?, ?,?, ?,?, ?,?, ?,?);

"""

var insertStatement: OpaquePointer?

if sqlite3_prepare_v2(op, insertStatementString, -1, &insertStatement, nil) ==

SQLITE_OK {

//let id: Int32 = 1

let fajr: NSString = calendarData.timings.fajr as NSString

let dhuhr: NSString = calendarData.timings.dhuhr as NSString

let asr: NSString = calendarData.timings.asr as NSString

let maghrib: NSString = calendarData.timings.maghrib as NSString

let isha: NSString = calendarData.timings.isha as NSString

let sunrise: NSString = calendarData.timings.sunrise as NSString

let sunset: NSString = calendarData.timings.sunset as NSString

let imask: NSString = calendarData.timings.imask as NSString

let midnight: NSString = calendarData.timings.midnight as NSString

let todayDateEnglish: NSString = calendarData.date.readable as NSString

let todayDateHijri: NSString = calendarData.date.hijriData.date as NSString

//sqlite3_bind_int(insertStatement, 1, id)

sqlite3_bind_text(insertStatement, 1, fajr.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 2, dhuhr.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 3, asr.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 4, maghrib.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 5, isha.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 6, sunrise.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 7, sunset.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 8, imask.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 9, midnight.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 10, todayDateEnglish.utf8String, -1, nil)

sqlite3_bind_text(insertStatement, 11, todayDateHijri.utf8String, -1, nil)

if sqlite3_step(insertStatement) == SQLITE_DONE {

print("\nSuccessfully inserted row.")

} else {

print("\nCould not insert row.")

}

} else {

print("\nINSERT statement is not prepared.")

}

sqlite3_finalize(insertStatement)

}

func getCalendarData(withDate date : String) -> CalendarData? {

var calendarData : CalendarData?

let queryStatementString = """

SELECT * FROM \(calendarTableName) where \(KEY_TODAY_DATE_ENGLISH) = '\(date)';

"""

var queryStatement: OpaquePointer?

if sqlite3_prepare_v2(op, queryStatementString, -1, &queryStatement, nil) ==

SQLITE_OK {

if sqlite3_step(queryStatement) == SQLITE_ROW {

//let id = sqlite3_column_int(queryStatement, 0)

let fajr = String(describing: String(cString: sqlite3_column_text(queryStatement, 1)))

let dhuhr = String(describing: String(cString: sqlite3_column_text(queryStatement, 2)))

let asr = String(describing: String(cString: sqlite3_column_text(queryStatement, 3)))

let maghrib = String(describing: String(cString: sqlite3_column_text(queryStatement, 4)))

let isha = String(describing: String(cString: sqlite3_column_text(queryStatement, 5)))

let sunrise = String(describing: String(cString: sqlite3_column_text(queryStatement, 6)))

let sunset = String(describing: String(cString: sqlite3_column_text(queryStatement, 7)))

let imask = String(describing: String(cString: sqlite3_column_text(queryStatement, 8)))

let midnight = String(describing: String(cString: sqlite3_column_text(queryStatement, 9)))

let todayDateEnglish = String(describing: String(cString: sqlite3_column_text(queryStatement, 10)))

let todayDateHijri = String(describing: String(cString: sqlite3_column_text(queryStatement, 11)))

let timings = Timings(fajr: fajr, dhuhr: dhuhr, asr: asr, maghrib: maghrib, isha: isha, sunrise: sunrise, sunset: sunset, imask: imask, midnight: midnight)

let dateData = DateData(readable: todayDateEnglish, hijriData: HijriData(date: todayDateHijri))

calendarData = CalendarData(timings: timings, date: dateData)

} else {

print("\nQuery returned no results.")

}

} else {

// 6

let errorMessage = String(cString: sqlite3_errmsg(op))

print("\nQuery is not prepared \(errorMessage)")

}

// 7

sqlite3_finalize(queryStatement)

return calendarData

}

// Insert a list into database using this method. Change as per your need

func insertMultiple() {

let insertStatementString = """

INSERT INTO \(calendarTableName) (

\(KEY_FAJR),

\(KEY_DHUHR),

\(KEY_ASR),

\(KEY_MAGHRIB),

\(KEY_ISHA),

\(KEY_SUNRISE),

\(KEY_SUNSET),

\(KEY_IMASK),

\(KEY_MIDNIGHT),

\(KEY_TODAY_DATE_ENGLISH),

\(KEY_TODAY_DATE_HIJRI)

)

VALUES (?, ?,?, ?,?, ?,?, ?,?, ?,?);

"""

var insertStatement: OpaquePointer?

// 1

let names: [NSString] = ["Ray", "Chris", "Martha", "Danielle"]

if sqlite3_prepare_v2(

op,

insertStatementString,

-1,

&insertStatement,

nil

) == SQLITE_OK {

print("\n")

// 2

for (index, name) in names.enumerated() {

// 3

let id = Int32(index + 1)

sqlite3_bind_int(insertStatement, 1, id)

sqlite3_bind_text(insertStatement, 2, name.utf8String, -1, nil)

if sqlite3_step(insertStatement) == SQLITE_DONE {

print("Successfully inserted row.")

} else {

print("Could not insert row.")

}

// 4

sqlite3_reset(insertStatement)

}

sqlite3_finalize(insertStatement)

} else {

print("\nINSERT statement is not prepared.")

}

// TODO change

func update() {

let updateStatementString = "UPDATE Contact SET Name = 'Adam' WHERE Id = 1;"

var updateStatement: OpaquePointer?

if sqlite3_prepare_v2(op, updateStatementString, -1, &updateStatement, nil) ==

SQLITE_OK {

if sqlite3_step(updateStatement) == SQLITE_DONE {

print("\nSuccessfully updated row.")

} else {

print("\nCould not update row.")

}

} else {

print("\nUPDATE statement is not prepared")

}

sqlite3_finalize(updateStatement)

}

// TODO Change

func delete() {

let deleteStatementString = "DELETE FROM Contact WHERE Id = 1;"

var deleteStatement: OpaquePointer?

if sqlite3_prepare_v2(op, deleteStatementString, -1, &deleteStatement, nil) ==

SQLITE_OK {

if sqlite3_step(deleteStatement) == SQLITE_DONE {

print("\nSuccessfully deleted row.")

} else {

print("\nCould not delete row.")

}

} else {

print("\nDELETE statement could not be prepared")

}

sqlite3_finalize(deleteStatement)

}

func closeDB() {

sqlite3_close(op)

}

Resources: 1) https://www.raywenderlich.com/6620276-sqlite-with-swift-tutorial-getting-started

Implement SQLite Db in iOS Using SQLite.swift by Stephen Celis

April 10, 2020April 10, 2020shaonLeave a comment

A type-safe, Swift-language layer over SQLite3. SQLite.swift provides compile-time confidence in SQL statement syntax and intent. https://github.com/stephencelis/SQLite.swift https://github.com/stephencelis/SQLite.swift/wiki Open Db in your AppDelegate

 func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        // Initializing db
        _ = DB.shared
        
        return true
 }

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

// Initializing db

_ = DB.shared

return true

}

//
//  DbHelper.swift
//  SalahAndDua
//
//  Created by Ashiq  on 10/4/20.
//  Copyright © 2020 LastBlade. All rights reserved.
//

import Foundation
import SQLite

class DbHelper {
    static let shared = DbHelper()
    
    private let dbPath = "mydb.sqlite"
    
    private let calenderTable = Table("Calendar")
    
    // Calendar table columns
    let id = Expression<Int64>("_id")
    let fajr = Expression<String>("fajr")
    let dhuhr = Expression<String>("dhuhr")
    let asr = Expression<String>("asr")
    let magrib = Expression<String>("maghrib")
    let isha = Expression<String>("isha")
    let sunrise = Expression<String>("sunrise")
    let sunset = Expression<String>("sunset")
    let imask = Expression<String>("imask")
    let midnight = Expression<String>("midnight")
    let todayDateEnglish = Expression<String>("today_date_english")
    let todayDateHijri = Expression<String>("today_date_hijri")
    
    private var connection : Connection?
    
    init() {
        openDb()
        createCalendarTable()
    }
    
    private func openDb()   {
        let path = NSSearchPathForDirectoriesInDomains(
            .documentDirectory, .userDomainMask, true
        ).first!
        
        do {
            connection = try Connection("\(path)/db.sqlite3")
        } catch {
            print(error)
        }
        
    }
    
    private func createCalendarTable() {
        
        do {
            try connection?.run(calenderTable.create { t in
                t.column(id, primaryKey: .autoincrement)
                t.column(fajr)
                t.column(dhuhr)
                t.column(asr)
                t.column(magrib)
                t.column(isha)
                t.column(sunrise)
                t.column(sunset)
                t.column(imask)
                t.column(midnight)
                t.column(todayDateEnglish)
                t.column(todayDateHijri)
            })
        } catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {
            print("constraint failed: \(message), in \(String(describing: statement))")
        } catch let error {
            print("Creation Calendar Table failed: \(error)")
        }
    }
    
    
    func insert(with calendarData : CalendarData) {
        do {
            try connection?.run(calenderTable.insert(
                fajr <- calendarData.timings.fajr,
                dhuhr <- calendarData.timings.dhuhr,
                asr <- calendarData.timings.asr,
                magrib <- calendarData.timings.maghrib,
                isha <- calendarData.timings.isha,
                sunrise <- calendarData.timings.sunrise,
                sunset <- calendarData.timings.sunset,
                imask <- calendarData.timings.imask,
                midnight <- calendarData.timings.midnight,
                todayDateEnglish <- calendarData.date.readable,
                todayDateHijri <- calendarData.date.hijriData.date
            ))
        } catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {
            print("constraint failed: \(message), in \(String(describing: statement))")
        } catch let error {
            print("insertion failed: \(error)")
        }
    }
    
    func getCalendarData(withDate date : String) -> CalendarData? {
        var calendarData : CalendarData?
        do {
            let query = calenderTable.filter(todayDateEnglish == date)
            for calendar in try (connection?.prepare(query))!  {
                
                let timings = Timings(fajr: calendar[fajr], dhuhr: calendar[dhuhr], asr: calendar[asr], maghrib: calendar[magrib], isha: calendar[isha], sunrise: calendar[sunrise], sunset: calendar[sunset], imask: calendar[imask], midnight: calendar[midnight])
                
                let dateData = DateData(readable: calendar[todayDateEnglish], hijriData: HijriData(date: calendar[todayDateHijri]))
                
                calendarData = CalendarData(timings: timings, date: dateData)
            }
        } catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {
            print("constraint failed: \(message), in \(String(describing: statement))")
        } catch let error {
            print("Data read failed for calendar table: \(error)")
        }
        
        return calendarData
    }
    
    func deleteCalendarTable() {
        do {
            try connection?.run(calenderTable.delete())
        } catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {
            print("constraint failed: \(message), in \(String(describing: statement))")
        } catch let error {
            print("Deletion failed for calendar table: \(error)")
        }
    }
    
    // Close db is autometically done by this library
    func closeDb() {
        
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

// DbHelper.swift

// SalahAndDua

// Created by Ashiq on 10/4/20.

import Foundation

import SQLite

class DbHelper {

static let shared = DbHelper()

private let dbPath = "mydb.sqlite"

private let calenderTable = Table("Calendar")

// Calendar table columns

let id = Expression<Int64>("_id")

let fajr = Expression<String>("fajr")

let dhuhr = Expression<String>("dhuhr")

let asr = Expression<String>("asr")

let magrib = Expression<String>("maghrib")

let isha = Expression<String>("isha")

let sunrise = Expression<String>("sunrise")

let sunset = Expression<String>("sunset")

let imask = Expression<String>("imask")

let midnight = Expression<String>("midnight")

let todayDateEnglish = Expression<String>("today_date_english")

let todayDateHijri = Expression<String>("today_date_hijri")

private var connection : Connection?

init() {

openDb()

createCalendarTable()

}

private func openDb() {

let path = NSSearchPathForDirectoriesInDomains(

.documentDirectory, .userDomainMask, true

).first!

do {

connection = try Connection("\(path)/db.sqlite3")

} catch {

print(error)

}

private func createCalendarTable() {

do {

try connection?.run(calenderTable.create { t in

t.column(id, primaryKey: .autoincrement)

t.column(fajr)

t.column(dhuhr)

t.column(asr)

t.column(magrib)

t.column(isha)

t.column(sunrise)

t.column(sunset)

t.column(imask)

t.column(midnight)

t.column(todayDateEnglish)

t.column(todayDateHijri)

})

} catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {

print("constraint failed: \(message), in \(String(describing: statement))")

} catch let error {

print("Creation Calendar Table failed: \(error)")

}

func insert(with calendarData : CalendarData) {

do {

try connection?.run(calenderTable.insert(

fajr <- calendarData.timings.fajr,

dhuhr <- calendarData.timings.dhuhr,

asr <- calendarData.timings.asr,

magrib <- calendarData.timings.maghrib,

isha <- calendarData.timings.isha,

sunrise <- calendarData.timings.sunrise,

sunset <- calendarData.timings.sunset,

imask <- calendarData.timings.imask,

midnight <- calendarData.timings.midnight,

todayDateEnglish <- calendarData.date.readable,

todayDateHijri <- calendarData.date.hijriData.date

))

} catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {

print("constraint failed: \(message), in \(String(describing: statement))")

} catch let error {

print("insertion failed: \(error)")

}

func getCalendarData(withDate date : String) -> CalendarData? {

var calendarData : CalendarData?

do {

let query = calenderTable.filter(todayDateEnglish == date)

for calendar in try (connection?.prepare(query))! {

let timings = Timings(fajr: calendar[fajr], dhuhr: calendar[dhuhr], asr: calendar[asr], maghrib: calendar[magrib], isha: calendar[isha], sunrise: calendar[sunrise], sunset: calendar[sunset], imask: calendar[imask], midnight: calendar[midnight])

let dateData = DateData(readable: calendar[todayDateEnglish], hijriData: HijriData(date: calendar[todayDateHijri]))

calendarData = CalendarData(timings: timings, date: dateData)

}

} catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {

print("constraint failed: \(message), in \(String(describing: statement))")

} catch let error {

print("Data read failed for calendar table: \(error)")

}

return calendarData

}

func deleteCalendarTable() {

do {

try connection?.run(calenderTable.delete())

} catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {

print("constraint failed: \(message), in \(String(describing: statement))")

} catch let error {

print("Deletion failed for calendar table: \(error)")

}

// Close db is autometically done by this library

func closeDb() {

}

A Retrofit util class help to make server connection easy

March 22, 2020shaonLeave a comment

import android.content.Context
import com.mediasoft.common.interfaces.RetryCallBackForNoInternet
import com.mediasoft.common.utils.C
import com.mediasoft.common.utils.D
import com.mediasoft.common.utils.Lg
import com.mediasoft.common.utils.U
import com.mediasoft.connectmediasoft.BuildConfig
import io.reactivex.schedulers.Schedulers
import okhttp3.OkHttpClient
import okhttp3.ResponseBody
import okhttp3.logging.HttpLoggingInterceptor
import org.json.JSONArray
import org.json.JSONException
import org.json.JSONObject
import retrofit2.Response
import retrofit2.Retrofit
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit

object Rester {
    private const val TAG = "Rester"

    fun executeRetrofit(
        context: Context,
        baseUrl: String = C.MAIN_URL,
        isToPromptNet: Boolean = false
    ): Retrofit? {
        return if (!U.isNetConnected(context)) {
            // show dialog to turn on internet
            if (isToPromptNet) {
                D.showNoInternetDialog(context, RetryCallBackForNoInternet {
                    executeRetrofit(context, baseUrl, isToPromptNet)
                })
            }

            null
        } else RestApiClient.getRetrofit(baseUrl)
    }

    // Parsing json object
    fun jo(response: Response&lt;ResponseBody&gt;): JSONObject {
        var jo: JSONObject
        try {
            jo = JSONObject(response.body()?.string() ?: "")
        } catch (e: JSONException) {
            jo = JSONObject()
            e.printStackTrace()
        }
        if (jo.length() &gt; 0)
            Lg.d(TAG, jo.toString())

        return jo
    }

    // Parsing json Array
    fun ja(response: Response&lt;ResponseBody&gt;): JSONArray {
        var ja: JSONArray
        try {
            ja = JSONArray(response.body()?.string() ?: "")
        } catch (e: JSONException) {
            ja = JSONArray()
            e.printStackTrace()
        }
        if (ja.length() &gt; 0)
            Lg.d(TAG, ja.toString())

        return ja
    }
}

private object RestApiClient {
    private var retrofit: Retrofit? = null
    private var okHttpClient: OkHttpClient? = null
    private var loggingInterceptor: HttpLoggingInterceptor? = null
    private var rxAdapter = RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io())


    fun getRetrofit(baseUrl: String): Retrofit {
        if (retrofit == null) {
            retrofit = create(baseUrl)
        }
        return retrofit!!
    }

    private fun create(baseUrl: String): Retrofit {
        // Level.BODY
        /*shows all the information of a request. We just want to see info when app
        * is in debug mode*/
        loggingInterceptor = HttpLoggingInterceptor()
        if (BuildConfig.DEBUG)
            loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BODY
        else loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BASIC

        okHttpClient = OkHttpClient.Builder().addInterceptor(loggingInterceptor!!)
            .readTimeout(5, TimeUnit.MINUTES)
            .connectTimeout(5, TimeUnit.MINUTES)
            .build()

        return Retrofit.Builder()
            .baseUrl(baseUrl)
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(rxAdapter)
            .client(okHttpClient!!)
            .build()
    }
}

100

101

102

103

104

105

106

107

import android.content.Context

import com.mediasoft.common.interfaces.RetryCallBackForNoInternet

import com.mediasoft.common.utils.C

import com.mediasoft.common.utils.D

import com.mediasoft.common.utils.Lg

import com.mediasoft.common.utils.U

import com.mediasoft.connectmediasoft.BuildConfig

import io.reactivex.schedulers.Schedulers

import okhttp3.OkHttpClient

import okhttp3.ResponseBody

import okhttp3.logging.HttpLoggingInterceptor

import org.json.JSONArray

import org.json.JSONException

import org.json.JSONObject

import retrofit2.Response

import retrofit2.Retrofit

import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory

import retrofit2.converter.gson.GsonConverterFactory

import java.util.concurrent.TimeUnit

object Rester {

private const val TAG = "Rester"

fun executeRetrofit(

context: Context,

baseUrl: String = C.MAIN_URL,

isToPromptNet: Boolean = false

): Retrofit? {

return if (!U.isNetConnected(context)) {

// show dialog to turn on internet

if (isToPromptNet) {

D.showNoInternetDialog(context, RetryCallBackForNoInternet {

executeRetrofit(context, baseUrl, isToPromptNet)

})

}

null

} else RestApiClient.getRetrofit(baseUrl)

}

// Parsing json object

fun jo(response: Response<ResponseBody>): JSONObject {

var jo: JSONObject

try {

jo = JSONObject(response.body()?.string() ?: "")

} catch (e: JSONException) {

jo = JSONObject()

e.printStackTrace()

}

if (jo.length() > 0)

Lg.d(TAG, jo.toString())

return jo

}

// Parsing json Array

fun ja(response: Response<ResponseBody>): JSONArray {

var ja: JSONArray

try {

ja = JSONArray(response.body()?.string() ?: "")

} catch (e: JSONException) {

ja = JSONArray()

e.printStackTrace()

}

if (ja.length() > 0)

Lg.d(TAG, ja.toString())

return ja

}

private object RestApiClient {

private var retrofit: Retrofit? = null

private var okHttpClient: OkHttpClient? = null

private var loggingInterceptor: HttpLoggingInterceptor? = null

private var rxAdapter = RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io())

fun getRetrofit(baseUrl: String): Retrofit {

if (retrofit == null) {

retrofit = create(baseUrl)

}

return retrofit!!

}

private fun create(baseUrl: String): Retrofit {

// Level.BODY

/*shows all the information of a request. We just want to see info when app

* is in debug mode*/

loggingInterceptor = HttpLoggingInterceptor()

if (BuildConfig.DEBUG)

loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BODY

else loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BASIC

okHttpClient = OkHttpClient.Builder().addInterceptor(loggingInterceptor!!)

.readTimeout(5, TimeUnit.MINUTES)

.connectTimeout(5, TimeUnit.MINUTES)

.build()

return Retrofit.Builder()

.baseUrl(baseUrl)

.addConverterFactory(GsonConverterFactory.create())

.addCallAdapterFactory(rxAdapter)

.client(okHttpClient!!)

.build()

}

object D {

    private val TAG = D::class.java.simpleName


    fun showNoInternetDialog(context: Context, rc4NoInt: RetryCallBackForNoInternet?) {
        MaterialDialog(context)
            .show {
                cancelOnTouchOutside(false)
                cancelable(false)
                message(null, "No internet! Please connect to internet ...")
                positiveButton(null,"Retry") {
                    if (rc4NoInt != null) {
                        dismiss()
                        rc4NoInt.retry()
                    }
                }
                negativeButton(null,"Settings") {
                    dismiss()
                    val intent = Intent(Settings.ACTION_WIFI_SETTINGS)
                    context.startActivity(intent)
                }
            }
    }
}

object D {

private val TAG = D::class.java.simpleName

fun showNoInternetDialog(context: Context, rc4NoInt: RetryCallBackForNoInternet?) {

MaterialDialog(context)

.show {

cancelOnTouchOutside(false)

cancelable(false)

message(null, "No internet! Please connect to internet ...")

positiveButton(null,"Retry") {

if (rc4NoInt != null) {

dismiss()

rc4NoInt.retry()

}

negativeButton(null,"Settings") {

dismiss()

val intent = Intent(Settings.ACTION_WIFI_SETTINGS)

context.startActivity(intent)

}

public interface RetryCallBackForNoInternet {
    void retry();
}

public interface RetryCallBackForNoInternet {

void retry();

}

Upload image into server converting image into base64

March 19, 2020shaonLeave a comment

Convert to base64

val bitmap = BitmapFactory.decodeFile("path")

val stream = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream)
val imageInByteArray = stream.toByteArray()
val encodeStr = Base64.encodeToString(imageInByteArray, Base64.DEFAULT)

val bitmap = BitmapFactory.decodeFile("path")

val stream = ByteArrayOutputStream()

bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream)

val imageInByteArray = stream.toByteArray()

val encodeStr = Base64.encodeToString(imageInByteArray, Base64.DEFAULT)

Upload image using encoded string

private fun upload(encodeStr: String) {
    val retrofit = Rester.executeRetrofit(
        context = this
    )

    retrofit?.let {
        val service = retrofit.create(ApiService::class.java)
        val call = service.uploadImage(encodeStr)

        call.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                val jo = Rester.jo(it)

            }, {
                it.printStackTrace()
            })
    }
}

private fun upload(encodeStr: String) {

val retrofit = Rester.executeRetrofit(

context = this

)

retrofit?.let {

val service = retrofit.create(ApiService::class.java)

val call = service.uploadImage(encodeStr)

call.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

.subscribe({

val jo = Rester.jo(it)

}, {

it.printStackTrace()

})

}

interface ApiService {

    @FormUrlEncoded
    @POST("base64_image_upload/upload_file.php")
    fun uploadImage(@Field("base64str") encodeStr: String): Observable&lt;Response&lt;ResponseBody&gt;&gt;

}

interface ApiService {

@FormUrlEncoded

@POST("base64_image_upload/upload_file.php")

fun uploadImage(@Field("base64str") encodeStr: String): Observable<Response<ResponseBody>>

}

object D {

    private val TAG = D::class.java.simpleName


    fun showNoInternetDialog(context: Context, rc4NoInt: RetryCallBackForNoInternet?) {
        MaterialDialog(context)
            .show {
                cancelOnTouchOutside(false)
                cancelable(false)
                message(null, "No internet! Please connect to internet ...")
                positiveButton(null,"Retry") {
                    if (rc4NoInt != null) {
                        dismiss()
                        rc4NoInt.retry()
                    }
                }
                negativeButton(null,"Settings") {
                    dismiss()
                    val intent = Intent(Settings.ACTION_WIFI_SETTINGS)
                    context.startActivity(intent)
                }
            }
    }

}

object D {

private val TAG = D::class.java.simpleName

fun showNoInternetDialog(context: Context, rc4NoInt: RetryCallBackForNoInternet?) {

MaterialDialog(context)

.show {

cancelOnTouchOutside(false)

cancelable(false)

message(null, "No internet! Please connect to internet ...")

positiveButton(null,"Retry") {

if (rc4NoInt != null) {

dismiss()

rc4NoInt.retry()

}

negativeButton(null,"Settings") {

dismiss()

val intent = Intent(Settings.ACTION_WIFI_SETTINGS)

context.startActivity(intent)

}

import android.content.Context
import android.util.Log
import io.reactivex.schedulers.Schedulers
import okhttp3.OkHttpClient
import okhttp3.ResponseBody
import okhttp3.logging.HttpLoggingInterceptor
import org.json.JSONArray
import org.json.JSONException
import org.json.JSONObject
import retrofit2.Response
import retrofit2.Retrofit
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit

object Rester {
    private const val TAG = "Rester"

    fun executeRetrofit(
        context: Context,
        baseUrl: String = "http://www.shaoniiuc.com/",
        isToPromptNet: Boolean = false
    ): Retrofit? {
        return if (!U.isNetConnected(context)) {
            // show dialog to turn on internet
            if (isToPromptNet) {
                D.showNoInternetDialog(context, RetryCallBackForNoInternet {
                    executeRetrofit(context, baseUrl, isToPromptNet)
                })
            }

            null
        } else RestApiClient.getRetrofit(baseUrl)
    }

    // Parsing json object
    fun jo(response: Response&lt;ResponseBody&gt;): JSONObject {
        var jo: JSONObject
        try {
            jo = JSONObject(response.body()?.string() ?: "")
        } catch (e: JSONException) {
            jo = JSONObject()
            e.printStackTrace()
        }
        if (jo.length() &gt; 0)
            Log.d(TAG, jo.toString())

        return jo
    }

    // Parsing json Array
    fun ja(response: Response&lt;ResponseBody&gt;): JSONArray {
        var ja: JSONArray
        try {
            ja = JSONArray(response.body()?.string() ?: "")
        } catch (e: JSONException) {
            ja = JSONArray()
            e.printStackTrace()
        }
        if (ja.length() &gt; 0)
            Log.d(TAG, ja.toString())

        return ja
    }
}

private object RestApiClient {
    private var retrofit: Retrofit? = null
    private var okHttpClient: OkHttpClient? = null
    private var loggingInterceptor: HttpLoggingInterceptor? = null
    private var rxAdapter = RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io())


    fun getRetrofit(baseUrl: String): Retrofit {
        if (retrofit == null) {
            retrofit = create(baseUrl)
        }
        return retrofit!!
    }

    private fun create(baseUrl: String): Retrofit {
        // Level.BODY
        /*shows all the information of a request. We just want to see info when app
        * is in debug mode*/
        loggingInterceptor = HttpLoggingInterceptor()
        if (BuildConfig.DEBUG)
            loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BODY
        else loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BASIC

        okHttpClient = OkHttpClient.Builder().addInterceptor(loggingInterceptor!!)
            .readTimeout(5, TimeUnit.MINUTES)
            .connectTimeout(5, TimeUnit.MINUTES)
            .build()

        return Retrofit.Builder()
            .baseUrl(baseUrl)
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(rxAdapter)
            .client(okHttpClient!!)
            .build()
    }
}

100

101

102

import android.content.Context

import android.util.Log

import io.reactivex.schedulers.Schedulers

import okhttp3.OkHttpClient

import okhttp3.ResponseBody

import okhttp3.logging.HttpLoggingInterceptor

import org.json.JSONArray

import org.json.JSONException

import org.json.JSONObject

import retrofit2.Response

import retrofit2.Retrofit

import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory

import retrofit2.converter.gson.GsonConverterFactory

import java.util.concurrent.TimeUnit

object Rester {

private const val TAG = "Rester"

fun executeRetrofit(

context: Context,

baseUrl: String = "http://www.shaoniiuc.com/",

isToPromptNet: Boolean = false

): Retrofit? {

return if (!U.isNetConnected(context)) {

// show dialog to turn on internet

if (isToPromptNet) {

D.showNoInternetDialog(context, RetryCallBackForNoInternet {

executeRetrofit(context, baseUrl, isToPromptNet)

})

}

null

} else RestApiClient.getRetrofit(baseUrl)

}

// Parsing json object

fun jo(response: Response<ResponseBody>): JSONObject {

var jo: JSONObject

try {

jo = JSONObject(response.body()?.string() ?: "")

} catch (e: JSONException) {

jo = JSONObject()

e.printStackTrace()

}

if (jo.length() > 0)

Log.d(TAG, jo.toString())

return jo

}

// Parsing json Array

fun ja(response: Response<ResponseBody>): JSONArray {

var ja: JSONArray

try {

ja = JSONArray(response.body()?.string() ?: "")

} catch (e: JSONException) {

ja = JSONArray()

e.printStackTrace()

}

if (ja.length() > 0)

Log.d(TAG, ja.toString())

return ja

}

private object RestApiClient {

private var retrofit: Retrofit? = null

private var okHttpClient: OkHttpClient? = null

private var loggingInterceptor: HttpLoggingInterceptor? = null

private var rxAdapter = RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io())

fun getRetrofit(baseUrl: String): Retrofit {

if (retrofit == null) {

retrofit = create(baseUrl)

}

return retrofit!!

}

private fun create(baseUrl: String): Retrofit {

// Level.BODY

/*shows all the information of a request. We just want to see info when app

* is in debug mode*/

loggingInterceptor = HttpLoggingInterceptor()

if (BuildConfig.DEBUG)

loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BODY

else loggingInterceptor!!.level = HttpLoggingInterceptor.Level.BASIC

okHttpClient = OkHttpClient.Builder().addInterceptor(loggingInterceptor!!)

.readTimeout(5, TimeUnit.MINUTES)

.connectTimeout(5, TimeUnit.MINUTES)

.build()

return Retrofit.Builder()

.baseUrl(baseUrl)

.addConverterFactory(GsonConverterFactory.create())

.addCallAdapterFactory(rxAdapter)

.client(okHttpClient!!)

.build()

}

public interface RetryCallBackForNoInternet {
    void retry();
}

public interface RetryCallBackForNoInternet {

void retry();

}

import android.annotation.SuppressLint

import android.content.Context

import android.net.ConnectivityManager


object U {

    fun isNetConnected(context: Context?): Boolean {
        if (context == null)
            return false
        val connectivityManager = context
            .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

        @SuppressLint("MissingPermission")
        val activeNetworkInfo = connectivityManager.activeNetworkInfo
        return activeNetworkInfo != null &amp;&amp; activeNetworkInfo.isConnected
    }


}

import android.annotation.SuppressLint

import android.content.Context

import android.net.ConnectivityManager

object U {

fun isNetConnected(context: Context?): Boolean {

if (context == null)

return false

val connectivityManager = context

.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

@SuppressLint("MissingPermission")

val activeNetworkInfo = connectivityManager.activeNetworkInfo

return activeNetworkInfo != null && activeNetworkInfo.isConnected

}

Dependency

implementation 'com.github.esafirm.android-image-picker:imagepicker:2.2.0'
// for experimental rx picker
implementation 'com.github.esafirm.android-image-picker:rximagepicker:2.2.0'
// If you have a problem with Glide, please use the same Glide version or simply open an issue
implementation 'com.github.bumptech.glide:glide:4.5.0'

/** Retrofit*/
implementation "com.squareup.retrofit2:retrofit:$retrofitVersion"
implementation "com.squareup.retrofit2:converter-gson:$retrofitVersion"
implementation "com.squareup.okhttp3:logging-interceptor:3.14.2"
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.6.1'

// Material dialog
implementation 'com.afollestad.material-dialogs:core:3.1.1'

// RxJava
implementation 'io.reactivex.rxjava2:rxjava:2.2.11'

implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

implementation 'com.github.esafirm.android-image-picker:imagepicker:2.2.0'

// for experimental rx picker

implementation 'com.github.esafirm.android-image-picker:rximagepicker:2.2.0'

// If you have a problem with Glide, please use the same Glide version or simply open an issue

implementation 'com.github.bumptech.glide:glide:4.5.0'

/** Retrofit*/

implementation "com.squareup.retrofit2:retrofit:$retrofitVersion"

implementation "com.squareup.retrofit2:converter-gson:$retrofitVersion"

implementation "com.squareup.okhttp3:logging-interceptor:3.14.2"

implementation 'com.squareup.retrofit2:adapter-rxjava2:2.6.1'

// Material dialog

implementation 'com.afollestad.material-dialogs:core:3.1.1'

// RxJava

implementation 'io.reactivex.rxjava2:rxjava:2.2.11'

implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

Convert an image to base64 and decode from base64

March 19, 2020shaonLeave a comment

Convert image to base64

val bitmap = BitmapFactory.decodeFile("path")

val stream = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream)
val imageInByteArray = stream.toByteArray()
val encodeStr = Base64.encodeToString(imageInByteArray, Base64.DEFAULT)

val bitmap = BitmapFactory.decodeFile("path")

val stream = ByteArrayOutputStream()

bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream)

val imageInByteArray = stream.toByteArray()

val encodeStr = Base64.encodeToString(imageInByteArray, Base64.DEFAULT)

Decode base64 to bitmap

val decodedStr = Base64.decode(encodeStr, Base64.DEFAULT)
val decodedBitmap = BitmapFactory.decodeByteArray(decodedStr, 0, decodedStr.size)

1 2	val decodedStr = Base64.decode(encodeStr, Base64.DEFAULT) val decodedBitmap = BitmapFactory.decodeByteArray(decodedStr, 0, decodedStr.size)

Android Custom Dialog Example

February 24, 2020February 24, 2020shaonLeave a comment

Dependency

implementation 'com.afollestad.material-dialogs:core:3.3.0'
implementation 'androidx.cardview:cardview:1.0.0'

1 2	implementation 'com.afollestad.material-dialogs:core:3.3.0' implementation 'androidx.cardview:cardview:1.0.0'

Add it to your style.xml

&lt;style name="AppTheme.DialogTheme" parent="Theme.AppCompat.Light.Dialog"&gt;
    &lt;item name="android:windowBackground"&gt;@android:color/transparent&lt;/item&gt;
    &lt;item name="android:windowCloseOnTouchOutside"&gt;true&lt;/item&gt;
&lt;/style&gt;

<item name="android:windowBackground">@android:color/transparent</item>

</style>

Add them to drawable folder Rectangle Shape

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">
    <solid android:color="@android:color/transparent" />
    <stroke
        android:width="1dp"
        android:color="@android:color/holo_orange_dark" />
    <corners

        android:bottomLeftRadius="4dp"
        android:bottomRightRadius="4dp"
        android:topLeftRadius="4dp"
        android:topRightRadius="4dp" />
</shape>

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

<shape xmlns:android="http://schemas.android.com/apk/res/android"

android:shape="rectangle">

<stroke

android:width="1dp"

android:color="@android:color/holo_orange_dark" />

<corners

android:bottomLeftRadius="4dp"

android:bottomRightRadius="4dp"

android:topLeftRadius="4dp"

android:topRightRadius="4dp" />

</shape>

Circle Shape

<?xml version="1.0" encoding="utf-8"?>
<shape
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval">

    <solid
        android:color="@android:color/white"/>

    <size
        android:width="120dp"
        android:height="120dp"/>
</shape>

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

<shape

xmlns:android="http://schemas.android.com/apk/res/android"

android:shape="oval">

<solid

android:color="@android:color/white"/>

<size

android:width="120dp"

android:height="120dp"/>

</shape>

Top middle circle dialog view

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_margin="32dp"
    android:background="@android:color/transparent"
    android:layout_height="wrap_content">

   <FrameLayout
       android:id="@+id/fl"
       android:background="@android:color/holo_blue_bright"
       android:layout_margin="32dp"
       android:layout_width="match_parent"
       android:layout_height="200dp">

   </FrameLayout>

   <ImageView
       android:src="@drawable/ic_add_black_24dp"
       android:background="@drawable/circle"
       android:layout_marginTop="-24dp"
       android:layout_centerInParent="true"
       android:layout_alignTop="@id/fl"
       android:layout_width="48dp"
       android:padding="8dp"
       android:layout_height="48dp"/>

</RelativeLayout>

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

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="match_parent"

android:layout_margin="32dp"

android:background="@android:color/transparent"

android:layout_height="wrap_content">

<FrameLayout

android:id="@+id/fl"

android:background="@android:color/holo_blue_bright"

android:layout_margin="32dp"

android:layout_width="match_parent"

android:layout_height="200dp">

</FrameLayout>

<ImageView

android:src="@drawable/ic_add_black_24dp"

android:background="@drawable/circle"

android:layout_marginTop="-24dp"

android:layout_centerInParent="true"

android:layout_alignTop="@id/fl"

android:layout_width="48dp"

android:padding="8dp"

android:layout_height="48dp"/>

</RelativeLayout>

Using Constraing Layout

&lt;?xml version="1.0" encoding="utf-8"?&gt;
&lt;androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_margin="32dp"
    android:background="@android:color/transparent"
    android:layout_height="wrap_content"&gt;

   &lt;FrameLayout
       android:id="@+id/fl"
       android:layout_width="match_parent"
       android:layout_height="200dp"
       android:layout_margin="32dp"
       android:background="@android:color/holo_blue_bright"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"&gt;

   &lt;/FrameLayout&gt;

   &lt;ImageView
       android:translationY="-24dp"
       android:layout_width="48dp"
       android:layout_height="48dp"
       android:background="@drawable/circle"
       android:padding="8dp"
       android:src="@drawable/ic_add_black_24dp"
       app:layout_constraintEnd_toEndOf="@+id/fl"
       app:layout_constraintStart_toStartOf="@+id/fl"
       app:layout_constraintTop_toTopOf="@+id/fl" /&gt;

&lt;/androidx.constraintlayout.widget.ConstraintLayout&gt;

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

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_margin="32dp"

android:background="@android:color/transparent"

android:layout_height="wrap_content">

<FrameLayout

android:id="@+id/fl"

android:layout_width="match_parent"

android:layout_height="200dp"

android:layout_margin="32dp"

android:background="@android:color/holo_blue_bright"

app:layout_constraintBottom_toBottomOf="parent"

app:layout_constraintEnd_toEndOf="parent"

app:layout_constraintStart_toStartOf="parent"

app:layout_constraintTop_toTopOf="parent">

</FrameLayout>

<ImageView

android:translationY="-24dp"

android:layout_width="48dp"

android:layout_height="48dp"

android:background="@drawable/circle"

android:padding="8dp"

android:src="@drawable/ic_add_black_24dp"

app:layout_constraintEnd_toEndOf="@+id/fl"

app:layout_constraintStart_toStartOf="@+id/fl"

app:layout_constraintTop_toTopOf="@+id/fl" />

</androidx.constraintlayout.widget.ConstraintLayout>

Input Dialog with top end cancel button

<FrameLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    android:layout_margin="16dp"
    android:background="@android:color/transparent"
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools">

    <androidx.cardview.widget.CardView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="16dp"
        app:cardElevation="24dp">

        <RelativeLayout
            android:id="@+id/edit_name"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">

            <TextView
                android:id="@+id/tvHeadTableNo"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_alignParentTop="true"
                android:layout_marginBottom="8dp"
                android:layout_marginLeft="16dp"
                android:layout_marginStart="16dp"
                android:layout_marginTop="16dp"
                android:text="@string/enter_token_no_for_the_order"
                android:textColor="@android:color/black"
                android:textSize="18sp"
                android:textStyle="bold" />

            <com.google.android.material.textfield.TextInputLayout
                android:id="@+id/evOrderTableNoContainer"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@+id/tvHeadTableNo"
                android:layout_marginEnd="16dp"
                android:layout_marginLeft="16dp"
                android:layout_marginRight="16dp"
                android:layout_marginStart="16dp">

                <EditText
                    android:id="@+id/evOrderTableNo"
                    android:layout_width="match_parent"
                    android:layout_height="48dp"
                    android:layout_gravity="center_horizontal"
                    android:layout_marginBottom="8dp"
                    android:background="@android:color/transparent"
                    android:hint="Token"
                    android:inputType="number"
                    android:maxLength="8"
                    android:maxLines="1"
                    android:paddingBottom="8dp"
                    android:paddingEnd="16dp"
                    android:paddingLeft="16dp"
                    android:paddingRight="16dp"
                    android:paddingStart="16dp"
                    android:paddingTop="8dp"
                    android:textColor="@android:color/black" />
            </com.google.android.material.textfield.TextInputLayout>

            <Button
                android:id="@+id/btnTableNoDoneBtn"
                android:layout_width="match_parent"
                android:layout_height="32dp"
                android:layout_below="@+id/evOrderTableNoContainer"
                android:layout_marginEnd="16dp"
                android:layout_marginLeft="16dp"
                android:layout_marginRight="16dp"
                android:layout_marginStart="16dp"
                android:background="@drawable/rectange_btn"
                android:gravity="center"
                android:text="@string/done"
                android:textColor="@android:color/holo_orange_dark"
                android:textStyle="bold" />

            <ProgressBar
                android:id="@+id/pbDialogInputTableNo"
                android:layout_width="32dp"
                android:layout_height="32dp"
                android:layout_alignLeft="@+id/btnTableNoDoneBtn"
                android:layout_alignStart="@+id/btnTableNoDoneBtn"
                android:layout_alignTop="@+id/btnTableNoDoneBtn"
                android:layout_marginLeft="4dp"
                android:layout_marginStart="4dp"
                android:padding="4dp"
                android:visibility="gone"
                tools:visibility="visible" />

            <TextView
                android:layout_marginTop="4dp"
                android:layout_marginBottom="4dp"
                android:id="@+id/tvOr"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_below="@+id/btnTableNoDoneBtn"
                android:layout_centerInParent="true"
                android:text="@string/or"
                android:textSize="14sp" />

            <Button
                android:id="@+id/btnHomeDelivery"
                android:layout_width="match_parent"
                android:layout_height="32dp"
                android:layout_below="@+id/tvOr"
                android:layout_marginBottom="16dp"
                android:layout_marginEnd="16dp"
                android:layout_marginLeft="16dp"
                android:layout_marginRight="16dp"
                android:layout_marginStart="16dp"
                android:background="@drawable/rectange_btn"
                android:gravity="center"
                android:text="@string/home_delivery"
                android:textColor="@android:color/holo_orange_dark"
                android:textStyle="bold" />
        </RelativeLayout>
    </androidx.cardview.widget.CardView>

    <ImageView
        android:id="@+id/ivCloseTableNo"
        android:layout_width="32dp"
        android:layout_height="32dp"
        android:layout_gravity="end|top"
        android:background="@drawable/circle"
        android:elevation="25dp"
        android:padding="4dp"
        android:src="@drawable/ic_close_black_24dp"
        tools:ignore="UnusedAttribute" />
</FrameLayout>

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

<FrameLayout

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_gravity="center"

android:layout_margin="16dp"

android:background="@android:color/transparent"

xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools">

<androidx.cardview.widget.CardView

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_margin="16dp"

app:cardElevation="24dp">

<RelativeLayout

android:id="@+id/edit_name"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:orientation="vertical">

<TextView

android:id="@+id/tvHeadTableNo"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_alignParentTop="true"

android:layout_marginBottom="8dp"

android:layout_marginLeft="16dp"

android:layout_marginStart="16dp"

android:layout_marginTop="16dp"

android:text="@string/enter_token_no_for_the_order"

android:textColor="@android:color/black"

android:textSize="18sp"

android:textStyle="bold" />

<com.google.android.material.textfield.TextInputLayout

android:id="@+id/evOrderTableNoContainer"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_below="@+id/tvHeadTableNo"

android:layout_marginEnd="16dp"

android:layout_marginLeft="16dp"

android:layout_marginRight="16dp"

android:layout_marginStart="16dp">

<EditText

android:id="@+id/evOrderTableNo"

android:layout_width="match_parent"

android:layout_height="48dp"

android:layout_gravity="center_horizontal"

android:layout_marginBottom="8dp"

android:background="@android:color/transparent"

android:hint="Token"

android:inputType="number"

android:maxLength="8"

android:maxLines="1"

android:paddingBottom="8dp"

android:paddingEnd="16dp"

android:paddingLeft="16dp"

android:paddingRight="16dp"

android:paddingStart="16dp"

android:paddingTop="8dp"

android:textColor="@android:color/black" />

</com.google.android.material.textfield.TextInputLayout>

<Button

android:id="@+id/btnTableNoDoneBtn"

android:layout_width="match_parent"

android:layout_height="32dp"

android:layout_below="@+id/evOrderTableNoContainer"

android:layout_marginEnd="16dp"

android:layout_marginLeft="16dp"

android:layout_marginRight="16dp"

android:layout_marginStart="16dp"

android:background="@drawable/rectange_btn"

android:gravity="center"

android:text="@string/done"

android:textColor="@android:color/holo_orange_dark"

android:textStyle="bold" />

<ProgressBar

android:id="@+id/pbDialogInputTableNo"

android:layout_width="32dp"

android:layout_height="32dp"

android:layout_alignLeft="@+id/btnTableNoDoneBtn"

android:layout_alignStart="@+id/btnTableNoDoneBtn"

android:layout_alignTop="@+id/btnTableNoDoneBtn"

android:layout_marginLeft="4dp"

android:layout_marginStart="4dp"

android:padding="4dp"

android:visibility="gone"

tools:visibility="visible" />

<TextView

android:layout_marginTop="4dp"

android:layout_marginBottom="4dp"

android:id="@+id/tvOr"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_below="@+id/btnTableNoDoneBtn"

android:layout_centerInParent="true"

android:text="@string/or"

android:textSize="14sp" />

<Button

android:id="@+id/btnHomeDelivery"

android:layout_width="match_parent"

android:layout_height="32dp"

android:layout_below="@+id/tvOr"

android:layout_marginBottom="16dp"

android:layout_marginEnd="16dp"

android:layout_marginLeft="16dp"

android:layout_marginRight="16dp"

android:layout_marginStart="16dp"

android:background="@drawable/rectange_btn"

android:gravity="center"

android:text="@string/home_delivery"

android:textColor="@android:color/holo_orange_dark"

android:textStyle="bold" />

</RelativeLayout>

</androidx.cardview.widget.CardView>

<ImageView

android:id="@+id/ivCloseTableNo"

android:layout_width="32dp"

android:layout_height="32dp"

android:layout_gravity="end|top"

android:background="@drawable/circle"

android:elevation="25dp"

android:padding="4dp"

android:src="@drawable/ic_close_black_24dp"

tools:ignore="UnusedAttribute" />

</FrameLayout>

Initialize from activity or fragment using these below code

btnMiddleCircleDialog.setOnClickListener {
    MaterialDialog(this@MainActivity).show {
        setTheme(R.style.AppTheme_DialogTheme)
        setContentView(R.layout.dialog_with_top_middle_circle_view)
    }
}

btnDialogInputTableNo.setOnClickListener {
    MaterialDialog(this@MainActivity).show {
        setTheme(R.style.AppTheme_DialogTheme)
        setContentView(R.layout.dialog_input_table_no)
    }
}

btnMiddleCircleDialog.setOnClickListener {

MaterialDialog(this@MainActivity).show {

setTheme(R.style.AppTheme_DialogTheme)

setContentView(R.layout.dialog_with_top_middle_circle_view)

}

btnDialogInputTableNo.setOnClickListener {

MaterialDialog(this@MainActivity).show {

setTheme(R.style.AppTheme_DialogTheme)

setContentView(R.layout.dialog_input_table_no)

}

Dagger in Action with Retrofit-2, RxJava 2 Part 1

January 26, 2020January 26, 2020shaonLeave a comment

Why should we use it? This may be the first question comes to your mind, r8? isn’t it? Ok, let me explain it. I was a beginner in Android App Development. That time learning a new thing was tedious for me. But I overcame it. Day by day, every developer overcomes it. It is the…

Android MVVM Pattern Tutorial

January 16, 2020January 16, 2020shaonLeave a comment

Android MVVM Pattern MVVM -> Model, View , ViewModel (MVVM Pattern) Model − এটা শুধু ডাটা ধরে রাখে, এখানে লজিকেল কোন কাজ করা হয় না। ViewModel – লজিকেল কাজ গুলো এখানে করা হয় এবং এটা ভিউ ও মডেলের মধ্যে সংযোগ…

Android LiveData with Kotlin Coroutine + Flow

October 31, 2019October 31, 2019shaonLeave a comment

Here I have tried to show two procedures to implement Room using Kotlin Coroutine. Using Flow Reactive pattern

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query

import com.durbinlabs.roomdemo.model.Client
import kotlinx.coroutines.flow.Flow

/**
 * Created by Shaon on 31/10/2019.
 */

@Dao
interface ClientDao {
    @Query("SELECT * FROM client")
    fun all(): Flow<List<Client>>

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(vararg clients: Client)

    @Query("DELETE FROM client")
    suspend fun removeAllClients()
}

import androidx.room.Dao

import androidx.room.Insert

import androidx.room.OnConflictStrategy

import androidx.room.Query

import com.durbinlabs.roomdemo.model.Client

import kotlinx.coroutines.flow.Flow

/**

* Created by Shaon on 31/10/2019.

@Dao

interface ClientDao {

@Query("SELECT * FROM client")

fun all(): Flow<List<Client>>

@Insert(onConflict = OnConflictStrategy.IGNORE)

suspend fun insert(vararg clients: Client)

@Query("DELETE FROM client")

suspend fun removeAllClients()

}

import androidx.lifecycle.*
import com.durbinlabs.roomdemo.interfaces.ClientDao
import com.durbinlabs.roomdemo.model.Client
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.launch

/**
 * Created by Shaon on 10/30/2019.
 */

class ClientVM constructor(val clientDao: ClientDao) : ViewModel() {

    fun insert(client: Client) = viewModelScope.launch {
        clientDao.insert(client)
    }

    // The stream will run in io dispatcher
    val clients  = clientDao.all().flowOn(Dispatchers.IO).asLiveData()

}

import androidx.lifecycle.*

import com.durbinlabs.roomdemo.interfaces.ClientDao

import com.durbinlabs.roomdemo.model.Client

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.flow.flowOn

import kotlinx.coroutines.launch

/**

* Created by Shaon on 10/30/2019.

class ClientVM constructor(val clientDao: ClientDao) : ViewModel() {

fun insert(client: Client) = viewModelScope.launch {

clientDao.insert(client)

}

// The stream will run in io dispatcher

val clients = clientDao.all().flowOn(Dispatchers.IO).asLiveData()

}

Using ViewModel Scope and liveData {} new Asynchronous pattern

import androidx.lifecycle.LiveData
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query

import com.durbinlabs.roomdemo.model.Client

/**
 * Created by Shaon on 31/10/2019.
 */

@Dao
interface ClientDao {


    Using suspend function
    @Query("SELECT * FROM client")
    suspend fun all(): LiveData<List<Client>>

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(vararg clients: Client)

    @Query("DELETE FROM client")
    suspend fun removeAllClients()
}

import androidx.lifecycle.LiveData

import androidx.room.Dao

import androidx.room.Insert

import androidx.room.OnConflictStrategy

import androidx.room.Query

import com.durbinlabs.roomdemo.model.Client

/**

* Created by Shaon on 31/10/2019.

@Dao

interface ClientDao {

Using suspend function

@Query("SELECT * FROM client")

suspend fun all(): LiveData<List<Client>>

@Insert(onConflict = OnConflictStrategy.IGNORE)

suspend fun insert(vararg clients: Client)

@Query("DELETE FROM client")

suspend fun removeAllClients()

}

import androidx.lifecycle.*
import com.durbinlabs.roomdemo.interfaces.ClientDao
import com.durbinlabs.roomdemo.model.Client
import kotlinx.coroutines.launch

/**
 * Created by Shaon on 10/30/2019.
 */

class ClientVM constructor(val clientDao: ClientDao) : ViewModel() {

    fun insert(client: Client) = viewModelScope.launch {
        clientDao.insert(client)
    }

     val clients  = liveData {
         val data = clientDao.all()
         emitSource(data)
     }

}

import androidx.lifecycle.*

import com.durbinlabs.roomdemo.interfaces.ClientDao

import com.durbinlabs.roomdemo.model.Client

import kotlinx.coroutines.launch

/**

* Created by Shaon on 10/30/2019.

class ClientVM constructor(val clientDao: ClientDao) : ViewModel() {

fun insert(client: Client) = viewModelScope.launch {

clientDao.insert(client)

}

val clients = liveData {

val data = clientDao.all()

emitSource(data)

}

To get data in activity or fragment

clientVM.clients
    .observe(this, Observer {
    adapter.addAll(it)
})

clientVM.clients

.observe(this, Observer {

adapter.addAll(it)

})

Helping Gradle Dependency

 //Room
    implementation "androidx.room:room-runtime:$room_version"
    kapt "androidx.room:room-compiler:$room_version"
    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
    implementation "androidx.room:room-ktx:$room_version"

    //  LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-rc01"

    // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version"

//Room

implementation "androidx.room:room-runtime:$room_version"

kapt "androidx.room:room-compiler:$room_version"

implementation 'androidx.legacy:legacy-support-v4:1.0.0'

implementation "androidx.room:room-ktx:$room_version"

// LiveData

implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"

implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-rc01"

// ViewModel

implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"

implementation "android.arch.lifecycle:viewmodel:$lifecycle_version"

Android Receiving location updates in Kotlin

May 29, 2018May 29, 2018shaonLeave a comment

Often we need our user location or need to update user location in our app. This is a simple util class that I build for my pet project. Use this below code as a util class

import android.Manifest
import android.annotation.SuppressLint
import android.app.Activity
import android.content.Context
import android.content.IntentSender
import android.content.pm.PackageManager
import android.os.Looper
import android.support.v4.app.ActivityCompat
import com.google.android.gms.common.api.ResolvableApiException
import com.google.android.gms.location.*
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.tasks.Task
import com.shaon2017.salahz.interfaces.SimpleCallback

/**
 * Created by Shaon on 4/18/2018.
 * Bismillahir Rohmanir Rohim :)
 */
class InitGeoLocationUpdate {
    companion object {
        private var locationCallBack: LocationCallback? = null
        private var fusedLocationClient: FusedLocationProviderClient? = null
        private val TAG = InitGeoLocationUpdate::class.simpleName
        private lateinit var locationLatLngCallback : SimpleCallback&lt;LatLng&gt;

        fun locationInit(context: Context, locationLatLngCallback: SimpleCallback&lt;LatLng&gt;) {
            this.locationLatLngCallback = locationLatLngCallback
            createLocationRequest(context, getLocationCallBack());
        }

        private fun getLocationCallBack(): LocationCallback {
            if (locationCallBack == null)
                return initLocationCallback()
            return locationCallBack!!
        }


        private fun initLocationCallback(): LocationCallback {
            locationCallBack = object : LocationCallback() {
                override fun onLocationResult(locationResult: LocationResult?) {
                    super.onLocationResult(locationResult)

                    val mCurrentLocation = locationResult!!.lastLocation
                    val mCurrentLatLng = LatLng(mCurrentLocation!!.latitude, mCurrentLocation.longitude)

                    locationLatLngCallback.callback(mCurrentLatLng)

                    Lg.d(TAG!!, "Current Location Latitude: " + mCurrentLatLng.latitude + " Longitude: " +
                            mCurrentLatLng.longitude)
                }
            }
            return locationCallBack!!
        }

        @SuppressLint("RestrictedApi")
        private fun createLocationRequest(context: Context, locationCallback: LocationCallback) {
            val locationRequest = LocationRequest().apply {
                interval = 1000
                fastestInterval = 2000
                priority = LocationRequest.PRIORITY_HIGH_ACCURACY
            }
            buildLocationSettingsRequest(context, locationRequest, locationCallback);
        }

        private fun getFusedLocationClient(context: Context): FusedLocationProviderClient? {
            if (fusedLocationClient == null)
                return createFusedLocationClient(context)

            return fusedLocationClient
        }

        private fun createFusedLocationClient(context: Context): FusedLocationProviderClient? {
            fusedLocationClient = LocationServices.getFusedLocationProviderClient(context)
            return fusedLocationClient
        }

        private val REQUEST_CHECK_SETTINGS = 0x1
        private fun buildLocationSettingsRequest(context: Context, locationRequest: LocationRequest,
                                                 locationCallback: LocationCallback) {

            val builder = LocationSettingsRequest.Builder();
            builder.addLocationRequest(locationRequest).setAlwaysShow(true);
//        val mLocationSettingsRequest = builder.build();

            val client: SettingsClient = LocationServices.getSettingsClient(context)
            val task: Task&lt;LocationSettingsResponse&gt; = client.checkLocationSettings(builder.build())


            task.addOnSuccessListener(context as Activity, {
                if (ActivityCompat.checkSelfPermission(context,
                                Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED)
                    getFusedLocationClient(context)!!.requestLocationUpdates(locationRequest,
                            locationCallback, Looper.myLooper());
            }).addOnFailureListener {
                if (it is ResolvableApiException) {
                    // Location settings are not satisfied, but this can be fixed
                    // by showing the user a dialog.
                    try {
                        // Show the dialog by calling startResolutionForResult(),
                        // and check the result in onActivityResult().
                        it.startResolutionForResult(context as Activity,
                                REQUEST_CHECK_SETTINGS)
                    } catch (sendEx: IntentSender.SendIntentException) {
                        // Ignore the error.
                    }
                }
            }
        }

        fun stopLocationUpdate(context: Context) {
            getFusedLocationClient(context as Activity)!!.removeLocationUpdates(getLocationCallBack())
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

import android.Manifest

import android.annotation.SuppressLint

import android.app.Activity

import android.content.Context

import android.content.IntentSender

import android.content.pm.PackageManager

import android.os.Looper

import android.support.v4.app.ActivityCompat

import com.google.android.gms.common.api.ResolvableApiException

import com.google.android.gms.location.*

import com.google.android.gms.maps.model.LatLng

import com.google.android.gms.tasks.Task

import com.shaon2017.salahz.interfaces.SimpleCallback

/**

* Created by Shaon on 4/18/2018.

* Bismillahir Rohmanir Rohim :)

class InitGeoLocationUpdate {

companion object {

private var locationCallBack: LocationCallback? = null

private var fusedLocationClient: FusedLocationProviderClient? = null

private val TAG = InitGeoLocationUpdate::class.simpleName

private lateinit var locationLatLngCallback : SimpleCallback<LatLng>

fun locationInit(context: Context, locationLatLngCallback: SimpleCallback<LatLng>) {

this.locationLatLngCallback = locationLatLngCallback

createLocationRequest(context, getLocationCallBack());

}

private fun getLocationCallBack(): LocationCallback {

if (locationCallBack == null)

return initLocationCallback()

return locationCallBack!!

}

private fun initLocationCallback(): LocationCallback {

locationCallBack = object : LocationCallback() {

override fun onLocationResult(locationResult: LocationResult?) {

super.onLocationResult(locationResult)

val mCurrentLocation = locationResult!!.lastLocation

val mCurrentLatLng = LatLng(mCurrentLocation!!.latitude, mCurrentLocation.longitude)

locationLatLngCallback.callback(mCurrentLatLng)

Lg.d(TAG!!, "Current Location Latitude: " + mCurrentLatLng.latitude + " Longitude: " +

mCurrentLatLng.longitude)

}

return locationCallBack!!

}

@SuppressLint("RestrictedApi")

private fun createLocationRequest(context: Context, locationCallback: LocationCallback) {

val locationRequest = LocationRequest().apply {

interval = 1000

fastestInterval = 2000

priority = LocationRequest.PRIORITY_HIGH_ACCURACY

}

buildLocationSettingsRequest(context, locationRequest, locationCallback);

}

private fun getFusedLocationClient(context: Context): FusedLocationProviderClient? {

if (fusedLocationClient == null)

return createFusedLocationClient(context)

return fusedLocationClient

}

private fun createFusedLocationClient(context: Context): FusedLocationProviderClient? {

fusedLocationClient = LocationServices.getFusedLocationProviderClient(context)

return fusedLocationClient

}

private val REQUEST_CHECK_SETTINGS = 0x1

private fun buildLocationSettingsRequest(context: Context, locationRequest: LocationRequest,

locationCallback: LocationCallback) {

val builder = LocationSettingsRequest.Builder();

builder.addLocationRequest(locationRequest).setAlwaysShow(true);

// val mLocationSettingsRequest = builder.build();

val client: SettingsClient = LocationServices.getSettingsClient(context)

val task: Task<LocationSettingsResponse> = client.checkLocationSettings(builder.build())

task.addOnSuccessListener(context as Activity, {

if (ActivityCompat.checkSelfPermission(context,

Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED)

getFusedLocationClient(context)!!.requestLocationUpdates(locationRequest,

locationCallback, Looper.myLooper());

}).addOnFailureListener {

if (it is ResolvableApiException) {

// Location settings are not satisfied, but this can be fixed

// by showing the user a dialog.

try {

// Show the dialog by calling startResolutionForResult(),

// and check the result in onActivityResult().

it.startResolutionForResult(context as Activity,

REQUEST_CHECK_SETTINGS)

} catch (sendEx: IntentSender.SendIntentException) {

// Ignore the error.

}

fun stopLocationUpdate(context: Context) {

getFusedLocationClient(context as Activity)!!.removeLocationUpdates(getLocationCallBack())

}

How to use? Follow the below code call this below code when you need location update. This…