26-02-2020 by maha

# WORK MANAGER (Periodic)
# Added Logger

Author: Mahalingam

app/src/main/java/com/example/simplework/activity/FirstActivity.kt

@@ -7,6 +7,7 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.lifecycle.Observer
 import androidx.work.*
 import com.example.simplework.R
+import com.example.simplework.utils.Logger
 import com.example.simplework.worker.OneTimeWorker
 import com.google.android.material.button.MaterialButton
 import com.google.android.material.textfield.TextInputEditText
@@ -26,6 +27,8 @@ class FirstActivity : AppCompatActivity() {
         setContentView(R.layout.activity_first)
 
         init()
+
+        Logger().e("asa","Show error")
     }
 
 

app/src/main/java/com/example/simplework/activity/MainActivity.kt

@@ -14,6 +14,7 @@ import androidx.databinding.DataBindingUtil
 import com.example.simplework.R
 import com.example.simplework.databinding.ActivityMainBinding
 import com.example.simplework.model.Taskinfo
+import com.example.simplework.utils.Logger
 import kotlinx.android.synthetic.main.activity_main.view.*
 
 class MainActivity : AppCompatActivity() {
@@ -36,7 +37,17 @@ class MainActivity : AppCompatActivity() {
             rocketAnimation = background as AnimationDrawable
         }
 
-        init()
+
+        val quotient = 285 / 60
+        val remainder = 285 % 60
+
+        val aFinalSleepHrs= "$quotient.${remainder.toString()[0]}"
+
+       // Log.e("Final string",aFinalSleepHrs)
+
+        Logger().e("Final string",aFinalSleepHrs)
+
+       // init()
     }
 
     private fun init() {
@@ -77,6 +88,8 @@ class MainActivity : AppCompatActivity() {
     }
 
     fun button2Click(view: View) {
+        Logger().e("Final string","button2Click")
+
         startActivity(Intent(this, ThirdActivity::class.java))
           //view.button2.setBackgroundResource(R.drawable.shake_anim)
         //rocketAnimation.start()

app/src/main/java/com/example/simplework/activity/ThirdActivity.kt

@@ -17,6 +17,7 @@ class ThirdActivity : AppCompatActivity() {
 
     lateinit var binding: ActivityThirdBinding
     lateinit var aPeriodicWork: PeriodicWorkRequest
+    lateinit var  mPeroidRequest:PeriodicWorkRequest.Builder
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -26,15 +27,35 @@ class ThirdActivity : AppCompatActivity() {
 
         binding.act = this
 
+        setWrokManager()
 
 
-        aPeriodicWork = PeriodicWorkRequestBuilder<PeriodicTimeWorker>(
+
+    }
+
+    /**
+     * TODO
+     * call work manager every 15 minutes
+     */
+    private fun setWrokManager() {
+       /* aPeriodicWork = PeriodicWorkRequestBuilder<PeriodicTimeWorker>(
             15,
             TimeUnit.MINUTES,
             10,
             TimeUnit.MINUTES
-        ).setConstraints(setConstraint()).build()
+        ).setConstraints(setConstraint())
+            .setInputData(createInputData())
+            .setBackoffCriteria(
+                BackoffPolicy.LINEAR,
+                OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
+                TimeUnit.MILLISECONDS)
 
+            .build()*/
+
+
+        mPeroidRequest=PeriodicWorkRequest.Builder(PeriodicTimeWorker::class.java,15,TimeUnit.MINUTES)
+            .setConstraints(setConstraint())
+         aPeriodicWork=mPeroidRequest.build()
     }
 
 
@@ -43,39 +64,49 @@ class ThirdActivity : AppCompatActivity() {
         return Constraints.Builder()
             .setRequiredNetworkType(NetworkType.CONNECTED) // check internet connectivity
             .setRequiresBatteryNotLow(true) // check battery level
-            .setRequiresCharging(true) // check charging mode
+            //.setRequiresCharging(true) // check charging mode
             // .setRequiresStorageNotLow(true) // check storage
             // .setRequiresDeviceIdle(false) // check device idle state
             .build()
 
     }
 
     fun startTask(aView: View) {
-        WorkManager.getInstance(this)
-            .enqueueUniquePeriodicWork("UNIQUE", ExistingPeriodicWorkPolicy.REPLACE, aPeriodicWork)
+        /*WorkManager.getInstance(this)
+            .enqueueUniquePeriodicWork("UNIQUE", ExistingPeriodicWorkPolicy.KEEP, aPeriodicWork)*/
+
+        WorkManager.getInstance(this).enqueue(aPeriodicWork)
+
 
         WorkManager.getInstance(this).getWorkInfoByIdLiveData(aPeriodicWork.id).observe(this,
             Observer {
                 if (it != null) {
                     when (it.state) {
 
                         WorkInfo.State.SUCCEEDED -> {
-                            //val myResult = it.outputData.getString("Success")
-                           // Log.e("Out put", myResult)
+                            val myResult = it.outputData.getString("Success")
+                            Log.e("Out put", myResult?:"")
                             Log.e("STATUS", "SUCCEEDED")
                         }
-
                         WorkInfo.State.RUNNING -> {
+                            val myResult = it.outputData.getString("Success")
+                            Log.e("Out put", myResult?:"")
                             Log.e("STATUS", "RUNNING")
                         }
-
                         WorkInfo.State.CANCELLED -> {
                             Log.e("STATUS", "CANCELLED")
                         }
-
                         WorkInfo.State.FAILED -> {
                             Log.e("STATUS", "FAILED")
                         }
+                        WorkInfo.State.ENQUEUED -> {
+                            val myResult = it.outputData.getString("Success")
+                            Log.e("Out put", myResult?:"")
+                            Log.e("STATUS", "ENQUEUED")
+                        }
+                        WorkInfo.State.BLOCKED -> {
+                            Log.e("STATUS", "BLOCKED")
+                        }
                         else -> {
                             Log.e("STATUS", "STATUS")
                         }
@@ -90,4 +121,20 @@ class ThirdActivity : AppCompatActivity() {
         WorkManager.getInstance(this).cancelUniqueWork("UNIQUE")
     }
 
+    private fun createInputData(): Data {
+
+        return Data.Builder()
+            .putString("username", "Maha")
+            .putString("password", "Lingam").build()
+
+
+    }
+
+
+    override fun onDestroy() {
+        super.onDestroy()
+        WorkManager.getInstance(this).cancelAllWork()
+        WorkManager.getInstance(this).cancelUniqueWork("UNIQUE")
+    }
+
 }

app/src/main/java/com/example/simplework/utils/Logger.kt

@@ -0,0 +1,53 @@
+package com.example.simplework.utils
+
+import android.util.Log
+import com.example.simplework.BuildConfig
+
+class Logger {
+
+    private val TAG: String = BuildConfig.APPLICATION_ID
+
+    fun e(Msg: String) {
+        LogIt(Log.ERROR, TAG, Msg)
+    }
+
+    fun e(Tag: String?, Msg: String) {
+        LogIt(Log.ERROR, Tag, Msg)
+    }
+
+    fun i(Msg: String) {
+        LogIt(Log.INFO, TAG, Msg)
+    }
+
+    fun i(Tag: String?, Msg: String) {
+        LogIt(Log.INFO, Tag, Msg)
+    }
+
+    fun d(Msg: String) {
+        LogIt(Log.DEBUG, TAG, Msg)
+    }
+
+    fun d(Tag: String?, Msg: String) {
+        LogIt(Log.DEBUG, Tag, Msg)
+    }
+
+    fun v(Msg: String) {
+        LogIt(Log.VERBOSE, TAG, Msg)
+    }
+
+    fun v(Tag: String?, Msg: String) {
+        LogIt(Log.VERBOSE, Tag, Msg)
+    }
+
+    fun w(Msg: String) {
+        LogIt(Log.WARN, TAG, Msg)
+    }
+
+    fun w(Tag: String?, Msg: String) {
+        LogIt(Log.WARN, Tag, Msg)
+    }
+
+    private fun LogIt(LEVEL: Int, Tag: String?, Message: String) {
+        if (BuildConfig.DEBUG) Log.println(LEVEL, Tag ?: TAG, Message)
+    }
+}

app/src/main/java/com/example/simplework/worker/PeriodicTimeWorker.kt

@@ -2,17 +2,27 @@ package com.example.simplework.worker
 
 import android.content.Context
 import android.util.Log
+import androidx.work.Data
 import androidx.work.Worker
 import androidx.work.WorkerParameters
 
-class PeriodicTimeWorker(context: Context, workerParams: WorkerParameters) : Worker(
+class PeriodicTimeWorker(context: Context, val workerParams: WorkerParameters) : Worker(
     context,
     workerParams
 ) {
     override fun doWork(): Result {
 
         Log.e("Periodic", "PeriodicTimeWorker")
 
-        return Result.success()
+        val aData = workerParams.inputData
+
+        Log.e("User ", "" + aData.getString("username") ?: "1")
+        Log.e("Password ", "" + aData.getString("password") ?: "1")
+
+        return Result.success(createOutputData())
+    }
+
+    private fun createOutputData(): Data {
+        return Data.Builder().putString("Success", "1").build()
     }
 }