Add NewTask Activity

app/build.gradle

@@ -25,19 +25,22 @@ android {
 
 ext {
     ankoVersion = '0.10.6'
-    room_version = "2.2.0-beta01"
+    room_version = "2.2.1"
 }
 
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
-    implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation 'androidx.appcompat:appcompat:1.1.0'
     implementation 'androidx.core:core-ktx:1.1.0'
     implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
     implementation 'androidx.recyclerview:recyclerview:1.0.0'
     implementation 'com.google.android.material:material:1.0.0'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2'
+
 
     //database
     implementation "androidx.room:room-runtime:$room_version"
+    implementation "androidx.room:room-ktx:$room_version"
     kapt "androidx.room:room-compiler:$room_version"
 }

app/src/main/AndroidManifest.xml

@@ -6,16 +6,22 @@
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
-        android:roundIcon="@mipmap/ic_launcher_round"
+        android:roundIcon="@mipmap/ic_launcher"
         android:supportsRtl="true"
         android:theme="@style/AppTheme">
+        <activity android:name=".NewTaskActivity"
+            android:parentActivityName=".MainActivity"
+            android:launchMode="singleTop"></activity>
         <activity android:name=".MainActivity">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+        <receiver
+            android:name=".AlarmReceiver"
+            android:enabled="true" />
     </application>
 
 </manifest>

app/src/main/java/com/codingblocks/todo/AlarmReceiver.kt

@@ -0,0 +1,78 @@
+package com.codingblocks.todo
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import android.media.RingtoneManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+
+class AlarmReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+
+        val mNotificationManager =
+            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            mNotificationManager.createNotificationChannel(
+                NotificationChannel(
+                    "default",
+                    "Todo",
+                    NotificationManager.IMPORTANCE_DEFAULT
+                )
+            )
+        }
+
+        val taskRowId = intent.extras?.getString(TASK_ID)
+        val taskTitle = intent.extras?.getString(TASK_TITLE)
+        val taskTask = intent.extras?.getString(TASK_TASK)
+
+        //To Open the app on clicking notification
+        val notificationIntent = Intent(context, MainActivity::class.java)
+        val pendingIntent = PendingIntent.getActivity(
+            context,
+            0,
+            notificationIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT
+        )
+
+        val notificationFinishIntent = Intent(context, MainActivity::class.java)
+        notificationFinishIntent.putExtra(TASK_ID, taskRowId)
+        notificationFinishIntent.action = "FINISH"
+        val pendingFinishIntent = PendingIntent.getActivity(
+            context,
+            0,
+            notificationFinishIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT
+        )
+
+        val title = taskTitle//taskTitle//task title
+        val message = taskTask//taskTask//task
+        val icon = R.mipmap.ic_launcher
+        val time = System.currentTimeMillis()
+
+        val notification = NotificationCompat.Builder(context, "default")
+            .setContentTitle(title)
+            .setLargeIcon(BitmapFactory.decodeResource(context.resources, R.mipmap.ic_launcher))
+            .setContentText(message)
+            .setContentIntent(pendingIntent)
+            .setColor(Color.argb(225, 225, 87, 34))
+            .setSmallIcon(icon)
+            .setWhen(time)
+            .addAction(R.drawable.ic_check_black_24dp, "Finish", pendingFinishIntent)
+            .setAutoCancel(true)
+            .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
+            .build()
+        mNotificationManager.notify(Integer.parseInt(taskRowId?:""/*rowId*/), notification)
+
+
+
+    }
+}

app/src/main/java/com/codingblocks/todo/AppDatabase.kt

@@ -0,0 +1,9 @@
+package com.codingblocks.todo
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+
+@Database(entities = [TaskModel::class],version = 1)
+abstract class AppDatabase : RoomDatabase() {
+    abstract fun taskDao(): TaskDao
+}

app/src/main/java/com/codingblocks/todo/Constants.kt

@@ -0,0 +1,16 @@
+package com.codingblocks.todo
+
+/*****************   Task  *****************/
+
+const val TABLE_TASK = "TASK"
+const val TASK_TITLE = "title"
+const val TASK_TASK = "task"
+const val TASK_CATEGORY = "category"
+const val TASK_DATE = "date"
+const val TASK_TIME = "time"
+const val TASK_FINISH = "finish"
+const val TASK_ID = "task_id"
+
+
+const val TASK_IS_FINISH = 1
+const val TASK_IS_NOT_FINISH = 0

app/src/main/java/com/codingblocks/todo/MainActivity.kt

@@ -1,12 +1,186 @@
 package com.codingblocks.todo
 
-import androidx.appcompat.app.AppCompatActivity
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.graphics.*
 import android.os.Bundle
+import android.util.DisplayMetrics
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.isVisible
+import androidx.lifecycle.Observer
+import androidx.recyclerview.widget.ItemTouchHelper
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import androidx.room.Room
+import kotlinx.android.synthetic.main.activity_main.*
 
 class MainActivity : AppCompatActivity() {
 
+    var mArrayList: ArrayList<TaskModel> = ArrayList()
+    lateinit var taskAdapter: TaskAdapter
+
+    val mNotificationManager by lazy {
+        getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    }
+
+    val db: AppDatabase by lazy {
+        Room.databaseBuilder(
+            this,
+            AppDatabase::class.java,
+            "todo.db"
+        ).fallbackToDestructiveMigration()
+            .build()
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
+
+        recyclerViewTask.setHasFixedSize(true)
+        recyclerViewTask.layoutManager = LinearLayoutManager(this)
+        taskAdapter = TaskAdapter(mArrayList)
+        recyclerViewTask.adapter = taskAdapter
+
+        initSwipe()
+
+        fabAddTask.setOnClickListener {
+            startActivity(Intent(this, NewTaskActivity::class.java))
+        }
+
+        db.taskDao().getTask(TASK_IS_NOT_FINISH).observe(this, Observer {
+            if (it.isNotEmpty()) {
+                mArrayList = it as ArrayList<TaskModel>
+                taskAdapter.setList(mArrayList)
+            } else {
+                mArrayList = it as ArrayList<TaskModel>
+                taskAdapter.setList(mArrayList)
+            }
+            txtNoTask.isVisible = it.isEmpty()
+        })
+    }
+
+    override fun onStart() {
+        super.onStart()
+
+        if (intent.action == "FINISH") {
+            val id = intent.getStringExtra(TASK_ID)
+            id?.let {
+                db.taskDao().finishTask(id.toLong())
+                mNotificationManager.cancel(id.toInt())
+            }
+        }
+
+    }
+
+    //Dont Explain this code
+    private fun initSwipe() {
+
+        val simpleItemTouchCallback = object :
+            ItemTouchHelper.SimpleCallback(0, ItemTouchHelper.LEFT or ItemTouchHelper.RIGHT) {
+
+            override fun onMove(
+                recyclerView: RecyclerView,
+                viewHolder: RecyclerView.ViewHolder,
+                target: RecyclerView.ViewHolder
+            ): Boolean {
+                return false
+            }
+
+            override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
+                val position = viewHolder.adapterPosition
+
+                if (direction == ItemTouchHelper.LEFT) {
+                    db.taskDao().deleleTask(taskAdapter.getItemId(position))
+                } else {
+                    db.taskDao().finishTask(taskAdapter.getItemId(position))
+                }
+            }
+
+            override fun onChildDraw(
+                canvas: Canvas,
+                recyclerView: RecyclerView,
+                viewHolder: RecyclerView.ViewHolder,
+                dX: Float,
+                dY: Float,
+                actionState: Int,
+                isCurrentlyActive: Boolean
+            ) {
+
+                if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
+
+                    val itemView = viewHolder.itemView
+
+                    val paint = Paint()
+                    val iconBitmap: Bitmap
+
+                    if (dX > 0) {
+
+                        iconBitmap =
+                            BitmapFactory.decodeResource(resources, R.mipmap.ic_check_white_png)
+
+                        paint.color = Color.parseColor(getString(R.color.green))
+
+                        canvas.drawRect(
+                            itemView.left.toFloat(), itemView.top.toFloat(),
+                            itemView.left.toFloat() + dX, itemView.bottom.toFloat(), paint
+                        )
+
+                        // Set the image icon for Right side swipe
+                        canvas.drawBitmap(
+                            iconBitmap,
+                            itemView.left.toFloat() + convertDpToPx(16),
+                            itemView.top.toFloat() + (itemView.bottom.toFloat() - itemView.top.toFloat() - iconBitmap.height.toFloat()) / 2,
+                            paint
+                        )
+                    } else {
+
+                        iconBitmap =
+                            BitmapFactory.decodeResource(resources, R.mipmap.ic_delete_white_png)
+
+                        paint.color = Color.parseColor(getString(R.color.red))
+
+                        canvas.drawRect(
+                            itemView.right.toFloat() + dX, itemView.top.toFloat(),
+                            itemView.right.toFloat(), itemView.bottom.toFloat(), paint
+                        )
+
+                        //Set the image icon for Left side swipe
+                        canvas.drawBitmap(
+                            iconBitmap,
+                            itemView.right.toFloat() - convertDpToPx(16) - iconBitmap.width,
+                            itemView.top.toFloat() + (itemView.bottom.toFloat() - itemView.top.toFloat() - iconBitmap.height.toFloat()) / 2,
+                            paint
+                        )
+                    }
+
+                    val ALPHA_FULL: Float = 1.0f
+
+                    // Fade out the view as it is swiped out of the parent's bounds
+                    val alpha: Float =
+                        ALPHA_FULL - Math.abs(dX) / viewHolder.itemView.width.toFloat()
+                    viewHolder.itemView.alpha = alpha
+                    viewHolder.itemView.translationX = dX
+
+                } else {
+                    super.onChildDraw(
+                        canvas,
+                        recyclerView,
+                        viewHolder,
+                        dX,
+                        dY,
+                        actionState,
+                        isCurrentlyActive
+                    )
+                }
+            }
+        }
+        val itemTouchHelper = ItemTouchHelper(simpleItemTouchCallback)
+        itemTouchHelper.attachToRecyclerView(recyclerViewTask)
+    }
+
+
+    private fun convertDpToPx(dp: Int): Int {
+        return Math.round(dp * (resources.displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT))
     }
 }