Implement activities (files versions)

LICENSES/BSD-2-Clause.txt

@@ -0,0 +1,9 @@
+Copyright (c) <year> <owner> 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

app/build.gradle.kts

@@ -6,9 +6,11 @@
  * SPDX-FileCopyrightText: 2020 Hui-Ouyang16 <11710106@mail.sustech.edu.cn>
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
+@file:Suppress("MagicNumber")
 
 plugins {
     id("com.android.application")
+    id("com.google.devtools.ksp")
 }
 
 val kotlinVersion = rootProject.extra["kotlinVersion"] as String
@@ -130,6 +132,7 @@ dependencies {
     implementation("commons-httpclient:commons-httpclient:3.1") {
         exclude(group = "commons-logging", module = "commons-logging")
     }
+    implementation("org.apache.jackrabbit:jackrabbit-webdav:2.13.5")
 
     implementation("com.github.nextcloud:android-library:2.26.1") {
         exclude(group = "org.ogce", module = "xpp3")
@@ -156,7 +159,8 @@ dependencies {
     // Glide
     val glideVersion = "5.0.9"
     implementation("com.github.bumptech.glide:glide:$glideVersion")
-    annotationProcessor("com.github.bumptech.glide:compiler:$glideVersion")
+    ksp("com.github.bumptech.glide:ksp:$glideVersion")
+    implementation("com.caverock:androidsvg-aar:1.4")
 
     // Android X
     implementation("androidx.appcompat:appcompat:1.8.0")

app/src/main/AndroidManifest.xml

@@ -58,7 +58,7 @@
         </activity>
 
         <activity
-            android:name=".share.NoteShareActivity" />
+            android:name=".itemdetails.ItemDetailsActivity" />
 
         <activity
             android:name=".share.NoteShareDetailActivity" />

app/src/main/java/it/niedermann/owncloud/notes/activities/ActivitiesDataProvider.kt

@@ -0,0 +1,123 @@
+/*
+ * Nextcloud Notes - Android Client
+ *
+ * SPDX-FileCopyrightText: 2026 Daniele Verducci <daniele.verducci@nextcloud.com>
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+package it.niedermann.owncloud.notes.activities
+
+import android.content.Context
+import android.util.Log
+import androidx.lifecycle.LifecycleCoroutineScope
+import com.nextcloud.android.sso.helper.SingleAccountHelper
+import it.niedermann.owncloud.notes.activities.ActivitiesFragment.Companion.TAG
+import it.niedermann.owncloud.notes.activities.adapter.ActivitiesData
+import it.niedermann.owncloud.notes.activities.repository.ActivitiesRepository
+import it.niedermann.owncloud.notes.activities.repository.model.ActivitiesResult
+import it.niedermann.owncloud.notes.activities.repository.VersionsRepository
+import it.niedermann.owncloud.notes.activities.repository.model.VersionsResult
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class ActivitiesDataProvider (
+    val context: Context,
+    val lifecycleScope: LifecycleCoroutineScope,
+    val noteId: Long,
+    val listener: OnPageFetchedListener
+) {
+    val data = ActivitiesData()
+    private var job: Job? = null
+
+    private val ssoAccount = SingleAccountHelper.getCurrentSingleSignOnAccount(context)
+    private val activitiesRepo = ActivitiesRepository(context, ssoAccount)
+    private val versionsRepo = VersionsRepository(context, ssoAccount)
+
+    fun fetchFirstPage() {
+        job?.cancel()
+        job = lifecycleScope.launch {
+            val (activitiesResult, versionsResult) = withContext(Dispatchers.IO) {
+                val activities = async {
+                    activitiesRepo.fetchActivities(noteId)
+                }
+                val versions = async {
+                    versionsRepo.fetchVersions(noteId)
+                }
+                activities.await() to versions.await()
+            }
+
+            if (!parseActivitiesResult(activitiesResult)) return@launch
+
+            if (!parseVersionsResult(versionsResult)) return@launch
+
+            listener.onPageFetched()
+        }
+    }
+
+    fun fetchNextPage() {
+        if (job?.isActive == true) return
+
+        if (!data.activitiesMore) return
+
+        job = lifecycleScope.launch {
+            val activitiesResult = withContext(Dispatchers.IO) {
+                activitiesRepo.fetchActivities(noteId, data.activitiesLastGiven)
+            }
+
+            if (!parseActivitiesResult(activitiesResult)) return@launch
+
+            listener.onPageFetched()
+        }
+    }
+
+    private fun parseActivitiesResult(activitiesResult: ActivitiesResult): Boolean {
+        return when (activitiesResult) {
+            is ActivitiesResult.Success -> {
+                data.activitiesLastGiven = activitiesResult.lastGiven
+                data.activitiesMore = activitiesResult.lastGiven != null
+                data.activities.addAll(activitiesResult.activities)
+                true
+            }
+
+            is ActivitiesResult.FailedNoCapability -> {
+                Log.d(TAG, "Server has no Activity endpoint")
+                data.activitiesMore = false
+                true
+            }
+
+            is ActivitiesResult.Failed -> {
+                Log.e(TAG, "Fetching activities failed")
+                listener.onPageFetchError()
+                false
+            }
+        }
+    }
+
+    private fun parseVersionsResult(versionsResult: VersionsResult): Boolean {
+        return when (versionsResult) {
+            is VersionsResult.Success -> {
+                data.versions.addAll(versionsResult.versions)
+                true
+            }
+            is VersionsResult.Failed -> {
+                Log.e(TAG, "Fetching versions failed")
+                false
+            }
+        }
+    }
+
+    fun reset() {
+        data.activities.clear()
+        data.versions.clear()
+        data.activitiesLastGiven = null
+        data.activitiesMore = true
+    }
+
+    interface OnPageFetchedListener {
+        fun onPageFetched()
+        fun onPageFetchError()
+    }
+}

app/src/main/java/it/niedermann/owncloud/notes/activities/ActivitiesFragment.kt

@@ -0,0 +1,178 @@
+/*
+ * Nextcloud Notes - Android Client
+ *
+ * SPDX-FileCopyrightText: 2026 Daniele Verducci <daniele.verducci@nextcloud.com>
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+package it.niedermann.owncloud.notes.activities
+
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.annotation.StringRes
+import androidx.lifecycle.lifecycleScope
+import com.google.android.material.snackbar.Snackbar
+import com.nextcloud.android.sso.helper.SingleAccountHelper
+import com.owncloud.android.lib.resources.files.model.FileVersion
+import it.niedermann.owncloud.notes.R
+import it.niedermann.owncloud.notes.activities.adapter.ActivityListAdapter
+import it.niedermann.owncloud.notes.activities.adapter.OnActivityClickListener
+import it.niedermann.owncloud.notes.activities.adapter.model.Activity
+import it.niedermann.owncloud.notes.activities.repository.ActivitiesRepository
+import it.niedermann.owncloud.notes.activities.repository.model.RestoreVersionsResult
+import it.niedermann.owncloud.notes.activities.repository.VersionsRepository
+import it.niedermann.owncloud.notes.branding.BrandedFragment
+import it.niedermann.owncloud.notes.branding.BrandedSnackbar
+import it.niedermann.owncloud.notes.branding.BrandingUtil
+import it.niedermann.owncloud.notes.databinding.FragmentActivitiesBinding
+import it.niedermann.owncloud.notes.persistence.NotesRepository
+import it.niedermann.owncloud.notes.persistence.entity.Account
+import it.niedermann.owncloud.notes.persistence.entity.Note
+import it.niedermann.owncloud.notes.shared.util.extensions.getSerializableArgument
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class ActivitiesFragment : BrandedFragment(), OnActivityClickListener, ActivitiesDataProvider.OnPageFetchedListener {
+
+    lateinit var binding : FragmentActivitiesBinding
+    private lateinit var note: Note
+    private lateinit var account: Account
+    private lateinit var adapter: ActivityListAdapter
+
+    private lateinit var activityDataProvider: ActivitiesDataProvider
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+        adapter = ActivityListAdapter(requireContext(), this)
+        binding = FragmentActivitiesBinding.inflate(inflater, container, false)
+
+        initializeArguments()
+        initializeList()
+
+        return binding.root
+    }
+
+    private fun initializeArguments() {
+        val bundler = arguments
+        note = bundler.getSerializableArgument(ARG_NOTE, Note::class.java)
+            ?: throw IllegalArgumentException("Argument $ARG_NOTE is mandatory")
+        account = bundler.getSerializableArgument(ARG_ACCOUNT, Account::class.java)
+            ?: throw IllegalArgumentException("Argument $ARG_ACCOUNT is mandatory")
+    }
+
+    private fun initializeList() {
+        val id = note.remoteId
+        if (id == null) {
+            Log.e(TAG, "Unable to load list: note has no remoteId")
+            return
+        }
+
+        activityDataProvider = ActivitiesDataProvider(
+            requireContext(),
+            lifecycleScope,
+            id,
+            this
+        )
+        binding.list.adapter = adapter
+        binding.swipeContainingList.setOnRefreshListener {
+            // Reload list
+            activityDataProvider.reset()
+            activityDataProvider.fetchFirstPage()
+        }
+
+        activityDataProvider.fetchFirstPage()
+    }
+
+    override fun applyBrand(color: Int) {
+        adapter.applyBrand(color)
+        val util = BrandingUtil.of(color, requireContext())
+        util.platform.colorViewBackground(binding.getRoot())
+        util.androidx.themeSwipeRefreshLayout(binding.swipeContainingList)
+    }
+
+    override fun onActivityItemClick(activity: Activity) = Unit
+
+    override fun onVersionItemClick(version: FileVersion) {
+        showProgress(true)
+        lifecycleScope.launch(Dispatchers.IO) {
+            // Restore the version
+            val ssoAccount =
+                SingleAccountHelper.getCurrentSingleSignOnAccount(requireContext())
+            val repository = VersionsRepository(requireContext(), ssoAccount)
+            val result = repository.restoreVersion(version)
+            withContext(Dispatchers.Main) {
+                when (result) {
+                    RestoreVersionsResult.Success -> syncNote()
+                    RestoreVersionsResult.FailedUnsupported ->
+                        showMessageAndHideProgress(R.string.version_restore_failed_unsupported)
+                    else -> showMessageAndHideProgress(R.string.version_restore_failed)
+                }
+            }
+        }
+    }
+
+    private fun syncNote() {
+        // Sync the restored note
+        val noteRepo = NotesRepository.getInstance(binding.root.context)
+        noteRepo.addCallbackPull(account, {
+            // Used in node editor: RESULT_OK means reload the note
+            requireActivity().setResult(android.app.Activity.RESULT_OK)
+
+            // Reload list
+            activityDataProvider.reset()
+            activityDataProvider.fetchFirstPage()
+
+            // Notify user
+            showMessageAndHideProgress(R.string.version_restored)
+        })
+        noteRepo.scheduleSync(account, false)
+    }
+
+    private fun showProgress(show: Boolean) { binding.swipeContainingList.isRefreshing = show }
+
+    private fun showMessageAndHideProgress(@StringRes message: Int) {
+        showProgress(false)
+        BrandedSnackbar.make(binding.root, message, Snackbar.LENGTH_LONG).show()
+    }
+
+    override fun lastActivityReached() {
+        if (adapter.itemCount < ActivitiesRepository.PAGE_SIZE)
+            return
+        activityDataProvider.fetchNextPage()
+    }
+
+    @SuppressLint("NotifyDataSetChanged")
+    override fun onPageFetched() {
+        showProgress(false)
+        binding.emptyList.visibility = View.GONE
+        adapter.items.clear()
+        adapter.items.addAll(
+            activityDataProvider.data.getAggregatedList(requireContext())
+        )
+        adapter.lastActivity = activityDataProvider.data.activities.lastOrNull()
+        adapter.notifyDataSetChanged()
+    }
+
+    override fun onPageFetchError() {
+        showProgress(false)
+        if (adapter.items.isEmpty()) binding.emptyList.visibility = View.VISIBLE
+        BrandedSnackbar.make(binding.root, R.string.activities_error, Snackbar.LENGTH_SHORT).show()
+    }
+
+    companion object {
+        val TAG = ActivitiesFragment::class.simpleName
+        const val ARG_NOTE = "NOTE"
+        const val ARG_ACCOUNT = "ACCOUNT"
+
+        fun newInstance(note: Note, account: Account) : ActivitiesFragment = ActivitiesFragment().apply {
+            arguments = Bundle().apply {
+                putSerializable(ARG_NOTE, note)
+                putSerializable(ARG_ACCOUNT, account)
+            }
+        }
+    }
+}

app/src/main/java/it/niedermann/owncloud/notes/activities/adapter/ActivitiesData.kt

@@ -0,0 +1,35 @@
+/*
+ * Nextcloud Notes - Android Client
+ *
+ * SPDX-FileCopyrightText: 2026 Daniele Verducci <daniele.verducci@nextcloud.com>
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+package it.niedermann.owncloud.notes.activities.adapter
+
+import android.content.Context
+import com.owncloud.android.lib.resources.files.model.FileVersion
+import it.niedermann.owncloud.notes.activities.adapter.model.Activity
+import it.niedermann.owncloud.notes.activities.adapter.model.ActivityListItem
+import it.niedermann.owncloud.notes.activities.adapter.model.ActivityListItem.FileVersionItem
+
+data class ActivitiesData(
+    val activities: ArrayList<Activity> = arrayListOf(),
+    val versions: ArrayList<FileVersion> = arrayListOf(),
+    var activitiesLastGiven: Long? = null,
+    var activitiesMore: Boolean = true
+) {
+    fun getAggregatedList(context: Context) : List<ActivityListItem> {
+        val items = arrayListOf<ActivityListItem>()
+        items.addAll(
+            activities.map { ActivityListItem.ActivityItem(it) }
+        )
+        items.addAll(
+            versions.map { FileVersionItem(context, it) }
+        )
+        items.sortDescending()
+        return items
+    }
+
+    fun isEmpty() : Boolean = activities.isEmpty() && versions.isEmpty()
+}