Reorganize and group modules

2022-12-13 17:37:26 +01:00
parent bac24baad2
commit 3f8880a90a
995 changed files with 501 additions and 298 deletions
@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.READ_CALENDAR" />
+</manifest>
@@ -0,0 +1,213 @@
+package de.mm20.launcher2.calendar
+
+import android.content.ContentUris
+import android.content.Context
+import android.provider.CalendarContract
+import androidx.core.database.getStringOrNull
+import de.mm20.launcher2.permissions.PermissionGroup
+import de.mm20.launcher2.permissions.PermissionsManager
+import de.mm20.launcher2.search.data.CalendarEvent
+import de.mm20.launcher2.search.data.UserCalendar
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
+import org.koin.core.component.KoinComponent
+import java.util.Calendar
+
+interface CalendarRepository {
+
+    fun search(query: String): Flow<ImmutableList<CalendarEvent>>
+    fun getUpcomingEvents(
+        excludeCalendars: List<Long>,
+        excludeAllDayEvents: Boolean
+    ): Flow<List<CalendarEvent>>
+
+    suspend fun getCalendars(): List<UserCalendar>
+}
+
+internal class CalendarRepositoryImpl(
+    private val context: Context,
+    private val permissionsManager: PermissionsManager,
+) : CalendarRepository {
+
+    override fun search(query: String): Flow<ImmutableList<CalendarEvent>> {
+        if (query.isBlank() || query.length < 3) {
+            return flow {
+                emit(persistentListOf())
+            }
+        }
+
+        val hasPermission = permissionsManager.hasPermission(PermissionGroup.Calendar)
+        return hasPermission.map {
+            if (it) {
+                val now = System.currentTimeMillis()
+                queryCalendarEvents(
+                    query,
+                    intervalStart = now,
+                    intervalEnd = now + 14 * 24 * 60 * 60 * 1000L,
+                ).toImmutableList()
+            } else {
+                persistentListOf()
+            }
+        }
+
+    }
+
+    private suspend fun queryCalendarEvents(
+        query: String,
+        intervalStart: Long,
+        intervalEnd: Long,
+        limit: Int = 10,
+        excludeAllDayEvents: Boolean = false,
+        excludeCalendars: List<Long> = emptyList(),
+    ): List<CalendarEvent> {
+        val results = withContext(Dispatchers.IO) {
+            val results = mutableListOf<CalendarEvent>()
+            val builder = CalendarContract.Instances.CONTENT_URI.buildUpon()
+            ContentUris.appendId(builder, intervalStart)
+            ContentUris.appendId(builder, intervalEnd)
+            val uri = builder.build()
+            val projection = arrayOf(
+                CalendarContract.Instances.EVENT_ID,
+                CalendarContract.Instances.TITLE,
+                CalendarContract.Instances.BEGIN,
+                CalendarContract.Instances.END,
+                CalendarContract.Instances.ALL_DAY,
+                CalendarContract.Instances.DISPLAY_COLOR,
+                CalendarContract.Instances.EVENT_LOCATION,
+                CalendarContract.Instances.CALENDAR_ID,
+                CalendarContract.Instances.DESCRIPTION
+            )
+            val selection = mutableListOf<String>()
+            if (query.isNotEmpty()) selection.add("${CalendarContract.Instances.TITLE} LIKE ?")
+            if (excludeCalendars.isNotEmpty()) selection.add("${CalendarContract.Instances.CALENDAR_ID} NOT IN (${excludeCalendars.joinToString()})")
+            if (excludeAllDayEvents) selection.add("${CalendarContract.Instances.ALL_DAY} = 0")
+            val selArgs = if (query.isBlank()) null else arrayOf("%$query%")
+            val sort =
+                "${CalendarContract.Instances.BEGIN} ASC" + if (limit > -1) " LIMIT $limit" else ""
+            val cursor = context.contentResolver.query(
+                uri,
+                projection,
+                selection.joinToString(separator = " AND "),
+                selArgs,
+                sort
+            ) ?: return@withContext mutableListOf()
+            val proj = arrayOf(
+                CalendarContract.Attendees.EVENT_ID,
+                CalendarContract.Attendees.ATTENDEE_NAME,
+                CalendarContract.Attendees.ATTENDEE_EMAIL
+            )
+            val s = "${CalendarContract.Attendees.ATTENDEE_NAME} COLLATE NOCASE ASC"
+            while (cursor.moveToNext()) {
+                val sel = "${CalendarContract.Attendees.EVENT_ID} = ${cursor.getLong(0)}"
+                val cur = context.contentResolver.query(
+                    CalendarContract.Attendees.CONTENT_URI,
+                    proj, sel, null, s
+                ) ?: return@withContext mutableListOf()
+                val attendees = mutableListOf<String>()
+                while (cur.moveToNext()) {
+                    attendees.add(
+                        cur.getStringOrNull(1).takeUnless { it.isNullOrBlank() }
+                            ?: cur.getStringOrNull(2)
+                            ?: continue
+                    )
+                }
+                cur.close()
+                val allday = cursor.getInt(4) > 0
+                val begin = cursor.getLong(2)
+
+                val tzOffset = if (allday) {
+                    Calendar.getInstance().timeZone.getOffset(begin)
+                } else {
+                    0
+                }
+                val event = CalendarEvent(
+                    label = cursor.getStringOrNull(1) ?: "",
+                    id = cursor.getLong(0),
+                    color = cursor.getInt(5),
+                    startTime = begin - tzOffset,
+                    endTime = cursor.getLong(3) - tzOffset - if (allday) 1 else 0,
+                    allDay = allday,
+                    location = cursor.getStringOrNull(6) ?: "",
+                    attendees = attendees,
+                    description = cursor.getStringOrNull(8)
+                        ?: "",
+                    calendar = cursor.getLong(7)
+                )
+                results.add(event)
+            }
+            cursor.close()
+            return@withContext results
+        }
+
+        return results
+    }
+
+    override fun getUpcomingEvents(
+        excludeCalendars: List<Long>,
+        excludeAllDayEvents: Boolean,
+    ): Flow<List<CalendarEvent>> = channelFlow {
+        val hasPermission = permissionsManager.hasPermission(PermissionGroup.Calendar)
+        hasPermission.collectLatest {
+            if (it) {
+                val now = System.currentTimeMillis()
+                val end = now + 14 * 24 * 60 * 60 * 1000L
+                val events = withContext(Dispatchers.IO) {
+                    queryCalendarEvents(
+                        query = "",
+                        intervalStart = now,
+                        intervalEnd = end,
+                        limit = 700,
+                        excludeAllDayEvents = excludeAllDayEvents,
+                        excludeCalendars = excludeCalendars
+                    )
+                }
+                send(events)
+            } else {
+                send(emptyList())
+            }
+        }
+    }
+
+    override suspend fun getCalendars(): List<UserCalendar> {
+        if (!permissionsManager.checkPermissionOnce(PermissionGroup.Calendar)) return emptyList()
+        return withContext(Dispatchers.IO) {
+            val calendars = mutableListOf<UserCalendar>()
+            val uri = CalendarContract.Calendars.CONTENT_URI
+            val proj = arrayOf(
+                CalendarContract.Calendars._ID,
+                CalendarContract.Calendars.NAME,
+                CalendarContract.Calendars.ACCOUNT_NAME,
+                CalendarContract.Calendars.CALENDAR_COLOR,
+                CalendarContract.Calendars.VISIBLE,
+                CalendarContract.Calendars.CALENDAR_DISPLAY_NAME,
+            )
+            val cursor = context.contentResolver.query(uri, proj, null, null, null)
+                ?: return@withContext emptyList()
+            while (cursor.moveToNext()) {
+                try {
+                    calendars.add(
+                        UserCalendar(
+                            id = cursor.getLong(0),
+                            name = cursor.getStringOrNull(5) ?: cursor.getStringOrNull(1) ?: "",
+                            owner = cursor.getStringOrNull(2) ?: "",
+                            color = cursor.getInt(3)
+                        )
+                    )
+                } catch (e: NullPointerException) {
+                    continue
+                }
+            }
+            cursor.close()
+            calendars.sortBy { it.owner }
+            return@withContext calendars
+        }
+    }
+}
@@ -0,0 +1,106 @@
+package de.mm20.launcher2.calendar
+
+import android.Manifest
+import android.content.ContentUris
+import android.content.Context
+import android.content.pm.PackageManager
+import android.provider.CalendarContract
+import androidx.core.content.ContextCompat
+import androidx.core.database.getStringOrNull
+import de.mm20.launcher2.search.SavableSearchable
+import de.mm20.launcher2.search.SearchableDeserializer
+import de.mm20.launcher2.search.SearchableSerializer
+import de.mm20.launcher2.search.data.CalendarEvent
+import org.json.JSONObject
+import java.util.*
+
+class CalendarEventSerializer: SearchableSerializer {
+    override fun serialize(searchable: SavableSearchable): String {
+        searchable as CalendarEvent
+        val json = JSONObject()
+        json.put("id", searchable.id)
+        return json.toString()
+    }
+
+    override val typePrefix: String
+        get() = "calendar"
+}
+
+class CalendarEventDeserializer(val context: Context): SearchableDeserializer {
+    override fun deserialize(serialized: String): SavableSearchable? {
+        if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CALENDAR) != PackageManager.PERMISSION_GRANTED) return null
+        val json = JSONObject(serialized)
+        val id = json.getLong("id")
+        val builder = CalendarContract.Instances.CONTENT_URI.buildUpon()
+        ContentUris.appendId(builder, System.currentTimeMillis())
+        ContentUris.appendId(builder, System.currentTimeMillis() + 63072000000L)
+        val uri = builder.build()
+        val projection = arrayOf(
+            CalendarContract.Instances.EVENT_ID,
+            CalendarContract.Instances.TITLE,
+            CalendarContract.Instances.BEGIN,
+            CalendarContract.Instances.END,
+            CalendarContract.Instances.ALL_DAY,
+            CalendarContract.Instances.DISPLAY_COLOR,
+            CalendarContract.Instances.EVENT_LOCATION,
+            CalendarContract.Instances.CALENDAR_ID,
+            CalendarContract.Instances.DESCRIPTION
+        )
+        val selection = CalendarContract.Instances.EVENT_ID + " = ?"
+        val selArgs = arrayOf(id.toString())
+        val cursor = context.contentResolver.query(uri, projection, selection, selArgs, null)
+            ?: return null
+        if (cursor.moveToNext()) {
+            val title = cursor.getStringOrNull(1) ?: ""
+            val begin = cursor.getLong(2)
+            val end = cursor.getLong(3)
+            val allday = cursor.getInt(4) != 0
+            val color = cursor.getInt(5)
+            val location = cursor.getStringOrNull(6)
+            val calendar = cursor.getLong(7)
+            val description = cursor.getStringOrNull(8)
+                ?: ""
+            cursor.close()
+            val proj = arrayOf(
+                CalendarContract.Attendees.EVENT_ID,
+                CalendarContract.Attendees.ATTENDEE_NAME,
+                CalendarContract.Attendees.ATTENDEE_EMAIL
+            )
+            val sel = "${CalendarContract.Attendees.EVENT_ID} = $id"
+            val s = "${CalendarContract.Attendees.ATTENDEE_NAME} COLLATE NOCASE ASC"
+            val cur = context.contentResolver.query(
+                CalendarContract.Attendees.CONTENT_URI,
+                proj, sel, null, s
+            ) ?: return null
+            val attendees = mutableListOf<String>()
+            while (cur.moveToNext()) {
+                attendees.add(
+                    cur.getStringOrNull(1).takeUnless { it.isNullOrBlank() }
+                    ?: cur.getStringOrNull(2)
+                    ?: continue
+                )
+            }
+            cur.close()
+            val tzOffset = if (allday) {
+                Calendar.getInstance().timeZone.getOffset(begin)
+            } else {
+                0
+            }
+            return CalendarEvent(
+                label = title,
+                id = id,
+                color = color,
+                startTime = begin - tzOffset,
+                endTime = end - tzOffset - if (allday) 1 else 0,
+                allDay = allday,
+                location = location ?: "",
+                attendees = attendees,
+                description = description,
+                calendar = calendar
+            )
+        }
+        cursor.close()
+        return null
+    }
+
+}
@@ -0,0 +1,8 @@
+package de.mm20.launcher2.calendar
+
+import org.koin.android.ext.koin.androidContext
+import org.koin.dsl.module
+
+val calendarModule = module {
+    single<CalendarRepository> { CalendarRepositoryImpl(androidContext(), get()) }
+}
@@ -0,0 +1,70 @@
+package de.mm20.launcher2.search.data
+
+import android.content.ContentUris
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.provider.CalendarContract
+import de.mm20.launcher2.icons.ColorLayer
+import de.mm20.launcher2.icons.StaticLauncherIcon
+import de.mm20.launcher2.icons.TextLayer
+import de.mm20.launcher2.ktx.tryStartActivity
+import de.mm20.launcher2.search.SavableSearchable
+import java.text.SimpleDateFormat
+
+data class CalendarEvent(
+    override val label: String,
+    val id: Long,
+    val color: Int,
+    val startTime: Long,
+    val endTime: Long,
+    val allDay: Boolean,
+    val location: String,
+    val attendees: List<String>,
+    val description: String,
+    val calendar: Long,
+    override val labelOverride: String? = null,
+) : SavableSearchable {
+
+    override val domain: String = Domain
+
+    override val key: String
+        get() = "$domain://$id"
+
+    override val preferDetailsOverLaunch: Boolean = true
+
+    override fun overrideLabel(label: String): CalendarEvent {
+        return this.copy(labelOverride = label)
+    }
+
+    override fun getPlaceholderIcon(context: Context): StaticLauncherIcon {
+        val df = SimpleDateFormat("dd")
+        return StaticLauncherIcon(
+            foregroundLayer = TextLayer(
+                text = df.format(startTime),
+                color = color
+            ),
+            backgroundLayer = ColorLayer(color)
+        )
+    }
+
+    private fun getLaunchIntent(): Intent {
+        val uri = ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, id)
+        return Intent(Intent.ACTION_VIEW).setData(uri).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+
+    override fun launch(context: Context, options: Bundle?): Boolean {
+        return context.tryStartActivity(getLaunchIntent(), options)
+    }
+
+    companion object {
+        const val Domain = "calendar"
+    }
+}
+
+data class UserCalendar(
+    val id: Long,
+    val name: String,
+    val owner: String,
+    val color: Int
+)