Merge branch 'master' of https://github.com/loki-project/loki-messenger-android

src/org/thoughtcrime/securesms/database/helpers/SQLCipherOpenHelper.java

@@ -113,7 +113,9 @@ public class SQLCipherOpenHelper extends SQLiteOpenHelper {
     for (String sql : JobDatabase.CREATE_TABLE) {
       db.execSQL(sql);
     }
-    db.execSQL(LokiAPIDatabase.getCreateTableCommand());
+    db.execSQL(LokiAPIDatabase.getCreateSwarmCacheTableCommand());
+    db.execSQL(LokiAPIDatabase.getCreateLastMessageHashValueTableCommand());
+    db.execSQL(LokiAPIDatabase.getCreateReceivedMessageHashValuesTableCommand());
 
     executeStatements(db, SmsDatabase.CREATE_INDEXS);
     executeStatements(db, MmsDatabase.CREATE_INDEXS);

src/org/thoughtcrime/securesms/dependencies/SignalCommunicationModule.java

@@ -46,13 +46,13 @@ import org.thoughtcrime.securesms.push.SecurityEventListener;
 import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess;
 import org.thoughtcrime.securesms.service.IncomingMessageObserver;
 import org.thoughtcrime.securesms.service.WebRtcCallService;
+import org.thoughtcrime.securesms.util.RealtimeSleepTimer;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 import org.whispersystems.libsignal.util.guava.Optional;
 import org.whispersystems.signalservice.api.SignalServiceAccountManager;
 import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
 import org.whispersystems.signalservice.api.SignalServiceMessageSender;
 import org.whispersystems.signalservice.api.util.CredentialsProvider;
-import org.whispersystems.signalservice.api.util.RealtimeSleepTimer;
 import org.whispersystems.signalservice.api.util.SleepTimer;
 import org.whispersystems.signalservice.api.util.UptimeSleepTimer;
 import org.whispersystems.signalservice.api.websocket.ConnectivityListener;

src/org/thoughtcrime/securesms/jobs/AttachmentUploadJob.java

@@ -85,7 +85,7 @@ public class AttachmentUploadJob extends BaseJob implements InjectableType {
     MediaConstraints               mediaConstraints = MediaConstraints.getPushMediaConstraints();
     Attachment                     scaledAttachment = scaleAndStripExif(database, mediaConstraints, databaseAttachment);
     SignalServiceAttachment        localAttachment  = getAttachmentFor(scaledAttachment);
-    SignalServiceAttachmentPointer remoteAttachment = messageSender.uploadAttachment(localAttachment.asStream());
+    SignalServiceAttachmentPointer remoteAttachment = messageSender.uploadAttachment(localAttachment.asStream(), false);
     Attachment                     attachment       = PointerAttachment.forPointer(Optional.of(remoteAttachment)).get();
 
     database.updateAttachmentAfterUpload(databaseAttachment.getAttachmentId(), attachment);

src/org/thoughtcrime/securesms/jobs/PushDecryptJob.java

@@ -106,7 +106,7 @@ import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage
 import org.whispersystems.signalservice.api.messages.shared.SharedContact;
 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
 import org.whispersystems.signalservice.loki.crypto.LokiServiceCipher;
-import org.whispersystems.signalservice.loki.messages.LokiServiceMessage;
+import org.whispersystems.signalservice.loki.messaging.LokiServiceMessage;
 
 import java.security.MessageDigest;
 import java.util.ArrayList;

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

@@ -1,44 +1,98 @@
 package org.thoughtcrime.securesms.loki
 
+import android.content.ContentValues
 import android.content.Context
+import android.database.Cursor
 import org.thoughtcrime.securesms.database.Database
 import org.thoughtcrime.securesms.database.helpers.SQLCipherOpenHelper
 import org.whispersystems.signalservice.loki.api.LokiAPIDatabaseProtocol
 import org.whispersystems.signalservice.loki.api.LokiAPITarget
 
-class LokiAPIDatabase(context: Context, helper: SQLCipherOpenHelper) : Database(context, helper), LokiAPIDatabaseProtocol {
+class LokiAPIDatabase(private val userPublicKey: String, context: Context, helper: SQLCipherOpenHelper) : Database(context, helper), LokiAPIDatabaseProtocol {
 
     companion object {
-        private val tableKey = "loki_api_database"
-        private val swarmCacheKey = "swarm_cache"
-        private val lastMessageHashValueKey = "last_message_hash_value"
-        private val receivedMessageHashValuesKey = "received_message_hash_values"
-
-        @JvmStatic
-        val createTableCommand = "CREATE TABLE $tableKey ($swarmCacheKey TEXT, $lastMessageHashValueKey TEXT, $receivedMessageHashValuesKey TEXT);"
+        // Swarm cache
+        private val swarmCache = "loki_api_swarm_cache"
+        private val hexEncodedPublicKey = "hex_encoded_public_key"
+        private val swarm = "swarm"
+        @JvmStatic val createSwarmCacheTableCommand = "CREATE TABLE $swarmCache ($hexEncodedPublicKey TEXT, $swarm TEXT);"
+        // Last message hash value cache
+        private val lastMessageHashValueCache = "loki_api_last_message_hash_value_cache"
+        private val target = "target"
+        private val lastMessageHashValue = "last_message_hash_value"
+        @JvmStatic val createLastMessageHashValueTableCommand = "CREATE TABLE $lastMessageHashValueCache ($target TEXT, $lastMessageHashValue TEXT);"
+        // Received message hash values cache
+        private val receivedMessageHashValuesCache = "loki_api_received_message_hash_values_cache"
+        private val userID = "user_id"
+        private val receivedMessageHashValues = "received_message_hash_values"
+        @JvmStatic val createReceivedMessageHashValuesTableCommand = "CREATE TABLE $receivedMessageHashValuesCache ($userID TEXT, $receivedMessageHashValues TEXT);"
     }
 
-    override fun getSwarmCache(): Map<String, List<LokiAPITarget>>? {
-        return null
+    override fun getSwarmCache(hexEncodedPublicKey: String): List<LokiAPITarget>? {
+        return get(swarmCache, "${Companion.hexEncodedPublicKey} = ?", wrap(hexEncodedPublicKey)) { cursor ->
+            val swarmAsString = cursor.getString(cursor.getColumnIndexOrThrow(swarm))
+            swarmAsString.split(",").map { targetAsString ->
+                val components = targetAsString.split("?port=")
+                LokiAPITarget(components[0], components[1].toInt())
+            }
+        }
     }
 
-    override fun setSwarmCache(newValue: Map<String, List<LokiAPITarget>>) {
-        // TODO: Implement
+    override fun setSwarmCache(hexEncodedPublicKey: String, newValue: List<LokiAPITarget>) {
+        val database = databaseHelper.writableDatabase
+        val swarmAsString = newValue.joinToString(",") { target ->
+            "${target.address}?port=${target.port}"
+        }
+        database.update(swarmCache, wrap(mapOf( swarm to swarmAsString )), "${Companion.hexEncodedPublicKey} = ?", wrap(hexEncodedPublicKey))
     }
 
     override fun getLastMessageHashValue(target: LokiAPITarget): String? {
-        return null
+        return get(lastMessageHashValueCache, "${Companion.target} = ?", wrap(target.address)) { cursor ->
+            cursor.getString(cursor.getColumnIndexOrThrow(lastMessageHashValue))
+        }
     }
 
     override fun setLastMessageHashValue(target: LokiAPITarget, newValue: String) {
-        // TODO: Implement
+        val database = databaseHelper.writableDatabase
+        database.update(lastMessageHashValueCache, wrap(mapOf( lastMessageHashValue to newValue )), "${Companion.target} = ?", wrap(target.address))
     }
 
     override fun getReceivedMessageHashValues(): Set<String>? {
-        return null
+        return get(receivedMessageHashValuesCache, "$userID = ?", wrap(userPublicKey)) { cursor ->
+            val receivedMessageHashValuesAsString = cursor.getString(cursor.getColumnIndexOrThrow(receivedMessageHashValues))
+            receivedMessageHashValuesAsString.split(",").toSet()
+        }
     }
 
     override fun setReceivedMessageHashValues(newValue: Set<String>) {
-        // TODO: Implement
+        val database = databaseHelper.writableDatabase
+        val receivedMessageHashValuesAsString = newValue.joinToString(",")
+        database.update(receivedMessageHashValuesCache, wrap(mapOf( receivedMessageHashValues to receivedMessageHashValuesAsString )), "$userID = ?", wrap(userPublicKey))
     }
-}
+
+    // region Convenience
+    private fun <T> get(table: String, query: String, arguments: Array<String>, get: (Cursor) -> T): T? {
+        val database = databaseHelper.readableDatabase
+        var cursor: Cursor? = null
+        try {
+            cursor = database.query(table, null, query, arguments, null, null, null)
+            if (cursor != null && cursor.moveToFirst()) { return get(cursor) }
+        } catch (e: Exception) {
+            // Do nothing
+        } finally {
+            cursor?.close()
+        }
+        return null
+    }
+}
+
+private inline fun <reified T> wrap(x: T): Array<T> {
+    return Array(1) { x }
+}
+
+private fun wrap(x: Map<String, String>): ContentValues {
+    val result = ContentValues(x.size)
+    x.forEach { result.put(it.key, it.value) }
+    return result
+}
+// endregion

src/org/thoughtcrime/securesms/mms/AttachmentStreamLocalUriFetcher.java

@@ -37,7 +37,7 @@ class AttachmentStreamLocalUriFetcher implements DataFetcher<InputStream> {
   public void loadData(Priority priority, DataCallback<? super InputStream> callback) {
     try {
       if (!digest.isPresent()) throw new InvalidMessageException("No attachment digest!");
-      is = AttachmentCipherInputStream.createFor(attachment, plaintextLength, key, digest.get());
+      is = AttachmentCipherInputStream.createForAttachment(attachment, plaintextLength, key, digest.get());
       callback.onDataReady(is);
     } catch (IOException | InvalidMessageException e) {
       callback.onLoadFailed(e);

src/org/thoughtcrime/securesms/util/RealtimeSleepTimer.java

@@ -0,0 +1,89 @@
+package org.thoughtcrime.securesms.util;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Build;
+import android.os.SystemClock;
+import android.util.Log;
+
+import org.whispersystems.signalservice.api.util.SleepTimer;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A sleep timer that is based on elapsed realtime, so
+ * that it works properly, even in low-power sleep modes.
+ *
+ */
+public class RealtimeSleepTimer implements SleepTimer {
+    private static final String TAG = RealtimeSleepTimer.class.getSimpleName();
+
+    private final AlarmReceiver alarmReceiver;
+    private final Context context;
+
+    public RealtimeSleepTimer(Context context) {
+        this.context = context;
+        alarmReceiver = new RealtimeSleepTimer.AlarmReceiver();
+    }
+
+    @Override
+    public void sleep(long millis) {
+        context.registerReceiver(alarmReceiver,
+                new IntentFilter(AlarmReceiver.WAKE_UP_THREAD_ACTION));
+
+        final long startTime = System.currentTimeMillis();
+        alarmReceiver.setAlarm(millis);
+
+        while (System.currentTimeMillis() - startTime < millis) {
+            try {
+                synchronized (this) {
+                    wait(millis - System.currentTimeMillis() + startTime);
+                }
+            } catch (InterruptedException e) {
+                Log.w(TAG, e);
+            }
+        }
+
+        context.unregisterReceiver(alarmReceiver);
+    }
+
+    private class AlarmReceiver extends BroadcastReceiver {
+        private static final String WAKE_UP_THREAD_ACTION = "org.whispersystems.signalservice.api.util.RealtimeSleepTimer.AlarmReceiver.WAKE_UP_THREAD";
+
+        private void setAlarm(long millis) {
+            final Intent        intent        = new Intent(WAKE_UP_THREAD_ACTION);
+            final PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
+            final AlarmManager  alarmManager  = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
+
+            Log.w(TAG, "Setting alarm to wake up in " + millis + "ms.");
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                alarmManager.setExactAndAllowWhileIdle(AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                        SystemClock.elapsedRealtime() + millis,
+                        pendingIntent);
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+                alarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                        SystemClock.elapsedRealtime() + millis,
+                        pendingIntent);
+            } else {
+                alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                        SystemClock.elapsedRealtime() + millis,
+                        pendingIntent);
+            }
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            Log.w(TAG, "Waking up.");
+
+            synchronized (RealtimeSleepTimer.this) {
+                RealtimeSleepTimer.this.notifyAll();
+            }
+        }
+    }
+}
+