Add note before archiving

This fixes https://github.com/syncthing/syncthing-lite/issues/133

README.md

@@ -1,3 +1,5 @@
+Nobody is working on this project anymore. If you’d like to pick up development, please ask about it on https://forum.syncthing.net/ 1, or feel free to fork.
+
 # Syncthing Lite
 
 [![Build Status](https://travis-ci.org/syncthing/syncthing-lite.svg?branch=master)](https://travis-ci.org/syncthing/syncthing-lite)

Releasing.md

@@ -1,8 +1,9 @@
 # Releasing
 
 - do tests
-- update translations using ``tx pull -a -af`` (as extra merge request or branch for the case it does not build correctly)
-- update the version name and version code of the app
+- update translations using ``tx pull -af`` (as extra merge request or branch for the case it does not build correctly)
+- update the version name and version code of the app [here](https://github.com/syncthing/syncthing-lite/blob/master/app/build.gradle)
 - update the changelog at [app/src/main/play/en-GB/whatsnew](https://github.com/syncthing/syncthing-lite/blob/master/app/src/main/play/en-GB/whatsnew)
 - create a tag/ release in GitHub with an changelog; The tag name should be the version number
-- F-Droid picks up the release by the tag; additonally, the tag triggers a CI build which uploads the generated APK to Google Play
+- trigger a release at <https://build.syncthing.net/> to publish the release to google play
+- F-Droid picks up the release by the tag

Roadmap.md

@@ -0,0 +1,20 @@
+# Roadmap
+
+## What should happen
+
+- fixing bugs and crashs
+  - just create a issue WITH a detailed crash report (not: it does not work)
+  - search if there is an other issue for it before creating a new one
+- add option to manually select the IP address of an device (<https://github.com/syncthing/syncthing-lite/issues/25>)
+- allow custom discovery servers or disabling device discovery (<https://github.com/syncthing/syncthing-lite/issues/105>)
+- downloading all files of an folder (<https://github.com/syncthing/syncthing-lite/issues/34>)
+- better server offline handling (<https://github.com/syncthing/syncthing-lite/issues/63>)
+- file uploading support (it currently does not work) <https://github.com/syncthing/syncthing-lite/issues/70>
+
+## What could happen
+
+- thumbnails (<https://github.com/syncthing/syncthing-lite/issues/37>)
+
+## What will not happen
+
+- additional encryption within the App (see <https://github.com/syncthing/syncthing-lite/issues/85>)

app/build.gradle

@@ -6,7 +6,6 @@ apply plugin: 'com.github.triplet.play'
 
 android {
     compileSdkVersion 27
-    buildToolsVersion "28.0.2"
     dataBinding.enabled = true
 
     playAccountConfigs {
@@ -19,8 +18,8 @@ android {
         applicationId "net.syncthing.lite"
         minSdkVersion 21
         targetSdkVersion 26
-        versionCode 15
-        versionName "0.3.5"
+        versionCode 22
+        versionName "0.3.12"
         multiDexEnabled true
         playAccountConfig = playAccountConfigs.defaultAccountConfig
     }
@@ -77,16 +76,6 @@ dependencies {
     implementation "com.android.support:support-v4:$support_version"
     implementation 'android.arch.lifecycle:extensions:1.1.1'
 
-    /**
-     * syncthing-java depends on the Apache HTTP Client
-     * https://github.com/syncthing/syncthing-java/blob/dd020737ba5fc6a7c681a1d258025b8ddb2e8f67/core/build.gradle#L9
-     *
-     * Android itself contains an older version of this HTTP Client. Due to that, there is an
-     * extra version of it which does not cause conflicts with the builtin client of Android.
-     *
-     * This extra implementation is included below. As this other version is used,
-     * it's ignored as dependency of syncthing-java.
-     */
     implementation(project(':syncthing-client')) {
         exclude group: 'commons-logging', module: 'commons-logging'
         exclude group: 'org.slf4j'
@@ -99,4 +88,5 @@ dependencies {
     implementation 'com.github.apl-devs:appintro:v4.2.3'
 
     implementation project(':syncthing-repository-android')
+    implementation project(':syncthing-temp-repository-encryption')
 }

app/proguard-rules.pro

@@ -28,6 +28,9 @@
   volatile <fields>;
 }
 
+# fix detecting the main dispatcher
+-keepnames class kotlinx.coroutines.internal.MainDispatcherFactory {}
+
 # disable warnings
 -dontwarn com.google.protobuf.UnsafeUtil
 -dontwarn com.google.protobuf.UnsafeUtil$1

app/src/main/kotlin/net/syncthing/lite/activities/FolderBrowserActivity.kt

@@ -4,48 +4,63 @@ import android.app.Activity
 import android.content.Intent
 import android.databinding.DataBindingUtil
 import android.os.Bundle
-import android.util.Log
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
-import net.syncthing.java.bep.IndexBrowser
+import android.view.Menu
+import android.view.MenuItem
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.ConflatedBroadcastChannel
+import kotlinx.coroutines.channels.consumeEach
+import net.syncthing.java.bep.index.browser.DirectoryContentListing
+import net.syncthing.java.bep.index.browser.DirectoryListing
+import net.syncthing.java.bep.index.browser.DirectoryNotFoundListing
+import net.syncthing.java.bep.index.browser.IndexBrowser
 import net.syncthing.java.core.beans.FileInfo
-import net.syncthing.java.core.beans.FolderInfo
 import net.syncthing.java.core.utils.PathUtils
-import net.syncthing.lite.BuildConfig
 import net.syncthing.lite.R
 import net.syncthing.lite.adapters.FolderContentsAdapter
 import net.syncthing.lite.adapters.FolderContentsListener
 import net.syncthing.lite.databinding.ActivityFolderBrowserBinding
+import net.syncthing.lite.dialogs.EnableFolderSyncForNewDeviceDialog
 import net.syncthing.lite.dialogs.FileMenuDialogFragment
 import net.syncthing.lite.dialogs.FileUploadDialog
 import net.syncthing.lite.dialogs.ReconnectIssueDialogFragment
 import net.syncthing.lite.dialogs.downloadfile.DownloadFileDialogFragment
-import org.jetbrains.anko.doAsync
 
 class FolderBrowserActivity : SyncthingActivity() {
 
     companion object {
-
-        private const val TAG = "FolderBrowserActivity"
         private const val REQUEST_SELECT_UPLOAD_FILE = 171
-
+        private const val STATUS_PATH = "path"
         const val EXTRA_FOLDER_NAME = "folder_name"
     }
 
-    private lateinit var binding: ActivityFolderBrowserBinding
-    private lateinit var indexBrowser: IndexBrowser
-    private val adapter = FolderContentsAdapter()
+    private lateinit var folder: String
+
+    private val path = ConflatedBroadcastChannel<String>()
+    private val listing = ConflatedBroadcastChannel<DirectoryListing?>(null)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = DataBindingUtil.setContentView(this, R.layout.activity_folder_browser)
-        binding.mainListViewUploadHereButton.setOnClickListener { showUploadHereDialog() }
+
+        val binding: ActivityFolderBrowserBinding = DataBindingUtil.setContentView(this, R.layout.activity_folder_browser)
+        val adapter = FolderContentsAdapter()
+
         binding.listView.adapter = adapter
+        binding.mainListViewUploadHereButton.setOnClickListener {
+            startActivityForResult(
+                    Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+                        addCategory(Intent.CATEGORY_OPENABLE)
+                        type = "*/*"
+                    },
+                    REQUEST_SELECT_UPLOAD_FILE
+            )
+        }
         adapter.listener = object: FolderContentsListener {
             override fun onItemClicked(fileInfo: FileInfo) {
-                navigateToFolder(fileInfo)
+                if (fileInfo.isDirectory()) {
+                    path.offer(fileInfo.path)
+                } else {
+                    DownloadFileDialogFragment.newInstance(fileInfo).show(supportFragmentManager)
+                }
             }
 
             override fun onItemLongClicked(fileInfo: FileInfo): Boolean {
@@ -58,26 +73,98 @@ class FolderBrowserActivity : SyncthingActivity() {
                 }
             }
         }
-        val folder = intent.getStringExtra(EXTRA_FOLDER_NAME)
-        libraryHandler.syncthingClient {
-            indexBrowser = it.indexHandler.newIndexBrowser(folder, true, true)
-            indexBrowser.setOnFolderChangedListener(this::onFolderChanged)
-        }
 
         ReconnectIssueDialogFragment.showIfNeeded(this)
+
+        folder = intent.getStringExtra(EXTRA_FOLDER_NAME)
+        path.offer(if (savedInstanceState == null) IndexBrowser.ROOT_PATH else savedInstanceState.getString(STATUS_PATH))
+
+        launch {
+            var job = Job()
+
+            path.consumeEach { path ->
+                job.cancel()
+                job = Job()
+
+                binding.listView.scrollToPosition(0)
+
+                listing.send(null)
+
+                async(job) {
+                    libraryHandler.libraryManager.streamDirectoryListing(folder, path).consumeEach {
+                        listing.send(it)
+                    }
+                }
+            }
+        }
+
+        launch {
+            listing.openSubscription().consumeEach { listing ->
+                if (listing == null) {
+                    binding.isLoading = true
+                } else {
+                    supportActionBar?.title = if (PathUtils.isRoot(listing.path)) folder else PathUtils.getFileName(listing.path)
+                    binding.isLoading = false
+                    adapter.data = if (listing is DirectoryContentListing)
+                        listing.entries.sortedWith(IndexBrowser.sortAlphabeticallyDirectoriesFirst)
+                    else
+                        emptyList()
+                }
+            }
+        }
+
+        if (savedInstanceState == null) {
+            launch {
+                val devicesToAskFor = libraryHandler.libraryManager.withLibrary {
+                    val folderInfo = it.configuration.folders.find { it.folderId == folder }
+                    val notIgnoredBlacklistEntries = folderInfo?.notIgnoredBlacklistEntries ?: emptySet()
+
+                    notIgnoredBlacklistEntries.mapNotNull { deviceId ->
+                        it.configuration.peers.find { peer -> peer.deviceId == deviceId }
+                    }
+                }
+
+                if (devicesToAskFor.isNotEmpty()) {
+                    EnableFolderSyncForNewDeviceDialog.newInstance(
+                            folderId = folder,
+                            devices = devicesToAskFor,
+                            folderName = libraryHandler.libraryManager.withLibrary {
+                                it.configuration.folders.find { it.folderId == folder }?.label ?: folder
+                            }
+                    ).show(supportFragmentManager)
+                }
+            }
+        }
     }
 
-    override fun onDestroy() {
-        super.onDestroy()
-        Thread {
-            indexBrowser.setOnFolderChangedListener(null)
-            indexBrowser.close()
-        }.start()
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+
+        outState.putString(STATUS_PATH, path.value)
+    }
+
+    private fun goUp(): Boolean {
+        val currentListing = listing.value
+
+        val parentPath = when (currentListing) {
+            is DirectoryContentListing -> currentListing.parentEntry?.path
+            is DirectoryNotFoundListing -> currentListing.theoreticalParentPath
+            else -> null
+        }
+
+        return if (parentPath == null) {
+            false
+        } else {
+            path.offer(parentPath)
+
+            true
+        }
     }
 
     override fun onBackPressed() {
-        //click item '0', ie '..' (go to parent)
-        navigateToFolder(adapter.data[0])
+        if (!goUp()) {
+            super.onBackPressed()
+        }
     }
 
     override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
@@ -85,9 +172,14 @@ class FolderBrowserActivity : SyncthingActivity() {
             libraryHandler.syncthingClient { syncthingClient ->
                 GlobalScope.launch (Dispatchers.Main) {
                     // FIXME: it would be better if the dialog would use the library handler
-                    FileUploadDialog(this@FolderBrowserActivity, syncthingClient, intent!!.data,
-                            indexBrowser.folder, indexBrowser.currentPath,
-                            { showFolderListView(indexBrowser.currentPath) }).show()
+                    FileUploadDialog(
+                            this@FolderBrowserActivity,
+                            syncthingClient,
+                            intent!!.data,
+                            folder,
+                            path.value,
+                            { /* nothing to do on success */ }
+                    ).show()
                 }
             }
         } else {
@@ -95,75 +187,25 @@ class FolderBrowserActivity : SyncthingActivity() {
         }
     }
 
-    private fun showFolderListView(path: String) {
-        indexBrowser.navigateToNearestPath(path)
-        navigateToFolder(indexBrowser.currentPathInfo())
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.folder_browser, menu)
+
+        return true
     }
 
-    private fun navigateToFolder(fileInfo: FileInfo) {
-        Log.d(TAG, "navigate to path = '" + fileInfo.path + "' from path = '" + indexBrowser.currentPath + "'")
-        if (indexBrowser.isRoot() && PathUtils.isParent(fileInfo.path)) {
+    override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
+        R.id.go_home -> {
             finish()
-        } else {
-            if (fileInfo.isDirectory()) {
-                doAsync {
-                    indexBrowser.navigateTo(fileInfo)
-                }
 
-                Log.d(TAG, "load folder cache bg")
-                binding.isLoading = true
-            } else {
-                if (BuildConfig.DEBUG) {
-                    Log.i(TAG, "pulling file = " + fileInfo)
-                }
-
-                DownloadFileDialogFragment.newInstance(fileInfo).show(supportFragmentManager)
-            }
+            true
         }
-    }
-
-    private fun onFolderChanged() {
-        GlobalScope.launch {
-            val list = indexBrowser.listFiles()
-
-            Log.i("navigateToFolder", "list for path = '" + indexBrowser.currentPath + "' list = " + list.size + " records")
-            Log.d("navigateToFolder", "list for path = '" + indexBrowser.currentPath + "' list = " + list)
-            assert(!list.isEmpty())//list must contain at least the 'parent' path
-
-            val title = if (indexBrowser.isRoot()) {
-                val result = CompletableDeferred<String?>()
-
-                libraryHandler.folderBrowser {
-                    result.complete(it.getFolderInfo(indexBrowser.folder)?.label)
-                }
-
-                result.await()
-            } else {
-                indexBrowser.currentPathInfo().fileName
+        android.R.id.home -> {
+            if (!goUp()) {
+                finish()
             }
 
-            runOnUiThread {
-                binding.isLoading = false
-                adapter.data = list
-                binding.listView.scrollToPosition(0)
-                supportActionBar?.title = title
-            }
+            true
         }
-    }
-
-    private fun updateFolderListView() {
-        showFolderListView(indexBrowser.currentPath)
-    }
-
-    private fun showUploadHereDialog() {
-        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT)
-        intent.addCategory(Intent.CATEGORY_OPENABLE)
-        intent.type = "*/*"
-        startActivityForResult(intent, REQUEST_SELECT_UPLOAD_FILE)
-    }
-
-    override fun onIndexUpdateComplete(folderInfo: FolderInfo) {
-        super.onIndexUpdateComplete(folderInfo)
-        updateFolderListView()
+        else -> super.onOptionsItemSelected(item)
     }
 }

app/src/main/kotlin/net/syncthing/lite/activities/IntroActivity.kt

@@ -12,9 +12,9 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.Button
 import com.github.paolorotolo.appintro.AppIntro
+import com.github.paolorotolo.appintro.ISlidePolicy
 import com.google.zxing.integration.android.IntentIntegrator
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.launch
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.lite.R
@@ -40,14 +40,6 @@ class IntroActivity : AppIntro() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        // Disable continue button on second slide until a valid device ID is entered.
-        nextButton.setOnClickListener {
-            val fragment = fragments[pager.currentItem]
-            if (fragment !is IntroFragmentTwo || fragment.isDeviceIdValid()) {
-                pager.goToNextSlide()
-            }
-        }
-
         addSlide(IntroFragmentOne())
         addSlide(IntroFragmentTwo())
         addSlide(IntroFragmentThree())
@@ -72,6 +64,19 @@ class IntroActivity : AppIntro() {
      * Display some simple welcome text.
      */
     class IntroFragmentOne : SyncthingFragment() {
+        override fun onCreate(savedInstanceState: Bundle?) {
+            super.onCreate(savedInstanceState)
+
+            launch {
+                libraryHandler.libraryManager.withLibrary { library ->
+                    library.configuration.update { oldConfig ->
+                        oldConfig.copy(localDeviceName = Util.getDeviceName())
+                    }
+
+                    library.configuration.persistLater()
+                }
+            }
+        }
 
         override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
             val binding = FragmentIntroOneBinding.inflate(inflater, container, false)
@@ -80,21 +85,12 @@ class IntroActivity : AppIntro() {
 
             return binding.root
         }
-
-        override fun onLibraryLoaded() {
-            super.onLibraryLoaded()
-
-            libraryHandler.configuration { config ->
-                config.localDeviceName = Util.getDeviceName()
-                config.persistLater()
-            }
-        }
     }
 
     /**
      * Display device ID entry field and QR scanner option.
      */
-    class IntroFragmentTwo : SyncthingFragment() {
+    class IntroFragmentTwo : SyncthingFragment(), ISlidePolicy {
 
         private lateinit var binding: FragmentIntroTwoBinding
 
@@ -122,7 +118,7 @@ class IntroActivity : AppIntro() {
         fun isDeviceIdValid(): Boolean {
             return try {
                 val deviceId = binding.enterDeviceId.deviceId.text.toString()
-                Util.importDeviceId(libraryHandler, context, deviceId, { })
+                Util.importDeviceId(libraryHandler.libraryManager, context!!, deviceId, { })
                 true
             } catch (e: IOException) {
                 binding.enterDeviceId.deviceId.error = getString(R.string.invalid_device_id)
@@ -130,6 +126,12 @@ class IntroActivity : AppIntro() {
             }
         }
 
+        override fun isPolicyRespected() = isDeviceIdValid()
+
+        override fun onUserIllegallyRequestedNextPage() {
+            // nothing to do, but some user feedback would be nice
+        }
+
         private val addedDeviceIds = HashSet<DeviceId>()
 
         override fun onResume() {
@@ -176,32 +178,31 @@ class IntroActivity : AppIntro() {
      */
     class IntroFragmentThree : SyncthingFragment() {
 
-        private lateinit var binding: FragmentIntroThreeBinding
-
         override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
-            binding = DataBindingUtil.inflate(inflater, R.layout.fragment_intro_three, container, false)
+            val binding = FragmentIntroThreeBinding.inflate(inflater, container, false)
 
-            libraryHandler.library { config, client, _ ->
-                GlobalScope.launch (Dispatchers.Main) {
-                    client.addOnConnectionChangedListener(this@IntroFragmentThree::onConnectionChanged)
-                    val deviceId = config.localDeviceId.deviceId
-                    val desc = activity?.getString(R.string.intro_page_three_description, "<b>$deviceId</b>")
-                    binding.description.text = Html.fromHtml(desc)
+            launch {
+                val ownDeviceId = libraryHandler.libraryManager.withLibrary { it.configuration.localDeviceId }
+
+                libraryHandler.subscribeToConnectionStatus().consumeEach {
+                    if (it.values.find { it.addresses.isNotEmpty() } != null) {
+                        val desc = activity?.getString(R.string.intro_page_three_description, "<b>$ownDeviceId</b>")
+                        binding.description.text = Html.fromHtml(desc)
+                    } else {
+                        binding.description.text = getString(R.string.intro_page_three_searching_device)
+                    }
+                }
+            }
+
+            launch {
+                libraryHandler.subscribeToFolderStatusList().consumeEach {
+                    if (it.isNotEmpty()) {
+                        (activity as IntroActivity?)?.onDonePressed(this@IntroFragmentThree)
+                    }
                 }
             }
 
             return binding.root
         }
-
-        private fun onConnectionChanged(deviceId: DeviceId) {
-            libraryHandler.library { config, client, _ ->
-                GlobalScope.launch (Dispatchers.Main) {
-                    if (config.folders.isNotEmpty()) {
-                        client.removeOnConnectionChangedListener(this@IntroFragmentThree::onConnectionChanged)
-                        (activity as IntroActivity?)?.onDonePressed(this@IntroFragmentThree)
-                    }
-                }
-            }
-        }
     }
 }

app/src/main/kotlin/net/syncthing/lite/activities/MainActivity.kt

@@ -102,9 +102,10 @@ class MainActivity : SyncthingActivity() {
     }
 
     private fun cleanCacheAndIndex() {
-        GlobalScope.launch (Dispatchers.Main) {
-            libraryHandler.syncthingClient { it.clearCacheAndIndex() }
-            recreate()
+        launch {
+            libraryHandler.libraryManager.withLibrary {
+                it.syncthingClient.clearCacheAndIndex()
+            }
         }
     }
 }

app/src/main/kotlin/net/syncthing/lite/activities/SyncthingActivity.kt

@@ -4,22 +4,18 @@ import android.app.AlertDialog
 import android.databinding.DataBindingUtil
 import android.os.Bundle
 import android.support.design.widget.Snackbar
-import android.support.v7.app.AppCompatActivity
 import android.view.LayoutInflater
-import net.syncthing.java.core.beans.FolderInfo
 import net.syncthing.lite.BuildConfig
 import net.syncthing.lite.R
+import net.syncthing.lite.async.CoroutineActivity
 import net.syncthing.lite.databinding.DialogLoadingBinding
 import net.syncthing.lite.library.LibraryHandler
-import org.jetbrains.anko.contentView
 import org.slf4j.impl.HandroidLoggerAdapter
 
-abstract class SyncthingActivity : AppCompatActivity() {
+abstract class SyncthingActivity : CoroutineActivity() {
     val libraryHandler: LibraryHandler by lazy {
         LibraryHandler(
-                context = this@SyncthingActivity,
-                onIndexUpdateProgressListener = this::onIndexUpdateProgress,
-                onIndexUpdateCompleteListener = this::onIndexUpdateComplete
+                context = this@SyncthingActivity
         )
     }
     private var loadingDialog: AlertDialog? = null
@@ -58,19 +54,6 @@ abstract class SyncthingActivity : AppCompatActivity() {
         loadingDialog?.dismiss()
     }
 
-    open fun onIndexUpdateProgress(folderInfo: FolderInfo, percentage: Int) {
-        val message = getString(R.string.index_update_progress_label, folderInfo.label, percentage)
-        snackBar?.setText(message) ?: run {
-            snackBar = Snackbar.make(contentView!!, message, Snackbar.LENGTH_INDEFINITE)
-            snackBar?.show()
-        }
-    }
-
-    open fun onIndexUpdateComplete(folderInfo: FolderInfo) {
-        snackBar?.dismiss()
-        snackBar = null
-    }
-
     open fun onLibraryLoaded() {
         // nothing to do
     }

app/src/main/kotlin/net/syncthing/lite/adapters/DevicesAdapter.kt

@@ -3,12 +3,15 @@ package net.syncthing.lite.adapters
 import android.support.v7.widget.RecyclerView
 import android.view.LayoutInflater
 import android.view.ViewGroup
+import net.syncthing.java.bep.connectionactor.ConnectionInfo
+import net.syncthing.java.bep.connectionactor.ConnectionStatus
 import net.syncthing.java.core.beans.DeviceInfo
+import net.syncthing.lite.R
 import net.syncthing.lite.databinding.ListviewDeviceBinding
 import kotlin.properties.Delegates
 
 class DevicesAdapter: RecyclerView.Adapter<DeviceViewHolder>() {
-    var data: List<DeviceInfo> by Delegates.observable(listOf()) {
+    var data: List<Pair<DeviceInfo, ConnectionInfo>> by Delegates.observable(listOf()) {
         _, _, _ -> notifyDataSetChanged()
     }
 
@@ -19,7 +22,7 @@ class DevicesAdapter: RecyclerView.Adapter<DeviceViewHolder>() {
     }
 
     override fun getItemCount() = data.size
-    override fun getItemId(position: Int) = data[position].deviceId.deviceId.hashCode().toLong()
+    override fun getItemId(position: Int) = data[position].first.deviceId.deviceId.hashCode().toLong()
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = DeviceViewHolder(
             ListviewDeviceBinding.inflate(
@@ -28,13 +31,23 @@ class DevicesAdapter: RecyclerView.Adapter<DeviceViewHolder>() {
     )
 
     override fun onBindViewHolder(holder: DeviceViewHolder, position: Int) {
-        val deviceStats = data[position]
         val binding = holder.binding
+        val context = binding.root.context
+        val (deviceInfo, connectionInfo) = data[position]
 
-        binding.name = deviceStats.name
-        binding.isConnected = deviceStats.isConnected
+        binding.name = deviceInfo.name
+        binding.isConnected = connectionInfo.status == ConnectionStatus.Connected
 
-        binding.root.setOnLongClickListener { listener?.onDeviceLongClicked(deviceStats) ?: false }
+        binding.status = when (connectionInfo.status) {
+            ConnectionStatus.Connected -> context.getString(R.string.device_status_connected, connectionInfo.currentAddress?.address)
+            ConnectionStatus.Connecting -> context.getString(R.string.device_status_connecting, connectionInfo.currentAddress?.address)
+            ConnectionStatus.Disconnected -> if (connectionInfo.addresses.isEmpty())
+                context.getString(R.string.device_status_no_address)
+            else
+                context.getString(R.string.device_status_disconnected, connectionInfo.addresses.size)
+        }
+
+        binding.root.setOnLongClickListener { listener?.onDeviceLongClicked(deviceInfo) ?: false }
 
         binding.executePendingBindings()
     }
@@ -44,4 +57,4 @@ interface DeviceAdapterListener {
     fun onDeviceLongClicked(deviceInfo: DeviceInfo): Boolean
 }
 
-class DeviceViewHolder(val binding: ListviewDeviceBinding): RecyclerView.ViewHolder(binding.root)
+class DeviceViewHolder(val binding: ListviewDeviceBinding): RecyclerView.ViewHolder(binding.root)

app/src/main/kotlin/net/syncthing/lite/adapters/FoldersListAdapter.kt

@@ -2,8 +2,10 @@ package net.syncthing.lite.adapters
 
 import android.support.v7.widget.RecyclerView
 import android.text.format.DateUtils
+import android.util.Log
 import android.view.LayoutInflater
 import android.view.ViewGroup
+import net.syncthing.java.bep.folder.FolderStatus
 import net.syncthing.java.core.beans.FolderInfo
 import net.syncthing.java.core.beans.FolderStats
 import net.syncthing.lite.R
@@ -11,7 +13,7 @@ import net.syncthing.lite.databinding.ListviewFolderBinding
 import kotlin.properties.Delegates
 
 class FoldersListAdapter: RecyclerView.Adapter<FolderListViewHolder>() {
-    var data: List<Pair<FolderInfo, FolderStats>> by Delegates.observable(listOf()) {
+    var data: List<FolderStatus> by Delegates.observable(listOf()) {
         _, _, _ -> notifyDataSetChanged()
     }
 
@@ -22,7 +24,7 @@ class FoldersListAdapter: RecyclerView.Adapter<FolderListViewHolder>() {
     }
 
     override fun getItemCount() = data.size
-    override fun getItemId(position: Int) = data[position].first.folderId.hashCode().toLong()
+    override fun getItemId(position: Int) = data[position].info.folderId.hashCode().toLong()
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = FolderListViewHolder (
             ListviewFolderBinding.inflate(
@@ -32,19 +34,31 @@ class FoldersListAdapter: RecyclerView.Adapter<FolderListViewHolder>() {
 
     override fun onBindViewHolder(holder: FolderListViewHolder, position: Int) {
         val binding = holder.binding
-        val (folderInfo, folderStats) = data[position]
+        val item = data[position]
+        val (folderInfo, folderStats) = item
         val context = holder.itemView.context
 
+        Log.d("FolderListAdapter", "$item")
+
         binding.folderName = context.getString(R.string.folder_label_format, folderInfo.label, folderInfo.folderId)
 
         binding.lastModification = context.getString(R.string.last_modified_time,
                 DateUtils.getRelativeDateTimeString(context, folderStats.lastUpdate.time, DateUtils.MINUTE_IN_MILLIS, DateUtils.WEEK_IN_MILLIS, 0))
 
-        binding.info = context.getString(R.string.folder_content_info, folderStats.describeSize(), folderStats.fileCount, folderStats.dirCount)
+        binding.info = context.getString(R.string.folder_content_info, folderStats.sizeDescription, folderStats.fileCount, folderStats.dirCount)
+
+        binding.info2 = if (item.missingIndexUpdates == 0L)
+            null
+        else
+            context.getString(R.string.pending_index_updates, item.missingIndexUpdates)
 
         binding.root.setOnClickListener {
             listener?.onFolderClicked(folderInfo, folderStats)
         }
+
+        binding.root.setOnLongClickListener {
+            listener?.onFolderLongClicked(folderInfo) ?: false
+        }
     }
 }
 
@@ -52,4 +66,5 @@ class FolderListViewHolder(val binding: ListviewFolderBinding): RecyclerView.Vie
 
 interface FolderListAdapterListener {
     fun onFolderClicked(folderInfo: FolderInfo, folderStats: FolderStats)
-}
+    fun onFolderLongClicked(folderInfo: FolderInfo): Boolean
+}

app/src/main/kotlin/net/syncthing/lite/android/Application.kt

@@ -1,52 +1,48 @@
 package net.syncthing.lite.android
 
 import android.app.Application
-import android.content.ClipData
-import android.content.ClipboardManager
-import android.content.Context
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
-import net.syncthing.lite.BuildConfig
-import org.jetbrains.anko.defaultSharedPreferences
-import java.io.PrintWriter
-import java.io.StringWriter
+import net.syncthing.lite.error.ErrorStorage
 
 class Application: Application() {
     companion object {
         private const val LOG_TAG = "Application"
-        private const val PREF_ENABLE_CRASH_HANDLER = "crash_handler"
+        private val handler = Handler(Looper.getMainLooper())
     }
 
     override fun onCreate() {
         super.onCreate()
 
-        val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
         val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()
+        val mainThread = Thread.currentThread()
 
         if (defaultHandler == null) {
             Log.w(LOG_TAG, "could not get default crash handler")
         }
 
-        Thread.setDefaultUncaughtExceptionHandler { thread, ex ->
+        fun handleCrash(ex: Throwable) {
             Log.w(LOG_TAG, "app crashed", ex)
 
-            val enableCustomCrashHandling = defaultSharedPreferences.getBoolean(PREF_ENABLE_CRASH_HANDLER, false)
-
-            if (enableCustomCrashHandling) {
-                clipboard.primaryClip = ClipData.newPlainText(
-                        "stacktrace",
-                        StringWriter().apply {
-                            append("Version: ").append(BuildConfig.VERSION_NAME).append('\n')
-                            append(Log.getStackTraceString(ex)).append('\n')
-                            ex.printStackTrace(PrintWriter(this))
-                        }.buffer.toString()
-                )
-            }
+            ErrorStorage.reportError(
+                    this,
+                    Log.getStackTraceString(ex)
+            )
 
             if (defaultHandler != null) {
-                defaultHandler.uncaughtException(thread, ex)
+                defaultHandler.uncaughtException(mainThread, ex)
             } else {
                 System.exit(1)
             }
         }
+
+        Thread.setDefaultUncaughtExceptionHandler { thread, ex ->
+            if (Looper.getMainLooper() === Looper.myLooper()) {
+                handleCrash(ex)
+            } else {
+                handler.post { handleCrash(ex) }
+            }
+        }
     }
 }

app/src/main/kotlin/net/syncthing/lite/async/CoroutineActivity.kt

@@ -0,0 +1,19 @@
+package net.syncthing.lite.async
+
+import android.support.v7.app.AppCompatActivity
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlin.coroutines.CoroutineContext
+
+abstract class CoroutineActivity: AppCompatActivity(), CoroutineScope {
+    val job = Job()
+
+    override val coroutineContext: CoroutineContext
+        get() = job + Dispatchers.Main
+
+    override fun onDestroy() {
+        super.onDestroy()
+        job.cancel()
+    }
+}

app/src/main/kotlin/net/syncthing/lite/async/CoroutineDialogFragment.kt

@@ -0,0 +1,19 @@
+package net.syncthing.lite.async
+
+import android.support.v4.app.DialogFragment
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlin.coroutines.CoroutineContext
+
+abstract class CoroutineDialogFragment: DialogFragment(), CoroutineScope {
+    val job = Job()
+
+    override val coroutineContext: CoroutineContext
+        get() = job + Dispatchers.Main
+
+    override fun onDestroy() {
+        super.onDestroy()
+        job.cancel()
+    }
+}

app/src/main/kotlin/net/syncthing/lite/async/CoroutineFragment.kt

@@ -0,0 +1,19 @@
+package net.syncthing.lite.async
+
+import android.support.v4.app.Fragment
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlin.coroutines.CoroutineContext
+
+abstract class CoroutineFragment: Fragment(), CoroutineScope {
+    val job = Job()
+
+    override val coroutineContext: CoroutineContext
+        get() = job + Dispatchers.Main
+
+    override fun onDestroy() {
+        super.onDestroy()
+        job.cancel()
+    }
+}

app/src/main/kotlin/net/syncthing/lite/dialogs/EnableFolderSyncForNewDeviceDialog.kt

@@ -0,0 +1,125 @@
+package net.syncthing.lite.dialogs
+
+import android.app.AlertDialog
+import android.app.Dialog
+import android.os.Bundle
+import android.support.v4.app.FragmentManager
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import net.syncthing.java.core.beans.DeviceInfo
+import net.syncthing.lite.R
+import net.syncthing.lite.fragments.SyncthingDialogFragment
+
+class EnableFolderSyncForNewDeviceDialog: SyncthingDialogFragment() {
+    companion object {
+        private const val FOLDER_ID = "folderId"
+        private const val FOLDER_NAME = "folderName"
+        private const val DEVICES = "devices"
+        private const val STATUS_CURRENT_DEVICE_ID = "currentDeviceId"
+
+        private const val TAG = "EnableFolderSyncForNewDeviceDialog"
+
+        fun newInstance(folderId: String, folderName: String, devices: List<DeviceInfo>) = EnableFolderSyncForNewDeviceDialog().apply {
+            arguments = Bundle().apply {
+                putString(FOLDER_ID, folderId)
+                putString(FOLDER_NAME, folderName)
+                putSerializable(DEVICES, ArrayList<DeviceInfo>(devices))
+            }
+        }
+    }
+
+    private var currentDeviceId = 0
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val folderId = arguments!!.getString(FOLDER_ID)
+        val folderName = arguments!!.getString(FOLDER_NAME)
+        val devices = arguments!!.getSerializable(DEVICES) as ArrayList<DeviceInfo>
+
+        if (savedInstanceState != null) {
+            currentDeviceId = savedInstanceState.getInt(STATUS_CURRENT_DEVICE_ID)
+        }
+
+        val dialog = AlertDialog.Builder(context!!)
+                .setTitle(R.string.dialog_enable_folder_sync_for_new_device_title)
+                .setMessage(R.string.dialog_enable_folder_sync_for_new_device_text)
+                .setPositiveButton(R.string.dialog_enable_folder_sync_for_new_device_positive, null)
+                .setNegativeButton(R.string.dialog_enable_folder_sync_for_new_device_negative, null)
+                .create()
+
+        fun bindDeviceId() {
+            if (currentDeviceId >= devices.size) {
+                dismissAllowingStateLoss()
+            } else {
+                val device = devices[currentDeviceId]
+
+                dialog.setMessage(getString(
+                        R.string.dialog_enable_folder_sync_for_new_device_text,
+                        folderName,
+                        device.name,
+                        device.deviceId.deviceId
+                ))
+
+                dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener {
+                    GlobalScope.launch {
+                        libraryHandler.libraryManager.withLibrary {
+                            val oldFolderEntry = it.configuration.folders.find { it.folderId == folderId }!!
+
+                            it.configuration.update { oldConfig ->
+                                oldConfig.copy(
+                                        folders = oldConfig.folders.filter { it != oldFolderEntry }.toSet() + setOf(
+                                                oldFolderEntry.copy(
+                                                        deviceIdWhitelist = oldFolderEntry.deviceIdWhitelist + setOf(device.deviceId),
+                                                        deviceIdBlacklist = oldFolderEntry.deviceIdBlacklist - setOf(device.deviceId)
+                                                )
+                                        )
+                                )
+                            }
+
+                            it.syncthingClient.reconnect(device.deviceId)
+                            it.configuration.persistLater()
+                        }
+                    }
+
+                    currentDeviceId++
+                    bindDeviceId()
+                }
+
+                dialog.getButton(AlertDialog.BUTTON_NEGATIVE).setOnClickListener {
+                    GlobalScope.launch {
+                        libraryHandler.libraryManager.withLibrary {
+                            val oldFolderEntry = it.configuration.folders.find { it.folderId == folderId }!!
+
+                            it.configuration.update { oldConfig ->
+                                oldConfig.copy(
+                                        folders = oldConfig.folders.filter { it != oldFolderEntry }.toSet() + setOf(
+                                                oldFolderEntry.copy(
+                                                        ignoredDeviceIdList = oldFolderEntry.deviceIdWhitelist + setOf(device.deviceId)
+                                                )
+                                        )
+                                )
+                            }
+
+                            it.syncthingClient.reconnect(device.deviceId)
+                            it.configuration.persistLater()
+                        }
+                    }
+
+                    currentDeviceId++
+                    bindDeviceId()
+                }
+            }
+        }
+
+        dialog.setOnShowListener { bindDeviceId() }
+
+        return dialog
+    }
+
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+
+        outState.putInt(STATUS_CURRENT_DEVICE_ID, currentDeviceId)
+    }
+
+    fun show(fragmentManager: FragmentManager) = show(fragmentManager, TAG)
+}

app/src/main/kotlin/net/syncthing/lite/dialogs/ErrorReportDialog.kt

@@ -0,0 +1,52 @@
+package net.syncthing.lite.dialogs
+
+import android.app.Dialog
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.os.Bundle
+import android.support.v4.app.DialogFragment
+import android.support.v4.app.FragmentManager
+import android.support.v7.app.AlertDialog
+import android.widget.Toast
+import net.syncthing.lite.R
+
+class ErrorReportDialog: DialogFragment() {
+    companion object {
+        private const val REPORT = "report"
+        private const val TAG = "ErrorReportDialog"
+
+        fun newInstance(report: String) = ErrorReportDialog().apply {
+            arguments = Bundle().apply {
+                putString(REPORT, report)
+            }
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val report = arguments!!.getString(REPORT)
+        val clipboard = context!!.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+
+        return AlertDialog.Builder(context!!)
+                .setTitle(R.string.settings_last_error_title)
+                .setMessage(report)
+                .setPositiveButton(android.R.string.ok, null)
+                .setNeutralButton(R.string.copy_to_clipboard, null)
+                .create()
+                .apply {
+                    setOnShowListener {
+                        getButton(AlertDialog.BUTTON_NEUTRAL).setOnClickListener {
+                            clipboard.primaryClip = ClipData.newPlainText(
+                                    context!!.getString(R.string.settings_last_error_title),
+                                    report
+                            )
+
+                            Toast.makeText(context, context!!.getString(R.string.copied_to_clipboard), Toast.LENGTH_SHORT)
+                                    .show()
+                        }
+                    }
+                }
+    }
+
+    fun show(fragmentManager: FragmentManager) = show(fragmentManager, TAG)
+}

app/src/main/kotlin/net/syncthing/lite/dialogs/FileMenuDialogFragment.kt

@@ -8,12 +8,11 @@ import android.support.v4.app.FragmentManager
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import android.webkit.MimeTypeMap
 import net.syncthing.java.core.beans.FileInfo
 import net.syncthing.lite.databinding.DialogFileBinding
 import net.syncthing.lite.dialogs.downloadfile.DownloadFileDialogFragment
 import net.syncthing.lite.dialogs.downloadfile.DownloadFileSpec
-import org.apache.commons.io.FilenameUtils
+import net.syncthing.lite.utils.MimeType
 
 class FileMenuDialogFragment: BottomSheetDialogFragment() {
     companion object {
@@ -48,9 +47,7 @@ class FileMenuDialogFragment: BottomSheetDialogFragment() {
                     Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
                         addCategory(Intent.CATEGORY_OPENABLE)
 
-                        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
-                                FilenameUtils.getExtension(fileSpec.fileName)
-                        )
+                        type = MimeType.getFromFilename(fileSpec.fileName)
 
                         putExtra(Intent.EXTRA_TITLE, fileSpec.fileName)
                     },

app/src/main/kotlin/net/syncthing/lite/dialogs/FolderInfoDialog.kt

@@ -0,0 +1,105 @@
+package net.syncthing.lite.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import android.support.v4.app.FragmentManager
+import android.support.v7.app.AlertDialog
+import android.support.v7.widget.AppCompatCheckBox
+import android.view.LayoutInflater
+import kotlinx.coroutines.launch
+import net.syncthing.lite.R
+import net.syncthing.lite.databinding.DialogFolderInfoBinding
+import net.syncthing.lite.fragments.SyncthingDialogFragment
+
+class FolderInfoDialog: SyncthingDialogFragment() {
+    companion object {
+        fun newInstance(folderId: String) = FolderInfoDialog().apply {
+            arguments = Bundle().apply {
+                putString(FOLDER_ID, folderId)
+            }
+        }
+
+        private const val FOLDER_ID = "folderId"
+        private const val TAG = "FolderInfoDialog"
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val folderId = arguments!!.getString(FOLDER_ID)
+        val binding = DialogFolderInfoBinding.inflate(LayoutInflater.from(context))
+
+        val dialog = AlertDialog.Builder(context!!)
+                .setTitle(folderId)
+                .setView(binding.root)
+                .create()
+
+        launch {
+            val configuration = libraryHandler.libraryManager.withLibrary { it.configuration }
+
+            val folderInfo = configuration.folders.find { it.folderId == folderId }
+
+            if (folderInfo == null) {
+                dismissAllowingStateLoss()
+                return@launch
+            }
+
+            dialog.setTitle(folderInfo.label)
+
+            binding.deviceCheckboxesContainer.removeAllViews()
+
+            val allRelatedDevices = (folderInfo.deviceIdWhitelist + folderInfo.deviceIdBlacklist).toSet()
+
+            allRelatedDevices.forEach { deviceId ->
+                val deviceInfo = configuration.peers.find { it.deviceId == deviceId }
+
+                val deviceLabel = if (deviceInfo == null)
+                    deviceId.deviceId
+                else
+                    context!!.getString(R.string.dialog_folder_info_device_list_item, deviceInfo.name, deviceId.deviceId)
+
+                binding.deviceCheckboxesContainer.addView(
+                        AppCompatCheckBox(context!!).apply {
+                            text = deviceLabel
+                            isChecked = folderInfo.deviceIdWhitelist.contains(deviceId)
+
+                            setOnCheckedChangeListener { _, isShared ->
+                                this@FolderInfoDialog.launch {
+                                    libraryHandler.libraryManager.withLibrary { library ->
+                                        // update the config
+                                        library.configuration.update { oldConfig ->
+                                            val oldFolders = oldConfig.folders
+                                            var folderToChange = oldFolders.find { it.folderId == folderId }!!
+                                            val foldersNotToChange = oldFolders.filterNot { it.folderId == folderId }.toSet()
+
+                                            if (isShared) {
+                                                folderToChange = folderToChange.copy(
+                                                        ignoredDeviceIdList = folderToChange.ignoredDeviceIdList.filterNot { it == deviceId }.toSet(),
+                                                        deviceIdBlacklist = folderToChange.deviceIdBlacklist.filterNot { it == deviceId }.toSet(),
+                                                        deviceIdWhitelist = folderToChange.deviceIdWhitelist + setOf(deviceId)
+                                                )
+                                            } else {
+                                                folderToChange = folderToChange.copy(
+                                                        deviceIdWhitelist = folderToChange.deviceIdWhitelist.filterNot { it == deviceId }.toSet(),
+                                                        deviceIdBlacklist = folderToChange.deviceIdBlacklist + setOf(deviceId),
+                                                        ignoredDeviceIdList = folderToChange.ignoredDeviceIdList + setOf(deviceId)
+                                                )
+                                            }
+
+                                            oldConfig.copy(folders = foldersNotToChange + folderToChange)
+                                        }
+                                        library.configuration.persistLater()
+
+                                        // apply the change
+                                        library.syncthingClient.reconnect(deviceId)
+                                    }
+                                }
+                            }
+                        }
+                )
+            }
+        }
+
+        return dialog
+    }
+
+    fun show(fragmentManager: FragmentManager) = show(fragmentManager, TAG)
+}

app/src/main/kotlin/net/syncthing/lite/dialogs/downloadfile/DownloadFileDialogFragment.kt

@@ -12,13 +12,12 @@ import android.os.Bundle
 import android.support.v4.app.DialogFragment
 import android.support.v4.app.FragmentManager
 import android.util.Log
-import android.webkit.MimeTypeMap
 import net.syncthing.java.core.beans.FileInfo
 import net.syncthing.lite.BuildConfig
 import net.syncthing.lite.R
 import net.syncthing.lite.library.CacheFileProviderUrl
 import net.syncthing.lite.library.LibraryHandler
-import org.apache.commons.io.FilenameUtils
+import net.syncthing.lite.utils.MimeType
 import org.jetbrains.anko.newTask
 import org.jetbrains.anko.toast
 
@@ -89,7 +88,7 @@ class DownloadFileDialogFragment : DialogFragment() {
                     dismissAllowingStateLoss()
 
                     if (outputUri == null) {
-                        val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(FilenameUtils.getExtension(fileSpec.fileName))
+                        val mimeType = MimeType.getFromFilename(fileSpec.fileName)
 
                         try {
                             context!!.startActivity(

app/src/main/kotlin/net/syncthing/lite/error/ErrorStorage.kt

@@ -0,0 +1,17 @@
+package net.syncthing.lite.error
+
+import android.content.Context
+import org.jetbrains.anko.defaultSharedPreferences
+
+object ErrorStorage {
+    private const val PREF_KEY = "last_error"
+
+    fun reportError(context: Context, error: String) {
+        // this uses commit because the App could be quit directly after that
+        context.defaultSharedPreferences.edit()
+                .putString(PREF_KEY, error)
+                .commit()
+    }
+
+    fun getLastErrorReport(context: Context) = context.defaultSharedPreferences.getString(PREF_KEY, "there is no saved report")
+}

app/src/main/kotlin/net/syncthing/lite/fragments/DevicesFragment.kt

@@ -10,9 +10,9 @@ import android.view.View
 import android.view.ViewGroup
 import android.view.inputmethod.InputMethodManager
 import com.google.zxing.integration.android.IntentIntegrator
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.launch
+import net.syncthing.java.bep.connectionactor.ConnectionInfo
 import net.syncthing.java.core.beans.DeviceInfo
 import net.syncthing.lite.R
 import net.syncthing.lite.adapters.DeviceAdapterListener
@@ -34,25 +34,7 @@ class DevicesFragment : SyncthingFragment() {
                               savedInstanceState: Bundle?): View? {
         binding = DataBindingUtil.inflate(layoutInflater, R.layout.fragment_devices, container, false)
         binding.addDevice.setOnClickListener { showDialog() }
-        return binding.root
-    }
 
-    override fun onResume() {
-        super.onResume()
-        libraryHandler.syncthingClient { it.addOnConnectionChangedListener { _ -> updateDeviceList() } }
-    }
-
-    override fun onPause() {
-        super.onPause()
-        libraryHandler.syncthingClient { it.removeOnConnectionChangedListener{ _ -> updateDeviceList() } }
-    }
-
-    override fun onLibraryLoaded() {
-        initDeviceList()
-        updateDeviceList()
-    }
-
-    private fun initDeviceList() {
         binding.list.adapter = adapter
 
         adapter.listener = object: DeviceAdapterListener {
@@ -61,12 +43,21 @@ class DevicesFragment : SyncthingFragment() {
                         .setTitle(getString(R.string.remove_device_title, deviceInfo.name))
                         .setMessage(getString(R.string.remove_device_message, deviceInfo.deviceId.deviceId.substring(0, 7)))
                         .setPositiveButton(android.R.string.yes) { _, _ ->
-                            libraryHandler.library { config, syncthingClient, _ ->
-                                config.peers = config.peers.filterNot { it.deviceId == deviceInfo.deviceId }.toSet()
-                                config.persistLater()
-                                updateDeviceList()
+                            launch {
+                                libraryHandler.libraryManager.withLibrary { library ->
+                                    library.configuration.update { oldConfig ->
+                                        oldConfig.copy(
+                                                peers = oldConfig.peers
+                                                        .filterNot { it.deviceId == deviceInfo.deviceId }
+                                                        .toSet()
+                                        )
+                                    }
 
-                                syncthingClient.disconnectFromRemovedDevices()
+                                    library.configuration.persistLater()
+
+                                    // TODO: update the device list (should become a side effect of the call below)
+                                    library.syncthingClient.disconnectFromRemovedDevices()
+                                }
                             }
                         }
                         .setNegativeButton(android.R.string.no, null)
@@ -75,15 +66,17 @@ class DevicesFragment : SyncthingFragment() {
                 return false
             }
         }
-    }
 
-    private fun updateDeviceList() {
-        libraryHandler.syncthingClient { syncthingClient ->
-            GlobalScope.launch (Dispatchers.Main) {
-                adapter.data = syncthingClient.getPeerStatus()
-                binding.isEmpty = adapter.data.isEmpty()
+        launch {
+            libraryHandler.subscribeToConnectionStatus().consumeEach { connectionInfo ->
+                val devices = libraryHandler.libraryManager.withLibrary { it.configuration.peers }
+
+                adapter.data = devices.map { device -> device to (connectionInfo[device.deviceId] ?: ConnectionInfo.empty) }
+                binding.isEmpty = devices.isEmpty()
             }
         }
+
+        return binding.root
     }
 
     override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
@@ -94,35 +87,38 @@ class DevicesFragment : SyncthingFragment() {
     }
 
     private fun showDialog() {
-        addDeviceDialogBinding = DataBindingUtil.inflate(LayoutInflater.from(context), R.layout.view_enter_device_id, null, false)
-        addDeviceDialogBinding?.let { binding ->
-            binding.scanQrCode.setOnClickListener {
-                FragmentIntentIntegrator(this@DevicesFragment).initiateScan()
-            }
-            binding.deviceId.post {
-                val imm = context!!.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
-                imm.showSoftInput(binding.deviceId, InputMethodManager.SHOW_IMPLICIT)
-            }
+        val binding = ViewEnterDeviceIdBinding.inflate(LayoutInflater.from(context), null, false)
+        addDeviceDialogBinding = binding
 
-            addDeviceDialog = AlertDialog.Builder(context)
-                    .setTitle(R.string.device_id_dialog_title)
-                    .setView(binding.root)
-                    .setPositiveButton(android.R.string.ok, null)
-                    .setNegativeButton(android.R.string.cancel, null)
-                    .show()
-
-            // Use different listener to keep dialog open after button click.
-            // https://stackoverflow.com/a/15619098
-            addDeviceDialog?.getButton(AlertDialog.BUTTON_POSITIVE)
-                    ?.setOnClickListener {
-                        try {
-                            val deviceId = binding.deviceId.text.toString()
-                            Util.importDeviceId(libraryHandler, context, deviceId, { updateDeviceList() })
-                            addDeviceDialog?.dismiss()
-                        } catch (e: IOException) {
-                            binding.deviceId.error = getString(R.string.invalid_device_id)
-                        }
-                    }
+        binding.scanQrCode.setOnClickListener {
+            FragmentIntentIntegrator(this@DevicesFragment).initiateScan()
         }
+        binding.deviceId.post {
+            val imm = context!!.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+            imm.showSoftInput(binding.deviceId, InputMethodManager.SHOW_IMPLICIT)
+        }
+
+        val dialog = AlertDialog.Builder(context)
+                .setTitle(R.string.device_id_dialog_title)
+                .setView(binding.root)
+                .setPositiveButton(android.R.string.ok, null)
+                .setNegativeButton(android.R.string.cancel, null)
+                .show()
+
+        addDeviceDialog = dialog
+
+        fun handleAddClick() {
+            try {
+                val deviceId = binding.deviceId.text.toString()
+                Util.importDeviceId(libraryHandler.libraryManager, context!!, deviceId, { /* TODO: Is updateDeviceList() still required? */ })
+                dialog.dismiss()
+            } catch (e: IOException) {
+                binding.deviceId.error = getString(R.string.invalid_device_id)
+            }
+        }
+
+        // Use different listener to keep dialog open after button click.
+        // https://stackoverflow.com/a/15619098
+        dialog.getButton(AlertDialog.BUTTON_POSITIVE)!!.setOnClickListener { handleAddClick() }
     }
 }

app/src/main/kotlin/net/syncthing/lite/fragments/FoldersFragment.kt

@@ -2,12 +2,10 @@ package net.syncthing.lite.fragments
 
 import android.arch.lifecycle.Observer
 import android.os.Bundle
-import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.launch
 import net.syncthing.java.core.beans.FolderInfo
 import net.syncthing.java.core.beans.FolderStats
@@ -15,52 +13,42 @@ import net.syncthing.lite.activities.FolderBrowserActivity
 import net.syncthing.lite.adapters.FolderListAdapterListener
 import net.syncthing.lite.adapters.FoldersListAdapter
 import net.syncthing.lite.databinding.FragmentFoldersBinding
+import net.syncthing.lite.dialogs.FolderInfoDialog
 import org.jetbrains.anko.intentFor
 
 class FoldersFragment : SyncthingFragment() {
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+        val adapter = FoldersListAdapter()
 
-    private val TAG = "FoldersFragment"
+        adapter.listener = object : FolderListAdapterListener {
+            override fun onFolderClicked(folderInfo: FolderInfo, folderStats: FolderStats) {
+                startActivity(
+                        activity!!.intentFor<FolderBrowserActivity>(
+                                FolderBrowserActivity.EXTRA_FOLDER_NAME to folderInfo.folderId
+                        )
+                )
+            }
 
-    private lateinit var binding: FragmentFoldersBinding
+            override fun onFolderLongClicked(folderInfo: FolderInfo): Boolean {
+                FolderInfoDialog
+                        .newInstance(folderId = folderInfo.folderId)
+                        .show(fragmentManager!!)
 
-    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
-                              savedInstanceState: Bundle?): View? {
-        binding = FragmentFoldersBinding.inflate(layoutInflater, container, false)
+                return true
+            }
+        }
 
+        val binding = FragmentFoldersBinding.inflate(layoutInflater, container, false)
+        binding.list.adapter = adapter
         libraryHandler.isListeningPortTaken.observe(this, Observer { binding.listeningPortTaken = it })
 
+        launch {
+            libraryHandler.subscribeToFolderStatusList().consumeEach {
+                adapter.data = it
+                binding.isEmpty = it.isEmpty()
+            }
+        }
+
         return binding.root
     }
-
-    override fun onLibraryLoaded() {
-        showAllFoldersListView()
-    }
-
-    private fun showAllFoldersListView() {
-        libraryHandler.folderBrowser { folderBrowser ->
-            val list = folderBrowser.folderInfoAndStatsList()
-
-            GlobalScope.launch (Dispatchers.Main) {
-                Log.i(TAG, "list folders = " + list + " (" + list.size + " records)")
-                val adapter = FoldersListAdapter().apply { data = list }
-                binding.list.adapter = adapter
-                adapter.listener = object : FolderListAdapterListener {
-                    override fun onFolderClicked(folderInfo: FolderInfo, folderStats: FolderStats) {
-                        startActivity(
-                                activity!!.intentFor<FolderBrowserActivity>(
-                                        FolderBrowserActivity.EXTRA_FOLDER_NAME to folderInfo.folderId
-                                )
-                        )
-                    }
-                }
-
-                binding.isEmpty = list.isEmpty()
-            }
-        }
-    }
-
-    override fun onIndexUpdateComplete(folderInfo: FolderInfo) {
-        super.onIndexUpdateComplete(folderInfo)
-        showAllFoldersListView()
-    }
 }

app/src/main/kotlin/net/syncthing/lite/fragments/SettingsFragment.kt

@@ -1,10 +1,17 @@
 package net.syncthing.lite.fragments
 
+import android.content.Intent
+import android.net.Uri
 import android.os.Bundle
 import android.support.v7.preference.EditTextPreference
 import android.support.v7.preference.PreferenceFragmentCompat
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 import net.syncthing.lite.R
-import net.syncthing.lite.activities.SyncthingActivity
+import net.syncthing.lite.dialogs.ErrorReportDialog
+import net.syncthing.lite.error.ErrorStorage
+import net.syncthing.lite.library.DefaultLibraryManager
 
 class SettingsFragment : PreferenceFragmentCompat() {
 
@@ -13,19 +20,48 @@ class SettingsFragment : PreferenceFragmentCompat() {
 
         val localDeviceName = findPreference("local_device_name") as EditTextPreference
         val appVersion      = findPreference("app_version")
+        val forceStop       = findPreference("force_stop")
+        val lastCrash       = findPreference("last_crash")
+        val reportBug       = findPreference("report_bug")
+        val libraryManager  = DefaultLibraryManager.with(context!!)
 
-        (activity as SyncthingActivity?)?.let { activity ->
-            val versionName = activity.packageManager.getPackageInfo(activity.packageName, 0)?.versionName
-            appVersion.summary = versionName
-
-            activity.libraryHandler.configuration { localDeviceName.text = it.localDeviceName }
-            localDeviceName.setOnPreferenceChangeListener { _, _ ->
-                activity.libraryHandler.configuration { conf ->
-                    conf.localDeviceName = localDeviceName.text
-                    conf.persistLater()
-                }
-                true
+        GlobalScope.launch (Dispatchers.Main) {
+            libraryManager.withLibrary { library ->
+                localDeviceName.text = library.configuration.localDeviceName
             }
         }
+
+        appVersion.summary = context!!.packageManager.getPackageInfo(context!!.packageName, 0)?.versionName
+
+        localDeviceName.setOnPreferenceChangeListener { _, _ ->
+            val newDeviceName = localDeviceName.text
+
+            GlobalScope.launch {
+                libraryManager.withLibrary { library ->
+                    library.configuration.update { it.copy(localDeviceName = newDeviceName) }
+                    library.configuration.persistLater()
+                }
+            }
+
+            true
+        }
+
+        forceStop.setOnPreferenceClickListener {
+            System.exit(0)
+
+            true
+        }
+
+        lastCrash.setOnPreferenceClickListener {
+            ErrorReportDialog.newInstance(ErrorStorage.getLastErrorReport(context!!)).show(fragmentManager!!)
+
+            true
+        }
+
+        reportBug.setOnPreferenceClickListener {
+            startActivity(Intent(Intent.ACTION_VIEW, Uri.parse("https://github.com/syncthing/syncthing-lite/issues")))
+
+            true
+        }
     }
 }

app/src/main/kotlin/net/syncthing/lite/fragments/SyncthingDialogFragment.kt

@@ -1,9 +1,9 @@
 package net.syncthing.lite.fragments
 
-import android.support.v4.app.DialogFragment
+import net.syncthing.lite.async.CoroutineDialogFragment
 import net.syncthing.lite.library.LibraryHandler
 
-abstract class SyncthingDialogFragment : DialogFragment() {
+abstract class SyncthingDialogFragment : CoroutineDialogFragment() {
     val libraryHandler: LibraryHandler by lazy { LibraryHandler(
             context = context!!
     )}

app/src/main/kotlin/net/syncthing/lite/fragments/SyncthingFragment.kt

@@ -1,15 +1,10 @@
 package net.syncthing.lite.fragments
 
-import android.support.v4.app.Fragment
-import net.syncthing.java.core.beans.FolderInfo
+import net.syncthing.lite.async.CoroutineFragment
 import net.syncthing.lite.library.LibraryHandler
 
-abstract class SyncthingFragment : Fragment() {
-    val libraryHandler: LibraryHandler by lazy { LibraryHandler(
-            context = context!!,
-            onIndexUpdateProgressListener = this::onIndexUpdateProgress,
-            onIndexUpdateCompleteListener = this::onIndexUpdateComplete
-    )}
+abstract class SyncthingFragment : CoroutineFragment() {
+    val libraryHandler: LibraryHandler by lazy { LibraryHandler(context = context!!)}
 
     override fun onStart() {
         super.onStart()
@@ -27,8 +22,4 @@ abstract class SyncthingFragment : Fragment() {
     }
 
     open fun onLibraryLoaded() {}
-
-    open fun onIndexUpdateProgress(folderInfo: FolderInfo, percentage: Int) {}
-
-    open fun onIndexUpdateComplete(folderInfo: FolderInfo) {}
-}
+}

app/src/main/kotlin/net/syncthing/lite/library/DefaultLibraryManager.kt

@@ -4,8 +4,10 @@ import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
+import android.widget.Toast
 import net.syncthing.lite.BuildConfig
 import net.syncthing.lite.R
+import net.syncthing.lite.error.ErrorStorage
 import org.jetbrains.anko.defaultSharedPreferences
 
 object DefaultLibraryManager {
@@ -39,7 +41,16 @@ object DefaultLibraryManager {
                     }
 
                     instance = LibraryManager(
-                            synchronousInstanceCreator = { LibraryInstance(context) },
+                            synchronousInstanceCreator = {
+                                LibraryInstance(context) { ex ->
+                                    // this delay ensures that the toast is shown even if the UI thread is busy
+                                    handler.postDelayed({
+                                        Toast.makeText(context, R.string.toast_error, Toast.LENGTH_LONG).show()
+                                    }, 100L)
+
+                                    ErrorStorage.reportError(context, "${ex.component}\n${ex.detailsReadableString}\n${Log.getStackTraceString(ex.exception)}")
+                                }
+                            },
                             userCounterListener = {
                                 newUserCounter ->
 

app/src/main/kotlin/net/syncthing/lite/library/LibraryHandler.kt

@@ -5,16 +5,18 @@ import android.arch.lifecycle.MutableLiveData
 import android.content.Context
 import android.os.Handler
 import android.os.Looper
-import android.util.Log
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.BroadcastChannel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ConflatedBroadcastChannel
+import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.launch
-import net.syncthing.java.bep.FolderBrowser
+import net.syncthing.java.bep.connectionactor.ConnectionInfo
+import net.syncthing.java.bep.folder.FolderBrowser
+import net.syncthing.java.bep.folder.FolderStatus
 import net.syncthing.java.client.SyncthingClient
 import net.syncthing.java.core.beans.DeviceId
-import net.syncthing.java.core.beans.FileInfo
-import net.syncthing.java.core.beans.FolderInfo
-import net.syncthing.java.core.beans.IndexInfo
 import net.syncthing.java.core.configuration.Configuration
 import org.jetbrains.anko.doAsync
 import java.util.concurrent.atomic.AtomicBoolean
@@ -25,18 +27,20 @@ import java.util.concurrent.atomic.AtomicBoolean
  *
  * It's possible to do multiple start and stop cycles with one instance of this class.
  */
-class LibraryHandler(context: Context,
-                     private val onIndexUpdateProgressListener: (FolderInfo, Int) -> Unit = {_, _ -> },
-                     private val onIndexUpdateCompleteListener: (FolderInfo) -> Unit = {}) {
+class LibraryHandler(context: Context) {
 
     companion object {
         private const val TAG = "LibraryHandler"
         private val handler = Handler(Looper.getMainLooper())
     }
 
-    private val libraryManager = DefaultLibraryManager.with(context)
+    val libraryManager = DefaultLibraryManager.with(context)
     private val isStarted = AtomicBoolean(false)
     private val isListeningPortTakenInternal = MutableLiveData<Boolean>().apply { postValue(false) }
+    private val indexUpdateCompleteMessages = BroadcastChannel<String>(capacity = 16)
+    private val folderStatusList = BroadcastChannel<List<FolderStatus>>(capacity = Channel.CONFLATED)
+    private val connectionStatus = ConflatedBroadcastChannel<Map<DeviceId, ConnectionInfo>>()
+    private var job: Job = Job()
 
     val isListeningPortTaken: LiveData<Boolean> = isListeningPortTakenInternal
 
@@ -62,9 +66,27 @@ class LibraryHandler(context: Context,
 
             val client = libraryInstance.syncthingClient
 
-            client.indexHandler.registerOnIndexRecordAcquiredListener(this::onIndexRecordAcquired)
-            client.indexHandler.registerOnFullIndexAcquiredListenersListener(this::onRemoteIndexAcquired)
             client.discoveryHandler.registerMessageFromUnknownDeviceListener(internalMessageFromUnknownDeviceListener)
+
+            job = Job()
+
+            GlobalScope.launch (job) {
+                libraryInstance.syncthingClient.indexHandler.subscribeToOnFullIndexAcquiredEvents().consumeEach {
+                    indexUpdateCompleteMessages.send(it)
+                }
+            }
+
+            GlobalScope.launch (job) {
+                libraryInstance.folderBrowser.folderInfoAndStatusStream().consumeEach {
+                    folderStatusList.send(it)
+                }
+            }
+
+            GlobalScope.launch (job) {
+                libraryInstance.syncthingClient.subscribeToConnectionStatus().consumeEach {
+                    connectionStatus.send(it)
+                }
+            }
         }
     }
 
@@ -73,10 +95,10 @@ class LibraryHandler(context: Context,
             throw IllegalStateException("already stopped")
         }
 
+        job!!.cancel()
+
         syncthingClient {
             try {
-                it.indexHandler.unregisterOnIndexRecordAcquiredListener(this::onIndexRecordAcquired)
-                it.indexHandler.unregisterOnFullIndexAcquiredListenersListener(this::onRemoteIndexAcquired)
                 it.discoveryHandler.unregisterMessageFromUnknownDeviceListener(internalMessageFromUnknownDeviceListener)
             } catch (e: IllegalArgumentException) {
                 // ignored, no idea why this is thrown
@@ -86,22 +108,6 @@ class LibraryHandler(context: Context,
         libraryManager.stopLibraryUsage()
     }
 
-    private fun onIndexRecordAcquired(folderInfo: FolderInfo, newRecords: List<FileInfo>, indexInfo: IndexInfo) {
-        Log.i(TAG, "handleIndexRecordEvent trigger folder list update from index record acquired")
-
-        GlobalScope.launch (Dispatchers.Main) {
-            onIndexUpdateProgressListener(folderInfo, (indexInfo.getCompleted() * 100).toInt())
-        }
-    }
-
-    private fun onRemoteIndexAcquired(folderInfo: FolderInfo) {
-        Log.i(TAG, "handleIndexAcquiredEvent trigger folder list update from index acquired")
-
-        GlobalScope.launch (Dispatchers.Main) {
-            onIndexUpdateCompleteListener(folderInfo)
-        }
-    }
-
     /*
      * The callback is executed asynchronously.
      * As soon as it returns, there is no guarantee about the availability of the library
@@ -139,4 +145,8 @@ class LibraryHandler(context: Context,
     fun unregisterMessageFromUnknownDeviceListener(listener: (DeviceId) -> Unit) {
         messageFromUnknownDeviceListeners.remove(listener)
     }
+
+    fun subscribeToOnFullIndexAcquiredEvents() = indexUpdateCompleteMessages.openSubscription()
+    fun subscribeToFolderStatusList() = folderStatusList.openSubscription()
+    fun subscribeToConnectionStatus() = connectionStatus.openSubscription()
 }

app/src/main/kotlin/net/syncthing/lite/library/LibraryInstance.kt

@@ -2,8 +2,13 @@ package net.syncthing.lite.library
 
 import android.content.Context
 import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 import net.syncthing.java.client.SyncthingClient
 import net.syncthing.java.core.configuration.Configuration
+import net.syncthing.java.core.exception.ExceptionReport
+import net.syncthing.java.repository.EncryptedTempRepository
 import net.syncthing.repository.android.SqliteIndexRepository
 import net.syncthing.repository.android.TempDirectoryLocalRepository
 import net.syncthing.repository.android.database.RepositoryDatabase
@@ -21,7 +26,10 @@ import java.net.SocketException
  *
  * The creation and the shutdown are synchronous, so keep them out of the UI Thread
  */
-class LibraryInstance (context: Context) {
+class LibraryInstance (
+        context: Context,
+        private val exceptionReportHandler: (ExceptionReport) -> Unit
+) {
     companion object {
         private const val LOG_TAG = "LibraryInstance"
 
@@ -42,7 +50,11 @@ class LibraryInstance (context: Context) {
         }
     }
 
-    private val tempRepository = TempDirectoryLocalRepository(File(context.filesDir, "temp_repository"))
+    private val tempRepository = EncryptedTempRepository(
+            TempDirectoryLocalRepository(
+                    File(context.filesDir, "temp_repository")
+            )
+    )
 
     val isListeningPortTaken = checkIsListeningPortTaken()  // this must come first to work correctly
     val configuration = Configuration(configFolder = context.filesDir)
@@ -51,14 +63,21 @@ class LibraryInstance (context: Context) {
             repository = SqliteIndexRepository(
                     database = RepositoryDatabase.with(context),
                     closeDatabaseOnClose = false,
-                    clearTempStorageHook = { tempRepository.deleteAllData() }
+                    clearTempStorageHook = { tempRepository.deleteAllTempData() }
             ),
-            tempRepository = tempRepository
-    )
-    val folderBrowser = syncthingClient.indexHandler.newFolderBrowser()
+            tempRepository = tempRepository,
+            exceptionReportHandler = { ex ->
+                Log.w(LOG_TAG, "${ex.component}\n${ex.detailsReadableString}\n${Log.getStackTraceString(ex.exception)}")
 
-    fun shutdown() {
-        folderBrowser.close()
+                GlobalScope.launch (Dispatchers.Main) {
+                    exceptionReportHandler(ex)
+                }
+            }
+    )
+    val folderBrowser = syncthingClient.indexHandler.folderBrowser
+    val indexBrowser = syncthingClient.indexHandler.indexBrowser
+
+    suspend fun shutdown() {
         syncthingClient.close()
         configuration.persistNow()
     }

app/src/main/kotlin/net/syncthing/lite/library/LibraryManager.kt

@@ -2,6 +2,13 @@ package net.syncthing.lite.library
 
 import android.os.Handler
 import android.os.Looper
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.channels.ConflatedBroadcastChannel
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.runBlocking
 import java.util.concurrent.Executors
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
@@ -35,7 +42,7 @@ class LibraryManager (
     // only this Thread should access instance and userCounter
     private val startStopExecutor = Executors.newSingleThreadExecutor()
 
-    private var instance: LibraryInstance? = null
+    private val instanceStream = ConflatedBroadcastChannel<LibraryInstance?>(null)
     private var userCounter = 0
 
     fun startLibraryUsage(callback: (LibraryInstance) -> Unit) {
@@ -43,12 +50,12 @@ class LibraryManager (
             val newUserCounter = ++userCounter
             handler.post { userCounterListener(newUserCounter) }
 
-            if (instance == null) {
-                instance = synchronousInstanceCreator()
+            if (instanceStream.value == null) {
+                instanceStream.offer(synchronousInstanceCreator())
                 handler.post { isRunningListener(true) }
             }
 
-            handler.post { callback(instance!!) }
+            handler.post { callback(instanceStream.value!!) }
         }
     }
 
@@ -60,6 +67,16 @@ class LibraryManager (
         }
     }
 
+    suspend fun <T> withLibrary(action: suspend (LibraryInstance) -> T): T {
+        val instance = startLibraryUsageCoroutine()
+
+        return try {
+            action(instance)
+        } finally {
+            stopLibraryUsage()
+        }
+    }
+
     fun stopLibraryUsage() {
         startStopExecutor.submit {
             val newUserCounter = --userCounter
@@ -77,8 +94,8 @@ class LibraryManager (
     fun shutdownIfThereAreZeroUsers(listener: (wasShutdownPerformed: Boolean) -> Unit = {}) {
         startStopExecutor.submit {
             if (userCounter == 0) {
-                instance?.shutdown()
-                instance = null
+                runBlocking { instanceStream.value?.shutdown() }
+                instanceStream.offer(null)
 
                 handler.post { isRunningListener(false) }
                 handler.post { listener(true) }
@@ -87,4 +104,21 @@ class LibraryManager (
             }
         }
     }
+
+    fun streamDirectoryListing(folder: String, path: String) = GlobalScope.produce {
+        var job = Job()
+
+        instanceStream.openSubscription().consumeEach { instance ->
+            job.cancel()
+            job = Job()
+
+            if (instance != null) {
+                async (job) {
+                    instance.indexBrowser.streamDirectoryListing(folder, path).consumeEach {
+                        send(it)
+                    }
+                }
+            }
+        }
+    }
 }

app/src/main/kotlin/net/syncthing/lite/library/SyncthingProvider.kt

@@ -10,33 +10,36 @@ import android.provider.DocumentsProvider
 import android.util.Log
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.runBlocking
-import net.syncthing.java.bep.IndexBrowser
+import net.syncthing.java.bep.index.browser.DirectoryContentListing
+import net.syncthing.java.bep.index.browser.DirectoryNotFoundListing
 import net.syncthing.java.core.beans.FileInfo
 import net.syncthing.java.core.beans.FolderInfo
-import net.syncthing.java.core.beans.FolderStats
 import net.syncthing.lite.R
+import net.syncthing.lite.utils.MimeType
 import java.io.FileNotFoundException
-import java.net.URLConnection
-import java.util.concurrent.CountDownLatch
 
 class SyncthingProvider : DocumentsProvider() {
 
     companion object {
         private const val Tag = "SyncthingProvider"
+
         private val DefaultRootProjection = arrayOf(
                 Root.COLUMN_ROOT_ID,
                 Root.COLUMN_FLAGS,
                 Root.COLUMN_TITLE,
                 Root.COLUMN_SUMMARY,
                 Root.COLUMN_DOCUMENT_ID,
-                Root.COLUMN_ICON)
+                Root.COLUMN_ICON
+        )
+
         private val DefaultDocumentProjection = arrayOf(
                 Document.COLUMN_DOCUMENT_ID,
                 Document.COLUMN_DISPLAY_NAME,
                 Document.COLUMN_SIZE,
                 Document.COLUMN_MIME_TYPE,
                 Document.COLUMN_LAST_MODIFIED,
-                Document.COLUMN_FLAGS)
+                Document.COLUMN_FLAGS
+        )
     }
 
     override fun onCreate(): Boolean {
@@ -45,96 +48,122 @@ class SyncthingProvider : DocumentsProvider() {
     }
 
     // this instance is not started -> it connects and disconnects on demand
-    private val libraryHandler: LibraryHandler by lazy { LibraryHandler(context) }
     private val libraryManager: LibraryManager by lazy { DefaultLibraryManager.with(context) }
 
     override fun queryRoots(projection: Array<String>?): Cursor {
         Log.d(Tag, "queryRoots($projection)")
-        val latch = CountDownLatch(1)
-        var folders: List<Pair<FolderInfo, FolderStats>>? = null
-        libraryHandler.folderBrowser { folderBrowser ->
-            folders = folderBrowser.folderInfoAndStatsList()
-            latch.countDown()
-        }
-        latch.await()
 
-        val result = MatrixCursor(projection ?: DefaultRootProjection)
-        folders!!.forEach { folder ->
-            val row = result.newRow()
-            row.add(Root.COLUMN_ROOT_ID, folder.first.folderId)
-            row.add(Root.COLUMN_SUMMARY, folder.first.label)
-            row.add(Root.COLUMN_FLAGS, 0)
-            row.add(Root.COLUMN_TITLE, context.getString(R.string.app_name))
-            row.add(Root.COLUMN_DOCUMENT_ID, getDocIdForFile(folder.first))
-            row.add(Root.COLUMN_ICON, R.mipmap.ic_launcher)
+        return runBlocking {
+            libraryManager.withLibrary { instance ->
+                MatrixCursor(projection ?: DefaultRootProjection).apply {
+                    instance.folderBrowser.folderInfoAndStatusList().forEach { folder ->
+                        newRow().apply {
+                            add(Root.COLUMN_ROOT_ID, folder.info.folderId)
+                            add(Root.COLUMN_SUMMARY, folder.info.label)
+                            add(Root.COLUMN_FLAGS, 0)
+                            add(Root.COLUMN_TITLE, context.getString(R.string.app_name))
+                            add(Root.COLUMN_DOCUMENT_ID, getDocIdForFile(folder.info))
+                            add(Root.COLUMN_ICON, R.mipmap.ic_launcher)
+                        }
+                    }
+                }
+            }
         }
-        return result
     }
 
     override fun queryChildDocuments(parentDocumentId: String, projection: Array<String>?,
                                      sortOrder: String?): Cursor {
         Log.d(Tag, "queryChildDocuments($parentDocumentId, $projection, $sortOrder)")
-        val result = MatrixCursor(projection ?: DefaultDocumentProjection)
-        getIndexBrowser(getFolderIdForDocId(parentDocumentId))
-                .listFiles(getPathForDocId(parentDocumentId))
-                .forEach { fileInfo ->
-                    includeFile(result, fileInfo)
+
+        return runBlocking {
+            libraryManager.withLibrary { instance ->
+                val listing = instance.indexBrowser.getDirectoryListing(
+                        folder = getFolderIdForDocId(parentDocumentId),
+                        path = getPathForDocId(parentDocumentId)
+                )
+
+                when (listing) {
+                    is DirectoryNotFoundListing -> throw FileNotFoundException()
+                    is DirectoryContentListing -> {
+                        val result = MatrixCursor(projection ?: DefaultDocumentProjection)
+
+                        listing.entries.forEach { entry ->
+                            includeFile(result, entry)
+                        }
+
+                        result
+                    }
                 }
-        return result
+            }
+        }
     }
 
     override fun queryDocument(documentId: String, projection: Array<String>?): Cursor {
         Log.d(Tag, "queryDocument($documentId, $projection)")
-        val result = MatrixCursor(projection ?: DefaultDocumentProjection)
-        val fileInfo = getIndexBrowser(getFolderIdForDocId(documentId))
-                .getFileInfoByAbsolutePath(getPathForDocId(documentId))
-        includeFile(result, fileInfo)
-        return result
+
+        return runBlocking {
+            libraryManager.withLibrary {  instance ->
+                val fileInfo = instance.indexBrowser.getFileInfoByAbsolutePathAllowNull(
+                        folder = getFolderIdForDocId(documentId),
+                        path = getPathForDocId(documentId)
+                ) ?: throw FileNotFoundException()
+
+                MatrixCursor(projection ?: DefaultDocumentProjection).apply {
+                    includeFile(this, fileInfo)
+                }
+            }
+        }
     }
 
     @Throws(FileNotFoundException::class)
     override fun openDocument(documentId: String, mode: String, signal: CancellationSignal?):
             ParcelFileDescriptor {
         Log.d(Tag, "openDocument($documentId, $mode, $signal)")
-        val fileInfo = getIndexBrowser(getFolderIdForDocId(documentId))
-                .getFileInfoByAbsolutePath(getPathForDocId(documentId))
+
         val accessMode = ParcelFileDescriptor.parseMode(mode)
+
         if (accessMode != ParcelFileDescriptor.MODE_READ_ONLY) {
             throw NotImplementedError()
         }
 
-        val outputFile = runBlocking {
-            signal?.setOnCancelListener {
-                this.coroutineContext.cancel()
-            }
+        return runBlocking {
+            libraryManager.withLibrary { instance ->
+                val fileInfo = instance.indexBrowser.getFileInfoByAbsolutePathAllowNull(
+                        folder = getFolderIdForDocId(documentId),
+                        path = getPathForDocId(documentId)
+                ) ?: throw FileNotFoundException()
 
-            val libraryInstance = libraryManager.startLibraryUsageCoroutine()
+                signal?.setOnCancelListener {
+                    this.coroutineContext.cancel()
+                }
 
-            try {
-                DownloadFileTask.downloadFileCoroutine(
+                val outputFile = DownloadFileTask.downloadFileCoroutine(
                         externalCacheDir = context.externalCacheDir,
-                        syncthingClient = libraryInstance.syncthingClient,
+                        syncthingClient = instance.syncthingClient,
                         fileInfo = fileInfo,
                         onProgress = { /* ignore the progress */ }
                 )
-            } finally {
-                libraryManager.stopLibraryUsage()
+
+                ParcelFileDescriptor.open(outputFile, ParcelFileDescriptor.MODE_READ_ONLY)
             }
         }
-
-        return ParcelFileDescriptor.open(outputFile, ParcelFileDescriptor.MODE_READ_ONLY)
     }
 
     private fun includeFile(result: MatrixCursor, fileInfo: FileInfo) {
-        val row = result.newRow()
-        row.add(Document.COLUMN_DOCUMENT_ID, getDocIdForFile(fileInfo))
-        row.add(Document.COLUMN_DISPLAY_NAME, fileInfo.fileName)
-        row.add(Document.COLUMN_SIZE, fileInfo.size)
-        val mime = if (fileInfo.isDirectory()) Document.MIME_TYPE_DIR
-        else URLConnection.guessContentTypeFromName(fileInfo.fileName)
-        row.add(Document.COLUMN_MIME_TYPE, mime)
-        row.add(Document.COLUMN_LAST_MODIFIED, fileInfo.lastModified)
-        row.add(Document.COLUMN_FLAGS, 0)
+        result.newRow().apply {
+            add(Document.COLUMN_DOCUMENT_ID, getDocIdForFile(fileInfo))
+            add(Document.COLUMN_DISPLAY_NAME, fileInfo.fileName)
+            add(Document.COLUMN_SIZE, fileInfo.size)
+            add(
+                    Document.COLUMN_MIME_TYPE,
+                    if (fileInfo.isDirectory())
+                        Document.MIME_TYPE_DIR
+                    else
+                        MimeType.getFromFilename(fileInfo.fileName)
+            )
+            add(Document.COLUMN_LAST_MODIFIED, fileInfo.lastModified)
+            add(Document.COLUMN_FLAGS, 0)
+        }
     }
 
     private fun getFolderIdForDocId(docId: String) = docId.split(":")[0]
@@ -144,15 +173,4 @@ class SyncthingProvider : DocumentsProvider() {
     private fun getDocIdForFile(folderInfo: FolderInfo) = folderInfo.folderId + ":"
 
     private fun getDocIdForFile(fileInfo: FileInfo) = fileInfo.folder + ":" + fileInfo.path
-
-    private fun getIndexBrowser(folderId: String): IndexBrowser {
-        val latch = CountDownLatch(1)
-        var indexBrowser: IndexBrowser? = null
-        libraryHandler.syncthingClient {
-            indexBrowser = it.indexHandler.newIndexBrowser(folderId)
-            latch.countDown()
-        }
-        latch.await()
-        return indexBrowser!!
-    }
 }

app/src/main/kotlin/net/syncthing/lite/utils/MimeType.kt

@@ -0,0 +1,18 @@
+package net.syncthing.lite.utils
+
+import android.webkit.MimeTypeMap
+import net.syncthing.java.core.utils.PathUtils
+
+object MimeType {
+    private const val DEFAULT_MIME_TYPE = "application/octet-stream"
+
+    private fun getFromExtension(extension: String): String {
+        val mimeType: String? = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension)
+
+        return mimeType ?: DEFAULT_MIME_TYPE
+    }
+
+    fun getFromFilename(path: String) = getFromExtension(
+            PathUtils.getFileExtensionFromFilename(path).toLowerCase()
+    )
+}

app/src/main/kotlin/net/syncthing/lite/utils/Util.kt

@@ -10,7 +10,7 @@ import kotlinx.coroutines.launch
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.beans.DeviceInfo
 import net.syncthing.lite.R
-import net.syncthing.lite.library.LibraryHandler
+import net.syncthing.lite.library.LibraryManager
 import org.apache.commons.lang3.StringUtils.capitalize
 import org.jetbrains.anko.toast
 import java.io.IOException
@@ -23,11 +23,11 @@ object Util {
         val manufacturer = Build.MANUFACTURER ?: ""
         val model = Build.MODEL ?: ""
         val deviceName =
-            if (model.startsWith(manufacturer)) {
-                capitalize(model)
-            } else {
-                capitalize(manufacturer) + " " + model
-            }
+                if (model.startsWith(manufacturer)) {
+                    capitalize(model)
+                } else {
+                    capitalize(manufacturer) + " " + model
+                }
         return deviceName ?: "android"
     }
 
@@ -41,22 +41,34 @@ object Util {
     }
 
     @Throws(IOException::class)
-    fun importDeviceId(libraryHandler: LibraryHandler?, context: Context?, deviceId: String,
-                       onComplete: () -> Unit) {
-        val deviceId2 = DeviceId(deviceId.toUpperCase(Locale.US))
-        libraryHandler?.library { configuration, syncthingClient, _ ->
-            if (!configuration.peerIds.contains(deviceId2)) {
-                configuration.peers = configuration.peers + DeviceInfo(deviceId2, null)
-                configuration.persistLater()
-                syncthingClient.connectToNewlyAddedDevices()
-                GlobalScope.launch (Dispatchers.Main) {
-                    context?.toast(context.getString(R.string.device_import_success, deviceId2.shortId))
+    fun importDeviceId(libraryManager: LibraryManager, context: Context, deviceId: String, onComplete: () -> Unit) {
+        val newDeviceId = DeviceId(deviceId.toUpperCase(Locale.US))
+
+        GlobalScope.launch (Dispatchers.Main) {
+            libraryManager.withLibrary { library ->
+                val didAddDevice = library.configuration.update { oldConfig ->
+                    if (oldConfig.peers.find { it.deviceId == newDeviceId } != null) {
+                        // already known
+
+                        oldConfig
+                    } else {
+                        oldConfig.copy(
+                                peers = oldConfig.peers + DeviceInfo(newDeviceId, newDeviceId.shortId)
+                        )
+                    }
+                }
+
+                if (didAddDevice) {
+                    library.configuration.persistLater()
+                    library.syncthingClient.connectToNewlyAddedDevices()
+
+                    context.toast(context.getString(R.string.device_import_success, newDeviceId.shortId))
                     onComplete()
+                } else {
+                    context.toast(context.getString(R.string.device_already_known, newDeviceId.shortId))
                 }
-            } else {
-                GlobalScope.launch (Dispatchers.Main) {
-                    context?.toast(context.getString(R.string.device_already_known, deviceId2.shortId))
-                }
+
+                null
             }
         }
     }

app/src/main/play/en-GB/whatsnew

@@ -1,3 +1 @@
-- new connection handling
-- option for users to get detailed crash reports
-- bugfixes
+- update translations

app/src/main/res/drawable/ic_home_white_24dp.xml

@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24.0" android:viewportWidth="24.0"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M10,20v-6h4v6h5v-8h3L12,3 2,12h3v8z"/>
+</vector>

app/src/main/res/layout/dialog_folder_info.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layout xmlns:android="http://schemas.android.com/apk/res/android">
+    <LinearLayout
+        android:padding="8dp"
+        android:orientation="vertical"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+
+        <TextView
+            android:textAppearance="?android:textAppearanceMedium"
+            android:text="@string/dialog_folder_info_device_list"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content" />
+
+        <LinearLayout
+            android:id="@+id/device_checkboxes_container"
+            android:orientation="vertical"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content">
+
+            <!--
+            <CheckBox
+                android:text="Test device 1 (the very very very very very very very very very very very long id)"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content" />
+
+            <CheckBox
+                android:text="Test device 2 (the very very very very very very very very very very very long id)"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content" />
+            -->
+
+        </LinearLayout>
+
+    </LinearLayout>
+</layout>

app/src/main/res/layout/listview_device.xml

@@ -7,46 +7,59 @@
             name="name"
             type="String" />
 
+        <variable
+            name="status"
+            type="String" />
+
         <variable
             name="isConnected"
             type="Boolean" />
     </data>
 
-    <RelativeLayout
+    <LinearLayout
+        android:orientation="horizontal"
         android:background="?selectableItemBackground"
+        android:padding="8dp"
         android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:paddingBottom="12dp"
-        android:paddingLeft="24dp"
-        android:paddingRight="24dp"
-        android:paddingTop="12dp">
+        android:layout_height="wrap_content">
 
         <ImageView
+            android:layout_gravity="center_vertical"
             android:id="@+id/device_icon"
             android:layout_width="32dp"
             android:layout_height="32dp"
             tools:src="@drawable/ic_laptop_green_24dp"
-            android:src="@{safeUnbox(isConnected) ? @drawable/ic_laptop_green_24dp : @drawable/ic_laptop_red_24dp}"
-            android:layout_alignParentStart="true"
-            android:layout_alignParentTop="true"/>
+            android:src="@{safeUnbox(isConnected) ? @drawable/ic_laptop_green_24dp : @drawable/ic_laptop_red_24dp}" />
 
-        <TextView
-            tools:text="Computer"
-            android:text="@{name}"
-            android:id="@+id/device_name"
+        <View
+            android:layout_width="16dp"
+            android:layout_height="0dp" />
+
+        <LinearLayout
+            android:orientation="vertical"
             android:layout_width="match_parent"
-            android:layout_alignParentEnd="true"
-            android:layout_height="wrap_content"
-            android:ellipsize="end"
-            android:maxLines="1"
-            android:layout_alignParentTop="true"
-            android:gravity="top"
-            android:textAlignment="gravity"
-            android:paddingStart="40dp"
-            android:paddingEnd="40dp"
-            android:textSize="18sp"
-            android:textStyle="bold"/>
+            android:layout_height="wrap_content">
 
-    </RelativeLayout>
+            <TextView
+                tools:text="Computer"
+                android:text="@{name}"
+                android:id="@+id/device_name"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:ellipsize="end"
+                android:maxLines="1"
+                android:textAlignment="gravity"
+                android:textSize="18sp"
+                android:textStyle="bold"/>
+
+            <TextView
+                android:text="@{status}"
+                tools:text="Trying to connect to 127.0.0.1 ..."
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content" />
+
+        </LinearLayout>
+
+    </LinearLayout>
 
 </layout>

app/src/main/res/layout/listview_folder.xml

@@ -13,9 +13,17 @@
         <variable
             name="info"
             type="String" />
+
+        <variable
+            name="info2"
+            type="String" />
+
+        <import type="android.view.View" />
+        <import type="android.text.TextUtils" />
     </data>
 
-    <RelativeLayout
+    <LinearLayout
+        android:orientation="vertical"
         android:background="?selectableItemBackground"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
@@ -29,13 +37,9 @@
             android:text="@{folderName}"
             android:id="@+id/folder_name_view"
             android:layout_width="match_parent"
-            android:layout_alignParentEnd="true"
             android:layout_height="wrap_content"
             android:ellipsize="end"
             android:maxLines="1"
-            android:layout_alignParentTop="true"
-            android:gravity="top"
-            android:textAlignment="gravity"
             android:textSize="20sp"
             android:textStyle="bold"/>
 
@@ -47,9 +51,7 @@
             android:layout_height="wrap_content"
             android:ellipsize="end"
             android:maxLines="1"
-            android:layout_below="@id/folder_name_view"
-            android:textSize="14sp"
-            android:layout_alignParentStart="true" />
+            android:textSize="14sp" />
 
         <TextView
             tools:text="Additional information"
@@ -59,11 +61,18 @@
             android:layout_height="wrap_content"
             android:ellipsize="end"
             android:maxLines="1"
-            android:layout_below="@id/folder_lastmod_info"
-            android:textSize="14sp"
-            android:layout_alignParentStart="true"  />
+            android:textSize="14sp" />
 
+        <TextView
+            android:visibility="@{TextUtils.isEmpty(info2) ? View.GONE : View.VISIBLE}"
+            tools:text="Index Update Progress"
+            android:text="@{info2}"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:ellipsize="end"
+            android:maxLines="1"
+            android:textSize="14sp" />
 
-    </RelativeLayout>
+    </LinearLayout>
 
-</layout>
+</layout>

app/src/main/res/menu/folder_browser.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto">
+    <item
+        app:showAsAction="always"
+        android:icon="@drawable/ic_home_white_24dp"
+        android:id="@+id/go_home"
+        android:title="@string/folder_browser_home" />
+</menu>

app/src/main/res/values-bg/strings.xml

@@ -0,0 +1,60 @@
+<resources>
+    <string name="folder_list_empty_message">Няма папки</string>
+    <string name="clear_local_cache_index_label">Изчисти кеша/индекса</string>
+    <string name="devices_list_view_empty_message">Няма устройства</string>
+    <string name="invalid_device_id">Грешка: Невалиден идентификатор</string>
+    <string name="dialog_downloading_file">Сваляне на файла %1$s</string>
+    <string name="toast_file_download_failed">Свалянето на файла се провали</string>
+    <string name="toast_open_file_failed">Не са намерени съвместими приложения</string>
+    <string name="toast_file_upload_failed">Качването на файла се провали</string>
+    <string name="toast_upload_complete">Файлът е качен</string>
+    <string name="dialog_uploading_file">Качване на файла %1$s</string>
+    <string name="clear_cache_and_index_title">Изчистване на локалния кеш/индекс?</string>
+    <string name="clear_cache_and_index_body">Да бъдат ли изтрити всички локално кеширани данни и индекси?</string>
+    <string name="loading_config_starting_syncthing_client">Зареждане на настройките, стартиране на Syncthing клиента...</string>
+    <string name="last_modified_time">Последна промяна: %1$s</string>
+    <string name="remove_device_title">Изтриване на устройството %1$s\?</string>
+    <string name="remove_device_message">Да бъде ли премахнато устройството %1$s от списъка с познати устройства?</string>
+    <string name="device_import_success">Устройството %1$s е внесено успешно</string>
+    <string name="device_already_known">Устройството %1$s вече съществува</string>
+    <string name="folders_label">Папки</string>
+    <string name="devices_label">Устройства</string>
+    <string name="folder_label_format">%1$s (%2$s)</string>
+    <string name="folder_content_info">%1$s, %2$d файла, %3$d директории</string>
+    <string name="file_info">%1$s, последна промяна %2$s</string>
+    <string name="show_device_id">Идентификатор на устройството</string>
+    <string name="device_id">Идентификатор на устройството</string>
+    <string name="device_id_copied">Идентификатора на устройството е копиран</string>
+    <string name="share_device_id_chooser">Споделяне на идентификатор чрез</string>
+    <string name="other_syncthing_instance_title">Syncthing вече е стартиран</string>
+    <string name="other_syncthing_instance_message">Локалното откриване няма да работи. За да сработи е необходимо да спрете друго стартирано Syncthing приложение.</string>
+    <string name="intro_page_one_title">Добре дошли в Syncthing Lite</string>
+    <string name="intro_page_two_title">Добавяне на устройство</string>
+    <string name="intro_page_three_title">Споделете папки</string>
+    <string name="intro_page_two_description">Въведете Syncthing идентификатор на устройство или го сканирайте от QR код</string>
+    <string name="intro_page_three_searching_device">Търсене за други устройства. Може да отнеме известно време.</string>
+    <string name="settings">Настройки</string>
+    <string name="settings_app_version_title">Версия на приложението</string>
+    <string name="settings_local_device_name">Име на устройството</string>
+    <string name="settings_local_device_summary">Въведеното име ще бъде ползвано за представяне пред други устройства</string>
+    <string name="settings_force_stop">Принудително спиране на приложението</string>
+    <string name="settings_last_error_title">Последна грешка</string>
+    <string name="settings_last_error_summary">Прегледайте подробностите за последната грешка</string>
+    <string name="copy_to_clipboard">Копирай</string>
+    <string name="copied_to_clipboard">Копирано в клипборда</string>
+    <string name="device_id_dialog_title">Въведете идентификатор на устройство</string>
+    <string name="settings_shutdown_delay_10_seconds">10 секунди</string>
+    <string name="settings_shutdown_delay_30_seconds">30 секунди</string>
+    <string name="settings_shutdown_delay_1_minute">1 минута</string>
+    <string name="settings_shutdown_delay_5_minutes">5 минути</string>
+    <string name="dialog_file_save_as">Запиши като</string>
+    <string name="device_status_connecting">Свързване с %s</string>
+    <string name="device_status_connected">Осъществена връзка с %s</string>
+    <string name="device_status_disconnected">Скоро ще бъде направен опит за свързване - %d известни адреса</string>
+    <string name="device_status_no_address">Устройството няма известен адрес</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Желаете ли да синхронизирате %1$s с %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Синхронизирай</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Не синхронизирай</string>
+    <string name="dialog_folder_info_device_list">Споделяне на папката с:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    </resources>

app/src/main/res/values-de/strings.xml

@@ -28,7 +28,7 @@
     <string name="device_id">Geräte ID</string>
     <string name="device_id_copied">Geräte ID in den Zwischenspeicher kopiert</string>
     <string name="share_device_id_chooser">Teile Geräte ID mit</string>
-    <string name="other_syncthing_instance_title">Eine andere Syncthing Instanz läuft bereits</string>
+    <string name="other_syncthing_instance_title">Eine andere Syncthing-Instanz läuft bereits</string>
     <string name="other_syncthing_instance_message">Lokale Auffindung wird nicht funktionieren. Stoppen Sie die andere Syncthing Instanz, um die lokale Auffindung zu ermöglichen.</string>
     <string name="intro_page_one_title">Willkommen zu Syncthing Lite</string>
     <string name="intro_page_one_description">Syncthing ersetzt proprietäre Sync- und Cloud-Services durch etwas Offenes, Vertrauenswürdiges und Dezentrales. Ihre Daten sind allein Ihre Daten, und Sie verdienen es zu wählen, wo sie gespeichert werden, ob sie an Dritte weitergegeben werden und wie sie über das Internet übertragen werden.</string>
@@ -36,9 +36,38 @@
     <string name="intro_page_three_title">Ordner teilen</string>
     <string name="intro_page_two_description">Eine Syncthing Geräte ID eingeben oder QR Code einer Geräte ID scannen.</string>
     <string name="intro_page_three_description">Akzeptieren Sie nun das Gerät mit der ID %1$s und geben Sie einen Ordner mit ihm frei. Es kann einige Minuten dauern, bis sich die Geräte verbinden.</string>
+    <string name="intro_page_three_searching_device">Versuche das andere Gerät zu finden. Dies kann einen Moment dauern.</string>
     <string name="settings">Einstellungen</string>
-    <string name="settings_app_version_title">App Version</string>
-    <string name="settings_local_device_name">Lokaler Geräte Namen</string>
+    <string name="settings_app_version_title">App-Version</string>
+    <string name="settings_local_device_name">Lokaler Gerätenamen</string>
     <string name="settings_local_device_summary">Name, den das andere Gerät für dieses Gerät sehen wird</string>
+    <string name="settings_shutdown_delay_title">Ausschaltverzögerung</string>
+    <string name="settings_force_stop">Beenden dieser App erzwingen</string>
+    <string name="settings_last_error_title">Letzter Fehler</string>
+    <string name="settings_last_error_summary">Details des letzten Fehlers anzeigen</string>
+    <string name="settings_report_bug_title">Einen Fehler melden</string>
+    <string name="settings_report_bug_summary">Den Bugtracker bei GitHub für diese App öffnen</string>
+    <string name="copy_to_clipboard">In die Zwischenablage kopieren</string>
+    <string name="copied_to_clipboard">In die Zwischenablage kopiert</string>
     <string name="device_id_dialog_title">Geräte ID eingeben</string>
-    </resources>
+    <string name="settings_shutdown_delay_10_seconds">10 Sekunden</string>
+    <string name="settings_shutdown_delay_30_seconds">30 Sekunden</string>
+    <string name="settings_shutdown_delay_1_minute">1 Minute</string>
+    <string name="settings_shutdown_delay_5_minutes">5 Minuten</string>
+    <string name="dialog_warning_reconnect_problem">
+Aufgrund des Verhaltens dieser App und des Verhaltens des Syncthing-Servers können Sie sich für einige Minuten nicht verbinden, wenn die App erzwungen beendet wurde (durch das Entfernen aus der Liste der aktiven Apps) oder die Verbindung unterbrochen wurde.
+Dies gilt nicht für Verbindungen, die per lokaler Gerätesuche hergestellt wurden.</string>
+    <string name="dialog_file_save_as">Speichern unter</string>
+    <string name="pending_index_updates">%d Index-Aktualisierungen verbleibend</string>
+    <string name="device_status_connecting">Verbinden mit %s</string>
+    <string name="device_status_connected">Mit %s verbunden</string>
+    <string name="device_status_disconnected">Verbinden wird bald erneut versucht - es sind %d Adressen bekannt</string>
+    <string name="device_status_no_address">Keine bekannte Adresse für dieses Gerät</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Ordnersynchronisation für neues Gerät aktivieren</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Möchten Sie den Ordner %1$s mit %2$s (%3$s) synchronisieren?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Synchronisieren</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Nicht synchronisieren</string>
+    <string name="dialog_folder_info_device_list">Ordner teilen mit:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Etwas in Syncthing Lite hat nicht funktioniert. Sie können die Details in den Einstellungen von Syncthing Lite anzeigen.</string>
+</resources>

app/src/main/res/values-es/strings.xml

@@ -4,7 +4,7 @@
     <string name="clear_local_cache_index_label">Limpia caché/índice local</string>
     <string name="devices_list_view_empty_message">Dispositivos no disponibles</string>
     <string name="invalid_device_id">Error: identificador de dispositivo inválido</string>
-    <string name="dialog_downloading_file">Descargando archivo%1$s</string>
+    <string name="dialog_downloading_file">Descargando archivo %1$s</string>
     <string name="toast_file_download_failed">Falló al descargar el archivo</string>
     <string name="toast_open_file_failed">No se ha encontrado una app compatible</string>
     <string name="toast_file_upload_failed">Error en la carga de archivos
@@ -24,7 +24,7 @@
     <string name="folders_label">Carpetas</string>
     <string name="devices_label">Dispositivos</string>
     <string name="folder_label_format">%1$s (%2$s)</string>
-    <string name="folder_content_info">%1$s, %2$d archivos, %3$ddirectorios</string>
+    <string name="folder_content_info">%1$s, %2$d archivos, %3$d directorios</string>
     <string name="file_info">%1$s, modificado por última vez %2$s</string>
     <string name="show_device_id">Mostrar ID de dispositivo </string>
     <string name="device_id">ID de dispositivo</string>
@@ -38,15 +38,42 @@
     <string name="intro_page_three_title">Compartir tus carpetas</string>
     <string name="intro_page_two_description">Introduce un ID de dispositivo de Syncthing o escanea un ID de dispositivo desde un código QR</string>
     <string name="intro_page_three_description">Acepta ahora el dispositivo con ID %1$s, y comparte una carpeta con él. Pueden pasar unos minutos hasta que los dispositivos se conecten.</string>
+    <string name="intro_page_three_searching_device">Intentando encontrar el otro dispositivo. Puede llevar un rato</string>
     <string name="settings">Configuración</string>
     <string name="settings_app_version_title">Versión de la aplicación</string>
     <string name="settings_local_device_name">Nombre del dispositivo local</string>
     <string name="settings_local_device_summary">El nombre que otros dispositivos verán para este dispositivo</string>
     <string name="settings_shutdown_delay_title">Retardo en el apagado</string>
-    <string name="settings_shutdown_delay_summary">Tiempo antes de apagar el cliente Syncthing después de su último uso</string>
+    <string name="settings_shutdown_delay_summary">Tiempo antes de que el cliente de Syncthing se cierre después de su último uso</string>
+    <string name="settings_force_stop">Fuerza a parar esta aplicación</string>
+    <string name="settings_last_error_title">Último error</string>
+    <string name="settings_last_error_summary">Ver los detalles del último error</string>
+    <string name="settings_report_bug_title">Informar de un error</string>
+    <string name="settings_report_bug_summary">Abrir las incidencias de esta aplicación en GitHub</string>
+    <string name="copy_to_clipboard">Copiar al portapapeles</string>
+    <string name="copied_to_clipboard">Copiado al portapapeles</string>
     <string name="device_id_dialog_title">Introducir la ID del dispositivo</string>
     <string name="settings_shutdown_delay_10_seconds">10 segundos</string>
     <string name="settings_shutdown_delay_30_seconds">30 segundos</string>
     <string name="settings_shutdown_delay_1_minute">1 minuto</string>
     <string name="settings_shutdown_delay_5_minutes">5 minutos</string>
+    <string name="dialog_warning_reconnect_problem">
+Debido al comportamiento de esta aplicación y al comportamiento del servidor de Syncthing, 
+        no puedes volver a conectar durante unos minutos si la aplicación fue cancelada (debido a la eliminación de la lista de aplicaciones recientes)
+        O la conexión fue interrumpida.
+        Esto no aplica a las conexiones de descubrimiento local.
+</string>
+    <string name="dialog_file_save_as">Guardar como</string>
+    <string name="pending_index_updates">%d actualizaciones de índice pendientes</string>
+    <string name="device_status_connecting">Conectando a %s</string>
+    <string name="device_status_connected">Conectado a %s</string>
+    <string name="device_status_disconnected">Volverá a conectar pronto - hay %d direcciones conocidas</string>
+    <string name="device_status_no_address">Sin dirección conocida para el dispositivo</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Activar sincronización para el nuevo dispositivo</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">¿Quieres sincronizar %1$s con %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Sincronizar</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">No sincronización</string>
+    <string name="dialog_folder_info_device_list">Compartir la carpeta con:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Algo salió mal en Syncthing Lite. Puedes ver los detalles en la configuración de Syncthing Lite.</string>
 </resources>

app/src/main/res/values-fr/strings.xml

@@ -36,15 +36,40 @@
     <string name="intro_page_three_title">Partager vos dossiers</string>
     <string name="intro_page_two_description">Entrer l\'ID Syncthing de l\'appareil, ou scanner le QR code de l\'ID d\'un appareil.</string>
     <string name="intro_page_three_description">Maintenant, acceptez l\'appareil avec l\'ID %1$s, et partagez un dossier avec lui. Cela peut prendre quelques minutes avant que les appareils ne se connectent.</string>
+    <string name="intro_page_three_searching_device">Essayer de trouver l\'autre appareil. Cela peut prendre un moment.</string>
     <string name="settings">Réglages</string>
     <string name="settings_app_version_title">Version d\'application</string>
     <string name="settings_local_device_name">Nom local de l\'appareil</string>
     <string name="settings_local_device_summary">Le nom que les autres appareils verront pour cet appareil</string>
     <string name="settings_shutdown_delay_title">Délai d\'arrêt</string>
     <string name="settings_shutdown_delay_summary">Délai avant d\'arrêter le client Syncthing après sa dernière utilisation</string>
+    <string name="settings_force_stop">Forcer l\'arrêt de cette application</string>
+    <string name="settings_last_error_title">Dernière erreur</string>
+    <string name="settings_last_error_summary">Voir les détails de la dernière erreur</string>
+    <string name="settings_report_bug_title">Rapporter un bug</string>
+    <string name="settings_report_bug_summary">Ouvrir un incident pour cette application sur GitHub</string>
+    <string name="copy_to_clipboard">Copier dans le presse-papiers</string>
+    <string name="copied_to_clipboard">Copié dans le presse-papiers</string>
     <string name="device_id_dialog_title">Entrer l\'ID de l\'appareil</string>
     <string name="settings_shutdown_delay_10_seconds">10 secondes</string>
     <string name="settings_shutdown_delay_30_seconds">30 secondes</string>
     <string name="settings_shutdown_delay_1_minute">1 minute</string>
     <string name="settings_shutdown_delay_5_minutes">5 minutes</string>
+    <string name="dialog_warning_reconnect_problem">En raison du comportement de cette application et du comportement du serveur Syncthing,
+vous ne pouvez pas vous reconnecter pendant quelques minutes si l\'application a été tuée (dû à sa suppression de la liste des applications récentes)
+ou la connexion a été interrompue.
+Cela ne s\'applique pas aux connexions de découverte locales.</string>
+    <string name="dialog_file_save_as">Enregistrer sous</string>
+    <string name="pending_index_updates">%d mises à jour d\'index en attente</string>
+    <string name="device_status_connecting">Connexion à %s</string>
+    <string name="device_status_connected">Connexion à %s</string>
+    <string name="device_status_disconnected">Nous essayerons de vous reconnecter bientôt - Il y a %dadresses connues.</string>
+    <string name="device_status_no_address">Pas d\'adresse connue pour cet appareil</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Activer la synchronisation des dossiers pour le nouvel appareil</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Voulez-vous synchroniser %1$s avec %2$s (%3$s) ?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Synchroniser</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Ne pas synchroniser</string>
+    <string name="dialog_folder_info_device_list">Partager le dossier avec:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Quelque chose s\'est mal passé dans Syncthing Lite. Vous pouvez afficher les détails à partir des paramètres de Syncthing Lite.</string>
 </resources>

app/src/main/res/values-hu/strings.xml

@@ -41,10 +41,10 @@
     <string name="settings_local_device_name">Helyi eszköz neve</string>
     <string name="settings_local_device_summary">Név amit a többi eszköz fog látni</string>
     <string name="settings_shutdown_delay_title">Leállítás késleltetés</string>
-    <string name="settings_shutdown_delay_summary">A Syncthing leállítása ennyi idő elteltével a kliens utolsó csatlakozása után</string>
     <string name="device_id_dialog_title">Eszközazonosító megadása</string>
     <string name="settings_shutdown_delay_10_seconds">10 másodperc</string>
     <string name="settings_shutdown_delay_30_seconds">30 másodperc</string>
     <string name="settings_shutdown_delay_1_minute">1 perc</string>
     <string name="settings_shutdown_delay_5_minutes">5 perc</string>
-</resources>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    </resources>

app/src/main/res/values-it/strings.xml

@@ -36,15 +36,42 @@
     <string name="intro_page_three_title">Condividi le tue cartelle</string>
     <string name="intro_page_two_description">Immetti un ID dispositivo Syncthing o esegui la scansione di un ID dispositivo da un codice QR</string>
     <string name="intro_page_three_description">Ora accetta il dispositivo con ID %1$s, e condividi una cartella con esso. Potrebbero essere necessari alcuni minuti prima che i dispositivi si connettano.</string>
+    <string name="intro_page_three_searching_device">In attesa di trovare altri dispositivi. Questo potrebbe richiedere un momento.</string>
     <string name="settings">Impostazioni</string>
     <string name="settings_app_version_title">Versione dell\'app</string>
     <string name="settings_local_device_name">Nome del dispositivo locale</string>
     <string name="settings_local_device_summary">Il nome che altri dispositivi vedranno per questo dispositivo</string>
     <string name="settings_shutdown_delay_title">Ritardo di chiusura</string>
     <string name="settings_shutdown_delay_summary">Tempo prima della chiusura del client Syncthing dopo l\'ultimo utilizzo</string>
+    <string name="settings_force_stop">Forza l\'arresto dell\'App</string>
+    <string name="settings_last_error_title">Ultimo errore</string>
+    <string name="settings_last_error_summary">Visualizza i dettagli dell\'ultimo errore</string>
+    <string name="settings_report_bug_title">Segnala un bug</string>
+    <string name="settings_report_bug_summary">Apri segnalazioni per quest\'App su GitHub</string>
+    <string name="copy_to_clipboard">Copia negli appunti</string>
+    <string name="copied_to_clipboard">Copiato negli appunti</string>
     <string name="device_id_dialog_title">Inserisci ID Dispositivo</string>
     <string name="settings_shutdown_delay_10_seconds">10 secondi</string>
     <string name="settings_shutdown_delay_30_seconds">30 secondi</string>
     <string name="settings_shutdown_delay_1_minute">1 minuto</string>
     <string name="settings_shutdown_delay_5_minutes">5 minuti</string>
+    <string name="dialog_warning_reconnect_problem">
+        A causa del comportamento di quest\'App e del comportamento del Server Syncthing,
+        non è possibile riconnettersi per alcuni minuti se l\'app è stata chiusa (a causa della rimozione dall\'elenco app recenti)
+        o la connessione è stata interrotta.
+        Questo non si applica alle connessioni di individuazione locale
+    </string>
+    <string name="dialog_file_save_as">Salva come</string>
+    <string name="pending_index_updates">%d aggiornamenti degli indici in sospeso</string>
+    <string name="device_status_connecting">Connessione a %s</string>
+    <string name="device_status_connected">Connesso a %s</string>
+    <string name="device_status_disconnected">Nuovo tentativo di connessione a breve: ci sono %d indirizzi noti</string>
+    <string name="device_status_no_address">Nessun indirizzo conosciuto per il dispositivo</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Abilita sincronizzazione cartella per il nuovo dispositivo</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Vuoi sincronizzare %1$s con %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Sincronizzare</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Non sincronizzare</string>
+    <string name="dialog_folder_info_device_list">Condividi la cartella con:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Qualcosa non ha funzionato in Syncthing Lite. È possibile visualizzare i dettagli dalle impostazioni di Syncthing Lite.</string>
 </resources>

app/src/main/res/values-ja/strings.xml

@@ -41,4 +41,5 @@
     <string name="settings_local_device_name">ローカルのデバイス名</string>
     <string name="settings_local_device_summary">他のデバイスがこのデバイスを表示する名前</string>
     <string name="device_id_dialog_title">デバイス ID を入力</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
     </resources>

app/src/main/res/values-nl-rBE/strings.xml

@@ -3,10 +3,10 @@
     <string name="folder_list_empty_message">Geen map beschikbaar</string>
     <string name="clear_local_cache_index_label">Lokaal cachegeheugen/index wissen</string>
     <string name="devices_list_view_empty_message">Geen apparaten beschikbaar</string>
-    <string name="invalid_device_id">Fout: ongeldigen apparaats-ID</string>
+    <string name="invalid_device_id">Fout: ongeldige apparaats-ID</string>
     <string name="dialog_downloading_file">Bestand %1$s wordt gedownload</string>
     <string name="toast_file_download_failed">Download van bestand mislukt</string>
-    <string name="toast_open_file_failed">Gene compatibelen app gevonden</string>
+    <string name="toast_open_file_failed">Geen compatibele app gevonden</string>
     <string name="toast_file_upload_failed">Uploaden van bestand mislukt</string>
     <string name="toast_upload_complete">Uploaden van bestand voltooid</string>
     <string name="dialog_uploading_file">Bestand %1$s wordt geüpload</string>
@@ -29,16 +29,48 @@
     <string name="device_id_copied">Apparaats-ID gekopieerd naar klembord</string>
     <string name="share_device_id_chooser">Apparaats-ID delen met</string>
     <string name="other_syncthing_instance_title">Een andere Syncthing-instantie wordt reeds uitgevoerd</string>
-    <string name="other_syncthing_instance_message">Lokale ontdekking gaat niet werken. Stopt de andere Syncthing-instantie voor lokale ontdekking in te schakelen.</string>
+    <string name="other_syncthing_instance_message">Lokale ontdekking zal niet werken. Stop de andere Syncthing-instantie om lokale ontdekking in te schakelen.</string>
     <string name="intro_page_one_title">Welkom bij Syncthing Lite</string>
-    <string name="intro_page_one_description">Syncthing vervangt niet-vrije synchronisatie- en clouddiensten door iets opens, betrouwbaars en gedecentraliseerds. Uw gegevens behoren enkel u toe en gij bepaalt waar dat ze worden opgeslagen, of dat ze worden gedeeld met een derde partij en hoe dat ze over het internet worden verzonden.</string>
-    <string name="intro_page_two_title">Voegt een apparaat toe</string>
-    <string name="intro_page_three_title">Deelt uw mappen</string>
-    <string name="intro_page_two_description">Voert ne Syncthing-apparaats-ID in, of scant nen apparaats-ID van een QR-code</string>
-    <string name="intro_page_three_description">Aanvaard nu het apparaat met ID %1$s, en deelt er een map mee. Het kan enkele minuten duren vooraleer dat de apparaten verbinding maken.</string>
+    <string name="intro_page_one_description">Syncthing vervangt niet-vrije synchronisatie- en clouddiensten door iets open, betrouwbaar en gedecentraliseerd. Uw gegevens behoren enkel u toe en u bepaalt waar ze worden opgeslagen, of ze worden gedeeld met een derde partij en hoe ze over het internet worden verzonden.</string>
+    <string name="intro_page_two_title">Voeg een apparaat toe</string>
+    <string name="intro_page_three_title">Deel uw mappen</string>
+    <string name="intro_page_two_description">Voer een Syncthing-apparaats-ID in, of scan een apparaats-ID van een QR-code</string>
+    <string name="intro_page_three_description">Aanvaard nu het apparaat met ID %1$s, en deel er een map mee. Het kan enkele minuten duren vooraleer de apparaten verbinding maken.</string>
+    <string name="intro_page_three_searching_device">Proberen het andere apparaat te vinden. Dit kan even duren.</string>
     <string name="settings">Instellingen</string>
     <string name="settings_app_version_title">Appversie</string>
     <string name="settings_local_device_name">Naam van lokaal apparaat</string>
-    <string name="settings_local_device_summary">De naam die dat andere apparaten voor dit apparaat gaan zien</string>
+    <string name="settings_local_device_summary">De naam die andere apparaten voor dit apparaat gaan zien</string>
+    <string name="settings_shutdown_delay_title">Wachten voor afsluiten</string>
+    <string name="settings_shutdown_delay_summary">Tijdsduur vóór afsluiten van Syncthing-cliënt na laatste gebruik</string>
+    <string name="settings_force_stop">Deze app gedwongen afsluiten</string>
+    <string name="settings_last_error_title">Laatste fout</string>
+    <string name="settings_last_error_summary">Bekijk de details van de laatste fout</string>
+    <string name="settings_report_bug_title">Fout melden</string>
+    <string name="settings_report_bug_summary">Bekijk de foutrapportages voor deze app op GitHub</string>
+    <string name="copy_to_clipboard">Kopiëren naar klembord</string>
+    <string name="copied_to_clipboard">Gekopieerd naar klembord</string>
     <string name="device_id_dialog_title">Voert nen apparaats-ID in</string>
-    </resources>
+    <string name="settings_shutdown_delay_10_seconds">10 seconden</string>
+    <string name="settings_shutdown_delay_30_seconds">30 seconden</string>
+    <string name="settings_shutdown_delay_1_minute">1 minuut</string>
+    <string name="settings_shutdown_delay_5_minutes">5 minuten</string>
+    <string name="dialog_warning_reconnect_problem">
+Omwille van het gedrag van deze app en het gedrag van de Syncthing-server,
+kunt u enkele minuten geen verbinding maken indien de app werd afgesloten (door deze uit de lijst met recente apps te verwijderen)
+of indien de verbinding werd verbroken.
+Dit is niet van toepassing op lokale ontdekkingsverbindingen.</string>
+    <string name="dialog_file_save_as">Opslaan als</string>
+    <string name="pending_index_updates">%d indexupdates in wacht</string>
+    <string name="device_status_connecting">Verbinden met %s</string>
+    <string name="device_status_connected">Verbonden met %s</string>
+    <string name="device_status_disconnected">Zal binnenkort opnieuw proberen verbinden - er zijn %d gekende adressen</string>
+    <string name="device_status_no_address">Geen gekend adres voor het apparaat</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Mapsynchronisatie inschakelen voor nieuw apparaat</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Wilt u %1$s synchroniseren met %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Synchroniseren</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Niet synchroniseren</string>
+    <string name="dialog_folder_info_device_list">Map delen met:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Er is iets misgegaan in Syncthing Lite. U kunt de details van de instellingen van Syncthing Lite bekijken.</string>
+</resources>

app/src/main/res/values-nl/strings.xml

@@ -16,7 +16,7 @@
     <string name="loading_config_starting_syncthing_client">Configuratie wordt geladen, Syncthing-cliënt wordt opgestart…</string>
     <string name="last_modified_time">Laatst gewijzigd: %1$s</string>
     <string name="remove_device_title">Apparaat %1$s verwijderen?</string>
-    <string name="remove_device_message">%1$s verwijderen uit de lijst van gekende apparaten?</string>
+    <string name="remove_device_message">%1$s verwijderen uit de lijst van bekende apparaten?</string>
     <string name="device_import_success">Apparaat %1$s geïmporteerd</string>
     <string name="device_already_known">Apparaat %1$s reeds aanwezig</string>
     <string name="folders_label">Mappen</string>
@@ -36,9 +36,42 @@
     <string name="intro_page_three_title">Deel je mappen</string>
     <string name="intro_page_two_description">Voer een Syncthing-apparaats-ID in, of scan een apparaats-ID van een QR-code</string>
     <string name="intro_page_three_description">Accepteer nu het apparaat met ID %1$s, en deel er een map mee. Het kan enkele minuten duren voordat de apparaten verbinden.</string>
+    <string name="intro_page_three_searching_device">Proberen het andere apparaat te vinden. Dit kan even duren.</string>
     <string name="settings">Instellingen</string>
     <string name="settings_app_version_title">Appversie</string>
     <string name="settings_local_device_name">Naam van lokaal apparaat</string>
     <string name="settings_local_device_summary">De naam die andere apparaten voor dit apparaat zullen zien</string>
+    <string name="settings_shutdown_delay_title">Wachten voor afsluiten</string>
+    <string name="settings_shutdown_delay_summary">Tijdsduur vóór afsluiten van Syncthing-cliënt na laatste gebruik</string>
+    <string name="settings_force_stop">Deze app gedwongen afsluiten</string>
+    <string name="settings_last_error_title">Laatste fout</string>
+    <string name="settings_last_error_summary">Bekijk de details van de laatste fout</string>
+    <string name="settings_report_bug_title">Fout melden</string>
+    <string name="settings_report_bug_summary">Open de foutrapportages voor deze app op GitHub</string>
+    <string name="copy_to_clipboard">Kopiëren naar klembord</string>
+    <string name="copied_to_clipboard">Gekopieerd naar klembord</string>
     <string name="device_id_dialog_title">Voer een apparaats-ID in</string>
-    </resources>
+    <string name="settings_shutdown_delay_10_seconds">10 seconden</string>
+    <string name="settings_shutdown_delay_30_seconds">30 seconden</string>
+    <string name="settings_shutdown_delay_1_minute">1 minuut</string>
+    <string name="settings_shutdown_delay_5_minutes">5 minuten</string>
+    <string name="dialog_warning_reconnect_problem">
+        Door het gedrag van deze app en het gedrag van de Syncthing-server,
+        kan je enkele minuten geen verbinding maken indien de app werd afgesloten (door deze uit de lijst met recente apps te verwijderen)
+        of indien de verbinding werd verbroken.
+        Dit is niet van toepassing op lokale ontdekkingsverbindingen.
+    </string>
+    <string name="dialog_file_save_as">Opslaan als</string>
+    <string name="pending_index_updates">%d indexupdates in wacht</string>
+    <string name="device_status_connecting">Verbinden met %s</string>
+    <string name="device_status_connected">Verbonden met %s</string>
+    <string name="device_status_disconnected">Zal binnenkort opnieuw proberen verbinden - er zijn %d bekende adressen</string>
+    <string name="device_status_no_address">Geen bekend adres voor het apparaat</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Mapsynchonisatie inschakelen voor apparaat</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Wil je %1$s synchroniseren met %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Synchroniseren</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Niet synchroniseren</string>
+    <string name="dialog_folder_info_device_list">Map delen met:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Er ging iets mis in Syncthing Lite. Je kan de details van de instellingen van Syncthing Lite bekijken.</string>
+</resources>

app/src/main/res/values-pt/strings.xml

@@ -0,0 +1,33 @@
+<resources>
+    <string name="app_name">Syncthing Lite</string>
+    <string name="folder_list_empty_message">Não há pastas disponíveis</string>
+    <string name="clear_local_cache_index_label">Limpar cache/índice local</string>
+    <string name="devices_list_view_empty_message">Não há dispositivos disponíveis</string>
+    <string name="invalid_device_id">Erro: ID de dispositivo inválido</string>
+    <string name="dialog_downloading_file">Recebendo ficheiro %1$s</string>
+    <string name="toast_file_download_failed">A recepção do ficheiro falhou</string>
+    <string name="toast_open_file_failed">Não foi encontrada uma aplicação compatível</string>
+    <string name="toast_file_upload_failed">O envio do ficheiro falhou</string>
+    <string name="toast_upload_complete">Envio de ficheiro terminado</string>
+    <string name="dialog_uploading_file">Enviando ficheiro %1$s</string>
+    <string name="clear_cache_and_index_title">Limpar a cache e o índice locais?</string>
+    <string name="clear_cache_and_index_body">Limpar todos os dados locais de cache e de índice?</string>
+    <string name="index_update_progress_label">Índice actualizado para a pasta %1$s, %2$d%% sincronizado</string>
+    <string name="loading_config_starting_syncthing_client">Carregando a configuração, iniciando o cliente syncthing...</string>
+    <string name="last_modified_time">Última alteração: %1$s</string>
+    <string name="remove_device_title">Remover o dispositivo %1$s\?</string>
+    <string name="remove_device_message">Remover %1$s da lista de dispositivos conhecidos?</string>
+    <string name="device_import_success">Dispositivo %1$s importado com sucesso</string>
+    <string name="device_already_known">Dispositivo %1$s já existente</string>
+    <string name="folders_label">Pastas</string>
+    <string name="devices_label">Dispositivos</string>
+    <string name="folder_label_format">%1$s (%2$s)</string>
+    <string name="folder_content_info">%1$s, %2$d ficheiros, %3$d pastas</string>
+    <string name="file_info">%1$s, última modificação em %2$s</string>
+    <string name="show_device_id">Mostrar ID do dispositivo</string>
+    <string name="device_id">ID do dispositivo</string>
+    <string name="device_id_copied">O ID do dispositivo foi copiado para a área de transferência</string>
+    <string name="share_device_id_chooser">Partilhar ID do dispositivo com</string>
+    <string name="other_syncthing_instance_title">Está outra instância do Syncthing em execução</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    </resources>

app/src/main/res/values-ro/strings.xml

@@ -40,15 +40,42 @@ fi stocate, dacă vor fi partajate cu terțe entități precum și cum vor fi
     <string name="intro_page_three_title">Partajați-vă directoarele</string>
     <string name="intro_page_two_description">Introduceți ID-ul Syncthing al unui dispozitiv sau scanați ID-ul unui dispozitiv dintr-un cod QR</string>
     <string name="intro_page_three_description">Acceptați acum dispozitivul cu ID-ul %1$s, și partajați un director cu el. S-ar putea să dureze câteva minute până când dispozitivele se vor conecta.</string>
+    <string name="intro_page_three_searching_device">Se încearcă găsirea celuilalt dispozitiv. Această operație poate dura un moment.</string>
     <string name="settings">Setări</string>
     <string name="settings_app_version_title">Versiune aplicație</string>
     <string name="settings_local_device_name">Nume local dispozitiv</string>
     <string name="settings_local_device_summary">Numele pe care celălalt dispozitiv îl va vedea pentru acest dispozitiv</string>
     <string name="settings_shutdown_delay_title">Temporizare oprire</string>
     <string name="settings_shutdown_delay_summary">După cât timp se va închide clientul Syncthing în funcție de ultima utilizare</string>
+    <string name="settings_force_stop">Forțează oprirea acestei aplicații</string>
+    <string name="settings_last_error_title">Ultima eroare</string>
+    <string name="settings_last_error_summary">Arată detaliile ultimei erori</string>
+    <string name="settings_report_bug_title">Raportează o eroare</string>
+    <string name="settings_report_bug_summary">Deschideți un raport de eroare pentru această aplicație pe GitHub</string>
+    <string name="copy_to_clipboard">Copiază în memorie</string>
+    <string name="copied_to_clipboard">Copiat în memorie</string>
     <string name="device_id_dialog_title">Introduceți ID dispozitiv</string>
     <string name="settings_shutdown_delay_10_seconds">10 secunde</string>
     <string name="settings_shutdown_delay_30_seconds">30 secunde</string>
     <string name="settings_shutdown_delay_1_minute">1 minut</string>
     <string name="settings_shutdown_delay_5_minutes">5 minute</string>
+    <string name="dialog_warning_reconnect_problem">
+        Datorită modului în care această aplicație și serverul Syncthing funcționează,
+        nu se poate face reconectarea timp de câteva minute după ce aplicația a fost oprită (ștearsă din lista de aplicații care rulează)
+        sau conexiunea a fost întreruptă.
+        Aceasta limitare nu se aplica la conexiunile descoperite local.
+    </string>
+    <string name="dialog_file_save_as">Salvează ca</string>
+    <string name="pending_index_updates">%d actualizări de index în așteptare</string>
+    <string name="device_status_connecting">Conectare la %s</string>
+    <string name="device_status_connected">Conectat la %s</string>
+    <string name="device_status_disconnected">Se va încerca conectarea în curând - există %d adrese cunoscute</string>
+    <string name="device_status_no_address">Nici o adresă cunoscută pentru acest dispozitiv</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Activați sincronizarea directorului pentru un dispozitiv nou</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Doriți să sincronizați %1$s cu %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Se sincronizează</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Nu se sincronizează</string>
+    <string name="dialog_folder_info_device_list">Partajează directorul cu:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">O eroare s-a produs in Syncthing Lite. Puteți vedea detalii în setările Syncthing Lite.</string>
 </resources>

app/src/main/res/values-sv/strings.xml

@@ -36,15 +36,42 @@
     <string name="intro_page_three_title">Dela dina mappar</string>
     <string name="intro_page_two_description">Ange ett Syncthing enhets-ID, eller skanna ett enhets-ID-nummer från en QR-kod</string>
     <string name="intro_page_three_description">Acceptera nu enheten med ID %1$s och dela en mapp med den. Det kan ta några minuter tills enheterna ansluter.</string>
+    <string name="intro_page_three_searching_device">Försöker hitta den andra enheten. Det kan ta ett ögonblick.</string>
     <string name="settings">Inställningar</string>
     <string name="settings_app_version_title">Appversion</string>
     <string name="settings_local_device_name">Lokala enhetens namn</string>
     <string name="settings_local_device_summary">Namnet som andra enheter kommer att se för den här enheten</string>
     <string name="settings_shutdown_delay_title">Avstängningsfördröjning</string>
     <string name="settings_shutdown_delay_summary">Tid innan du stänger av Syncthing-klienten efter den senaste användningen</string>
+    <string name="settings_force_stop">Tvinga stoppa denna App</string>
+    <string name="settings_last_error_title">Senaste felet</string>
+    <string name="settings_last_error_summary">Visa detaljerna för det senaste felet</string>
+    <string name="settings_report_bug_title">Rapportera ett fel</string>
+    <string name="settings_report_bug_summary">Öppna problemen för den här appen på GitHub</string>
+    <string name="copy_to_clipboard">Kopiera till urklipp</string>
+    <string name="copied_to_clipboard">Kopierad till urklipp</string>
     <string name="device_id_dialog_title">Ange enhets-ID</string>
     <string name="settings_shutdown_delay_10_seconds">10 sekunder</string>
     <string name="settings_shutdown_delay_30_seconds">30 sekunder</string>
     <string name="settings_shutdown_delay_1_minute">1 minut</string>
     <string name="settings_shutdown_delay_5_minutes">5 minuter</string>
+    <string name="dialog_warning_reconnect_problem">
+        På grund av beteendet hos denna App och beteendet hos Syncthing-servern,
+        du kan inte återansluta i några minuter om appen dödades (på grund av att du tog bort från den senaste applistan)
+        eller anslutningen avbröts.
+        Detta gäller inte lokala upptäcktsanslutningar.
+   </string>
+    <string name="dialog_file_save_as">Spara som</string>
+    <string name="pending_index_updates">%d indexuppdateringar som väntar</string>
+    <string name="device_status_connecting">Ansluter till %s</string>
+    <string name="device_status_connected">Ansluten till %s</string>
+    <string name="device_status_disconnected">Kommer att försöka ansluta snart - det finns%d kända adresser</string>
+    <string name="device_status_no_address">Ingen känd adress för enheten</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Aktivera mappsynkronisering för ny enhet</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Vill du synkronisera %1$s med %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Synkronisera</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Synkronisera inte</string>
+    <string name="dialog_folder_info_device_list">Dela mapp med:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Något gick fel i Syncthing Lite. Du kan visa detaljerna från inställningarna för Syncthing Lite.</string>
 </resources>

app/src/main/res/values-zh-rCN/strings.xml

@@ -40,10 +40,10 @@
     <string name="settings_local_device_name">本地设备名称</string>
     <string name="settings_local_device_summary">此设备将被其他设备看到的名称</string>
     <string name="settings_shutdown_delay_title">关闭延迟</string>
-    <string name="settings_shutdown_delay_summary">关闭 Syncthing 客户端与其最后使用之间的时间</string>
     <string name="device_id_dialog_title">输入设备 ID</string>
     <string name="settings_shutdown_delay_10_seconds">10 秒</string>
     <string name="settings_shutdown_delay_30_seconds">30 秒</string>
     <string name="settings_shutdown_delay_1_minute">1 分钟</string>
     <string name="settings_shutdown_delay_5_minutes">5 分钟</string>
-</resources>
+    <string name="dialog_folder_info_device_list_item">%1$s（%2$s）</string>
+    </resources>

app/src/main/res/values/strings.xml

@@ -36,14 +36,20 @@
     <string name="intro_page_three_title">Share your folders</string>
     <string name="intro_page_two_description">Enter a Syncthing device ID, or scan a device ID from a QR code</string>
     <string name="intro_page_three_description">Now accept the device with ID %1$s, and share a folder with it. It may take a few minutes until the devices connect.</string>
+    <string name="intro_page_three_searching_device">Trying to find the other device. This may take a moment.</string>
     <string name="settings">Settings</string>
     <string name="settings_app_version_title">App version</string>
     <string name="settings_local_device_name">Local device name</string>
     <string name="settings_local_device_summary">The name that other devices will see for this device</string>
     <string name="settings_shutdown_delay_title">Shutdown delay</string>
-    <string name="settings_shutdown_delay_summary">Time before shuting down the Syncthing client after its last usage</string>
-    <string name="settings_crash_handler_title">Custom Crash-Handler</string>
-    <string name="settings_crash_handler_summary">Copy the error message to the clipboard when the App crashes</string>
+    <string name="settings_shutdown_delay_summary">Time before shutting down the Syncthing client after its last usage</string>
+    <string name="settings_force_stop">Force stop this App</string>
+    <string name="settings_last_error_title">Last error</string>
+    <string name="settings_last_error_summary">View the details of the last error</string>
+    <string name="settings_report_bug_title">Report a bug</string>
+    <string name="settings_report_bug_summary">Open the issues for this App at GitHub</string>
+    <string name="copy_to_clipboard">Copy to clipboard</string>
+    <string name="copied_to_clipboard">Copied to the clipboard</string>
     <string name="device_id_dialog_title">Enter Device ID</string>
     <string name="settings_shutdown_delay_10_seconds">10 seconds</string>
     <string name="settings_shutdown_delay_30_seconds">30 seconds</string>
@@ -56,4 +62,17 @@
         This does not apply to local discovery connections.
     </string>
     <string name="dialog_file_save_as">Save as</string>
+    <string name="pending_index_updates">%d index updates pending</string>
+    <string name="device_status_connecting">Connecting to %s</string>
+    <string name="device_status_connected">Connected to %s</string>
+    <string name="device_status_disconnected">Will retry connecting soon - there are %d known addresses</string>
+    <string name="device_status_no_address">No known address for the device</string>
+    <string name="dialog_enable_folder_sync_for_new_device_title">Enable folder sync for new device</string>
+    <string name="dialog_enable_folder_sync_for_new_device_text">Do you want to sync %1$s with %2$s (%3$s)?</string>
+    <string name="dialog_enable_folder_sync_for_new_device_positive">Sync</string>
+    <string name="dialog_enable_folder_sync_for_new_device_negative">Do not sync</string>
+    <string name="dialog_folder_info_device_list">Share folder with:</string>
+    <string name="dialog_folder_info_device_list_item">%1$s (%2$s)</string>
+    <string name="toast_error">Something went wrong in Syncthing Lite. You can view the details from the settings of Syncthing Lite.</string>
+    <string name="folder_browser_home">Home</string>
 </resources>

app/src/main/res/xml/preferences.xml

@@ -24,15 +24,24 @@
 
         -->
 
-        <CheckBoxPreference
-            android:key="crash_handler"
-            android:title="@string/settings_crash_handler_title"
-            android:summary="@string/settings_crash_handler_summary" />
+        <Preference
+            android:key="last_crash"
+            android:title="@string/settings_last_error_title"
+            android:summary="@string/settings_last_error_summary" />
 
         <Preference
             android:key="app_version"
             android:title="@string/settings_app_version_title"/>
 
+        <Preference
+            android:key="report_bug"
+            android:title="@string/settings_report_bug_title"
+            android:summary="@string/settings_report_bug_summary" />
+
+        <Preference
+            android:key="force_stop"
+            android:title="@string/settings_force_stop" />
+
     </PreferenceCategory>
 
 </PreferenceScreen>

build.gradle

@@ -2,8 +2,8 @@
 
 buildscript {
     ext.kotlin_version = '1.3.0'
-    ext.support_version = '27.0.2'
-    ext.build_tools_version = '3.2.0'
+    ext.support_version = '27.1.1'
+    ext.build_tools_version = '3.2.1'
     ext.anko_version = '0.10.8'
     ext.protobuf_lite_version = '3.0.1'
     repositories {

settings.gradle

@@ -1 +1 @@
-include ':app', ':syncthing-repository-android', ':syncthing-repository-default', ':syncthing-relay-client', ':syncthing-bep', ':syncthing-core', ':syncthing-client', ':syncthing-discovery', ':syncthing-client-cli'
+include ':app', ':syncthing-repository-android', ':syncthing-repository-default', ':syncthing-relay-client', ':syncthing-bep', ':syncthing-core', ':syncthing-client', ':syncthing-discovery', ':syncthing-client-cli', ':syncthing-temp-repository-encryption'

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/BlockPuller.kt

@@ -18,6 +18,7 @@ import com.google.protobuf.ByteString
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import net.syncthing.java.bep.connectionactor.ConnectionActorWrapper
+import net.syncthing.java.bep.index.IndexHandler
 import net.syncthing.java.bep.utils.longSumBy
 import net.syncthing.java.core.beans.BlockInfo
 import net.syncthing.java.core.beans.FileBlocks

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/BlockPusher.kt

@@ -17,10 +17,16 @@ package net.syncthing.java.bep
 import com.google.protobuf.ByteString
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import net.syncthing.java.bep.BlockExchangeProtos.Vector
 import net.syncthing.java.bep.connectionactor.ConnectionActorWrapper
-import net.syncthing.java.core.beans.*
+import net.syncthing.java.bep.index.*
+import net.syncthing.java.core.beans.BlockInfo
+import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.beans.FileInfo.Version
+import net.syncthing.java.core.beans.FolderStats
 import net.syncthing.java.core.utils.BlockUtils
 import net.syncthing.java.core.utils.NetworkUtils
 import org.apache.commons.io.IOUtils
@@ -46,7 +52,7 @@ class BlockPusher(private val localDeviceId: DeviceId,
     private val logger = LoggerFactory.getLogger(javaClass)
 
     suspend fun pushDelete(folderId: String, targetPath: String): BlockExchangeProtos.IndexUpdate {
-        val fileInfo = indexHandler.waitForRemoteIndexAcquired(connectionHandler).getFileInfoByPath(folderId, targetPath)!!
+        val fileInfo = indexHandler.waitForRemoteIndexAcquiredWithTimeout(connectionHandler).getFileInfoByPath(folderId, targetPath)!!
         NetworkUtils.assertProtocol(connectionHandler.hasFolder(fileInfo.folder), {"supplied connection handler $connectionHandler will not share folder ${fileInfo.folder}"})
         return sendIndexUpdate(folderId, BlockExchangeProtos.FileInfo.newBuilder()
                 .setName(targetPath)
@@ -62,7 +68,7 @@ class BlockPusher(private val localDeviceId: DeviceId,
     }
 
     suspend fun pushFile(inputStream: InputStream, folderId: String, targetPath: String): FileUploadObserver {
-        val fileInfo = indexHandler.waitForRemoteIndexAcquired(connectionHandler).getFileInfoByPath(folderId, targetPath)
+        val fileInfo = indexHandler.waitForRemoteIndexAcquiredWithTimeout(connectionHandler).getFileInfoByPath(folderId, targetPath)
         NetworkUtils.assertProtocol(connectionHandler.hasFolder(folderId), {"supplied connection handler $connectionHandler will not share folder $folderId"})
         assert(fileInfo == null || fileInfo.folder == folderId)
         assert(fileInfo == null || fileInfo.path == targetPath)
@@ -99,20 +105,26 @@ class BlockPusher(private val localDeviceId: DeviceId,
         }
 
         logger.debug("send index update for file = {}", targetPath)
-        val indexListener = { folderInfo: FolderInfo, newRecords: List<FileInfo>, _: IndexInfo ->
-            if (folderInfo.folderId == folderId) {
-                for (fileInfo2 in newRecords) {
-                    if (fileInfo2.path == targetPath && fileInfo2.hash == dataSource.getHash()) { //TODO check not invalid
-                        //                                sentBlocks.addAll(dataSource.getHashes());
-                        isCompleted.set(true)
-                        synchronized(updateLock) {
-                            updateLock.notifyAll()
+        val indexListenerStream = indexHandler.subscribeToOnIndexUpdateEvents()
+        GlobalScope.launch {
+            indexListenerStream.consumeEach { event ->
+                if (event is IndexRecordAcquiredEvent) {
+                    val (indexFolderId, newRecords, _) = event
+
+                    if (indexFolderId == folderId) {
+                        for (fileInfo2 in newRecords) {
+                            if (fileInfo2.path == targetPath && fileInfo2.hash == dataSource.getHash()) { //TODO check not invalid
+                                //                                sentBlocks.addAll(dataSource.getHashes());
+                                isCompleted.set(true)
+                                synchronized(updateLock) {
+                                    updateLock.notifyAll()
+                                }
+                            }
                         }
                     }
                 }
             }
         }
-        indexHandler.registerOnIndexRecordAcquiredListener(indexListener)
         val indexUpdate = sendIndexUpdate(folderId, BlockExchangeProtos.FileInfo.newBuilder()
                 .setName(targetPath)
                 .setSize(fileSize)
@@ -128,9 +140,27 @@ class BlockPusher(private val localDeviceId: DeviceId,
             override fun close() {
                 logger.debug("closing upload process")
                 monitoringProcessExecutorService.shutdown()
-                indexHandler.unregisterOnIndexRecordAcquiredListener(indexListener)
+                indexListenerStream.cancel()
                 requestHandlerRegistry.unregisterListener(requestFilter)
-                val fileInfo1 = indexHandler.pushRecord(indexUpdate.folder, indexUpdate.filesList.single())
+                val (fileInfo1, folderStatsUpdate) = indexHandler.indexRepository.runInTransaction {
+                    val folderStatsUpdateCollector = FolderStatsUpdateCollector(folderId)
+
+                    // TODO: notify the IndexBrowsers again (as it was earlier)
+                    val fileInfo = IndexElementProcessor.pushRecord(
+                            it,
+                            indexUpdate.folder,
+                            indexUpdate.filesList.single(),
+                            folderStatsUpdateCollector,
+                            it.findFileInfo(folderId, indexUpdate.filesList.single().name)
+                    )
+
+                    IndexMessageProcessor.handleFolderStatsUpdate(it, folderStatsUpdateCollector)
+                    val folderStatsUpdate = it.findFolderStats(folderId) ?: FolderStats.createDummy(folderId)
+
+                    fileInfo to folderStatsUpdate
+                }
+
+                runBlocking { indexHandler.sendFolderStatsUpdate(folderStatsUpdate) }
                 logger.info("sent file info record = {}", fileInfo1)
             }
 
@@ -151,7 +181,7 @@ class BlockPusher(private val localDeviceId: DeviceId,
     private suspend fun sendIndexUpdate(folderId: String, fileInfoBuilder: BlockExchangeProtos.FileInfo.Builder,
                                         oldVersions: Iterable<Version>?): BlockExchangeProtos.IndexUpdate {
         run {
-            val nextSequence = indexHandler.sequencer().nextSequence()
+            val nextSequence = indexHandler.getNextSequenceNumber()
             val list = oldVersions ?: emptyList()
             logger.debug("version list = {}", list)
             val id = ByteBuffer.wrap(localDeviceId.toHashData()).long

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/FolderBrowser.kt

@@ -1,58 +0,0 @@
-/* 
- * Copyright (C) 2016 Davide Imbriaco
- *
- * This Java file is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package net.syncthing.java.bep
-
-import net.syncthing.java.core.beans.FolderInfo
-import net.syncthing.java.core.beans.FolderStats
-import net.syncthing.java.core.interfaces.IndexRepository
-import java.io.Closeable
-
-class FolderBrowser internal constructor(private val indexHandler: IndexHandler) : Closeable {
-    private val folderStatsCache = mutableMapOf<String, FolderStats>()
-    private val indexRepositoryEventListener = { event: IndexRepository.FolderStatsUpdatedEvent ->
-        addFolderStats(event.getFolderStats())
-    }
-
-    fun folderInfoAndStatsList(): List<Pair<FolderInfo, FolderStats>> =
-            indexHandler.folderInfoList()
-                    .map { folderInfo -> Pair(folderInfo, getFolderStats(folderInfo.folderId)) }
-                    .sortedBy { it.first.label }
-
-    init {
-        indexHandler.indexRepository.setOnFolderStatsUpdatedListener(indexRepositoryEventListener)
-        addFolderStats(indexHandler.indexRepository.findAllFolderStats())
-    }
-
-    private fun addFolderStats(folderStatsList: List<FolderStats>) {
-        for (folderStats in folderStatsList) {
-            folderStatsCache.put(folderStats.folderId, folderStats)
-        }
-    }
-
-    fun getFolderStats(folder: String): FolderStats {
-        return folderStatsCache[folder] ?: let {
-            FolderStats.Builder()
-                    .setFolder(folder)
-                    .build()
-        }
-    }
-
-    fun getFolderInfo(folder: String): FolderInfo? {
-        return indexHandler.getFolderInfo(folder)
-    }
-
-    override fun close() {
-        indexHandler.indexRepository.setOnFolderStatsUpdatedListener(null)
-    }
-}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/IndexBrowser.kt

@@ -1,184 +0,0 @@
-/* 
- * Copyright (C) 2016 Davide Imbriaco
- *
- * This Java file is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package net.syncthing.java.bep
-
-import net.syncthing.java.core.beans.FileInfo
-import net.syncthing.java.core.interfaces.IndexRepository
-import net.syncthing.java.core.utils.PathUtils
-import net.syncthing.java.core.utils.awaitTerminationSafe
-import net.syncthing.java.core.utils.submitLogging
-import org.apache.commons.lang3.StringUtils
-import org.slf4j.LoggerFactory
-import java.io.Closeable
-import java.util.*
-import java.util.concurrent.Executors
-
-class IndexBrowser internal constructor(private val indexRepository: IndexRepository, private val indexHandler: IndexHandler,
-                                       val folder: String, private val includeParentInList: Boolean = false,
-                                       private val allowParentInRoot: Boolean = false, ordering: Comparator<FileInfo>?) : Closeable {
-
-    private fun isParent(fileInfo: FileInfo) = PathUtils.isParent(fileInfo.path)
-
-    val ALPHA_ASC_DIR_FIRST: Comparator<FileInfo> =
-            compareBy<FileInfo>({!isParent(it)}, {!it.isDirectory()})
-                    .thenBy { it.fileName.toLowerCase() }
-    val LAST_MOD_DESC: Comparator<FileInfo> =
-            compareBy<FileInfo>({!isParent(it)}, {it.lastModified})
-                    .thenBy { it.fileName.toLowerCase() }
-
-    private val ordering = ordering ?: ALPHA_ASC_DIR_FIRST
-    private val logger = LoggerFactory.getLogger(javaClass)
-
-    var currentPath: String = PathUtils.ROOT_PATH
-        private set
-    private val PARENT_FILE_INFO: FileInfo
-    private val ROOT_FILE_INFO: FileInfo
-    private val executorService = Executors.newSingleThreadScheduledExecutor()
-    private val preloadJobs = mutableSetOf<String>()
-    private val preloadJobsLock = Any()
-    private var mOnPathChangedListener: (() -> Unit)? = null
-
-    private fun isCacheReady(): Boolean {
-        synchronized(preloadJobsLock) {
-            return preloadJobs.isEmpty()
-        }
-    }
-
-    internal fun onIndexChangedevent(folder: String) {
-        if (folder == this.folder) {
-            preloadFileInfoForCurrentPath()
-        }
-    }
-
-    fun currentPathInfo(): FileInfo = getFileInfoByAbsolutePath(currentPath)
-
-    fun currentPathFileName(): String? = PathUtils.getFileName(currentPath)
-
-    fun isRoot(): Boolean = PathUtils.isRoot(currentPath)
-
-    init {
-        assert(folder.isNotEmpty())
-        PARENT_FILE_INFO = FileInfo(folder = folder, type = FileInfo.FileType.DIRECTORY, path = PathUtils.PARENT_PATH)
-        ROOT_FILE_INFO = FileInfo(folder = folder, type = FileInfo.FileType.DIRECTORY, path = PathUtils.ROOT_PATH)
-        navigateToAbsolutePath(PathUtils.ROOT_PATH)
-    }
-
-    fun setOnFolderChangedListener(onPathChangedListener: (() -> Unit)?) {
-        mOnPathChangedListener = onPathChangedListener
-    }
-
-    private fun preloadFileInfoForCurrentPath() {
-        logger.debug("trigger preload for folder = '{}'", folder)
-        synchronized(preloadJobsLock) {
-            currentPath.let<String, Any> { currentPath ->
-                if (preloadJobs.contains(currentPath)) {
-                    preloadJobs.remove(currentPath)
-                    preloadJobs.add(currentPath) ///add last
-                } else {
-                    preloadJobs.add(currentPath)
-                    executorService.submitLogging(object : Runnable {
-
-                        override fun run() {
-
-                            val preloadPath =
-                                    synchronized(preloadJobsLock) {
-                                        assert(!preloadJobs.isEmpty())
-                                        preloadJobs.last() //pop last job
-                                    }
-
-                            logger.info("folder preload BEGIN for folder = '{}' path = '{}'", folder, preloadPath)
-                            getFileInfoByAbsolutePath(preloadPath)
-                            if (!PathUtils.isRoot(preloadPath)) {
-                                val parent = PathUtils.getParentPath(preloadPath)
-                                getFileInfoByAbsolutePath(parent)
-                                listFiles(parent)
-                            }
-                            for (record in listFiles(preloadPath)) {
-                                if (record.path == PARENT_FILE_INFO.path && record.isDirectory()) {
-                                    listFiles(record.path)
-                                }
-                            }
-                            logger.info("folder preload END for folder = '{}' path = '{}'", folder, preloadPath)
-                            synchronized(preloadJobsLock) {
-                                preloadJobs.remove(preloadPath)
-                                if (isCacheReady()) {
-                                    logger.info("cache ready, notify listeners")
-                                    mOnPathChangedListener?.invoke()
-                                } else {
-                                    logger.info("still {} job[s] left in cache loader", preloadJobs.size)
-                                    executorService.submitLogging(this)
-                                }
-                            }
-                        }
-                    })
-                }
-            }
-        }
-    }
-
-    fun listFiles(path: String = currentPath): List<FileInfo> {
-        logger.debug("doListFiles for path = '{}' BEGIN", path)
-        val list = ArrayList(indexRepository.findNotDeletedFilesByFolderAndParent(folder, path))
-        logger.debug("doListFiles for path = '{}' : {} records loaded)", path, list.size)
-        if (includeParentInList && (!PathUtils.isRoot(path) || allowParentInRoot)) {
-            list.add(0, PARENT_FILE_INFO)
-        }
-        return list.sortedWith(ordering)
-    }
-
-    fun getFileInfoByAbsolutePath(path: String): FileInfo {
-        return if (PathUtils.isRoot(path)) {
-            ROOT_FILE_INFO
-        } else {
-            logger.debug("doGetFileInfoByAbsolutePath for path = '{}' BEGIN", path)
-            val fileInfo = indexRepository.findNotDeletedFileInfo(folder, path) ?: error("file not found for path = $path")
-            logger.debug("doGetFileInfoByAbsolutePath for path = '{}' END", path)
-            fileInfo
-        }
-    }
-
-    fun navigateTo(fileInfo: FileInfo) {
-        assert(fileInfo.isDirectory())
-        assert(fileInfo.folder == folder)
-        return if (fileInfo.path == PARENT_FILE_INFO.path)
-            navigateToAbsolutePath(PathUtils.getParentPath(currentPath))
-        else
-            navigateToAbsolutePath(fileInfo.path)
-    }
-
-    fun navigateToNearestPath(oldPath: String) {
-        if (!StringUtils.isBlank(oldPath)) {
-            navigateToAbsolutePath(oldPath)
-        }
-    }
-
-    private fun navigateToAbsolutePath(newPath: String) {
-        if (PathUtils.isRoot(newPath)) {
-            currentPath = PathUtils.ROOT_PATH
-        } else {
-            val fileInfo = getFileInfoByAbsolutePath(newPath)
-            assert(fileInfo.isDirectory(), {"cannot navigate to path ${fileInfo.path}: not a directory"})
-            currentPath = fileInfo.path
-        }
-        logger.info("navigate to path = '{}'", currentPath)
-        preloadFileInfoForCurrentPath()
-    }
-
-    override fun close() {
-        logger.info("closing")
-        indexHandler.unregisterIndexBrowser(this)
-        executorService.shutdown()
-        executorService.awaitTerminationSafe()
-    }
-}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/IndexHandler.kt

@@ -1,451 +0,0 @@
-/* 
- * Copyright (C) 2016 Davide Imbriaco
- *
- * This Java file is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package net.syncthing.java.bep
-
-import net.syncthing.java.bep.connectionactor.ClusterConfigInfo
-import net.syncthing.java.bep.connectionactor.ConnectionActorWrapper
-import net.syncthing.java.core.beans.*
-import net.syncthing.java.core.beans.FileInfo.Version
-import net.syncthing.java.core.configuration.Configuration
-import net.syncthing.java.core.interfaces.IndexRepository
-import net.syncthing.java.core.interfaces.Sequencer
-import net.syncthing.java.core.interfaces.TempRepository
-import net.syncthing.java.core.utils.NetworkUtils
-import net.syncthing.java.core.utils.awaitTerminationSafe
-import net.syncthing.java.core.utils.trySubmitLogging
-import org.apache.commons.lang3.tuple.Pair
-import org.bouncycastle.util.encoders.Hex
-import org.slf4j.LoggerFactory
-import java.io.Closeable
-import java.io.IOException
-import java.util.*
-import java.util.concurrent.Executors
-
-class IndexHandler(private val configuration: Configuration, val indexRepository: IndexRepository,
-                   private val tempRepository: TempRepository) : Closeable {
-    private val logger = LoggerFactory.getLogger(javaClass)
-    private val folderInfoByFolder = mutableMapOf<String, FolderInfo>()
-    private val indexMessageProcessor = IndexMessageProcessor()
-    private var lastIndexActivity: Long = 0
-    private val writeAccessLock = Object()
-    private val indexWaitLock = Object()
-    private val indexBrowsers = mutableSetOf<IndexBrowser>()
-    private val onIndexRecordAcquiredListeners = mutableSetOf<(FolderInfo, List<FileInfo>, IndexInfo) -> Unit>()
-    private val onFullIndexAcquiredListeners = mutableSetOf<(FolderInfo) -> Unit>()
-
-    private fun lastActive(): Long = System.currentTimeMillis() - lastIndexActivity
-
-    fun sequencer(): Sequencer = indexRepository.getSequencer()
-
-    fun folderList(): List<String> = folderInfoByFolder.keys.toList()
-
-    fun folderInfoList(): List<FolderInfo> = folderInfoByFolder.values.toList()
-
-    private fun markActive() {
-        lastIndexActivity = System.currentTimeMillis()
-    }
-
-    fun registerOnIndexRecordAcquiredListener(listener: (FolderInfo, List<FileInfo>, IndexInfo) -> Unit) {
-        onIndexRecordAcquiredListeners.add(listener)
-    }
-
-    fun unregisterOnIndexRecordAcquiredListener(listener: (FolderInfo, List<FileInfo>, IndexInfo) -> Unit) {
-        assert(onIndexRecordAcquiredListeners.contains(listener))
-        onIndexRecordAcquiredListeners.remove(listener)
-    }
-
-    fun registerOnFullIndexAcquiredListenersListener(listener: (FolderInfo) -> Unit) {
-        onFullIndexAcquiredListeners.add(listener)
-    }
-
-    fun unregisterOnFullIndexAcquiredListenersListener(listener: (FolderInfo) -> Unit) {
-        assert(onFullIndexAcquiredListeners.contains(listener))
-        onFullIndexAcquiredListeners.remove(listener)
-    }
-
-    init {
-        loadFolderInfoFromConfig()
-    }
-
-    private fun loadFolderInfoFromConfig() {
-        synchronized(writeAccessLock) {
-            for (folderInfo in configuration.folders) {
-                folderInfoByFolder.put(folderInfo.folderId, folderInfo) //TODO reference 'folder info' repository
-            }
-        }
-    }
-
-    @Synchronized
-    fun clearIndex() {
-        synchronized(writeAccessLock) {
-            indexRepository.clearIndex()
-            folderInfoByFolder.clear()
-            loadFolderInfoFromConfig()
-        }
-    }
-
-    internal fun isRemoteIndexAcquired(clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId): Boolean {
-        var ready = true
-        for (folder in clusterConfigInfo.sharedFolderIds) {
-            val indexSequenceInfo = indexRepository.findIndexInfoByDeviceAndFolder(peerDeviceId, folder)
-            if (indexSequenceInfo == null || indexSequenceInfo.localSequence < indexSequenceInfo.maxSequence) {
-                logger.debug("waiting for index on folder = {} sequenceInfo = {}", folder, indexSequenceInfo)
-                ready = false
-            }
-        }
-        return ready
-    }
-
-    @Throws(InterruptedException::class)
-    fun waitForRemoteIndexAcquired(connectionHandler: ConnectionActorWrapper, timeoutSecs: Long? = null): IndexHandler {
-        val timeoutMillis = (timeoutSecs ?: DEFAULT_INDEX_TIMEOUT) * 1000
-        synchronized(indexWaitLock) {
-            while (!isRemoteIndexAcquired(connectionHandler.getClusterConfig(), connectionHandler.deviceId)) {
-                indexWaitLock.wait(timeoutMillis)
-                NetworkUtils.assertProtocol(/* TODO connectionHandler.getLastActive() < timeoutMillis || */ lastActive() < timeoutMillis,
-                        {"unable to acquire index from connection $connectionHandler, timeout reached!"})
-            }
-        }
-        logger.debug("acquired all indexes on connection {}", connectionHandler)
-        return this
-    }
-
-    fun handleClusterConfigMessageProcessedEvent(clusterConfig: BlockExchangeProtos.ClusterConfig) {
-        synchronized(writeAccessLock) {
-            for (folderRecord in clusterConfig.foldersList) {
-                val folder = folderRecord.id
-                val folderInfo = updateFolderInfo(folder, folderRecord.label)
-                logger.debug("acquired folder info from cluster config = {}", folderInfo)
-                for (deviceRecord in folderRecord.devicesList) {
-                    val deviceId = DeviceId.fromHashData(deviceRecord.id.toByteArray())
-                    if (deviceRecord.hasIndexId() && deviceRecord.hasMaxSequence()) {
-                        val folderIndexInfo = updateIndexInfo(folder, deviceId, deviceRecord.indexId, deviceRecord.maxSequence, null)
-                        logger.debug("acquired folder index info from cluster config = {}", folderIndexInfo)
-                    }
-                }
-            }
-        }
-    }
-
-    internal fun handleIndexMessageReceivedEvent(folderId: String, filesList: List<BlockExchangeProtos.FileInfo>, clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId) {
-        indexMessageProcessor.handleIndexMessageReceivedEvent(folderId, filesList, clusterConfigInfo, peerDeviceId)
-    }
-
-    fun pushRecord(folder: String, bepFileInfo: BlockExchangeProtos.FileInfo): FileInfo? {
-        var fileBlocks: FileBlocks? = null
-        val builder = FileInfo.Builder()
-                .setFolder(folder)
-                .setPath(bepFileInfo.name)
-                .setLastModified(Date(bepFileInfo.modifiedS * 1000 + bepFileInfo.modifiedNs / 1000000))
-                .setVersionList((if (bepFileInfo.hasVersion()) bepFileInfo.version.countersList else null ?: emptyList()).map { record -> Version(record.id, record.value) })
-                .setDeleted(bepFileInfo.deleted)
-        when (bepFileInfo.type) {
-            BlockExchangeProtos.FileInfoType.FILE -> {
-                fileBlocks = FileBlocks(folder, builder.getPath()!!, ((bepFileInfo.blocksList ?: emptyList())).map { record ->
-                    BlockInfo(record.offset, record.size, Hex.toHexString(record.hash.toByteArray()))
-                })
-                builder
-                        .setTypeFile()
-                        .setHash(fileBlocks.hash)
-                        .setSize(bepFileInfo.size)
-            }
-            BlockExchangeProtos.FileInfoType.DIRECTORY -> builder.setTypeDir()
-            else -> {
-                logger.warn("unsupported file type = {}, discarding file info", bepFileInfo.type)
-                return null
-            }
-        }
-        return addRecord(builder.build(), fileBlocks)
-    }
-
-    private fun updateIndexInfo(folder: String, deviceId: DeviceId, indexId: Long?, maxSequence: Long?, localSequence: Long?): IndexInfo {
-        synchronized(writeAccessLock) {
-            var indexSequenceInfo = indexRepository.findIndexInfoByDeviceAndFolder(deviceId, folder)
-            var shouldUpdate = false
-            val builder: IndexInfo.Builder
-            if (indexSequenceInfo == null) {
-                shouldUpdate = true
-                assert(indexId != null, {"index sequence info not found, and supplied null index id (folder = $folder, device = $deviceId)"})
-                builder = IndexInfo.newBuilder()
-                        .setFolder(folder)
-                        .setDeviceId(deviceId.deviceId)
-                        .setIndexId(indexId!!)
-                        .setLocalSequence(0)
-                        .setMaxSequence(-1)
-            } else {
-                builder = indexSequenceInfo.copyBuilder()
-            }
-            if (indexId != null && indexId != builder.getIndexId()) {
-                shouldUpdate = true
-                builder.setIndexId(indexId)
-            }
-            if (maxSequence != null && maxSequence > builder.getMaxSequence()) {
-                shouldUpdate = true
-                builder.setMaxSequence(maxSequence)
-            }
-            if (localSequence != null && localSequence > builder.getLocalSequence()) {
-                shouldUpdate = true
-                builder.setLocalSequence(localSequence)
-            }
-            if (shouldUpdate) {
-                indexSequenceInfo = builder.build()
-                indexRepository.updateIndexInfo(indexSequenceInfo)
-            }
-            return indexSequenceInfo!!
-        }
-    }
-
-    private fun addRecord(record: FileInfo, fileBlocks: FileBlocks?): FileInfo? {
-        synchronized(writeAccessLock) {
-            val lastModified = indexRepository.findFileInfoLastModified(record.folder, record.path)
-            return if (lastModified != null && record.lastModified < lastModified) {
-                logger.trace("discarding record = {}, modified before local record", record)
-                null
-            } else {
-                indexRepository.updateFileInfo(record, fileBlocks)
-                logger.trace("loaded new record = {}", record)
-                indexBrowsers.forEach {
-                    it.onIndexChangedevent(record.folder)
-                }
-                record
-            }
-        }
-    }
-
-    fun getFileInfoByPath(folder: String, path: String): FileInfo? {
-        return indexRepository.findFileInfo(folder, path)
-    }
-
-    fun getFileInfoAndBlocksByPath(folder: String, path: String): Pair<FileInfo, FileBlocks>? {
-        val fileInfo = getFileInfoByPath(folder, path)
-        return if (fileInfo == null) {
-            null
-        } else {
-            assert(fileInfo.isFile())
-            val fileBlocks = indexRepository.findFileBlocks(folder, path)
-            checkNotNull(fileBlocks) {"file blocks not found for file info = $fileInfo"}
-
-            FileInfo.checkBlocks(fileInfo, fileBlocks)
-
-            Pair.of(fileInfo, fileBlocks)
-        }
-    }
-
-    private fun updateFolderInfo(folder: String, label: String?): FolderInfo {
-        var folderInfo: FolderInfo? = folderInfoByFolder[folder]
-        if (folderInfo == null || label.isNullOrEmpty()) {
-            folderInfo = FolderInfo(folder, label)
-            folderInfoByFolder.put(folderInfo.folderId, folderInfo)
-        }
-        return folderInfo
-    }
-
-    fun getFolderInfo(folder: String): FolderInfo? {
-        return folderInfoByFolder[folder]
-    }
-
-    fun getIndexInfo(device: DeviceId, folder: String): IndexInfo? {
-        return indexRepository.findIndexInfoByDeviceAndFolder(device, folder)
-    }
-
-    fun newFolderBrowser(): FolderBrowser {
-        return FolderBrowser(this)
-    }
-
-    fun newIndexBrowser(folder: String, includeParentInList: Boolean = false, allowParentInRoot: Boolean = false,
-                        ordering: Comparator<FileInfo>? = null): IndexBrowser {
-        val indexBrowser = IndexBrowser(indexRepository, this, folder, includeParentInList, allowParentInRoot, ordering)
-        indexBrowsers.add(indexBrowser)
-        return indexBrowser
-    }
-
-    internal fun unregisterIndexBrowser(indexBrowser: IndexBrowser) {
-        assert(indexBrowsers.contains(indexBrowser))
-        indexBrowsers.remove(indexBrowser)
-    }
-
-    override fun close() {
-        assert(indexBrowsers.isEmpty())
-        assert(onIndexRecordAcquiredListeners.isEmpty())
-        assert(onFullIndexAcquiredListeners.isEmpty())
-        indexMessageProcessor.stop()
-    }
-
-    private inner class IndexMessageProcessor {
-
-        private val executorService = Executors.newSingleThreadExecutor()
-        private var queuedMessages = 0
-        private var queuedRecords: Long = 0
-        //        private long lastRecordProcessingTime = 0;
-        //        , delay = 0;
-        //        private boolean addProcessingDelayForInterface = true;
-        //        private final int MIN_DELAY = 0, MAX_DELAY = 5000, MAX_RECORD_PER_PROCESS = 16, DELAY_FACTOR = 1;
-        private var startTime: Long? = null
-
-        fun handleIndexMessageReceivedEvent(folderId: String, filesList: List<BlockExchangeProtos.FileInfo>, clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId) {
-            logger.info("received index message event, preparing (queued records = {} event record count = {})", queuedRecords, filesList.size)
-            markActive()
-            //            List<BlockExchangeProtos.FileInfo> fileList = event.getFilesList();
-            //            for (int index = 0; index < fileList.size(); index += MAX_RECORD_PER_PROCESS) {
-            //                BlockExchangeProtos.IndexUpdate data = BlockExchangeProtos.IndexUpdate.newBuilder()
-            //                    .addAllFiles(Iterables.limit(Iterables.skip(fileList, index), MAX_RECORD_PER_PROCESS))
-            //                    .setFolder(event.getFolder())
-            //                    .build();
-            //                if (queuedMessages > 0) {
-            //                    storeAndProcessBg(data, clusterConfigInfo, peerDeviceId);
-            //                } else {
-            //                    processBg(data, clusterConfigInfo, peerDeviceId);
-            //                }
-            //            }
-            val data = BlockExchangeProtos.IndexUpdate.newBuilder()
-                    .addAllFiles(filesList)
-                    .setFolder(folderId)
-                    .build()
-            if (queuedMessages > 0) {
-                storeAndProcessBg(data, clusterConfigInfo, peerDeviceId)
-            } else {
-                processBg(data, clusterConfigInfo, peerDeviceId)
-            }
-        }
-
-        private fun processBg(data: BlockExchangeProtos.IndexUpdate, clusterConfigInfo: ClusterConfigInfo?, peerDeviceId: DeviceId) {
-            logger.debug("received index message event, queuing for processing")
-            queuedMessages++
-            queuedRecords += data.filesCount.toLong()
-            executorService.trySubmitLogging(object : ProcessingRunnable() {
-                override fun runProcess() {
-                    doHandleIndexMessageReceivedEvent(data, clusterConfigInfo, peerDeviceId)
-                }
-            })
-        }
-
-        private fun storeAndProcessBg(data: BlockExchangeProtos.IndexUpdate, clusterConfigInfo: ClusterConfigInfo?, peerDeviceId: DeviceId) {
-            val key = tempRepository.pushTempData(data.toByteArray())
-            logger.debug("received index message event, stored to temp record {}, queuing for processing", key)
-            queuedMessages++
-            queuedRecords += data.filesCount.toLong()
-            executorService.trySubmitLogging(object : ProcessingRunnable() {
-                override fun runProcess() {
-                    try {
-                        doHandleIndexMessageReceivedEvent(key, clusterConfigInfo, peerDeviceId)
-                    } catch (ex: IOException) {
-                        logger.error("error processing index message", ex)
-                    }
-
-                }
-
-            })
-        }
-
-        private abstract inner class ProcessingRunnable : Runnable {
-
-            override fun run() {
-                startTime = System.currentTimeMillis()
-                runProcess()
-                queuedMessages--
-                //                lastRecordProcessingTime = stopwatch.elapsed(TimeUnit.MILLISECONDS) - delay;
-                //                logger.info("processed a bunch of records, {}*{} remaining", queuedMessages, MAX_RECORD_PER_PROCESS);
-                //                logger.debug("processed index message in {} secs", lastRecordProcessingTime / 1000d);
-                startTime = null
-            }
-
-            protected abstract fun runProcess()
-
-            //        private boolean isVersionOlderThanSequence(BlockExchangeProtos.FileInfo fileInfo, long localSequence) {
-            //            long fileSequence = fileInfo.getSequence();
-            //            //TODO should we check last version instead of sequence? verify
-            //            return fileSequence < localSequence;
-            //        }
-            @Throws(IOException::class)
-            protected fun doHandleIndexMessageReceivedEvent(key: String, clusterConfigInfo: ClusterConfigInfo?, peerDeviceId: DeviceId) {
-                logger.debug("processing index message event from temp record {}", key)
-                markActive()
-                val data = tempRepository.popTempData(key)
-                val message = BlockExchangeProtos.IndexUpdate.parseFrom(data)
-                doHandleIndexMessageReceivedEvent(message, clusterConfigInfo, peerDeviceId)
-            }
-
-            protected fun doHandleIndexMessageReceivedEvent(message: BlockExchangeProtos.IndexUpdate, clusterConfigInfo: ClusterConfigInfo?, peerDeviceId: DeviceId) {
-                //            synchronized (writeAccessLock) {
-                //                if (addProcessingDelayForInterface) {
-                //                    delay = Math.min(MAX_DELAY, Math.max(MIN_DELAY, lastRecordProcessingTime * DELAY_FACTOR));
-                //                    logger.info("add delay of {} secs before processing index message (to allow UI to process)", delay / 1000d);
-                //                    try {
-                //                        Thread.sleep(delay);
-                //                    } catch (InterruptedException ex) {
-                //                        logger.warn("interrupted", ex);
-                //                    }
-                //                } else {
-                //                    delay = 0;
-                //                }
-                logger.info("processing index message with {} records (queue size: messages = {} records = {})", message.filesCount, queuedMessages, queuedRecords)
-                //            String deviceId = connectionHandler.getDeviceId();
-                val folderId = message.folder
-                var sequence: Long = -1
-                val newRecords = mutableListOf<FileInfo>()
-                //                IndexInfo oldIndexInfo = indexRepository.findIndexInfoByDeviceAndFolder(deviceId, folder);
-                //            Stopwatch stopwatch = Stopwatch.createStarted();
-                logger.debug("processing {} index records for folder {}", message.filesList.size, folderId)
-                for (fileInfo in message.filesList) {
-                    markActive()
-                    //                    if (oldIndexInfo != null && isVersionOlderThanSequence(fileInfo, oldIndexInfo.getLocalSequence())) {
-                    //                        logger.trace("skipping file {}, version older than sequence {}", fileInfo, oldIndexInfo.getLocalSequence());
-                    //                    } else {
-                    val newRecord = pushRecord(folderId, fileInfo)
-                    if (newRecord != null) {
-                        newRecords.add(newRecord)
-                    }
-                    sequence = Math.max(fileInfo.sequence, sequence)
-                    markActive()
-                    //                    }
-                }
-                val newIndexInfo = updateIndexInfo(folderId, peerDeviceId, null, null, sequence)
-                val elap = System.currentTimeMillis() - startTime!!
-                queuedRecords -= message.filesCount.toLong()
-                logger.info("processed {} index records, acquired {} ({} secs, {} record/sec)", message.filesCount, newRecords.size, elap / 1000.0, Math.round(message.filesCount / (elap / 1000.0) * 100) / 100.0)
-                if (logger.isInfoEnabled && newRecords.size <= 10) {
-                    for (fileInfo in newRecords) {
-                        logger.info("acquired record = {}", fileInfo)
-                    }
-                }
-                val folderInfo = folderInfoByFolder[folderId]
-                if (!newRecords.isEmpty()) {
-                    onIndexRecordAcquiredListeners.forEach { it(folderInfo!!, newRecords, newIndexInfo) }
-                }
-                logger.debug("index info = {}", newIndexInfo)
-                if (isRemoteIndexAcquired(clusterConfigInfo!!, peerDeviceId)) {
-                    logger.debug("index acquired")
-                    onFullIndexAcquiredListeners.forEach { it(folderInfo!!)}
-                }
-                //                IndexHandler.this.notifyAll();
-                markActive()
-                synchronized(indexWaitLock) {
-                    indexWaitLock.notifyAll()
-                }
-            }
-        }
-
-        fun stop() {
-            logger.info("stopping index record processor")
-            executorService.shutdown()
-            executorService.awaitTerminationSafe()
-        }
-
-    }
-
-    companion object {
-
-        private const val DEFAULT_INDEX_TIMEOUT: Long = 30
-    }
-}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/connectionactor/ClusterConfigHandler.kt

@@ -16,7 +16,7 @@ package net.syncthing.java.bep.connectionactor
 
 import com.google.protobuf.ByteString
 import net.syncthing.java.bep.BlockExchangeProtos
-import net.syncthing.java.bep.IndexHandler
+import net.syncthing.java.bep.index.IndexHandler
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.beans.FolderInfo
 import net.syncthing.java.core.configuration.Configuration
@@ -32,48 +32,52 @@ object ClusterConfigHandler {
     ): BlockExchangeProtos.ClusterConfig {
         val builder = BlockExchangeProtos.ClusterConfig.newBuilder()
 
-        for (folder in configuration.folders) {
-            val folderBuilder = BlockExchangeProtos.Folder.newBuilder()
-                    .setId(folder.folderId)
-                    .setLabel(folder.label)
+        indexHandler.indexRepository.runInTransaction { indexTransaction ->
+            configuration.folders
+                    .filter { it.deviceIdWhitelist.contains(deviceId) }
+                    .forEach { folder ->
+                        val folderBuilder = BlockExchangeProtos.Folder.newBuilder()
+                                .setId(folder.folderId)
+                                .setLabel(folder.label)
 
-            // add this device
-            folderBuilder.addDevices(
-                    BlockExchangeProtos.Device.newBuilder()
-                            .setId(ByteString.copyFrom(configuration.localDeviceId.toHashData()))
-                            .setIndexId(indexHandler.sequencer().indexId())
-                            .setMaxSequence(indexHandler.sequencer().currentSequence())
-            )
+                        // add this device
+                        folderBuilder.addDevices(
+                                BlockExchangeProtos.Device.newBuilder()
+                                        .setId(ByteString.copyFrom(configuration.localDeviceId.toHashData()))
+                                        .setIndexId(indexTransaction.getSequencer().indexId())
+                                        .setMaxSequence(indexTransaction.getSequencer().currentSequence())
+                        )
 
-            // add other device
-            val indexSequenceInfo = indexHandler.indexRepository.findIndexInfoByDeviceAndFolder(deviceId, folder.folderId)
+                        // add other device
+                        val indexSequenceInfo = indexTransaction.findIndexInfoByDeviceAndFolder(deviceId, folder.folderId)
 
-            folderBuilder.addDevices(
-                    BlockExchangeProtos.Device.newBuilder()
-                            .setId(ByteString.copyFrom(deviceId.toHashData()))
-                            .apply {
-                                indexSequenceInfo?.let {
-                                    setIndexId(indexSequenceInfo.indexId)
-                                    setMaxSequence(indexSequenceInfo.localSequence)
+                        folderBuilder.addDevices(
+                                BlockExchangeProtos.Device.newBuilder()
+                                        .setId(ByteString.copyFrom(deviceId.toHashData()))
+                                        .apply {
+                                            indexSequenceInfo?.let {
+                                                indexId = indexSequenceInfo.indexId
+                                                maxSequence = indexSequenceInfo.localSequence
 
-                                    logger.info("send delta index info device = {} index = {} max (local) sequence = {}",
-                                            indexSequenceInfo.deviceId,
-                                            indexSequenceInfo.indexId,
-                                            indexSequenceInfo.localSequence)
-                                }
-                            }
-            )
+                                                logger.info("send delta index info device = {} index = {} max (local) sequence = {}",
+                                                        indexSequenceInfo.deviceId,
+                                                        indexSequenceInfo.indexId,
+                                                        indexSequenceInfo.localSequence)
+                                            }
+                                        }
+                        )
 
-            builder.addFolders(folderBuilder)
+                        builder.addFolders(folderBuilder)
 
-            // TODO: add the other devices to the cluster config
+                        // TODO: add the other devices to the cluster config
+                    }
         }
 
         return builder.build()
     }
 
     // TODO: understand this
-    internal fun handleReceivedClusterConfig(
+    internal suspend fun handleReceivedClusterConfig(
             clusterConfig: BlockExchangeProtos.ClusterConfig,
             configuration: Configuration,
             otherDeviceId: DeviceId,
@@ -82,33 +86,69 @@ object ClusterConfigHandler {
         val folderInfoList = mutableListOf<ClusterConfigFolderInfo>()
         val newSharedFolders = mutableListOf<FolderInfo>()
 
-        for (folder in clusterConfig.foldersList ?: emptyList()) {
-            var folderInfo = ClusterConfigFolderInfo(folder.id, folder.label)
-            val devicesById = (folder.devicesList ?: emptyList())
-                    .associateBy { input ->
-                        DeviceId.fromHashData(input.id!!.toByteArray())
-                    }
-            val otherDevice = devicesById[otherDeviceId]
-            val ourDevice = devicesById[configuration.localDeviceId]
-            if (otherDevice != null) {
-                folderInfo = folderInfo.copy(isAnnounced = true)
-            }
-            if (ourDevice != null) {
-                folderInfo = folderInfo.copy(isShared = true)
-                logger.info("folder shared from device = {} folder = {}", otherDeviceId, folderInfo)
-                val folderIds = configuration.folders.map { it.folderId }
-                if (!folderIds.contains(folderInfo.folderId)) {
-                    val fi = FolderInfo(folderInfo.folderId, folderInfo.label)
-                    configuration.folders = configuration.folders + fi
-                    newSharedFolders.add(fi)
-                    logger.info("new folder shared = {}", folderInfo)
+        configuration.update { oldConfig ->
+            val configFolders = oldConfig.folders.toMutableSet()
+
+            for (folder in clusterConfig.foldersList ?: emptyList()) {
+                var folderInfo = ClusterConfigFolderInfo(folder.id, folder.label, isDeviceInSharedFolderWhitelist = false)
+                val devicesById = (folder.devicesList ?: emptyList())
+                        .associateBy { input ->
+                            DeviceId.fromHashData(input.id!!.toByteArray())
+                        }
+                val otherDevice = devicesById[otherDeviceId]
+                val ourDevice = devicesById[configuration.localDeviceId]
+                if (otherDevice != null) {
+                    folderInfo = folderInfo.copy(isAnnounced = true)
                 }
-            } else {
-                logger.info("folder not shared from device = {} folder = {}", otherDeviceId, folderInfo)
+                if (ourDevice != null) {
+                    folderInfo = folderInfo.copy(isShared = true)
+                    logger.info("folder shared from device = {} folder = {}", otherDeviceId, folderInfo)
+
+                    val oldFolderEntry = configFolders.find { it.folderId == folderInfo.folderId }
+
+                    if (oldFolderEntry == null) {
+                        folderInfo = folderInfo.copy(isDeviceInSharedFolderWhitelist = true)
+
+                        val newFolderInfo = FolderInfo(
+                                folderId = folderInfo.folderId,
+                                label = folderInfo.label,
+                                deviceIdWhitelist = setOf(otherDeviceId),
+                                deviceIdBlacklist = emptySet(),
+                                ignoredDeviceIdList = emptySet()
+                        )
+
+                        configFolders.add(newFolderInfo)
+                        newSharedFolders.add(newFolderInfo)
+                        logger.info("new folder shared = {}", folderInfo)
+                    } else {
+                        if (oldFolderEntry.deviceIdWhitelist.contains(otherDeviceId)) {
+                            folderInfo = folderInfo.copy(isDeviceInSharedFolderWhitelist = true)
+
+                            if (oldFolderEntry.label != folderInfo.label) {
+                                configFolders.remove(oldFolderEntry)
+                                configFolders.add(oldFolderEntry.copy(label = folderInfo.label))
+                            }
+                        } else {
+                            if (!oldFolderEntry.deviceIdBlacklist.contains(otherDeviceId)) {
+                                configFolders.remove(oldFolderEntry)
+                                configFolders.add(
+                                        oldFolderEntry.copy(
+                                                deviceIdBlacklist = oldFolderEntry.deviceIdBlacklist + setOf(otherDeviceId)
+                                        )
+                                )
+                            }
+                        }
+                    }
+                } else {
+                    logger.info("folder not shared from device = {} folder = {}", otherDeviceId, folderInfo)
+                }
+
+                folderInfoList.add(folderInfo)
             }
 
-            folderInfoList.add(folderInfo)
+            oldConfig.copy(folders = configFolders)
         }
+
         configuration.persistLater()
         indexHandler.handleClusterConfigMessageProcessedEvent(clusterConfig)
 
@@ -123,7 +163,7 @@ class ClusterConfigInfo (val folderInfo: List<ClusterConfigFolderInfo>, val newS
 
     val folderInfoById = folderInfo.associateBy { it.folderId }
     val sharedFolderIds: Set<String> by lazy {
-        folderInfo.filter { it.isShared }.map { it.folderId }.toSet()
+        folderInfo.filter { it.isShared && it.isDeviceInSharedFolderWhitelist }.map { it.folderId }.toSet()
     }
 }
 
@@ -131,7 +171,8 @@ data class ClusterConfigFolderInfo(
         val folderId: String,
         val label: String = folderId,
         val isAnnounced: Boolean = false,
-        val isShared: Boolean = false
+        val isShared: Boolean = false,
+        val isDeviceInSharedFolderWhitelist: Boolean
 ) {
     init {
         assert(folderId.isNotEmpty())

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/connectionactor/ConnectionActorGenerator.kt

@@ -17,12 +17,17 @@ package net.syncthing.java.bep.connectionactor
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.*
 import net.syncthing.java.bep.BlockExchangeProtos
-import net.syncthing.java.bep.IndexHandler
+import net.syncthing.java.bep.index.IndexHandler
 import net.syncthing.java.core.beans.DeviceAddress
 import net.syncthing.java.core.configuration.Configuration
 import org.slf4j.LoggerFactory
 import java.io.IOException
 
+data class Connection (
+        val actor: SendChannel<ConnectionAction>,
+        val clusterConfigInfo: ClusterConfigInfo
+)
+
 object ConnectionActorGenerator {
     private val closed = Channel<ConnectionAction>().apply { cancel() }
     private val logger = LoggerFactory.getLogger(ConnectionActorGenerator::class.java)
@@ -89,18 +94,42 @@ object ConnectionActorGenerator {
             configuration: Configuration,
             indexHandler: IndexHandler,
             requestHandler: (BlockExchangeProtos.Request) -> Deferred<BlockExchangeProtos.Response>
-    ) = GlobalScope.produce<Pair<SendChannel<ConnectionAction>, ClusterConfigInfo>> {
+    ) = GlobalScope.produce<Pair<Connection, ConnectionInfo>> {
         var currentActor: SendChannel<ConnectionAction> = closed
+        var currentClusterConfig = ClusterConfigInfo.dummy
         var currentDeviceAddress: DeviceAddress? = null
+        var currentStatus = ConnectionInfo.empty
+
+        suspend fun dispatchStatus() {
+            send(Connection(currentActor, currentClusterConfig) to currentStatus)
+        }
 
         suspend fun closeCurrent() {
             if (currentActor != closed) {
                 currentActor.close()
                 currentActor = closed
-                send(currentActor to ClusterConfigInfo.dummy)
+                currentClusterConfig = ClusterConfigInfo.dummy
+
+                if (currentStatus.status != ConnectionStatus.Disconnected) {
+                    currentStatus = currentStatus.copy(status = ConnectionStatus.Disconnected)
+                }
+
+                dispatchStatus()
             }
         }
 
+        suspend fun dispatchConnection(
+                connection: SendChannel<ConnectionAction>,
+                clusterConfig: ClusterConfigInfo,
+                deviceAddress: DeviceAddress
+        ) {
+            currentActor = connection
+            currentDeviceAddress = deviceAddress
+            currentClusterConfig = clusterConfig
+
+            dispatchStatus()
+        }
+
         suspend fun tryConnectingToAddressHandleBaseErrors(deviceAddress: DeviceAddress) = try {
             val newActor = ConnectionActor.createInstance(deviceAddress, configuration, indexHandler, requestHandler)
             val clusterConfig = ConnectionActorUtil.waitUntilConnected(newActor)
@@ -118,31 +147,37 @@ object ConnectionActorGenerator {
             null
         }
 
-        suspend fun dispatchConnection(
-                connection: SendChannel<ConnectionAction>,
-                clusterConfig: ClusterConfigInfo,
-                deviceAddress: DeviceAddress
-        ) {
-            currentActor = connection
-            currentDeviceAddress = deviceAddress
-
-            send(connection to clusterConfig)
-        }
-
         suspend fun tryConnectingToAddress(deviceAddress: DeviceAddress): Boolean {
             closeCurrent()
 
-            var connection = tryConnectingToAddressHandleBaseErrors(deviceAddress) ?: return false
+            suspend fun handleCancel() {
+                currentStatus = currentStatus.copy(
+                        status = ConnectionStatus.Disconnected
+                )
+                dispatchStatus()
+            }
+
+            currentStatus = currentStatus.copy(
+                    status = ConnectionStatus.Connecting,
+                    currentAddress = deviceAddress
+            )
+            dispatchStatus()
+
+            var connection = tryConnectingToAddressHandleBaseErrors(deviceAddress) ?: return run {handleCancel(); false}
 
             if (connection.second.newSharedFolders.isNotEmpty()) {
                 logger.debug("connected to $deviceAddress with new folders -> reconnect")
                 // reconnect to send new cluster config
                 connection.first.close()
-                connection = tryConnectingToAddressHandleBaseErrors(deviceAddress) ?: return false
+                connection = tryConnectingToAddressHandleBaseErrors(deviceAddress) ?: return run {handleCancel(); false}
             }
 
             logger.debug("connected to $deviceAddress")
 
+            currentStatus = currentStatus.copy(
+                    status = ConnectionStatus.Connected,
+                    currentAddress = deviceAddress
+            )
             dispatchConnection(connection.first, connection.second, deviceAddress)
 
             return true
@@ -157,18 +192,26 @@ object ConnectionActorGenerator {
         val reconnectTicker = ticker(delayMillis = 30 * 1000, initialDelayMillis = 0)
 
         deviceAddressSource.consume {
-            var lastDeviceAddressList: List<DeviceAddress> = emptyList()
-
             while (true) {
-                if (isConnected()) {
-                    lastDeviceAddressList = deviceAddressSource.poll() ?: lastDeviceAddressList
+                run {
+                    // get the new list version if there is any
+                    val newDeviceAddressList = deviceAddressSource.poll()
 
-                    if (lastDeviceAddressList.isNotEmpty()) {
+                    if (newDeviceAddressList != null) {
+                        currentStatus = currentStatus.copy(addresses = newDeviceAddressList)
+                        dispatchStatus()
+                    }
+                }
+
+                if (isConnected()) {
+                    val deviceAddressList = currentStatus.addresses
+
+                    if (deviceAddressList.isNotEmpty()) {
                         if (reconnectTicker.poll() != null) {
-                            if (currentDeviceAddress != lastDeviceAddressList.first()) {
+                            if (currentDeviceAddress != deviceAddressList.first()) {
                                 val oldDeviceAddress = currentDeviceAddress!!
 
-                                if (!tryConnectingToAddress(lastDeviceAddressList.first())) {
+                                if (!tryConnectingToAddress(deviceAddressList.first())) {
                                     tryConnectingToAddress(oldDeviceAddress)
                                 }
                             }
@@ -179,11 +222,15 @@ object ConnectionActorGenerator {
 
                     delay(500)  // don't take too much CPU
                 } else /* is not connected */ {
-                    // get the new list version if there is any
-                    lastDeviceAddressList = deviceAddressSource.poll() ?: lastDeviceAddressList
+                    if (currentStatus.status == ConnectionStatus.Connected) {
+                        currentStatus = currentStatus.copy(status = ConnectionStatus.Disconnected)
+                        dispatchStatus()
+                    }
+
+                    val deviceAddressList = currentStatus.addresses
 
                     // try all addresses
-                    for (address in lastDeviceAddressList) {
+                    for (address in deviceAddressList) {
                         if (tryConnectingToAddress(address)) {
                             break
                         }
@@ -194,9 +241,14 @@ object ConnectionActorGenerator {
                     reconnectTicker.poll()
 
                     // wait for new device address list but not more than 15 seconds before the next iteration
-                    lastDeviceAddressList = withTimeoutOrNull(15 * 1000) {
+                    val newDeviceAddressList = withTimeoutOrNull(15 * 1000) {
                         deviceAddressSource.receive()
-                    } ?: lastDeviceAddressList
+                    }
+
+                    if (newDeviceAddressList != null) {
+                        currentStatus = currentStatus.copy(addresses = newDeviceAddressList)
+                        dispatchStatus()
+                    }
                 }
             }
         }

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/connectionactor/ConnectionActorUtil.kt

@@ -16,6 +16,7 @@ package net.syncthing.java.bep.connectionactor
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.channels.SendChannel
 import net.syncthing.java.bep.BlockExchangeProtos
+import java.io.IOException
 
 object ConnectionActorUtil {
     suspend fun waitUntilConnected(actor: SendChannel<ConnectionAction>): ClusterConfigInfo {
@@ -28,18 +29,34 @@ object ConnectionActorUtil {
     }
 
     suspend fun sendRequest(request: BlockExchangeProtos.Request, actor: SendChannel<ConnectionAction>): BlockExchangeProtos.Response {
-        val deferred = CompletableDeferred<BlockExchangeProtos.Response>()
+        try {
+            val deferred = CompletableDeferred<BlockExchangeProtos.Response>()
 
-        actor.send(SendRequestConnectionAction(request, deferred))
+            actor.send(SendRequestConnectionAction(request, deferred))
 
-        return deferred.await()
+            return deferred.await()
+        } catch (ex: Exception) {
+            throw IOException("not connected", ex)
+        }
     }
 
     suspend fun sendIndexUpdate(update: BlockExchangeProtos.IndexUpdate, actor: SendChannel<ConnectionAction>) {
-        val deferred = CompletableDeferred<Unit?>()
+        try {
+            val deferred = CompletableDeferred<Unit?>()
 
-        actor.send(SendIndexUpdateAction(update, deferred))
+            actor.send(SendIndexUpdateAction(update, deferred))
 
-        deferred.await()
+            deferred.await()
+        } catch (ex: Exception) {
+            throw IOException("not connected", ex)
+        }
+    }
+
+    suspend fun disconnect(actor: SendChannel<ConnectionAction>) {
+        try {
+            actor.send(CloseConnectionAction)
+        } catch (ex: Exception) {
+            // ignore if the channel is closed already
+        }
     }
 }

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/connectionactor/ConnectionActorWrapper.kt

@@ -14,73 +14,67 @@
 package net.syncthing.java.bep.connectionactor
 
 import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.ConflatedBroadcastChannel
 import kotlinx.coroutines.channels.ReceiveChannel
-import kotlinx.coroutines.channels.SendChannel
 import kotlinx.coroutines.channels.consumeEach
 import net.syncthing.java.bep.BlockExchangeProtos
 import net.syncthing.java.core.beans.DeviceId
+import net.syncthing.java.core.exception.ExceptionReport
+import net.syncthing.java.core.exception.reportExceptions
 import java.io.IOException
 
 class ConnectionActorWrapper (
-        private val source: ReceiveChannel<Pair<SendChannel<ConnectionAction>, ClusterConfigInfo>>,
+        private val source: ReceiveChannel<Pair<Connection, ConnectionInfo>>,
         val deviceId: DeviceId,
-        val connectivityChangeListener: () -> Unit
+        private val exceptionReportHandler: (ExceptionReport) -> Unit
 ) {
     private val job = Job()
 
-    private var currentConnectionActor: SendChannel<ConnectionAction>? = null
-    private var clusterConfigInfo: ClusterConfigInfo? = null
+    private var connection: Connection? = null
+    private val connectionInfo = ConflatedBroadcastChannel<ConnectionInfo>(ConnectionInfo.empty)
 
-    var isConnected = false
-        get() = currentConnectionActor?.isClosedForSend == false
+    val isConnected
+        get() = connectionInfo.valueOrNull?.status == ConnectionStatus.Connected
 
     init {
-        GlobalScope.launch (job) {
-            source.consumeEach { (connectionActor, clusterConfig) ->
-                currentConnectionActor = connectionActor
-                clusterConfigInfo = clusterConfig
+        GlobalScope.async (job) {
+            source.consumeEach { (connection, connectionInfo) ->
+                this@ConnectionActorWrapper.connection = connection
+                this@ConnectionActorWrapper.connectionInfo.send(connectionInfo)
             }
-        }
-
-        // this is a very simple solution but it does its job
-        GlobalScope.launch (job) {
-            var previousConnected = false
-
-            while (isActive) {
-                val nowConnected = isConnected
-
-                if (previousConnected != nowConnected) {
-                    previousConnected = nowConnected
-
-                    connectivityChangeListener()
-                }
-
-                delay(200)
-            }
-        }
+        }.reportExceptions("ConnectionActorWrapper(${deviceId.deviceId})", exceptionReportHandler)
     }
 
     suspend fun sendRequest(request: BlockExchangeProtos.Request) = ConnectionActorUtil.sendRequest(
             request,
-            currentConnectionActor ?: throw IOException("not connected")
+            connection?.actor ?: throw IOException("not connected")
     )
 
     suspend fun sendIndexUpdate(update: BlockExchangeProtos.IndexUpdate) = ConnectionActorUtil.sendIndexUpdate(
             update,
-            currentConnectionActor ?: throw IOException("not connected")
+            connection?.actor ?: throw IOException("not connected")
     )
 
-    fun hasFolder(folderId: String) = clusterConfigInfo?.sharedFolderIds?.contains(folderId) ?: false
+    fun hasFolder(folderId: String) = connection?.clusterConfigInfo?.sharedFolderIds?.contains(folderId) ?: false
 
-    fun getClusterConfig() = clusterConfigInfo ?: throw IOException("not connected")
+    fun getClusterConfig() = connection?.clusterConfigInfo ?: throw IOException("not connected")
 
     fun shutdown() {
         job.cancel()
+        connectionInfo.close()
     }
 
     // this triggers a disconnection
     // the ConnectionActorGenerator will reconnect soon
     fun reconnect() {
-        currentConnectionActor?.close()
+        val actor = connection?.actor
+
+        GlobalScope.launch {
+            if (actor != null) {
+                ConnectionActorUtil.disconnect(actor)
+            }
+        }
     }
+
+    fun subscribeToConnectionInfo() = connectionInfo.openSubscription()
 }

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/connectionactor/ConnectionInfo.kt

@@ -0,0 +1,21 @@
+package net.syncthing.java.bep.connectionactor
+
+import net.syncthing.java.core.beans.DeviceAddress
+
+data class ConnectionInfo (
+        val addresses: List<DeviceAddress>,
+        val currentAddress: DeviceAddress?,
+        val status: ConnectionStatus
+) {
+    companion object {
+        val empty = ConnectionInfo(
+                addresses = emptyList(),
+                currentAddress = null,
+                status = ConnectionStatus.Disconnected
+        )
+    }
+}
+
+enum class ConnectionStatus {
+    Disconnected, Connecting, Connected
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/connectionactor/HelloMessageHandler.kt

@@ -73,7 +73,7 @@ object HelloMessageHandler {
         )
     }
 
-    fun processHelloMessage(
+    suspend fun processHelloMessage(
             hello: BlockExchangeProtos.Hello,
             configuration: Configuration,
             deviceId: DeviceId
@@ -81,14 +81,17 @@ object HelloMessageHandler {
         logger.info("Received hello message, deviceName=${hello.deviceName}, clientName=${hello.clientName}, clientVersion=${hello.clientVersion}")
 
         // update the local device name
-        // TODO: this could need some locking
-        configuration.peers = configuration.peers.map { peer ->
-            if (peer.deviceId == deviceId) {
-                DeviceInfo(deviceId, hello.deviceName)
-            } else {
-                peer
-            }
-        }.toSet()
+        configuration.update { oldConfig ->
+            oldConfig.copy(
+                    peers = oldConfig.peers.map { peer ->
+                        if (peer.deviceId == deviceId) {
+                            DeviceInfo(deviceId, hello.deviceName)
+                        } else {
+                            peer
+                        }
+                    }.toSet()
+            )
+        }
 
         configuration.persistLater()
     }

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/connectionactor/Instance.kt

@@ -22,7 +22,7 @@ import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import net.syncthing.java.bep.BlockExchangeProtos
-import net.syncthing.java.bep.IndexHandler
+import net.syncthing.java.bep.index.IndexHandler
 import net.syncthing.java.core.beans.DeviceAddress
 import net.syncthing.java.core.configuration.Configuration
 import net.syncthing.java.core.security.KeystoreHandler

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/folder/FolderBrowser.kt

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
+ *
+ * This Java file is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.syncthing.java.bep.folder
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.ConflatedBroadcastChannel
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.channels.first
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import net.syncthing.java.bep.index.*
+import net.syncthing.java.core.beans.FolderStats
+import net.syncthing.java.core.configuration.Configuration
+import java.io.Closeable
+
+class FolderBrowser internal constructor(private val indexHandler: IndexHandler, private val configuration: Configuration) : Closeable {
+    private val job = Job()
+    private val foldersStatus = ConflatedBroadcastChannel<Map<String, FolderStatus>>()
+
+    init {
+        GlobalScope.launch (job) {
+            // get initial status
+            val currentFolderStats = mutableMapOf<String, FolderStats>()
+
+            val currentIndexInfo = withContext(Dispatchers.IO) {
+                indexHandler.indexRepository.runInTransaction { indexTransaction ->
+                    configuration.folders.map { it.folderId }.forEach { folderId ->
+                        currentFolderStats[folderId] = indexTransaction.findFolderStats(folderId) ?: FolderStats.createDummy(folderId)
+                    }
+
+                    indexTransaction.findAllIndexInfos().groupBy { it.folderId }.toMutableMap()
+                }
+            }
+
+            // send status
+            suspend fun dispatch() {
+                foldersStatus.send(
+                        configuration.folders.map { info ->
+                            FolderStatus(
+                                    info = info,
+                                    stats = currentFolderStats[info.folderId] ?: FolderStats.createDummy(info.folderId),
+                                    indexInfo = currentIndexInfo[info.folderId] ?: emptyList()
+                            )
+                        }.associateBy { it.info.folderId }
+                )
+            }
+
+            dispatch()
+
+            // handle changes
+            val updateLock = Mutex()
+
+            async {
+                indexHandler.subscribeFolderStatsUpdatedEvents().consumeEach { event ->
+                    updateLock.withLock {
+                        when (event) {
+                            is FolderStatsUpdatedEvent -> currentFolderStats[event.folderStats.folderId] = event.folderStats
+                            FolderStatsResetEvent -> currentFolderStats.clear()
+                        }.let { /* require that all cases are handled */ }
+
+                        dispatch()
+                    }
+                }
+            }
+
+            async {
+                indexHandler.subscribeToOnIndexUpdateEvents().consumeEach { event ->
+                    updateLock.withLock {
+                        when (event) {
+                            is IndexRecordAcquiredEvent -> {
+                                val oldList = currentIndexInfo[event.folderId] ?: emptyList()
+                                val newList = oldList.filter { it.deviceId != event.indexInfo.deviceId } + event.indexInfo
+
+                                currentIndexInfo[event.folderId] = newList
+                            }
+                            IndexInfoClearedEvent -> currentIndexInfo.clear()
+                        }.let { /* require that all cases are handled */ }
+
+                        dispatch()
+                    }
+                }
+            }
+
+            async {
+                configuration.subscribe().consumeEach {
+                    dispatch()
+                }
+            }
+        }
+    }
+
+    fun folderInfoAndStatusStream() = GlobalScope.produce {
+        foldersStatus.openSubscription().consumeEach { folderStats ->
+            send(
+                    folderStats
+                            .values
+                            .sortedBy { it.info.label }
+            )
+        }
+    }
+
+    suspend fun folderInfoAndStatusList(): List<FolderStatus> = folderInfoAndStatusStream().first()
+
+    suspend fun getFolderStatus(folder: String): FolderStatus {
+        return getFolderStatus(folder, foldersStatus.openSubscription().first())
+    }
+
+    fun getFolderStatusSync(folder: String) = runBlocking { getFolderStatus(folder) }
+
+    private fun getFolderStatus(folder: String, folderStatus: Map<String, FolderStatus>) = folderStatus[folder] ?: FolderStatus.createDummy(folder)
+
+    override fun close() {
+        job.cancel()
+    }
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/folder/FolderStatus.kt

@@ -0,0 +1,35 @@
+package net.syncthing.java.bep.folder
+
+import net.syncthing.java.bep.utils.longMaxBy
+import net.syncthing.java.core.beans.FolderInfo
+import net.syncthing.java.core.beans.FolderStats
+import net.syncthing.java.core.beans.IndexInfo
+
+data class FolderStatus(
+        val info: FolderInfo,
+        val stats: FolderStats,
+        val indexInfo: List<IndexInfo>
+) {
+    companion object {
+        fun createDummy(folder: String) = FolderStatus(
+                info = FolderInfo(
+                        folder,
+                        folder,
+                        deviceIdBlacklist = emptySet(),
+                        deviceIdWhitelist = emptySet(),
+                        ignoredDeviceIdList = emptySet()
+                ),
+                stats = FolderStats.createDummy(folder),
+                indexInfo = emptyList()
+        )
+    }
+
+    val missingIndexUpdates: Long by lazy {
+        Math.max(
+                0,
+                indexInfo.longMaxBy ({ it.maxSequence }, 0) -
+                        indexInfo.longMaxBy ({ it.localSequence }, 0)
+
+        )
+    }
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/FolderStatsChangedEvent.kt

@@ -0,0 +1,7 @@
+package net.syncthing.java.bep.index
+
+import net.syncthing.java.core.beans.FolderStats
+
+sealed class FolderStatsChangedEvent
+data class FolderStatsUpdatedEvent(val folderStats: FolderStats): FolderStatsChangedEvent()
+object FolderStatsResetEvent: FolderStatsChangedEvent()

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/FolderStatsUpdateCollector.kt

@@ -0,0 +1,17 @@
+package net.syncthing.java.bep.index
+
+import java.util.*
+
+class FolderStatsUpdateCollector (val folderId: String) {
+    var deltaFileCount = 0L
+    var deltaDirCount = 0L
+    var deltaSize = 0L
+    var lastModified = Date(0)
+
+    fun isEmpty() = (
+            deltaFileCount == 0L &&
+                    deltaDirCount == 0L &&
+                    deltaSize == 0L &&
+                    lastModified.time == 0L
+            )
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/IndexElementProcessor.kt

@@ -0,0 +1,164 @@
+package net.syncthing.java.bep.index
+
+import net.syncthing.java.bep.BlockExchangeProtos
+import net.syncthing.java.core.beans.BlockInfo
+import net.syncthing.java.core.beans.FileBlocks
+import net.syncthing.java.core.beans.FileInfo
+import net.syncthing.java.core.exception.ExceptionDetailException
+import net.syncthing.java.core.exception.ExceptionDetails
+import net.syncthing.java.core.interfaces.IndexTransaction
+import org.bouncycastle.util.encoders.Hex
+import org.slf4j.LoggerFactory
+import java.io.IOException
+import java.util.*
+
+object IndexElementProcessor {
+    private val logger = LoggerFactory.getLogger(IndexElementProcessor::class.java)
+
+    fun pushRecords(
+            transaction: IndexTransaction,
+            folder: String,
+            updates: List<BlockExchangeProtos.FileInfo>,
+            oldRecords: Map<String, FileInfo>,
+            folderStatsUpdateCollector: FolderStatsUpdateCollector
+    ): List<FileInfo> {
+        // this always keeps the last version per path
+        val filesToProcess = updates
+                .sortedBy { it.sequence }
+                .reversed()
+                .distinctBy { it.name /* this is the whole path */ }
+                .reversed()
+
+        val preparedUpdates = filesToProcess.mapNotNull { prepareUpdate(folder, it) }
+
+        val updatesToApply = preparedUpdates.filter { shouldUpdateRecord(oldRecords[it.first.path], it.first) }
+
+        transaction.updateFileInfoAndBlocks(
+                fileInfos = updatesToApply.map { it.first },
+                fileBlocks = updatesToApply.mapNotNull { it.second }
+        )
+
+        for ((newRecord) in updatesToApply) {
+            updateFolderStatsCollector(oldRecords[newRecord.path], newRecord, folderStatsUpdateCollector)
+        }
+
+        return updatesToApply.map { it.first }
+    }
+
+    fun pushRecord(
+            transaction: IndexTransaction,
+            folder: String,
+            bepFileInfo: BlockExchangeProtos.FileInfo,
+            folderStatsUpdateCollector: FolderStatsUpdateCollector,
+            oldRecord: FileInfo?
+    ): FileInfo? {
+        val update = prepareUpdate(folder, bepFileInfo)
+
+        return if (update != null) {
+            addRecord(
+                    transaction = transaction,
+                    newRecord = update.first,
+                    fileBlocks = update.second,
+                    folderStatsUpdateCollector = folderStatsUpdateCollector,
+                    oldRecord = oldRecord
+            )
+        } else {
+            null
+        }
+    }
+
+    private fun prepareUpdate(
+            folder: String,
+            bepFileInfo: BlockExchangeProtos.FileInfo
+    ): Pair<FileInfo, FileBlocks?>? {
+        val builder = FileInfo.Builder()
+                .setFolder(folder)
+                .setPath(bepFileInfo.name)
+                .setLastModified(Date(bepFileInfo.modifiedS * 1000 + bepFileInfo.modifiedNs / 1000000))
+                .setVersionList((if (bepFileInfo.hasVersion()) bepFileInfo.version.countersList else null ?: emptyList()).map { record -> FileInfo.Version(record.id, record.value) })
+                .setDeleted(bepFileInfo.deleted)
+
+        var fileBlocks: FileBlocks? = null
+
+        when (bepFileInfo.type) {
+            BlockExchangeProtos.FileInfoType.FILE -> {
+                fileBlocks = FileBlocks(folder, builder.getPath()!!, ((bepFileInfo.blocksList ?: emptyList())).map { record ->
+                    BlockInfo(record.offset, record.size, Hex.toHexString(record.hash.toByteArray()))
+                })
+                builder
+                        .setTypeFile()
+                        .setHash(fileBlocks.hash)
+                        .setSize(bepFileInfo.size)
+            }
+            BlockExchangeProtos.FileInfoType.DIRECTORY -> builder.setTypeDir()
+            else -> {
+                logger.warn("unsupported file type = {}, discarding file info", bepFileInfo.type)
+                return null
+            }
+        }
+
+        return builder.build() to fileBlocks
+    }
+
+    private fun shouldUpdateRecord(
+            oldRecord: FileInfo?,
+            newRecord: FileInfo
+    ) = oldRecord == null || newRecord.lastModified >= oldRecord.lastModified
+
+    private fun addRecord(
+            transaction: IndexTransaction,
+            newRecord: FileInfo,
+            oldRecord: FileInfo?,
+            fileBlocks: FileBlocks?,
+            folderStatsUpdateCollector: FolderStatsUpdateCollector
+    ): FileInfo? {
+        return if (shouldUpdateRecord(oldRecord, newRecord)) {
+            logger.trace("discarding record = {}, modified before local record", newRecord)
+            null
+        } else {
+            logger.trace("loaded new record = {}", newRecord)
+
+            transaction.updateFileInfo(newRecord, fileBlocks)
+            updateFolderStatsCollector(oldRecord, newRecord, folderStatsUpdateCollector)
+
+            newRecord
+        }
+    }
+
+    private fun updateFolderStatsCollector(
+            oldRecord: FileInfo?,
+            newRecord: FileInfo,
+            folderStatsUpdateCollector: FolderStatsUpdateCollector
+    ) {
+        val oldMissing = oldRecord == null || oldRecord.isDeleted
+        val newMissing = newRecord.isDeleted
+        val oldSizeMissing = oldMissing || !oldRecord!!.isFile()
+        val newSizeMissing = newMissing || !newRecord.isFile()
+
+        if (!oldSizeMissing) {
+            folderStatsUpdateCollector.deltaSize -= oldRecord!!.size!!
+        }
+
+        if (!newSizeMissing) {
+            folderStatsUpdateCollector.deltaSize += newRecord.size!!
+        }
+
+        if (!oldMissing) {
+            if (oldRecord!!.isFile()) {
+                folderStatsUpdateCollector.deltaFileCount--
+            } else if (oldRecord.isDirectory()) {
+                folderStatsUpdateCollector.deltaDirCount--
+            }
+        }
+
+        if (!newMissing) {
+            if (newRecord.isFile()) {
+                folderStatsUpdateCollector.deltaFileCount++
+            } else if (newRecord.isDirectory()) {
+                folderStatsUpdateCollector.deltaDirCount++
+            }
+        }
+
+        folderStatsUpdateCollector.lastModified = newRecord.lastModified
+    }
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/IndexHandler.kt

@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
+ *
+ * This Java file is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.syncthing.java.bep.index
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BroadcastChannel
+import kotlinx.coroutines.channels.consume
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import net.syncthing.java.bep.BlockExchangeProtos
+import net.syncthing.java.bep.connectionactor.ClusterConfigInfo
+import net.syncthing.java.bep.connectionactor.ConnectionActorWrapper
+import net.syncthing.java.bep.folder.FolderBrowser
+import net.syncthing.java.bep.index.browser.IndexBrowser
+import net.syncthing.java.core.beans.*
+import net.syncthing.java.core.configuration.Configuration
+import net.syncthing.java.core.exception.ExceptionReport
+import net.syncthing.java.core.interfaces.IndexRepository
+import net.syncthing.java.core.interfaces.IndexTransaction
+import net.syncthing.java.core.interfaces.TempRepository
+import org.apache.commons.lang3.tuple.Pair
+import org.slf4j.LoggerFactory
+import java.io.Closeable
+import java.io.IOException
+
+class IndexHandler(
+        configuration: Configuration,
+        val indexRepository: IndexRepository,
+        tempRepository: TempRepository,
+        exceptionReportHandler: (ExceptionReport) -> Unit
+) : Closeable {
+    private val logger = LoggerFactory.getLogger(javaClass)
+    private val indexInfoUpdateEvents = BroadcastChannel<IndexInfoUpdateEvent>(capacity = 16)
+    private val onFullIndexAcquiredEvents = BroadcastChannel<String>(capacity = 16)
+    private val onFolderStatsUpdatedEvents = BroadcastChannel<FolderStatsChangedEvent>(capacity = 16)
+
+    private val indexMessageProcessor = IndexMessageQueueProcessor(
+            indexRepository = indexRepository,
+            tempRepository = tempRepository,
+            isRemoteIndexAcquired = ::isRemoteIndexAcquired,
+            onIndexRecordAcquiredEvents = indexInfoUpdateEvents,
+            onFullIndexAcquiredEvents = onFullIndexAcquiredEvents,
+            onFolderStatsUpdatedEvents = onFolderStatsUpdatedEvents,
+            exceptionReportHandler = exceptionReportHandler
+    )
+
+    fun subscribeToOnFullIndexAcquiredEvents() = onFullIndexAcquiredEvents.openSubscription()
+    fun subscribeToOnIndexUpdateEvents() = indexInfoUpdateEvents.openSubscription()
+    fun subscribeFolderStatsUpdatedEvents() = onFolderStatsUpdatedEvents.openSubscription()
+
+    fun getNextSequenceNumber() = indexRepository.runInTransaction { it.getSequencer().nextSequence() }
+
+    suspend fun clearIndex() {
+        withContext(Dispatchers.IO) {
+            indexRepository.runInTransaction { it.clearIndex() }
+        }
+
+        onFolderStatsUpdatedEvents.send(FolderStatsResetEvent)
+        indexInfoUpdateEvents.send(IndexInfoClearedEvent)
+    }
+
+    private fun isRemoteIndexAcquiredWithoutTransaction(clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId): Boolean {
+        return indexRepository.runInTransaction { transaction -> isRemoteIndexAcquired(clusterConfigInfo, peerDeviceId, transaction) }
+    }
+
+    private fun isRemoteIndexAcquired(clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId, transaction: IndexTransaction): Boolean {
+        return clusterConfigInfo.sharedFolderIds.find { sharedFolderId ->
+            // try to find one folder which is not yet ready
+            val indexSequenceInfo = transaction.findIndexInfoByDeviceAndFolder(peerDeviceId, sharedFolderId)
+
+            indexSequenceInfo == null || indexSequenceInfo.localSequence < indexSequenceInfo.maxSequence
+        } == null
+    }
+
+    // the old implementation kept waiting when index updates were still happening, but waiting 30 seconds should be enough
+    suspend fun waitForRemoteIndexAcquiredWithTimeout(connectionHandler: ConnectionActorWrapper, timeoutSecs: Long? = null): IndexHandler {
+        val timeoutMillis = (timeoutSecs ?: DEFAULT_INDEX_TIMEOUT) * 1000
+
+        val ok = withTimeoutOrNull(timeoutMillis) {
+            waitForRemoteIndexAcquiredWithoutTimeout(connectionHandler)
+
+            true
+        } ?: false
+
+        if (!ok) {
+            throw IOException("unable to acquire index from connection $connectionHandler, timeout reached!")
+        }
+
+        return this
+    }
+
+    suspend fun waitForRemoteIndexAcquiredWithoutTimeout(connectionHandler: ConnectionActorWrapper) {
+        val events = onFullIndexAcquiredEvents.openSubscription()
+
+        events.consume {
+            fun isDone() = isRemoteIndexAcquiredWithoutTransaction(connectionHandler.getClusterConfig(), connectionHandler.deviceId)
+
+            if (isDone()) {
+                return
+            }
+
+            for (event in events) {
+                if (isDone()) {
+                    return
+                }
+            }
+        }
+    }
+
+    suspend fun handleClusterConfigMessageProcessedEvent(clusterConfig: BlockExchangeProtos.ClusterConfig) {
+        val updatedIndexInfos = indexRepository.runInTransaction { transaction ->
+            val updatedIndexInfos = mutableListOf<IndexInfo>()
+
+            for (folderRecord in clusterConfig.foldersList) {
+                val folder = folderRecord.id
+                logger.debug("acquired folder info from cluster config = {}", folder)
+                for (deviceRecord in folderRecord.devicesList) {
+                    val deviceId = DeviceId.fromHashData(deviceRecord.id.toByteArray())
+                    if (deviceRecord.hasIndexId() && deviceRecord.hasMaxSequence()) {
+                        val folderIndexInfo = UpdateIndexInfo.updateIndexInfoFromClusterConfig(transaction, folder, deviceId, deviceRecord.indexId, deviceRecord.maxSequence)
+                        logger.debug("acquired folder index info from cluster config = {}", folderIndexInfo)
+                        updatedIndexInfos.add(folderIndexInfo)
+                    }
+                }
+            }
+
+            updatedIndexInfos
+        }
+
+        updatedIndexInfos.forEach {
+            indexInfoUpdateEvents.send(
+                    IndexRecordAcquiredEvent(
+                            folderId = it.folderId,
+                            indexInfo = it,
+                            files = emptyList()
+                    )
+            )
+        }
+    }
+
+    internal suspend fun handleIndexMessageReceivedEvent(folderId: String, filesList: List<BlockExchangeProtos.FileInfo>, clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId) {
+        indexMessageProcessor.handleIndexMessageReceivedEvent(folderId, filesList, clusterConfigInfo, peerDeviceId)
+    }
+
+    fun getFileInfoByPath(folder: String, path: String): FileInfo? {
+        return indexRepository.runInTransaction { it.findFileInfo(folder, path) }
+    }
+
+    fun getFileInfoAndBlocksByPath(folder: String, path: String): Pair<FileInfo, FileBlocks>? {
+        return indexRepository.runInTransaction { transaction ->
+            val fileInfo = transaction.findFileInfo(folder, path)
+
+            if (fileInfo == null) {
+                null
+            } else {
+                val fileBlocks = transaction.findFileBlocks(folder, path)
+
+                assert(fileInfo.isFile())
+                checkNotNull(fileBlocks) {"file blocks not found for file info = $fileInfo"}
+
+                FileInfo.checkBlocks(fileInfo, fileBlocks)
+
+                Pair.of(fileInfo, fileBlocks)
+            }
+        }
+    }
+
+    val folderBrowser = FolderBrowser(this, configuration)
+    val indexBrowser = IndexBrowser(indexRepository, this)
+
+    suspend fun sendFolderStatsUpdate(event: FolderStats) {
+        onFolderStatsUpdatedEvents.send(FolderStatsUpdatedEvent(event))
+    }
+
+    override fun close() {
+        indexInfoUpdateEvents.close()
+        onFullIndexAcquiredEvents.close()
+        indexMessageProcessor.stop()
+    }
+
+    companion object {
+
+        private const val DEFAULT_INDEX_TIMEOUT: Long = 30
+    }
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/IndexInfoUpdateEvent.kt

@@ -0,0 +1,8 @@
+package net.syncthing.java.bep.index
+
+import net.syncthing.java.core.beans.FileInfo
+import net.syncthing.java.core.beans.IndexInfo
+
+sealed class IndexInfoUpdateEvent
+data class IndexRecordAcquiredEvent(val folderId: String, val files: List<FileInfo>, val indexInfo: IndexInfo): IndexInfoUpdateEvent()
+object IndexInfoClearedEvent: IndexInfoUpdateEvent()

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/IndexMessageProcessor.kt

@@ -0,0 +1,70 @@
+package net.syncthing.java.bep.index
+
+import net.syncthing.java.bep.BlockExchangeProtos
+import net.syncthing.java.core.beans.DeviceId
+import net.syncthing.java.core.beans.FileInfo
+import net.syncthing.java.core.beans.FolderStats
+import net.syncthing.java.core.beans.IndexInfo
+import net.syncthing.java.core.interfaces.IndexTransaction
+import org.slf4j.LoggerFactory
+import java.lang.RuntimeException
+
+object IndexMessageProcessor {
+    private val logger = LoggerFactory.getLogger(IndexMessageProcessor::class.java)
+
+    fun doHandleIndexMessageReceivedEvent(
+            message: BlockExchangeProtos.IndexUpdate,
+            peerDeviceId: DeviceId,
+            transaction: IndexTransaction
+    ): Result {
+        val folderId = message.folder
+        val oldIndexInfo = transaction.findIndexInfoByDeviceAndFolder(peerDeviceId, folderId)
+                ?: throw IndexInfoNotFoundException()
+
+        logger.debug("processing {} index records for folder {}", message.filesList.size, folderId)
+
+        val oldRecords = transaction.findFileInfo(folderId, message.filesList.map { it.name })
+        val folderStatsUpdateCollector = FolderStatsUpdateCollector(message.folder)
+
+        val newRecords = IndexElementProcessor.pushRecords(
+                transaction = transaction,
+                oldRecords = oldRecords,
+                folder = folderId,
+                folderStatsUpdateCollector = folderStatsUpdateCollector,
+                updates = message.filesList
+        )
+
+        val newIndexInfo = if (message.filesList.isEmpty()) {
+            oldIndexInfo
+        } else {
+            var sequence: Long = -1
+
+            for (newRecord in message.filesList) {
+                sequence = Math.max(newRecord.sequence, sequence)
+            }
+
+            handleFolderStatsUpdate(transaction, folderStatsUpdateCollector)
+
+            UpdateIndexInfo.updateIndexInfoFromIndexElementProcessor(transaction, oldIndexInfo, sequence)
+        }
+
+        return Result(newIndexInfo, newRecords.toList(), transaction.findFolderStats(folderId) ?: FolderStats.createDummy(folderId))
+    }
+
+    fun handleFolderStatsUpdate(transaction: IndexTransaction, folderStatsUpdateCollector: FolderStatsUpdateCollector) {
+        if (folderStatsUpdateCollector.isEmpty()) {
+            return
+        }
+
+        transaction.updateOrInsertFolderStats(
+                folder = folderStatsUpdateCollector.folderId,
+                deltaSize = folderStatsUpdateCollector.deltaSize,
+                deltaFileCount = folderStatsUpdateCollector.deltaFileCount,
+                deltaDirCount = folderStatsUpdateCollector.deltaDirCount,
+                lastUpdate = folderStatsUpdateCollector.lastModified
+        )
+    }
+
+    data class Result(val newIndexInfo: IndexInfo, val updatedFiles: List<FileInfo>, val newFolderStats: FolderStats)
+    class IndexInfoNotFoundException: RuntimeException()
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/IndexMessageQueueProcessor.kt

@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
+ *
+ * This Java file is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.syncthing.java.bep.index
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.BroadcastChannel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import net.syncthing.java.bep.BlockExchangeProtos
+import net.syncthing.java.bep.connectionactor.ClusterConfigInfo
+import net.syncthing.java.core.beans.DeviceId
+import net.syncthing.java.core.exception.ExceptionReport
+import net.syncthing.java.core.exception.reportExceptions
+import net.syncthing.java.core.interfaces.IndexRepository
+import net.syncthing.java.core.interfaces.IndexTransaction
+import net.syncthing.java.core.interfaces.TempRepository
+import org.slf4j.LoggerFactory
+
+class IndexMessageQueueProcessor (
+        private val indexRepository: IndexRepository,
+        private val tempRepository: TempRepository,
+        private val onIndexRecordAcquiredEvents: BroadcastChannel<IndexInfoUpdateEvent>,
+        private val onFullIndexAcquiredEvents: BroadcastChannel<String>,
+        private val onFolderStatsUpdatedEvents: BroadcastChannel<FolderStatsChangedEvent>,
+        private val isRemoteIndexAcquired: (ClusterConfigInfo, DeviceId, IndexTransaction) -> Boolean,
+        exceptionReportHandler: (ExceptionReport) -> Unit
+) {
+    private data class IndexUpdateAction(val update: BlockExchangeProtos.IndexUpdate, val clusterConfigInfo: ClusterConfigInfo, val peerDeviceId: DeviceId)
+    private data class StoredIndexUpdateAction(val updateId: String, val clusterConfigInfo: ClusterConfigInfo, val peerDeviceId: DeviceId)
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(IndexMessageQueueProcessor::class.java)
+        private const val BATCH_SIZE = 128
+    }
+
+    private val job = Job()
+    private val indexUpdateIncomingLock = Mutex()
+    private val indexUpdateProcessStoredQueue = Channel<StoredIndexUpdateAction>(capacity = Channel.UNLIMITED)
+    private val indexUpdateProcessingQueue = Channel<IndexUpdateAction>(capacity = Channel.RENDEZVOUS)
+
+    suspend fun handleIndexMessageReceivedEvent(folderId: String, filesList: List<BlockExchangeProtos.FileInfo>, clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId) {
+        filesList.chunked(BATCH_SIZE).forEach { chunck ->
+            handleIndexMessageReceivedEventWithoutChuncking(folderId, chunck, clusterConfigInfo, peerDeviceId)
+        }
+    }
+
+    suspend fun handleIndexMessageReceivedEventWithoutChuncking(folderId: String, filesList: List<BlockExchangeProtos.FileInfo>, clusterConfigInfo: ClusterConfigInfo, peerDeviceId: DeviceId) {
+        indexUpdateIncomingLock.withLock {
+            logger.info("received index message event, preparing")
+
+            val data = BlockExchangeProtos.IndexUpdate.newBuilder()
+                    .addAllFiles(filesList)
+                    .setFolder(folderId)
+                    .build()
+
+            if (indexUpdateProcessingQueue.offer(IndexUpdateAction(data, clusterConfigInfo, peerDeviceId))) {
+                // message is beeing processed now
+            } else {
+                val key = tempRepository.pushTempData(data.toByteArray())
+
+                logger.debug("received index message event, stored to temp record {}, queuing for processing", key)
+                indexUpdateProcessStoredQueue.send(StoredIndexUpdateAction(key, clusterConfigInfo, peerDeviceId))
+            }
+        }
+    }
+
+    init {
+        GlobalScope.async(Dispatchers.IO + job) {
+            indexUpdateProcessingQueue.consumeEach {
+                try {
+                    doHandleIndexMessageReceivedEvent(it)
+                } catch (ex: IndexMessageProcessor.IndexInfoNotFoundException) {
+                    // ignored
+                    // this is expected when the data is deleted but some index updates are still in the queue
+
+                    logger.warn("could not find index info for index update")
+                }
+            }
+        }.reportExceptions("IndexMessageQueueProcessor.indexUpdateProcessingQueue", exceptionReportHandler)
+
+        GlobalScope.async(Dispatchers.IO + job) {
+            indexUpdateProcessStoredQueue.consumeEach { action ->
+                logger.debug("processing index message event from temp record {}", action.updateId)
+
+                val data = tempRepository.popTempData(action.updateId)
+                val message = BlockExchangeProtos.IndexUpdate.parseFrom(data)
+
+                indexUpdateProcessingQueue.send(IndexUpdateAction(
+                        message,
+                        action.clusterConfigInfo,
+                        action.peerDeviceId
+                ))
+            }
+        }.reportExceptions("IndexMessageQueueProcessor.indexUpdateProcessStoredQueue", exceptionReportHandler)
+    }
+
+    private suspend fun doHandleIndexMessageReceivedEvent(action: IndexUpdateAction) {
+        val (message, clusterConfigInfo, peerDeviceId) = action
+
+        val folderInfo = clusterConfigInfo.folderInfoById[message.folder]
+                ?: throw IllegalStateException("got folder info for folder without known folder info")
+
+        if (!folderInfo.isDeviceInSharedFolderWhitelist) {
+            throw IllegalStateException("received index update for folder which is not shared")
+        }
+
+        logger.info("processing index message with {} records", message.filesCount)
+
+        val (indexResult, wasIndexAcquired) = indexRepository.runInTransaction { indexTransaction ->
+            val wasIndexAcquiredBefore = isRemoteIndexAcquired(clusterConfigInfo, peerDeviceId, indexTransaction)
+
+            val startTime = System.currentTimeMillis()
+
+            val indexResult = IndexMessageProcessor.doHandleIndexMessageReceivedEvent(
+                    message = message,
+                    peerDeviceId = peerDeviceId,
+                    transaction = indexTransaction
+            )
+
+            val endTime = System.currentTimeMillis()
+
+            logger.info("processed {} index records, acquired {} in ${endTime - startTime} ms", message.filesCount, indexResult.updatedFiles.size)
+
+            logger.debug("index info = {}", indexResult.newIndexInfo)
+
+            indexResult to ((!wasIndexAcquiredBefore) && isRemoteIndexAcquired(clusterConfigInfo, peerDeviceId, indexTransaction))
+        }
+
+        if (indexResult.updatedFiles.isNotEmpty()) {
+            onIndexRecordAcquiredEvents.send(IndexRecordAcquiredEvent(message.folder, indexResult.updatedFiles, indexResult.newIndexInfo))
+        }
+
+        onFolderStatsUpdatedEvents.send(FolderStatsUpdatedEvent(indexResult.newFolderStats))
+
+        if (wasIndexAcquired) {
+            logger.debug("index acquired")
+            onFullIndexAcquiredEvents.send(message.folder)
+        }
+    }
+
+    fun stop() {
+        logger.info("stopping index record processor")
+        job.cancel()
+    }
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/UpdateIndexInfo.kt

@@ -0,0 +1,57 @@
+package net.syncthing.java.bep.index
+
+import net.syncthing.java.core.beans.DeviceId
+import net.syncthing.java.core.beans.IndexInfo
+import net.syncthing.java.core.interfaces.IndexTransaction
+
+object UpdateIndexInfo {
+    fun updateIndexInfoFromClusterConfig(
+            transaction: IndexTransaction,
+            folder: String,
+            deviceId: DeviceId,
+            indexId: Long,
+            maxSequence: Long
+    ): IndexInfo {
+        val oldIndexSequenceInfo = transaction.findIndexInfoByDeviceAndFolder(deviceId, folder)
+
+        var newIndexSequenceInfo = oldIndexSequenceInfo ?: IndexInfo(
+                folderId = folder,
+                deviceId = deviceId.deviceId,
+                indexId = indexId,
+                localSequence = 0,
+                maxSequence = -1
+        )
+
+        if (indexId != newIndexSequenceInfo.indexId) {
+            newIndexSequenceInfo = newIndexSequenceInfo.copy(indexId = indexId)
+        }
+
+        if (maxSequence > newIndexSequenceInfo.maxSequence) {
+            newIndexSequenceInfo = newIndexSequenceInfo.copy(maxSequence = maxSequence)
+        }
+
+        if (oldIndexSequenceInfo != newIndexSequenceInfo) {
+            transaction.updateIndexInfo(newIndexSequenceInfo)
+        }
+
+        return newIndexSequenceInfo
+    }
+
+    fun updateIndexInfoFromIndexElementProcessor(
+            transaction: IndexTransaction,
+            oldIndexInfo: IndexInfo,
+            localSequence: Long?
+    ): IndexInfo {
+        var newIndexSequenceInfo = oldIndexInfo
+
+        if (localSequence != null && localSequence > newIndexSequenceInfo.localSequence) {
+            newIndexSequenceInfo = newIndexSequenceInfo.copy(localSequence = localSequence)
+        }
+
+        if (oldIndexInfo != newIndexSequenceInfo) {
+            transaction.updateIndexInfo(newIndexSequenceInfo)
+        }
+
+        return newIndexSequenceInfo
+    }
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/browser/DirectoryListing.kt

@@ -0,0 +1,25 @@
+package net.syncthing.java.bep.index.browser
+
+import net.syncthing.java.core.beans.FileInfo
+import net.syncthing.java.core.utils.PathUtils
+
+sealed class DirectoryListing {
+    abstract val folder: String
+    abstract val path: String
+}
+
+data class DirectoryContentListing(
+        val directoryInfo: FileInfo,
+        val parentEntry: FileInfo?,
+        val entries: List<FileInfo>
+): DirectoryListing() {
+    override val folder = directoryInfo.folder
+    override val path = directoryInfo.path
+}
+
+data class DirectoryNotFoundListing(
+        override val folder: String,
+        override val path: String
+): DirectoryListing() {
+    val theoreticalParentPath = if (PathUtils.isRoot(path)) null else PathUtils.getParentPath(path)
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/index/browser/IndexBrowser.kt

@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
+ *
+ * This Java file is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.syncthing.java.bep.index.browser
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.consume
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.withContext
+import net.syncthing.java.bep.index.FolderStatsUpdatedEvent
+import net.syncthing.java.bep.index.IndexHandler
+import net.syncthing.java.bep.index.IndexInfoUpdateEvent
+import net.syncthing.java.bep.index.IndexRecordAcquiredEvent
+import net.syncthing.java.core.beans.FileInfo
+import net.syncthing.java.core.interfaces.IndexRepository
+import net.syncthing.java.core.interfaces.IndexTransaction
+import net.syncthing.java.core.utils.PathUtils
+import java.util.*
+
+class IndexBrowser internal constructor(
+        private val indexRepository: IndexRepository,
+        private val indexHandler: IndexHandler
+) {
+    companion object {
+        val sortAlphabeticallyDirectoriesFirst: Comparator<FileInfo> =
+                compareBy<FileInfo>({!isParent(it) }, {!it.isDirectory()})
+                        .thenBy { it.fileName.toLowerCase() }
+
+        val sortByLastModification: Comparator<FileInfo> =
+                compareBy<FileInfo>({!isParent(it) }, {it.lastModified})
+                        .thenBy { it.fileName.toLowerCase() }
+
+        private fun isParent(fileInfo: FileInfo) = PathUtils.isParent(fileInfo.path)
+
+        fun getPathFileName(path: String) = PathUtils.getFileName(path)
+
+        const val ROOT_PATH = PathUtils.ROOT_PATH
+    }
+
+    fun getDirectoryListing(folder: String, path: String): DirectoryListing = indexRepository.runInTransaction { indexTransaction ->
+        val entries = indexTransaction.findNotDeletedFilesByFolderAndParent(folder, path)
+        val parentPath = if (PathUtils.isRoot(path)) null else PathUtils.getParentPath(path)
+        val parentEntry = if (PathUtils.isRoot(path)) null else getFileInfoByPathAllowNull(folder, PathUtils.getParentPath(path), indexTransaction)
+        val directoryInfo = getFileInfoByPathAllowNull(folder, path, indexTransaction)
+
+        if ((parentPath != null && parentEntry == null) || directoryInfo == null || directoryInfo.type != FileInfo.FileType.DIRECTORY) {
+            DirectoryNotFoundListing(folder, path)
+        } else {
+            DirectoryContentListing(
+                    entries = entries,
+                    parentEntry = parentEntry,
+                    directoryInfo = directoryInfo
+            )
+        }
+    }
+
+    fun streamDirectoryListing(folder: String, path: String) = GlobalScope.produce {
+        indexHandler.subscribeToOnIndexUpdateEvents().consume {
+            val directoryName = PathUtils.getFileName(path)
+            val parentPath = if (PathUtils.isRoot(path)) null else PathUtils.getParentPath(path)
+            val parentDirectoryName = if (parentPath != null) PathUtils.getFileName(parentPath) else null
+            val parentParentPath = if (parentPath == null || PathUtils.isRoot(parentPath)) null else PathUtils.getParentPath(parentPath)
+
+            // get the initial state
+            var (entries, parentEntry, directoryInfo) = withContext (Dispatchers.IO) {
+                indexRepository.runInTransaction { indexTransaction ->
+                    val entries = indexTransaction.findNotDeletedFilesByFolderAndParent(folder, path)
+                    val parentEntry = if (PathUtils.isRoot(path)) null else getFileInfoByPathAllowNull(folder, PathUtils.getParentPath(path), indexTransaction)
+                    val directoryInfo = getFileInfoByPathAllowNull(folder, path, indexTransaction)
+
+                    Triple(entries, parentEntry, directoryInfo)
+                }
+            }
+
+            var previousStatus: DirectoryListing? = null
+
+            suspend fun dispatch() {
+                // let Kotlin understand that the value does not change during running this
+                val directoryInfo = directoryInfo
+
+                val newStatus = if ((parentPath != null && parentEntry == null) || directoryInfo == null || directoryInfo.type != FileInfo.FileType.DIRECTORY) {
+                    DirectoryNotFoundListing(folder, path)
+                } else {
+                    DirectoryContentListing(
+                            entries = entries,
+                            parentEntry = parentEntry,
+                            directoryInfo = directoryInfo
+                    )
+                }
+
+                if (newStatus != previousStatus) {
+                    previousStatus = newStatus
+                    send(newStatus)
+                }
+            }
+
+            dispatch()
+
+            // handle updates
+            for (event in this) {
+                if (event is IndexRecordAcquiredEvent) {
+                    var hadChanges = false
+
+                    if (event.folderId == folder) {
+                        event.files.forEach { fileUpdate ->
+                            // entry change
+                            if (fileUpdate.parent == path) {
+                                hadChanges = true
+
+                                entries = entries.filter { it.fileName != fileUpdate.fileName }
+
+                                if (!fileUpdate.isDeleted) {
+                                    entries += listOf(fileUpdate)
+                                }
+                            }
+
+                            // handle directory info changes
+                            if (fileUpdate.parent == parentPath && fileUpdate.fileName == directoryName) {
+                                directoryInfo = if (fileUpdate.isDeleted) null else fileUpdate
+                                hadChanges = true
+                            }
+
+                            // handle parent directory info changes
+                            if (fileUpdate.parent == parentParentPath && fileUpdate.fileName == parentDirectoryName) {
+                                parentEntry = if (fileUpdate.isDeleted) null else fileUpdate
+                                hadChanges = true
+                            }
+                        }
+                    }
+
+                    if (hadChanges) {
+                        dispatch()
+                    }
+                }
+            }
+        }
+    }
+
+    fun getFileInfoByAbsolutePath(folder: String, path: String): FileInfo = getFileInfoByAbsolutePathAllowNull(folder, path)
+            ?: error("file not found for path = $path")
+
+    fun getFileInfoByAbsolutePathAllowNull(folder: String, path: String): FileInfo? {
+        return if (PathUtils.isRoot(path)) {
+            FileInfo(folder = folder, type = FileInfo.FileType.DIRECTORY, path = PathUtils.ROOT_PATH)
+        } else {
+            indexRepository.runInTransaction { it.findNotDeletedFileInfo(folder, path) }
+        }
+    }
+
+    fun getFileInfoByPath(folder: String, path: String, transaction: IndexTransaction) = getFileInfoByPathAllowNull(folder, path, transaction)
+            ?: error("file not found for path = $path")
+
+    fun getFileInfoByPathAllowNull(folder: String, path: String, transaction: IndexTransaction): FileInfo? {
+        return if (PathUtils.isRoot(path)) {
+            FileInfo(folder = folder, type = FileInfo.FileType.DIRECTORY, path = PathUtils.ROOT_PATH)
+        } else {
+            transaction.findNotDeletedFileInfo(folder, path)
+        }
+    }
+}

syncthing-bep/src/main/kotlin/net/syncthing/java/bep/utils/MaxBy.kt

@@ -0,0 +1,11 @@
+package net.syncthing.java.bep.utils
+
+inline fun <T> Iterable<T>.longMaxBy(selector: (T) -> Long, defaultValue: Long): Long {
+    var max = defaultValue
+
+    this.forEach {
+        max = Math.max(max, selector(it))
+    }
+
+    return max
+}

syncthing-client-cli/src/main/kotlin/net/syncthing/java/client/cli/Main.kt

@@ -13,7 +13,10 @@
  */
 package net.syncthing.java.client.cli
 
+import kotlinx.coroutines.channels.consume
 import kotlinx.coroutines.runBlocking
+import net.syncthing.java.bep.index.browser.DirectoryContentListing
+import net.syncthing.java.bep.index.browser.IndexBrowser
 import net.syncthing.java.client.SyncthingClient
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.beans.DeviceInfo
@@ -26,7 +29,6 @@ import org.slf4j.LoggerFactory
 import java.io.File
 import java.io.FileInputStream
 import java.io.IOException
-import java.util.concurrent.CountDownLatch
 
 class Main(private val commandLine: CommandLine) {
 
@@ -46,7 +48,13 @@ class Main(private val commandLine: CommandLine) {
 
             val repository = SqlRepository(configuration.databaseFolder)
 
-            SyncthingClient(configuration, repository, repository).use { syncthingClient ->
+            SyncthingClient(
+                    configuration,
+                    repository,
+                    repository
+            ) { ex ->
+                throw ex.exception
+            }.use { syncthingClient ->
                 val main = Main(cmd)
                 cmd.options.forEach { main.handleOption(it, configuration, syncthingClient) }
             }
@@ -84,8 +92,16 @@ class Main(private val commandLine: CommandLine) {
                         .map { DeviceId(it.trim()) }
                         .toList()
                 System.out.println("set peers = $peers")
-                configuration.peers = peers.map { DeviceInfo(it, null) }.toSet()
-                configuration.persistNow()
+
+                runBlocking {
+                    configuration.update { oldConfig ->
+                        oldConfig.copy(
+                                peers = peers.map { DeviceInfo(it, it.shortId) }.toSet()
+                        )
+                    }
+                }
+
+                runBlocking { configuration.persistNow() }
             }
             "p" -> {
                 val folderAndPath = option.value
@@ -117,7 +133,6 @@ class Main(private val commandLine: CommandLine) {
                 System.out.println("file path = $path")
                 val folder = path.split(":".toRegex()).dropLastWhile({ it.isEmpty() }).toTypedArray()[0]
                 path = path.split(":".toRegex()).dropLastWhile({ it.isEmpty() }).toTypedArray()[1]
-                val latch = CountDownLatch(1)
                 val blockPusher = syncthingClient.getBlockPusher(folder)
 
                 val observer = runBlocking {
@@ -169,33 +184,35 @@ class Main(private val commandLine: CommandLine) {
                 System.out.println("uploaded dir to network")
             }
             "L" -> {
-                waitForIndexUpdate(syncthingClient, configuration)
-                for (folder in syncthingClient.indexHandler.folderList()) {
-                    syncthingClient.indexHandler.newIndexBrowser(folder).use { indexBrowser ->
-                        System.out.println("list folder = ${indexBrowser.folder}")
-                        for (fileInfo in indexBrowser.listFiles()) {
+                waitForIndexUpdate(syncthingClient)
+                for (folder in configuration.folders) {
+                    System.out.println("list folder = ${folder}")
+                    val listing = syncthingClient.indexHandler.indexBrowser.getDirectoryListing(folder.folderId, IndexBrowser.ROOT_PATH)
+
+                    if (listing is DirectoryContentListing) {
+                        for (fileInfo in listing.entries) {
                             System.out.println("${fileInfo.type.name.substring(0, 1)}\t${fileInfo.describeSize()}\t${fileInfo.path}")
                         }
                     }
                 }
             }
             "I" -> {
-                waitForIndexUpdate(syncthingClient, configuration)
+                waitForIndexUpdate(syncthingClient)
                 val folderInfo = StringBuilder()
-                for (folder in syncthingClient.indexHandler.folderList()) {
+                for (folder in configuration.folders) {
                     folderInfo.append("\nfolder info: ")
-                            .append(syncthingClient.indexHandler.getFolderInfo(folder))
+                            .append(folder)
                     folderInfo.append("\nfolder stats: ")
-                            .append(syncthingClient.indexHandler.newFolderBrowser().getFolderStats(folder).dumpInfo())
+                            .append(syncthingClient.indexHandler.folderBrowser.getFolderStatusSync(folder.folderId).stats.infoDump)
                             .append("\n")
                 }
                 System.out.println("folders:\n$folderInfo\n")
             }
             "l" -> {
                 var folderInfo = ""
-                for (folder in syncthingClient.indexHandler.folderList()) {
-                    folderInfo += "\nfolder info: " + syncthingClient.indexHandler.getFolderInfo(folder)
-                    folderInfo += "\nfolder stats: " + syncthingClient.indexHandler.newFolderBrowser().getFolderStats(folder).dumpInfo() + "\n"
+                for (folder in configuration.folders) {
+                    folderInfo += "\nfolder info: " + folder
+                    folderInfo += "\nfolder stats: " + syncthingClient.indexHandler.folderBrowser.getFolderStatusSync(folder.folderId).stats.infoDump + "\n"
                 }
                 System.out.println("folders:\n$folderInfo\n")
             }
@@ -211,11 +228,12 @@ class Main(private val commandLine: CommandLine) {
     }
 
     @Throws(InterruptedException::class)
-    private fun waitForIndexUpdate(client: SyncthingClient, configuration: Configuration) {
-        val latch = CountDownLatch(configuration.peers.size)
-        client.indexHandler.registerOnFullIndexAcquiredListenersListener {
-            latch.countDown()
+    private fun waitForIndexUpdate(client: SyncthingClient) {
+        // FIXME: what happens if the index update happened already?
+        runBlocking {
+            client.indexHandler.subscribeToOnFullIndexAcquiredEvents().consume {
+                this.receive()  // wait until there is one event
+            }
         }
-        latch.await()
     }
 }

syncthing-client/src/main/kotlin/net/syncthing/java/client/Connections.kt

@@ -13,14 +13,25 @@
  */
 package net.syncthing.java.client
 
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.ConflatedBroadcastChannel
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import net.syncthing.java.bep.connectionactor.ConnectionActorWrapper
+import net.syncthing.java.bep.connectionactor.ConnectionInfo
 import net.syncthing.java.core.beans.DeviceId
 
 class Connections (val generate: (DeviceId) -> ConnectionActorWrapper) {
     private val map = mutableMapOf<DeviceId, ConnectionActorWrapper>()
+    private val connectionStatus = ConflatedBroadcastChannel<Map<DeviceId, ConnectionInfo>>(emptyMap())
+    private val connectionStatusLock = Mutex()
+    private val job = Job()
 
     fun getByDeviceId(deviceId: DeviceId): ConnectionActorWrapper {
-        return synchronized(map) {
+        synchronized(map) {
             val oldEntry = map[deviceId]
 
             if (oldEntry != null) {
@@ -30,6 +41,17 @@ class Connections (val generate: (DeviceId) -> ConnectionActorWrapper) {
 
                 map[deviceId] = newEntry
 
+                GlobalScope.launch (job) {
+                    newEntry.subscribeToConnectionInfo().consumeEach {  status ->
+                        connectionStatusLock.withLock {
+                            connectionStatus.send(
+                                    connectionStatus.value +
+                                            mapOf(deviceId to status)
+                            )
+                        }
+                    }
+                }
+
                 return newEntry
             }
         }
@@ -39,6 +61,8 @@ class Connections (val generate: (DeviceId) -> ConnectionActorWrapper) {
         synchronized(map) {
             map.values.forEach { it.shutdown() }
         }
+
+        job.cancel()
     }
 
     fun reconnectAllConnections() {
@@ -46,4 +70,12 @@ class Connections (val generate: (DeviceId) -> ConnectionActorWrapper) {
             map.values.forEach { it.reconnect() }
         }
     }
+
+    fun reconnect(deviceId: DeviceId) {
+        synchronized(map) {
+            map[deviceId]?.reconnect()
+        }
+    }
+
+    fun subscribeToConnectionStatusMap() = connectionStatus.openSubscription()
 }

syncthing-client/src/main/kotlin/net/syncthing/java/client/SyncthingClient.kt

@@ -16,27 +16,31 @@ package net.syncthing.java.client
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
-import net.syncthing.java.bep.*
+import net.syncthing.java.bep.BlockPuller
+import net.syncthing.java.bep.BlockPullerStatus
+import net.syncthing.java.bep.BlockPusher
+import net.syncthing.java.bep.RequestHandlerRegistry
 import net.syncthing.java.bep.connectionactor.ConnectionActorGenerator
 import net.syncthing.java.bep.connectionactor.ConnectionActorWrapper
+import net.syncthing.java.bep.index.IndexHandler
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.beans.FileInfo
 import net.syncthing.java.core.configuration.Configuration
+import net.syncthing.java.core.exception.ExceptionReport
 import net.syncthing.java.core.interfaces.IndexRepository
 import net.syncthing.java.core.interfaces.TempRepository
 import net.syncthing.java.discovery.DiscoveryHandler
 import java.io.Closeable
 import java.io.InputStream
-import java.util.*
 
 class SyncthingClient(
         private val configuration: Configuration,
         private val repository: IndexRepository,
-        private val tempRepository: TempRepository
+        private val tempRepository: TempRepository,
+        exceptionReportHandler: (ExceptionReport) -> Unit
 ) : Closeable {
-    val indexHandler = IndexHandler(configuration, repository, tempRepository)
-    val discoveryHandler = DiscoveryHandler(configuration)
-    private val onConnectionChangedListeners = Collections.synchronizedList(mutableListOf<(DeviceId) -> Unit>())
+    val indexHandler = IndexHandler(configuration, repository, tempRepository, exceptionReportHandler)
+    val discoveryHandler = DiscoveryHandler(configuration, exceptionReportHandler)
 
     private val requestHandlerRegistry = RequestHandlerRegistry()
     private val connections = Connections(
@@ -56,31 +60,20 @@ class SyncthingClient(
                                 configuration = configuration
                         ),
                         deviceId = deviceId,
-                        connectivityChangeListener = {
-                            synchronized(onConnectionChangedListeners) {
-                                onConnectionChangedListeners.forEach { it(deviceId) }
-                            }
-                        }
+                        exceptionReportHandler = exceptionReportHandler
                 )
             }
     )
 
-    fun clearCacheAndIndex() {
+    suspend fun clearCacheAndIndex() {
         indexHandler.clearIndex()
-        configuration.folders = emptySet()
+        configuration.update {
+            it.copy(folders = emptySet())
+        }
         configuration.persistLater()
         connections.reconnectAllConnections()
     }
 
-    fun addOnConnectionChangedListener(listener: (DeviceId) -> Unit) {
-        onConnectionChangedListeners.add(listener)
-    }
-
-    fun removeOnConnectionChangedListener(listener: (DeviceId) -> Unit) {
-        assert(onConnectionChangedListeners.contains(listener))
-        onConnectionChangedListeners.remove(listener)
-    }
-
     private fun getConnections() = configuration.peerIds.map { connections.getByDeviceId(it) }
 
     init {
@@ -88,6 +81,10 @@ class SyncthingClient(
         getConnections()
     }
 
+    fun reconnect(deviceId: DeviceId) {
+        connections.reconnect(deviceId)
+    }
+
     fun connectToNewlyAddedDevices() {
         getConnections()
     }
@@ -124,11 +121,7 @@ class SyncthingClient(
         )
     }
 
-    fun getPeerStatus() = configuration.peers.map { device ->
-        device.copy(
-                isConnected = connections.getByDeviceId(device.deviceId).isConnected
-        )
-    }
+    fun subscribeToConnectionStatus() = connections.subscribeToConnectionStatusMap()
 
     override fun close() {
         discoveryHandler.close()
@@ -136,6 +129,5 @@ class SyncthingClient(
         repository.close()
         tempRepository.close()
         connections.shutdown()
-        assert(onConnectionChangedListeners.isEmpty())
     }
 }

syncthing-core/build.gradle

@@ -11,4 +11,5 @@ dependencies {
     compile "com.google.code.gson:gson:2.8.2"
     compile "org.bouncycastle:bcmail-jdk15on:1.59"
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.0'
 }

syncthing-core/src/main/kotlin/net/syncthing/java/core/beans/DeviceId.kt

@@ -5,8 +5,9 @@ import com.google.gson.stream.JsonWriter
 import net.syncthing.java.core.utils.NetworkUtils
 import org.apache.commons.codec.binary.Base32
 import java.io.IOException
+import java.io.Serializable
 
-data class DeviceId @Throws(IOException::class) constructor(val deviceId: String) {
+data class DeviceId @Throws(IOException::class) constructor(val deviceId: String): Serializable {
 
     init {
         val withoutDashes = this.deviceId.replace("-", "")

syncthing-core/src/main/kotlin/net/syncthing/java/core/beans/DeviceInfo.kt

@@ -16,8 +16,9 @@ package net.syncthing.java.core.beans
 
 import com.google.gson.stream.JsonReader
 import com.google.gson.stream.JsonWriter
+import java.io.Serializable
 
-data class DeviceInfo(val deviceId: DeviceId, val name: String, val isConnected: Boolean? = null) {
+data class DeviceInfo(val deviceId: DeviceId, val name: String): Serializable {
 
     companion object {
         private const val DEVICE_ID = "deviceId"
@@ -44,9 +45,6 @@ data class DeviceInfo(val deviceId: DeviceId, val name: String, val isConnected:
         }
     }
 
-    constructor(deviceId: DeviceId, name: String?) :
-            this(deviceId, if (name != null && !name.isBlank()) name else deviceId.shortId, null)
-
     fun serialize(writer: JsonWriter) {
         writer.beginObject()
 

syncthing-core/src/main/kotlin/net/syncthing/java/core/beans/FolderInfo.kt

@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2016 Davide Imbriaco
  * Copyright (C) 2018 Jonas Lochmann
  *
@@ -17,20 +17,72 @@ package net.syncthing.java.core.beans
 import com.google.gson.stream.JsonReader
 import com.google.gson.stream.JsonWriter
 
-open class FolderInfo(val folderId: String, label: String? = null) {
+// the whitelist are device ids with which the folder should be shared
+
+// the blacklist are device ids with which the folder should not be shared
+
+// the ignored device ids are devices for which the user confirmed the blacklist entry so that
+// there should not be any question
+data class FolderInfo(
+        val folderId: String,
+        val label: String,
+        val deviceIdWhitelist: Set<DeviceId>,
+        val deviceIdBlacklist: Set<DeviceId>,
+        val ignoredDeviceIdList: Set<DeviceId>
+) {
     companion object {
         private const val FOLDER_ID = "folderId"
         private const val LABEL = "label"
+        private const val DEVICE_ID_WHITELIST = "deviceWhitelist"
+        private const val DEVICE_ID_BLACKLIST = "deviceBlacklist"
+        private const val IGNORED_DEVICE_ID_LIST = "ignoredDeviceIdList"
 
         fun parse(reader: JsonReader): FolderInfo {
             var folderId: String? = null
             var label: String? = null
+            // the following fields were added later and thus have got a default value
+            var deviceIdWhitelist = emptySet<DeviceId>()
+            var deviceIdBlacklist = emptySet<DeviceId>()
+            var ignoredDeviceIdList = emptySet<DeviceId>()
 
             reader.beginObject()
             while (reader.hasNext()) {
                 when (reader.nextName()) {
                     FOLDER_ID -> folderId = reader.nextString()
                     LABEL -> label = reader.nextString()
+                    DEVICE_ID_WHITELIST -> {
+                        reader.beginArray()
+
+                        deviceIdWhitelist = mutableSetOf<DeviceId>().apply {
+                            while (reader.hasNext()) {
+                                add(DeviceId(reader.nextString()))
+                            }
+                        }
+
+                        reader.endArray()
+                    }
+                    DEVICE_ID_BLACKLIST -> {
+                        reader.beginArray()
+
+                        deviceIdBlacklist = mutableSetOf<DeviceId>().apply {
+                            while (reader.hasNext()) {
+                                add(DeviceId(reader.nextString()))
+                            }
+                        }
+
+                        reader.endArray()
+                    }
+                    IGNORED_DEVICE_ID_LIST -> {
+                        reader.beginArray()
+
+                        ignoredDeviceIdList = mutableSetOf<DeviceId>().apply {
+                            while (reader.hasNext()) {
+                                add(DeviceId(reader.nextString()))
+                            }
+                        }
+
+                        reader.endArray()
+                    }
                     else -> reader.skipValue()
                 }
             }
@@ -38,16 +90,23 @@ open class FolderInfo(val folderId: String, label: String? = null) {
 
             return FolderInfo(
                     folderId = folderId!!,
-                    label = label!!
+                    label = label!!,
+                    deviceIdBlacklist = deviceIdBlacklist,
+                    deviceIdWhitelist = deviceIdWhitelist,
+                    ignoredDeviceIdList = ignoredDeviceIdList
             )
         }
     }
 
-    val label: String
-
     init {
         assert(!folderId.isEmpty())
-        this.label = if (label != null && !label.isEmpty()) label else folderId
+        assert(deviceIdWhitelist.find { deviceIdBlacklist.contains(it) } == null)
+    }
+
+    val notIgnoredBlacklistEntries: Set<DeviceId> by lazy {
+        deviceIdBlacklist
+                .filterNot { ignoredDeviceIdList.contains(it) }
+                .toSet()
     }
 
     override fun toString(): String {
@@ -60,7 +119,18 @@ open class FolderInfo(val folderId: String, label: String? = null) {
         writer.name(FOLDER_ID).value(folderId)
         writer.name(LABEL).value(label)
 
+        writer.name(DEVICE_ID_WHITELIST).beginArray()
+        deviceIdWhitelist.forEach { writer.value(it.deviceId) }
+        writer.endArray()
+
+        writer.name(DEVICE_ID_BLACKLIST).beginArray()
+        deviceIdBlacklist.forEach { writer.value(it.deviceId) }
+        writer.endArray()
+
+        writer.name(IGNORED_DEVICE_ID_LIST).beginArray()
+        ignoredDeviceIdList.forEach { writer.value(it.deviceId) }
+        writer.endArray()
+
         writer.endObject()
     }
-
 }

syncthing-core/src/main/kotlin/net/syncthing/java/core/beans/FolderStats.kt

@@ -1,5 +1,6 @@
 /* 
  * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
  *
  * This Java file is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -16,87 +17,22 @@ package net.syncthing.java.core.beans
 import org.apache.commons.io.FileUtils
 import java.util.*
 
-class FolderStats private constructor(val fileCount: Long, val dirCount: Long, val size: Long, val lastUpdate: Date, folder: String, label: String?) : FolderInfo(folder, label) {
-
-    fun getRecordCount(): Long = dirCount + fileCount
-
-    fun describeSize(): String = FileUtils.byteCountToDisplaySize(size)
-
-    fun dumpInfo(): String {
-        return ("folder " + label + " (" + folderId + ") file count = " + fileCount
-                + " dir count = " + dirCount + " folder size = " + describeSize() + " last update = " + lastUpdate)
+data class FolderStats(val fileCount: Long, val dirCount: Long, val size: Long, val lastUpdate: Date, val folderId: String) {
+    companion object {
+        fun createDummy(folderId: String) = FolderStats(
+                fileCount = 0,
+                dirCount = 0,
+                size = 0,
+                lastUpdate = Date(0),
+                folderId = folderId
+        )
     }
 
-    override fun toString(): String {
-        return "FolderStats{folder=$folderId, fileCount=$fileCount, dirCount=$dirCount, size=$size, lastUpdate=$lastUpdate}"
-    }
+    val recordCount: Long = dirCount + fileCount
 
-    fun copyBuilder(): Builder = Builder(fileCount, dirCount, size, folderId, label)
-
-    class Builder {
-
-        private var fileCount: Long = 0
-        private var dirCount: Long = 0
-        private var size: Long = 0
-        private var lastUpdate = Date(0)
-        private var folder: String? = null
-        private var label: String? = null
-
-        constructor()
-
-        constructor(fileCount: Long, dirCount: Long, size: Long, folder: String, label: String) {
-            this.fileCount = fileCount
-            this.dirCount = dirCount
-            this.size = size
-            this.folder = folder
-            this.label = label
-        }
-
-        fun getFileCount(): Long = fileCount
-
-        fun setFileCount(fileCount: Long): Builder {
-            this.fileCount = fileCount
-            return this
-        }
-
-        fun getDirCount(): Long = dirCount
-
-        fun setDirCount(dirCount: Long): Builder {
-            this.dirCount = dirCount
-            return this
-        }
-
-        fun getSize(): Long = size
-
-        fun setSize(size: Long): Builder {
-            this.size = size
-            return this
-        }
-
-        fun getLastUpdate(): Date = lastUpdate
-
-        fun setLastUpdate(lastUpdate: Date): Builder {
-            this.lastUpdate = lastUpdate
-            return this
-        }
-
-        fun getFolder(): String? = folder
-
-        fun setFolder(folder: String): Builder {
-            this.folder = folder
-            return this
-        }
-
-        fun getLabel(): String? = label
-
-        fun setLabel(label: String): Builder {
-            this.label = label
-            return this
-        }
-
-        fun build(): FolderStats {
-            return FolderStats(fileCount, dirCount, size, lastUpdate, folder!!, label)
-        }
+    val sizeDescription: String by lazy { FileUtils.byteCountToDisplaySize(size) }
 
+    val infoDump: String by lazy {
+        "folder $folderId file count = $fileCount dir count = $dirCount folder size = $sizeDescription last update = $lastUpdate"
     }
 }

syncthing-core/src/main/kotlin/net/syncthing/java/core/beans/IndexInfo.kt

@@ -1,5 +1,6 @@
 /* 
  * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
  *
  * This Java file is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -14,98 +15,11 @@
 package net.syncthing.java.core.beans
 
 
-class IndexInfo private constructor(folder: String, val deviceId: String, val indexId: Long, val localSequence: Long, val maxSequence: Long) : FolderInfo(folder) {
+data class IndexInfo(val folderId: String, val deviceId: String, val indexId: Long, val localSequence: Long, val maxSequence: Long) {
 
-    fun getCompleted(): Double = if (maxSequence > 0) localSequence.toDouble() / maxSequence else 0.0
+    val completed: Double = if (maxSequence > 0) localSequence.toDouble() / maxSequence else 0.0
 
     init {
-        assert(!deviceId.isEmpty())
+        assert(deviceId.isNotEmpty())
     }
-
-    fun copyBuilder(): Builder {
-        return Builder(folderId, indexId, deviceId, localSequence, maxSequence)
-    }
-
-    override fun toString(): String {
-        return "FolderIndexInfo{indexId=$indexId, folder=$folderId, deviceId=$deviceId, localSequence=$localSequence, maxSequence=$maxSequence}"
-    }
-
-    class Builder {
-
-        private var indexId: Long = 0
-        private var deviceId: String? = null
-        private var folder: String? = null
-        private var localSequence: Long = 0
-        private var maxSequence: Long = 0
-
-        internal constructor()
-
-        internal constructor(folder: String, indexId: Long, deviceId: String, localSequence: Long, maxSequence: Long) {
-            assert(!folder.isEmpty())
-            assert(!deviceId.isEmpty())
-            this.folder = folder
-            this.indexId = indexId
-            this.deviceId = deviceId
-            this.localSequence = localSequence
-            this.maxSequence = maxSequence
-        }
-
-        fun getIndexId(): Long {
-            return indexId
-        }
-
-        fun getDeviceId(): String? {
-            return deviceId
-        }
-
-        fun getFolder(): String? {
-            return folder
-        }
-
-        fun getLocalSequence(): Long {
-            return localSequence
-        }
-
-        fun getMaxSequence(): Long {
-            return maxSequence
-        }
-
-        fun setIndexId(indexId: Long): Builder {
-            this.indexId = indexId
-            return this
-        }
-
-        fun setDeviceId(deviceId: String): Builder {
-            this.deviceId = deviceId
-            return this
-        }
-
-        fun setFolder(folder: String): Builder {
-            this.folder = folder
-            return this
-        }
-
-        fun setLocalSequence(localSequence: Long): Builder {
-            this.localSequence = localSequence
-            return this
-        }
-
-        fun setMaxSequence(maxSequence: Long): Builder {
-            this.maxSequence = maxSequence
-            return this
-        }
-
-        fun build(): IndexInfo {
-            return IndexInfo(folder!!, deviceId!!, indexId, localSequence, maxSequence)
-        }
-
-    }
-
-    companion object {
-
-        fun newBuilder(): Builder {
-            return Builder()
-        }
-    }
-
 }

syncthing-core/src/main/kotlin/net/syncthing/java/core/configuration/Configuration.kt

@@ -2,6 +2,14 @@ package net.syncthing.java.core.configuration
 
 import com.google.gson.stream.JsonReader
 import com.google.gson.stream.JsonWriter
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.ConflatedBroadcastChannel
+import kotlinx.coroutines.channels.sendBlocking
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.beans.DeviceInfo
 import net.syncthing.java.core.beans.FolderInfo
@@ -17,12 +25,14 @@ import java.util.*
 class Configuration(configFolder: File = DefaultConfigFolder) {
 
     private val logger = LoggerFactory.getLogger(javaClass)
+    private val modifyLock = Mutex()
+    private val saveLock = Mutex()
+    private val configChannel = ConflatedBroadcastChannel<Config>()
 
     private val configFile = File(configFolder, ConfigFileName)
     val databaseFolder = File(configFolder, DatabaseFolderName)
 
     private var isSaved = true
-    private var config: Config
 
     init {
         configFolder.mkdirs()
@@ -36,19 +46,23 @@ class Configuration(configFolder: File = DefaultConfigFolder) {
             }
             val keystoreData = KeystoreHandler.Loader().generateKeystore()
             isSaved = false
-            config = Config(peers = setOf(), folders = setOf(),
-                    localDeviceName = localDeviceName,
-                    localDeviceId = keystoreData.first.deviceId,
-                    keystoreData = Base64.toBase64String(keystoreData.second),
-                    keystoreAlgorithm = keystoreData.third,
-                    customDiscoveryServers = emptySet(),
-                    useDefaultDiscoveryServers = true
+            configChannel.sendBlocking(
+                    Config(peers = setOf(), folders = setOf(),
+                            localDeviceName = localDeviceName,
+                            localDeviceId = keystoreData.first.deviceId,
+                            keystoreData = Base64.toBase64String(keystoreData.second),
+                            keystoreAlgorithm = keystoreData.third,
+                            customDiscoveryServers = emptySet(),
+                            useDefaultDiscoveryServers = true
+                    )
             )
-            persistNow()
+            runBlocking { persistNow() }
         } else {
-            config = Config.parse(JsonReader(StringReader(configFile.readText())))
+            configChannel.sendBlocking(
+                    Config.parse(JsonReader(StringReader(configFile.readText())))
+            )
         }
-        logger.debug("Loaded config = $config")
+        logger.debug("Loaded config = ${configChannel.value}")
     }
 
     companion object {
@@ -60,72 +74,89 @@ class Configuration(configFolder: File = DefaultConfigFolder) {
     val instanceId = Math.abs(Random().nextLong())
 
     val localDeviceId: DeviceId
-        get() = DeviceId(config.localDeviceId)
+        get() = DeviceId(configChannel.value.localDeviceId)
 
     val discoveryServers: Set<DiscoveryServer>
-        get() = config.customDiscoveryServers + (if (config.useDefaultDiscoveryServers) DiscoveryServer.defaultDiscoveryServers else emptySet())
+        get() = configChannel.value.let { config ->
+            config.customDiscoveryServers + (if (config.useDefaultDiscoveryServers) DiscoveryServer.defaultDiscoveryServers else emptySet())
+        }
 
     val keystoreData: ByteArray
-        get() = Base64.decode(config.keystoreData)
+        get() = Base64.decode(configChannel.value.keystoreData)
 
     val keystoreAlgorithm: String
-        get() = config.keystoreAlgorithm
+        get() = configChannel.value.keystoreAlgorithm
 
     val clientName = "syncthing-java"
 
     val clientVersion = javaClass.`package`.implementationVersion ?: "0.0.0"
 
     val peerIds: Set<DeviceId>
-        get() = config.peers.map { it.deviceId }.toSet()
+        get() = configChannel.value.peers.map { it.deviceId }.toSet()
 
-    var localDeviceName: String
-        get() = config.localDeviceName
-        set(localDeviceName) {
-            config = config.copy(localDeviceName = localDeviceName)
-            isSaved = false
+    val localDeviceName: String
+        get() = configChannel.value.localDeviceName
+
+    val folders: Set<FolderInfo>
+        get() = configChannel.value.folders
+
+    val peers: Set<DeviceInfo>
+        get() = configChannel.value.peers
+
+    suspend fun update(operation: suspend (Config) -> Config): Boolean {
+        modifyLock.withLock {
+            val oldConfig = configChannel.value
+            val newConfig = operation(oldConfig)
+
+            if (oldConfig != newConfig) {
+                configChannel.send(newConfig)
+                isSaved = false
+
+                return true
+            } else {
+                return false
+            }
         }
+    }
 
-    var folders: Set<FolderInfo>
-        get() = config.folders
-        set(folders) {
-            config = config.copy(folders = folders)
-            isSaved = false
-        }
-
-    var peers: Set<DeviceInfo>
-        get() = config.peers
-        set(peers) {
-            config = config.copy(peers = peers)
-            isSaved = false
-        }
-
-    fun persistNow() {
+    suspend fun persistNow() {
         persist()
     }
 
     fun persistLater() {
-        Thread { persist() }.start()
+        GlobalScope.launch (Dispatchers.IO) { persist() }
     }
 
-    private fun persist() {
-        if (isSaved)
-            return
+    private suspend fun persist() {
+        saveLock.withLock {
+            val (config1, isConfig1Saved) = modifyLock.withLock { configChannel.value to isSaved }
+
+            if (isConfig1Saved) {
+                return
+            }
 
-        config.let {
             System.out.println("writing config to $configFile")
+
             configFile.writeText(
                     StringWriter().apply {
                         JsonWriter(this).apply {
                             setIndent("  ")
 
-                            config.serialize(this)
+                            config1.serialize(this)
                         }
                     }.toString()
             )
-            isSaved = true
+
+            modifyLock.withLock {
+                if (config1 === configChannel.value) {
+                    isSaved = true
+                }
+            }
         }
     }
 
+    fun subscribe() = configChannel.openSubscription()
+
     override fun toString() = "Configuration(peers=$peers, folders=$folders, localDeviceName=$localDeviceName, " +
             "localDeviceId=${localDeviceId.deviceId}, discoveryServers=$discoveryServers, instanceId=$instanceId, " +
             "configFile=$configFile, databaseFolder=$databaseFolder)"

syncthing-core/src/main/kotlin/net/syncthing/java/core/exception/ExceptionReport.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2018 Jonas Lochmann
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.syncthing.java.core.exception
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Job
+import kotlin.Exception
+
+data class ExceptionReport(
+        val component: String,
+        val exception: Exception,
+        val details: List<ExceptionDetails>
+) {
+    companion object {
+        fun fromException(exception: Exception, component: String) = ExceptionReport(
+                component,
+                exception,
+                ExceptionDetailException.getExceptionReportDetails(exception)
+        )
+    }
+
+    val detailsReadableString: String by lazy {
+        details.map { it.readableString }.joinToString("\n")
+    }
+}
+
+data class ExceptionDetails(
+        val component: String,
+        val details: String
+) {
+    val readableString: String by lazy { component + "\n" + details + "\n" }
+}
+
+class ExceptionDetailException(
+        cause: Throwable,
+        val details: ExceptionDetails
+): Exception(cause) {
+    companion object {
+        fun getExceptionReportDetails(exception: Exception): List<ExceptionDetails> {
+            val result = mutableListOf<ExceptionDetails>()
+
+            var ex: Throwable? = exception
+
+            while (ex != null) {
+                if (ex is ExceptionDetailException) {
+                    result.add(ex.details)
+                }
+
+                ex = ex.cause
+            }
+
+            return result.reversed()
+        }
+    }
+}
+
+fun Job.reportExceptions(component: String, exceptionReportHandler: (ExceptionReport) -> Unit) {
+    invokeOnCompletion {
+        if (it != null) {
+            if (it is Exception) {
+                if (it is CancellationException) {
+                    // ignore
+                } else {
+                    exceptionReportHandler(ExceptionReport.fromException(it, component))
+                }
+            } else {
+                throw it
+            }
+        }
+    }
+}

syncthing-core/src/main/kotlin/net/syncthing/java/core/interfaces/IndexRepository.kt

@@ -1,5 +1,6 @@
 /* 
  * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
  *
  * This Java file is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -13,46 +14,8 @@
  */
 package net.syncthing.java.core.interfaces
 
-import net.syncthing.java.core.beans.*
 import java.io.Closeable
-import java.util.*
 
 interface IndexRepository: Closeable {
-
-    fun setOnFolderStatsUpdatedListener(listener: ((IndexRepository.FolderStatsUpdatedEvent) -> Unit)?)
-
-    fun getSequencer(): Sequencer
-
-    fun updateIndexInfo(indexInfo: IndexInfo)
-
-    fun findIndexInfoByDeviceAndFolder(deviceId: DeviceId, folder: String): IndexInfo?
-
-    fun findFileInfo(folder: String, path: String): FileInfo?
-
-    fun findFileInfoLastModified(folder: String, path: String): Date?
-
-    fun findNotDeletedFileInfo(folder: String, path: String): FileInfo?
-
-    fun findFileBlocks(folder: String, path: String): FileBlocks?
-
-    fun updateFileInfo(fileInfo: FileInfo, fileBlocks: FileBlocks?)
-
-    fun findNotDeletedFilesByFolderAndParent(folder: String, parentPath: String): List<FileInfo>
-
-    fun clearIndex()
-
-    fun findFolderStats(folder: String): FolderStats?
-
-    fun findAllFolderStats(): List<FolderStats>
-
-    fun findFileInfoBySearchTerm(query: String): List<FileInfo>
-
-    fun countFileInfoBySearchTerm(query: String): Long
-
-    abstract class FolderStatsUpdatedEvent {
-
-        abstract fun getFolderStats(): List<FolderStats>
-
-    }
-
+    fun <T> runInTransaction(action: (IndexTransaction) -> T): T
 }

syncthing-core/src/main/kotlin/net/syncthing/java/core/interfaces/IndexTransaction.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
+ *
+ * This Java file is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.syncthing.java.core.interfaces
+
+import net.syncthing.java.core.beans.*
+import java.util.*
+
+interface IndexTransaction {
+    fun getSequencer(): Sequencer
+
+    fun updateIndexInfo(indexInfo: IndexInfo)
+
+    fun findAllIndexInfos(): List<IndexInfo>
+
+    fun findIndexInfoByDeviceAndFolder(deviceId: DeviceId, folder: String): IndexInfo?
+
+    fun findFileInfo(folder: String, path: String): FileInfo?
+
+    // path to FileInfo
+    fun findFileInfo(folder: String, path: List<String>): Map<String, FileInfo>
+
+    fun findFileInfoLastModified(folder: String, path: String): Date?
+
+    fun findNotDeletedFileInfo(folder: String, path: String): FileInfo?
+
+    fun findFileBlocks(folder: String, path: String): FileBlocks?
+
+    fun updateFileInfo(fileInfo: FileInfo, fileBlocks: FileBlocks?)
+
+    fun updateFileInfoAndBlocks(fileInfos: List<FileInfo>, fileBlocks: List<FileBlocks>)
+
+    fun findNotDeletedFilesByFolderAndParent(folder: String, parentPath: String): List<FileInfo>
+
+    fun clearIndex()
+
+    fun findFolderStats(folder: String): FolderStats?
+
+    fun findAllFolderStats(): List<FolderStats>
+
+    fun updateOrInsertFolderStats(folder: String, deltaFileCount: Long, deltaDirCount: Long, deltaSize: Long, lastUpdate: Date)
+
+    fun findFileInfoBySearchTerm(query: String): List<FileInfo>
+
+    fun countFileInfoBySearchTerm(query: String): Long
+}

syncthing-core/src/main/kotlin/net/syncthing/java/core/interfaces/TempRepository.kt

@@ -1,5 +1,6 @@
 /* 
  * Copyright (C) 2016 Davide Imbriaco
+ * Copyright (C) 2018 Jonas Lochmann
  *
  * This Java file is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -22,4 +23,6 @@ interface TempRepository: Closeable {
     fun popTempData(key: String): ByteArray
 
     fun deleteTempData(keys: List<String>)
+
+    fun deleteAllTempData()
 }

syncthing-core/src/main/kotlin/net/syncthing/java/core/utils/ExecutorUtils.kt

@@ -1,56 +0,0 @@
-/* 
- * Copyright (C) 2016 Davide Imbriaco
- *
- * This Java file is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package net.syncthing.java.core.utils
-
-import org.slf4j.LoggerFactory
-import java.util.concurrent.ExecutorService
-import java.util.concurrent.Future
-import java.util.concurrent.RejectedExecutionException
-import java.util.concurrent.TimeUnit
-
-private val logger = LoggerFactory.getLogger(ExecutorService::class.java)
-
-fun ExecutorService.awaitTerminationSafe() {
-    try {
-        awaitTermination(2, TimeUnit.SECONDS)
-    } catch (ex: InterruptedException) {
-        logger.warn("", ex)
-    }
-}
-
-fun ExecutorService.submitLogging(runnable: Runnable) = submitLogging { runnable.run() }
-
-/**
- * Wrapper method for [[ExecutorService.submit]], which silently swallows exceptions. If an exception is thrown in
- * [[runnable]], logs the exception and force crashes
- */
-fun <T> ExecutorService.submitLogging(runnable: () -> T): Future<T> {
-    return submit<T>({
-        try {
-            runnable()
-        } catch (e: Exception) {
-            logger.error("", e)
-            System.exit(1)
-            null
-        }
-    })
-}
-
-fun ExecutorService.trySubmitLogging(runnable: Runnable) {
-    try {
-        submitLogging(runnable)
-    } catch (ex: RejectedExecutionException) {
-        logger.warn("could not submit task", ex)
-    }
-}

syncthing-core/src/main/kotlin/net/syncthing/java/core/utils/PathUtils.kt

@@ -14,6 +14,9 @@
  */
 package net.syncthing.java.core.utils
 
+import net.syncthing.java.core.exception.ExceptionDetailException
+import net.syncthing.java.core.exception.ExceptionDetails
+
 object PathUtils {
     const val ROOT_PATH = ""
     const val PATH_SEPARATOR = "/"
@@ -31,29 +34,56 @@ object PathUtils {
         return pathSegments.contains(PARENT_PATH) or pathSegments.contains(CURRENT_PATH)
     }
 
-    private fun isTrimmed(value: String) = value.trim() == value
     private fun containsWindowsPathSeparator(path: String) = path.contains(PATH_SEPARATOR_WIN)
-    private fun startsWithPathSeperator(path: String) = path.startsWith(PATH_SEPARATOR)
-    private fun isValidPath(path: String) = (!containsRelativeElements(path)) and
-            (!containsWindowsPathSeparator(path)) and
-            path.isNotEmpty() and
-            (!startsWithPathSeperator(path)) and
-            isTrimmed(path)
+    private fun startsWithPathSeparator(path: String) = path.startsWith(PATH_SEPARATOR)
 
     private fun containsPathSeparator(file: String) = file.contains(PATH_SEPARATOR) or file.contains(PATH_SEPARATOR_WIN)
-    private fun isFilenameValid(file: String) = file.isNotBlank() and
-            (!containsPathSeparator(file)) and
-            isTrimmed(file)
 
     private fun assertPathValid(path: String) {
-        if (!isValidPath(path)) {
-            throw IllegalArgumentException("provided path is invalid")
+        fun throwException(reason: String) {
+            throw ExceptionDetailException(
+                    IllegalArgumentException("provided path is invalid because it $reason"),
+                    ExceptionDetails(
+                            component = "PathUtils",
+                            details = "processed path: \"$path\""
+                    )
+            )
+        }
+
+        if (containsRelativeElements(path)) {
+            throwException("contains relative path elements")
+        }
+
+        if (containsWindowsPathSeparator(path)) {
+            throwException("contains windows path separators")
+        }
+
+        if (path.isEmpty()) {
+            throwException("is empty")
+        }
+
+        if (startsWithPathSeparator(path)) {
+            throwException("starts with a path separator")
         }
     }
 
     private fun assertFilenameValid(filename: String) {
-        if (!isFilenameValid(filename)) {
-            throw IllegalArgumentException("provided filename is invalid")
+        fun throwException(reason: String) {
+            throw ExceptionDetailException(
+                    IllegalArgumentException("provided filename is invalid because the filename $reason"),
+                    ExceptionDetails(
+                            component = "PathUtils",
+                            details = "processed filename: \"$filename\""
+                    )
+            )
+        }
+
+        if (filename.isBlank()) {
+            throwException("is blank")
+        }
+
+        if (containsPathSeparator(filename)) {
+            throwException("contains a path separator")
         }
     }
 
@@ -100,4 +130,12 @@ object PathUtils {
 
         return dir.removeSuffix(PATH_SEPARATOR) + file
     }
+
+    fun getFileExtensionFromFilename(filename: String): String {
+        assertFilenameValid(filename)
+
+        val dotIndex = filename.lastIndexOf(".")
+
+        return if (dotIndex != 0) filename.substring(dotIndex + 1) else ""
+    }
 }

syncthing-discovery/src/main/kotlin/net/syncthing/java/discovery/DiscoveryHandler.kt

@@ -20,6 +20,7 @@ import kotlinx.coroutines.launch
 import net.syncthing.java.core.beans.DeviceAddress
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.configuration.Configuration
+import net.syncthing.java.core.exception.ExceptionReport
 import net.syncthing.java.discovery.protocol.GlobalDiscoveryHandler
 import net.syncthing.java.discovery.protocol.LocalDiscoveryHandler
 import net.syncthing.java.discovery.utils.AddressRanker
@@ -27,19 +28,27 @@ import org.slf4j.LoggerFactory
 import java.io.Closeable
 import java.util.*
 
-class DiscoveryHandler(private val configuration: Configuration) : Closeable {
+class DiscoveryHandler(
+        private val configuration: Configuration,
+        exceptionReportHandler: (ExceptionReport) -> Unit
+) : Closeable {
 
     private val logger = LoggerFactory.getLogger(javaClass)
     private val globalDiscoveryHandler = GlobalDiscoveryHandler(configuration)
-    private val localDiscoveryHandler = LocalDiscoveryHandler(configuration, { message ->
-        logger.info("received device address list from local discovery")
+    private val localDiscoveryHandler = LocalDiscoveryHandler(
+            configuration,
+            exceptionReportHandler,
+            { message ->
+                logger.info("received device address list from local discovery")
 
-        GlobalScope.launch {
-            processDeviceAddressBg(message.addresses)
-        }
-    }, { deviceId ->
-        onMessageFromUnknownDeviceListeners.forEach { listener -> listener(deviceId) }
-    })
+                GlobalScope.launch {
+                    processDeviceAddressBg(message.addresses)
+                }
+            },
+            { deviceId ->
+                onMessageFromUnknownDeviceListeners.forEach { listener -> listener(deviceId) }
+            }
+    )
     val devicesAddressesManager = DevicesAddressesManager()
     private var isClosed = false
     private val onMessageFromUnknownDeviceListeners = Collections.synchronizedSet(HashSet<(DeviceId) -> Unit>())

syncthing-discovery/src/main/kotlin/net/syncthing/java/discovery/Main.kt

@@ -83,14 +83,20 @@ class Main {
     private fun queryLocalDiscovery(configuration: Configuration, deviceId: DeviceId): Collection<DeviceAddress> {
         val lock = Object()
         val discoveredAddresses = mutableListOf<DeviceAddress>()
-        val handler = LocalDiscoveryHandler(configuration, { message ->
-            synchronized(lock) {
-                if (message.deviceId == deviceId) {
-                    discoveredAddresses.addAll(message.addresses)
-                    lock.notify()
+        val handler = LocalDiscoveryHandler(
+                configuration,
+                {
+                    throw it.exception
+                },
+                { message ->
+                    synchronized(lock) {
+                        if (message.deviceId == deviceId) {
+                            discoveredAddresses.addAll(message.addresses)
+                            lock.notify()
+                        }
+                    }
                 }
-            }
-        })
+        )
         handler.startListener()
         handler.sendAnnounceMessage()
         synchronized(lock) {

syncthing-discovery/src/main/kotlin/net/syncthing/java/discovery/protocol/LocalDiscoveryHandler.kt

@@ -14,34 +14,37 @@
  */
 package net.syncthing.java.discovery.protocol
 
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.Job
+import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.consumeEach
-import kotlinx.coroutines.launch
 import net.syncthing.java.core.beans.DeviceId
 import net.syncthing.java.core.configuration.Configuration
+import net.syncthing.java.core.exception.ExceptionReport
+import net.syncthing.java.core.exception.reportExceptions
 import org.slf4j.LoggerFactory
 import java.io.Closeable
 import java.io.IOException
 
-internal class LocalDiscoveryHandler(private val configuration: Configuration,
-                                     private val onMessageReceivedListener: (LocalDiscoveryMessage) -> Unit,
-                                     private val onMessageFromUnknownDeviceListener: (DeviceId) -> Unit = {}) : Closeable {
+internal class LocalDiscoveryHandler(
+        private val configuration: Configuration,
+        private val exceptionReportHandler: (ExceptionReport) -> Unit,
+        private val onMessageReceivedListener: (LocalDiscoveryMessage) -> Unit,
+        private val onMessageFromUnknownDeviceListener: (DeviceId) -> Unit = {}
+) : Closeable {
 
     private val logger = LoggerFactory.getLogger(javaClass)
     private val job = Job()
 
     fun sendAnnounceMessage() {
-        GlobalScope.launch {
+        GlobalScope.async (Dispatchers.IO) {
             LocalDiscoveryUtil.sendAnnounceMessage(
                     ownDeviceId = configuration.localDeviceId,
                     instanceId = configuration.instanceId
             )
-        }
+        }.reportExceptions("LocalDiscoveryHandler.sendAnnounceMessage", exceptionReportHandler)
     }
 
     fun startListener() {
-        GlobalScope.launch (job) {
+        GlobalScope.async (job) {
             try {
                 LocalDiscoveryUtil.listenForAnnounceMessages().consumeEach { message ->
                     if (message.deviceId == configuration.localDeviceId) {
@@ -59,7 +62,7 @@ internal class LocalDiscoveryHandler(private val configuration: Configuration,
             } catch (ex: IOException) {
                 logger.warn("Failed to listen for announcement messages", ex)
             }
-        }
+        }.reportExceptions("LocalDiscoveryHandler.startListener", exceptionReportHandler)
     }
 
     override fun close() {