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/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.ActivitiesResult
+import it.niedermann.owncloud.notes.activities.repository.VersionsRepository
+import it.niedermann.owncloud.notes.activities.repository.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,180 @@
+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.model.Activity
+import it.niedermann.owncloud.notes.activities.repository.ActivitiesRepository
+import it.niedermann.owncloud.notes.activities.repository.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
+
+/*
+ * 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, 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) {
+        // No action
+    }
+
+    override fun onVersionItemClick(version: FileVersion) {
+        binding.swipeContainingList.isRefreshing = true
+        // 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) {
+                when (result) {
+                    RestoreVersionsResult.Success -> syncNote()
+                    RestoreVersionsResult.FailedUnsupported -> showMessage(R.string.version_restore_failed_unsupported)
+                    else -> showMessage(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
+            showMessage(R.string.version_restored)
+        })
+        noteRepo.scheduleSync(account, false)
+    }
+
+    private fun showMessage(@StringRes message: Int) {
+        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() {
+        binding.swipeContainingList.isRefreshing = 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() {
+        binding.swipeContainingList.isRefreshing = 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 {
+            val f = ActivitiesFragment()
+
+            val bundle = Bundle()
+            bundle.putSerializable(ARG_NOTE, note)
+            bundle.putSerializable(ARG_ACCOUNT, account)
+
+            f.arguments = bundle
+            return f
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+/*
+ * 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.model.Activity
+
+class ActivitiesData {
+    val activities = arrayListOf<Activity>()
+    val versions = arrayListOf<FileVersion>()
+    var activitiesLastGiven: Long? = null
+    var activitiesMore: Boolean = true
+
+    fun getAggregatedList(context: Context) : List<ActivityListItem> {
+        val items = arrayListOf<ActivityListItem>()
+        items.addAll(
+            activities.map { ActivityListItem(context, it) }
+        )
+        items.addAll(
+            versions.map { ActivityListItem(context, it) }
+        )
+        items.sortDescending()
+        return items
+    }
+
+    fun isEmpty() : Boolean = activities.isEmpty() && versions.isEmpty()
+}