Implement activities (files versions)

app/build.gradle

@@ -8,6 +8,7 @@
  */
 
 apply plugin: 'com.android.application'
+apply plugin: 'com.google.devtools.ksp'
 
 android {
     namespace = 'it.niedermann.owncloud.notes'
@@ -130,6 +131,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.0") {
         exclude group: 'org.ogce', module: 'xpp3'
@@ -155,7 +157,8 @@ dependencies {
 
     // Glide
     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/ActivitiesFragment.kt

@@ -0,0 +1,220 @@
+package it.niedermann.owncloud.notes.activities
+
+import android.os.Bundle
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+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.model.Activity
+import it.niedermann.owncloud.notes.activities.repository.ActivitiesRepository
+import it.niedermann.owncloud.notes.activities.repository.ActivitiesResult
+import it.niedermann.owncloud.notes.activities.repository.RestoreVersionsResult
+import it.niedermann.owncloud.notes.activities.repository.VersionsRepository
+import it.niedermann.owncloud.notes.activities.repository.VersionsResult
+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.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
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+
+/*
+ * 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
+ */
+class ActivitiesFragment : BrandedFragment(), OnActivityClickListener {
+
+    lateinit var binding : FragmentActivitiesBinding
+    private lateinit var note: Note
+    private lateinit var account: Account
+    private lateinit var adapter: ActivityListAdapter
+    private var lastGiven: Long? = null
+
+    private var executorService: ScheduledExecutorService? = null
+
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+        executorService = Executors.newSingleThreadScheduledExecutor()
+        binding = FragmentActivitiesBinding.inflate(inflater, container, false)
+
+        initializeArguments()
+        initializeList()
+
+        fetchData()
+
+        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() {
+        adapter = ActivityListAdapter(
+            requireContext(),
+            this
+        )
+        binding.list.adapter = adapter
+        binding.swipeContainingList.setOnRefreshListener { fetchData() }
+    }
+
+    override fun applyBrand(color: Int) {
+        adapter.applyBrand(color)
+        val util = BrandingUtil.of(color, requireContext())
+        util.platform.colorViewBackground(binding.getRoot())
+        util.androidx.themeSwipeRefreshLayout(binding.swipeContainingList)
+    }
+
+    private fun fetchData() {
+        fetchActivities()
+        fetchVersions()
+    }
+
+    private fun fetchActivities(reqLastGiven: Long? = null) {
+        val noteId = note.remoteId ?: return
+
+        binding.swipeContainingList.isRefreshing = true
+
+        executorService!!.submit(Runnable submit@{
+            val ssoAccount =
+                SingleAccountHelper.getCurrentSingleSignOnAccount(requireContext())
+            val repository = ActivitiesRepository(requireContext(), ssoAccount)
+            lifecycleScope.launch(Dispatchers.IO) {
+                val result = repository.fetchActivities(noteId, reqLastGiven)
+                withContext(Dispatchers.Main) {
+                    when (result) {
+                        is ActivitiesResult.Success -> {
+                            val isFirstPage = reqLastGiven == null || lastGiven == null
+                            lastGiven = result.lastGiven
+                            showActivities(result.activities, isFirstPage)
+                        }
+
+                        is ActivitiesResult.FailedNotModified -> {
+                            Log.i(TAG, "Reached end of list (last page starting from item $lastGiven")
+                        }
+
+                        is ActivitiesResult.Failed -> {
+                            adapter.clear()
+                            showEmptyContent(getString(R.string.activities_error))
+                        }
+                    }
+
+                    binding.swipeContainingList.isRefreshing = false
+                }
+            }
+
+        })
+    }
+
+    private fun fetchVersions() {
+        val noteId = note.remoteId ?: return
+        executorService!!.submit(Runnable submit@{
+            val ssoAccount =
+                SingleAccountHelper.getCurrentSingleSignOnAccount(requireContext())
+            val repository = VersionsRepository(requireContext(), ssoAccount)
+            lifecycleScope.launch(Dispatchers.IO) {
+                val result = repository.fetchVersions(noteId)
+                withContext(Dispatchers.Main) {
+                    when (result) {
+                        is VersionsResult.Success -> {
+                            showVersions(result.versions)
+                            result.versions.forEach {
+                                Log.d("DEBUG", "Version: ${it.remoteId} ${it.fileName} ${it.modifiedTimestamp}")
+                            }
+                        }
+
+                        is VersionsResult.Failed -> {
+                            Log.e("DEBUG", "Versions failed")
+                        }
+                    }
+                }
+            }
+        })
+    }
+
+    private fun showActivities(items: List<Activity>, isFirstPage: Boolean) {
+        binding.emptyList.visibility = View.GONE
+        if (isFirstPage) adapter.clear()
+        adapter.addActivities(items)
+    }
+
+    private fun showVersions(items: List<FileVersion>) {
+        binding.emptyList.visibility = View.GONE
+        adapter.addVersions(items)
+    }
+
+    private fun showEmptyContent(message: String) =
+        with (binding.emptyList) {
+            visibility = View.VISIBLE
+            text = message
+        }
+
+    override fun onActivityItemClick(activity: Activity) {
+        // No action
+    }
+
+    override fun onVersionItemClick(version: FileVersion) {
+        // Restore the version
+        val ssoAccount =
+            SingleAccountHelper.getCurrentSingleSignOnAccount(requireContext())
+        val repository = VersionsRepository(requireContext(), ssoAccount)
+        lifecycleScope.launch(Dispatchers.IO) {
+            val result = repository.restoreVersion(version)
+            withContext(Dispatchers.Main) {
+                val message =
+                    if (result == RestoreVersionsResult.Success)
+                        R.string.version_restored
+                    else
+                        R.string.version_restore_failed
+
+                BrandedSnackbar.make(binding.root, message, Snackbar.LENGTH_LONG).show()
+
+                // Reload list
+                if (result == RestoreVersionsResult.Success) fetchData()
+            }
+        }
+    }
+
+    override fun lastActivityReached() {
+        if (adapter.itemCount < ActivitiesRepository.PAGE_SIZE)
+            return
+        fetchActivities(lastGiven)
+    }
+
+    companion object {
+        val TAG = ActivitiesFragment::class.simpleName
+        const val ARG_NOTE = "NOTE"
+        const val ARG_ACCOUNT = "ACCOUNT"
+
+        fun newInstance(note: Note, account: Account) : ActivitiesFragment {
+            val f = ActivitiesFragment()
+
+            val bundle = Bundle()
+            bundle.putSerializable(ARG_NOTE, note)
+            bundle.putSerializable(ARG_ACCOUNT, account)
+
+            f.arguments = bundle
+            return f
+        }
+    }
+}