support e2e encryption

app/src/main/AndroidManifest.xml

@@ -3,6 +3,8 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
+        tools:ignore="ScopedStorage" />
     <application
         android:name=".SampleApp"
         android:allowBackup="true"

app/src/main/java/org/sdn/android/sdk/sample/data/RoomSummaryDialogWrapper.kt

@@ -19,12 +19,13 @@ package org.sdn.android.sdk.sample.data
 import com.stfalcon.chatkit.commons.models.IDialog
 import com.stfalcon.chatkit.commons.models.IUser
 import org.sdn.android.sdk.api.session.room.model.RoomSummary
+import org.sdn.android.sdk.api.util.toSDNItem
 
 class RoomSummaryDialogWrapper(val roomSummary: RoomSummary) : IDialog<TimelineEventMessageWrapper> {
 
     override fun getId() = roomSummary.roomId
 
-    override fun getDialogPhoto() = roomSummary.avatarUrl
+    override fun getDialogPhoto() = roomSummary.avatarUrl.ifEmpty { roomSummary.toSDNItem().firstLetterOfDisplayName() }
 
     override fun getDialogName() = roomSummary.displayName
 

app/src/main/java/org/sdn/android/sdk/sample/data/TimelineEventMessageWrapper.kt

@@ -45,4 +45,8 @@ data class TimelineEventMessageWrapper(private val timelineEvent: TimelineEvent)
     override fun getUser() = TimelineEventSenderWrapper(timelineEvent.senderInfo)
 
     override fun getCreatedAt() = Date(timelineEvent.root.originServerTs ?: 0)
+
+    fun getTimelineEvent() : TimelineEvent {
+        return timelineEvent
+    }
 }

app/src/main/java/org/sdn/android/sdk/sample/data/TimelineEventSenderWrapper.kt

@@ -24,5 +24,5 @@ data class TimelineEventSenderWrapper(private val senderInfo: SenderInfo) : IUse
 
     override fun getName() = senderInfo.disambiguatedDisplayName
 
-    override fun getAvatar() = senderInfo.avatarUrl
+    override fun getAvatar() = if (!senderInfo.avatarUrl.isNullOrEmpty()) senderInfo.avatarUrl else "https://static.sending.me/beam/70/${senderInfo.userId}?colors=FC774B,FFB197,B27AFF,DAC2FB,F0E7FD&square=true"
 }

app/src/main/java/org/sdn/android/sdk/sample/ui/RoomDetailFragment.kt

@@ -17,6 +17,7 @@
 package org.sdn.android.sdk.sample.ui
 
 import android.content.Context
+import android.content.DialogInterface
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -41,12 +42,19 @@ import org.sdn.android.sdk.sample.databinding.FragmentRoomDetailBinding
 import org.sdn.android.sdk.sample.utils.*
 
 import org.sdn.android.sdk.api.meet.SdnMeetActivity
-import android.util.Log
-import kotlinx.coroutines.GlobalScope
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.widget.Toast
+import androidx.appcompat.app.AlertDialog
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-//import com.github.zhanghai.android.kotlin.BaseEncoding
 import org.apache.commons.codec.binary.Base32
+import org.sdn.android.sdk.api.session.events.model.toModel
+import org.sdn.android.sdk.api.session.room.model.message.MessageContent
+import org.sdn.android.sdk.sample.R
+import org.sdn.android.sdk.sample.data.TimelineEventMessageWrapper
+import org.sdn.android.sdk.sample.ui.dialog.PasswordDialogFragment
 
 class RoomDetailFragment : Fragment(), Timeline.Listener, ToolbarConfigurable {
 
@@ -112,6 +120,18 @@ class RoomDetailFragment : Fragment(), Timeline.Listener, ToolbarConfigurable {
             }
         })
 
+        adapter.setOnMessageLongClickListener {
+            val event = (it as TimelineEventMessageWrapper).getTimelineEvent()
+             with(AlertDialog.Builder(requireContext())) {
+//                setTitle("Androidly Alert")
+                setMessage("Request decryption key?")
+                setPositiveButton(R.string.ok) { _: DialogInterface, _: Int ->
+                    session.cryptoService().reRequestRoomKeyForEvent(event.root)
+                }
+                setNegativeButton(R.string.cancel, null)
+                show()
+            }
+        }
         views.timelineEventList.setAdapter(adapter)
         views.timelineEventList.itemAnimator = null
         views.timelineEventList.addOnScrollListener(RecyclerScrollMoreListener(views.timelineEventList.layoutManager as LinearLayoutManager) {
@@ -149,11 +169,39 @@ class RoomDetailFragment : Fragment(), Timeline.Listener, ToolbarConfigurable {
             }
         }
 
-        views.toolbarBtnVideo.setOnClickListener {
-            Log.d("getMeeting","start")
-            GlobalScope.launch {
-                joinRoomMeeting(context!!, roomID)
+        setHasOptionsMenu(true)
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+        inflater.inflate(R.menu.room_detail_options, menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        return when (item.itemId) {
+            R.id.invite -> {
+                val dlg = PasswordDialogFragment.newInstance("")
+                dlg.show(childFragmentManager, "")
+                true
             }
+            R.id.meeting -> {
+                room?.roomId?.let {
+                    lifecycleScope.launch {
+                        joinRoomMeeting(requireContext(), it)
+                    }
+                }
+                true
+            }
+            R.id.leave -> {
+                room?.roomId?.let {
+                    lifecycleScope.launch {
+                        session.roomService().leaveRoom(it)
+                        showRoomList()
+                    }
+                }
+                true
+            }
+
+            else -> super.onOptionsItemSelected(item)
         }
     }
 
@@ -215,5 +263,11 @@ class RoomDetailFragment : Fragment(), Timeline.Listener, ToolbarConfigurable {
         }
     }
 
-
+    private fun showRoomList() {
+        (activity as MainActivity).supportFragmentManager
+            .beginTransaction()
+            .addToBackStack(null)
+            .replace(R.id.fragmentContainer, RoomListFragment())
+            .commit()
+    }
 }

app/src/main/java/org/sdn/android/sdk/sample/ui/RoomListFragment.kt

@@ -16,17 +16,16 @@
 
 package org.sdn.android.sdk.sample.ui
 
-import android.content.DialogInterface
-import android.content.res.Resources
+import android.annotation.SuppressLint
 import android.os.Bundle
+import android.os.Environment
 import android.view.*
 import android.widget.Toast
 import androidx.appcompat.app.AlertDialog
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
 import com.stfalcon.chatkit.commons.ImageLoader
 import com.stfalcon.chatkit.dialogs.DialogsListAdapter
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import org.sdn.android.sdk.api.session.room.model.Membership
 import org.sdn.android.sdk.api.session.room.model.RoomSummary
@@ -38,18 +37,47 @@ import org.sdn.android.sdk.sample.SessionHolder
 import org.sdn.android.sdk.sample.data.RoomSummaryDialogWrapper
 import org.sdn.android.sdk.sample.databinding.FragmentRoomListBinding
 import org.sdn.android.sdk.sample.formatter.RoomListDateFormatter
+import org.sdn.android.sdk.sample.ui.dialog.PasswordDialogFragment
 import org.sdn.android.sdk.sample.utils.AvatarRenderer
 import org.sdn.android.sdk.sample.utils.SDNItemColorProvider
+import timber.log.Timber
+import java.io.File
+import java.io.FileOutputStream
 
 class RoomListFragment : Fragment(), ToolbarConfigurable {
 
     private val session = SessionHolder.currentSession!!
+    private val exportListenerKey = "export"
+    private val importListenerKey = "import"
+    private val e2eBackupDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
+    private val e2eBackupFile = "e2e_xx_keys.txt"
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        childFragmentManager.setFragmentResultListener(exportListenerKey, this) { _, bundle ->
+            val password = bundle.getString("password") ?: "default"
+            lifecycleScope.launch {
+                val exportedBytes = session.cryptoService().exportRoomKeys(password)
+                saveFileToExternalStorage(e2eBackupFile, exportedBytes)
+            }
+        }
+
+        childFragmentManager.setFragmentResultListener(importListenerKey, this) { _, bundle ->
+            val password = bundle.getString("password") ?: "default"
+            lifecycleScope.launch {
+                val importedBytes = readFileFromExternalStorage(e2eBackupFile)
+                val result = session.cryptoService().importRoomKeys(importedBytes, password, null)
+                Timber.i("totalNumberOfKeys: ${result.totalNumberOfKeys}, successfullyNumberOfImportedKeys: ${result.successfullyNumberOfImportedKeys}")
+            }
+        }
+    }
 
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
         savedInstanceState: Bundle?,
-    ): View? {
+    ): View {
         _views = FragmentRoomListBinding.inflate(inflater, container, false)
         return views.root
     }
@@ -63,19 +91,24 @@ class RoomListFragment : Fragment(), ToolbarConfigurable {
     }
 
     private val imageLoader = ImageLoader { imageView, url, _ ->
-        avatarRenderer.render(url, imageView)
+        avatarRenderer.renderDrawable(url, imageView)
     }
     private val roomAdapter = DialogsListAdapter<RoomSummaryDialogWrapper>(imageLoader)
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
         configureToolbar(views.toolbar, displayBack = false)
-11
+
         views.createRoomButton.setOnClickListener {
             val userId = views.otherUserIdField.text.toString().trim()
 
             viewLifecycleOwner.lifecycleScope.launch {
-                session.roomService().createDirectRoom(otherUserId = userId)
+//                session.roomService().createDirectRoom(otherUserId = userId)
+                session.roomService().createRoom(CreateRoomParams()
+                    .apply {
+                        invitedUserIds.add(userId)
+                        enableEncryption()
+                    })
             }
         //            GlobalScope.launch {
 //                println("contact-signOut out")
@@ -99,13 +132,13 @@ class RoomListFragment : Fragment(), ToolbarConfigurable {
                 builder.setMessage("Do you want to join this room?")
                 builder.setPositiveButton("Join") { _, _ ->
                     viewLifecycleOwner.lifecycleScope.launch {
-                        session.roomService().joinRoom(it.roomSummary.roomId);
+                        session.roomService().joinRoom(it.roomSummary.roomId)
                         showRoomDetail(it.roomSummary)
                     }
                 }
                 builder.setNegativeButton("Cancel", null)
                 val dialog = builder.create()
-                dialog.setOnShowListener { _ ->
+                dialog.setOnShowListener {
                     dialog.getButton(AlertDialog.BUTTON_POSITIVE).setTextColor(resources.getColor(R.color.dark_gray))
                     dialog.getButton(AlertDialog.BUTTON_NEGATIVE).setTextColor(resources.getColor(R.color.dark_gray))
                 }
@@ -141,6 +174,16 @@ class RoomListFragment : Fragment(), ToolbarConfigurable {
 
     override fun onOptionsItemSelected(item: MenuItem): Boolean {
         return when (item.itemId) {
+            R.id.export_key -> {
+                val dlg = PasswordDialogFragment.newInstance(exportListenerKey)
+                dlg.show(childFragmentManager, "export")
+                true
+            }
+            R.id.import_key -> {
+                val dlg = PasswordDialogFragment.newInstance(importListenerKey)
+                dlg.show(childFragmentManager, "import")
+                true
+            }
             R.id.logout -> {
                 signOut()
                 true
@@ -152,7 +195,7 @@ class RoomListFragment : Fragment(), ToolbarConfigurable {
     private fun signOut() {
         lifecycleScope.launch {
             try {
-                session.signOutService().signOut(true)
+                session.signOutService().signOut(signOutFromHomeserver = true, deleteCrypto = false)
             } catch (failure: Throwable) {
                 activity?.let {
                     Toast.makeText(it, "Failure: $failure", Toast.LENGTH_SHORT).show()
@@ -186,4 +229,20 @@ class RoomListFragment : Fragment(), ToolbarConfigurable {
         }
         roomAdapter.setItems(sortedRoomSummaryList)
     }
+
+    @SuppressLint("SetWorldReadable")
+    private fun saveFileToExternalStorage(fileName: String, data: ByteArray) {
+        val targetFile = File(e2eBackupDir, fileName)
+        targetFile.setReadable(true, false)
+        data.inputStream().use { input ->
+            FileOutputStream(targetFile).use { output ->
+                input.copyTo(output)
+            }
+        }
+    }
+
+    private fun readFileFromExternalStorage(fileName: String): ByteArray {
+        val targetFile = File(e2eBackupDir, fileName)
+        return targetFile.readBytes()
+    }
 }

app/src/main/java/org/sdn/android/sdk/sample/ui/SimpleLoginFragment.kt

@@ -16,6 +16,7 @@
 
 package org.sdn.android.sdk.sample.ui
 
+import android.content.Context.MODE_PRIVATE
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
@@ -106,8 +107,16 @@ class SimpleLoginFragment : Fragment() {
 
             val ecKeyPair: ECKeyPair = ECKeyPair.create(privateKey.decodeHex().toByteArray())
             val authService = SampleApp.getSDNClient(requireContext()).authenticationService()
+            val sp = requireContext().getSharedPreferences("device_data", MODE_PRIVATE)
+            var deviceIdKey = "device_id_$address"
+            var deviceId = ""
             try {
-                val loginDidMsg = authService.didPreLogin(edgeNodeConnectionConfig, address)
+                val fedInfo = authService.getFedInfo(edgeNodeConnectionConfig)
+                edgeNodeConnectionConfig.peerId = fedInfo.peer
+                deviceIdKey = "device_id_${fedInfo.peer}_$address"
+                deviceId = sp.getString(deviceIdKey, "") ?: ""
+
+                val loginDidMsg = authService.didPreLogin(edgeNodeConnectionConfig, address, deviceId)
                 if (loginDidMsg.message is String) {
                     Log.d("loginLoginDidMsg", loginDidMsg.message)
                 }
@@ -127,6 +136,11 @@ class SimpleLoginFragment : Fragment() {
                 Toast.makeText(requireContext(), "Failure: $failure", Toast.LENGTH_SHORT).show()
                 null
             }?.let {
+                val retDeviceId = it.sessionParams.deviceId
+                if (retDeviceId != deviceId) {
+                    Timber.tag("login").i("get new device id: $retDeviceId")
+                    sp.edit().putString(deviceIdKey, retDeviceId).apply()
+                }
                 SessionHolder.currentSession = it
                 it.open()
                 it.syncService().startSync(true)