Handle unpair request flag.

src/org/thoughtcrime/securesms/loki/LinkedDevicesActivity.kt

@@ -8,6 +8,7 @@ import org.thoughtcrime.securesms.*
 import org.thoughtcrime.securesms.util.DynamicTheme
 import org.thoughtcrime.securesms.util.DynamicLanguage
 import network.loki.messenger.R
+import nl.komponents.kovenant.then
 import org.thoughtcrime.securesms.database.DatabaseFactory
 import org.thoughtcrime.securesms.sms.MessageSender
 import org.thoughtcrime.securesms.util.TextSecurePreferences
@@ -44,9 +45,10 @@ class LinkedDevicesActivity : PassphraseRequiredActionBarActivity(), DeviceLinki
       val database = DatabaseFactory.getLokiAPIDatabase(this)
       database.removePairingAuthorisation(ourPublicKey, devicePublicKey)
       // Update mapping on the file server
-      LokiStorageAPI.shared.updateUserDeviceMappings()
-      // Send a background message to let the device know that it has been revoked
-      MessageSender.sendBackgroundMessage(this, devicePublicKey)
+      LokiStorageAPI.shared.updateUserDeviceMappings().success {
+        // Send an unpair request to let the device know that it has been revoked
+        MessageSender.sendUnpairRequest(this, devicePublicKey)
+      }
       // Refresh the list
       this.deviceListFragment.refresh()
       Toast.makeText(this, R.string.DeviceListActivity_unlinked_device, Toast.LENGTH_LONG).show()

src/org/thoughtcrime/securesms/loki/MultiDeviceUtilities.kt

@@ -6,6 +6,7 @@ import nl.komponents.kovenant.Promise
 import nl.komponents.kovenant.all
 import nl.komponents.kovenant.functional.bind
 import nl.komponents.kovenant.functional.map
+import nl.komponents.kovenant.then
 import nl.komponents.kovenant.toFailVoid
 import org.thoughtcrime.securesms.ApplicationContext
 import org.thoughtcrime.securesms.crypto.IdentityKeyUtil
@@ -27,6 +28,23 @@ import org.whispersystems.signalservice.loki.utilities.retryIfNeeded
 import java.util.*
 import kotlin.concurrent.schedule
 
+fun checkForRevocation(context: Context) {
+  val primaryDevice = TextSecurePreferences.getMasterHexEncodedPublicKey(context) ?: return
+  val ourDevice = TextSecurePreferences.getLocalNumber(context)
+
+  LokiStorageAPI.shared.fetchDeviceMappings(primaryDevice).bind { mappings ->
+    val ourMapping = mappings.find { it.secondaryDevicePublicKey == ourDevice }
+    if (ourMapping != null) throw Error("Device has not been revoked")
+    // remove pairing auths for our device
+    DatabaseFactory.getLokiAPIDatabase(context).removePairingAuthorisations(ourDevice)
+    LokiStorageAPI.shared.updateUserDeviceMappings()
+  }.success {
+    // TODO: Revoke here
+  }.fail { error ->
+    Log.d("Loki", "Revocation check failed: $error")
+  }
+}
+
 fun getAllDeviceFriendRequestStatuses(context: Context, hexEncodedPublicKey: String): Promise<Map<String, LokiThreadFriendRequestStatus>, Exception> {
   val lokiThreadDatabase = DatabaseFactory.getLokiThreadDatabase(context)
   return LokiStorageAPI.shared.getAllDevicePublicKeys(hexEncodedPublicKey).map { keys ->

src/org/thoughtcrime/securesms/loki/PushBackgroundMessageSendJob.kt

@@ -11,39 +11,58 @@ import org.whispersystems.libsignal.util.guava.Optional
 import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair
 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage
 import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.util.JsonUtil
 import java.io.IOException
 import java.util.concurrent.TimeUnit
 
+data class BackgroundMessage private constructor(val recipient: String, val body: String?, val friendRequest: Boolean, val unpairingRequest: Boolean) {
+  companion object {
+    @JvmStatic
+    fun create(recipient: String) = BackgroundMessage(recipient, null, false, false)
+    @JvmStatic
+    fun createFriendRequest(recipient: String, messageBody: String) = BackgroundMessage(recipient, messageBody, true, false)
+    @JvmStatic
+    fun createUnpairingRequest(recipient: String) = BackgroundMessage(recipient, null, false, true)
+            
+    internal fun parse(serialized: String): BackgroundMessage {
+      val node = JsonUtil.fromJson(serialized)
+      val recipient = node.get("recipient").asText()
+      val body = if (node.hasNonNull("body")) node.get("body").asText() else null
+      val friendRequest = node.get("friendRequest").asBoolean(false)
+      val unpairingRequest = node.get("unpairingRequest").asBoolean(false)
+      return BackgroundMessage(recipient, body, friendRequest, unpairingRequest)
+    }
+  }
+
+  fun serialize(): String {
+    val map = mapOf("recipient" to recipient, "body" to body, "friendRequest" to friendRequest, "unpairingRequest" to unpairingRequest)
+    return JsonUtil.toJson(map)
+  }
+}
+
 class PushBackgroundMessageSendJob private constructor(
     parameters: Parameters,
-    private val recipient: String,
-    private val messageBody: String?,
-    private val friendRequest: Boolean
+    private val message: BackgroundMessage
 ) : BaseJob(parameters) {
   companion object {
     const val KEY = "PushBackgroundMessageSendJob"
 
     private val TAG = PushBackgroundMessageSendJob::class.java.simpleName
 
-    private val KEY_RECIPIENT = "recipient"
-    private val KEY_MESSAGE_BODY = "message_body"
-    private val KEY_FRIEND_REQUEST = "asFriendRequest"
+    private val KEY_MESSAGE = "message"
   }
 
-  constructor(recipient: String): this(recipient, null, false)
-  constructor(recipient: String, messageBody: String?, friendRequest: Boolean) : this(Parameters.Builder()
+  constructor(message: BackgroundMessage) : this(Parameters.Builder()
           .addConstraint(NetworkConstraint.KEY)
           .setQueue(KEY)
           .setLifespan(TimeUnit.DAYS.toMillis(1))
           .setMaxAttempts(1)
           .build(),
-          recipient, messageBody, friendRequest)
+          message)
 
   override fun serialize(): Data {
     return Data.Builder()
-            .putString(KEY_RECIPIENT, recipient)
-            .putString(KEY_MESSAGE_BODY, messageBody)
-            .putBoolean(KEY_FRIEND_REQUEST, friendRequest)
+            .putString(KEY_MESSAGE, message.serialize())
             .build()
   }
 
@@ -52,22 +71,24 @@ class PushBackgroundMessageSendJob private constructor(
   }
 
   public override fun onRun() {
-    val message = SignalServiceDataMessage.newBuilder()
+    val dataMessage = SignalServiceDataMessage.newBuilder()
             .withTimestamp(System.currentTimeMillis())
-            .withBody(messageBody)
+            .withBody(message.body)
 
-    if (friendRequest) {
-      val bundle = DatabaseFactory.getLokiPreKeyBundleDatabase(context).generatePreKeyBundle(recipient)
-      message.withPreKeyBundle(bundle)
+    if (message.friendRequest) {
+      val bundle = DatabaseFactory.getLokiPreKeyBundleDatabase(context).generatePreKeyBundle(message.recipient)
+      dataMessage.withPreKeyBundle(bundle)
               .asFriendRequest(true)
+    } else if (message.unpairingRequest) {
+      dataMessage.asUnpairingRequest(true)
     }
 
     val messageSender = ApplicationContext.getInstance(context).communicationModule.provideSignalMessageSender()
-    val address = SignalServiceAddress(recipient)
+    val address = SignalServiceAddress(message.recipient)
     try {
-      messageSender.sendMessage(-1, address, Optional.absent<UnidentifiedAccessPair>(), message.build()) // The message ID doesn't matter
+      messageSender.sendMessage(-1, address, Optional.absent<UnidentifiedAccessPair>(), dataMessage.build()) // The message ID doesn't matter
     } catch (e: Exception) {
-      Log.d("Loki", "Failed to send background message to: $recipient.")
+      Log.d("Loki", "Failed to send background message to: ${message.recipient}.")
       throw e
     }
   }
@@ -82,10 +103,8 @@ class PushBackgroundMessageSendJob private constructor(
   class Factory : Job.Factory<PushBackgroundMessageSendJob> {
     override fun create(parameters: Parameters, data: Data): PushBackgroundMessageSendJob {
       try {
-        val recipient = data.getString(KEY_RECIPIENT)
-        val messageBody = if (data.hasString(KEY_MESSAGE_BODY)) data.getString(KEY_MESSAGE_BODY) else null
-        val friendRequest = data.getBooleanOrDefault(KEY_FRIEND_REQUEST, false)
-        return PushBackgroundMessageSendJob(parameters, recipient, messageBody, friendRequest)
+        val messageJSON = data.getString(KEY_MESSAGE)
+        return PushBackgroundMessageSendJob(parameters, BackgroundMessage.parse(messageJSON))
       } catch (e: IOException) {
         throw AssertionError(e)
       }