Adds liking videos and mostly functional profile page

app/src/main/java/nl/tudelft/trustchain/app/TrustChainApplication.kt

@@ -450,10 +450,15 @@ class TrustChainApplication : Application() {
     }
 
     private fun createDeToksCommunity(): OverlayConfiguration<DeToksCommunity> {
-        val randomWalk = RandomWalk.Factory()
+        val settings = TrustChainSettings()
+        val driver = AndroidSqliteDriver(Database.Schema, this, "trustchain.db")
+        val store = TrustChainSQLiteStore(Database(driver))
         return OverlayConfiguration(
-            DeToksCommunity.Factory(this),
-            listOf(randomWalk)
+            DeToksCommunity.Factory(this, settings, store),
+            listOf(
+                RandomWalk.Factory(),
+                NetworkServiceDiscovery.Factory(getSystemService()!!)
+            )
         )
     }
 

detoks/src/main/AndroidManifest.xml

@@ -5,8 +5,10 @@
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+        android:maxSdkVersion="32"/>
+    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
 
     <application>
         <activity

detoks/src/main/java/nl/tudelft/trustchain/detoks/DeToksCommunity.kt

@@ -1,22 +1,50 @@
 package nl.tudelft.trustchain.detoks
 
 import android.content.Context
+import android.os.Build
 import android.util.Log
-import nl.tudelft.ipv8.Community
+import androidx.annotation.RequiresApi
+import nl.tudelft.ipv8.IPv4Address
 import nl.tudelft.ipv8.Overlay
 import nl.tudelft.ipv8.Peer
+import nl.tudelft.ipv8.attestation.trustchain.*
+import nl.tudelft.ipv8.attestation.trustchain.store.TrustChainStore
 import nl.tudelft.ipv8.messaging.Packet
+import nl.tudelft.ipv8.messaging.payload.IntroductionResponsePayload
+import java.util.*
 
+const val LIKE_BLOCK: String = "like_block"
 
-class DeToksCommunity(private val context: Context) : Community() {
+class DeToksCommunity(
+    private val context: Context, settings: TrustChainSettings,
+    database: TrustChainStore,
+    crawler: TrustChainCrawler = TrustChainCrawler()
+) : TrustChainCommunity(settings, database, crawler) {
 
     private val walletManager = WalletManager(context)
     private val visitedPeers  = mutableListOf<Peer>()
 
     init {
         messageHandlers[MESSAGE_TORRENT_ID] = ::onGossip
         messageHandlers[MESSAGE_TRANSACTION_ID] = ::onTransactionMessage
+        registerBlockSigner(LIKE_BLOCK, object : BlockSigner {
+            override fun onSignatureRequest(block: TrustChainBlock) {
+                if(userLikedVideo(block.transaction["video"] as String,block.transaction["torrent"] as String, block.transaction["liker"] as String)) return
+                createAgreementBlock(block, block.transaction)
+            }
+        })
+        addListener(LIKE_BLOCK, object : BlockListener {
+            @RequiresApi(Build.VERSION_CODES.O)
+            override fun onBlockReceived(block: TrustChainBlock) {
+                Log.d("Detoks", "onBlockReceived: ${block.blockId} ${block.transaction}")
+                val video = block.transaction.get("video") as String
+                val torrent = block.transaction.get("torrent") as String
+                val magnet = block.transaction.get("torrentMagnet") as String
+                Log.d("Detoks", "Received like for $video, $torrent")
+                if (firstInstance(video, torrent)) TorrentManager.getInstance(context).addMagnet(magnet)
 
+            }
+        })
     }
 
     companion object {
@@ -26,7 +54,8 @@ class DeToksCommunity(private val context: Context) : Community() {
     }
 
     override val serviceId = "c86a7db45eb3563ae047639817baec4db2bc7c25"
-
+    val discoveredAddressesContacted: MutableMap<IPv4Address, Date> = mutableMapOf()
+    val lastTrackerResponses = mutableMapOf<IPv4Address, Date>()
 
     fun sendTokens(amount: Int, recipientMid: String) {
         val senderWallet = walletManager.getOrCreateWallet(myPeer.mid)
@@ -99,11 +128,83 @@ class DeToksCommunity(private val context: Context) : Community() {
         }
     }
 
+    override fun onIntroductionResponse(peer: Peer, payload: IntroductionResponsePayload) {
+        super.onIntroductionResponse(peer, payload)
+
+        if (peer.address in DEFAULT_ADDRESSES) {
+            lastTrackerResponses[peer.address] = Date()
+        }
+    }
+
+    fun broadcastLike(vid: String, torrent: String, creator: String, magnet: String) {
+        if(userLikedVideo(vid,torrent,myPeer.publicKey.toString())) return
+        Log.d("DeToks", "Liking: $vid")
+        val timestamp = System.currentTimeMillis().toString()
+        val like = Like(myPeer.publicKey.toString(), vid, torrent, creator,timestamp, magnet)
+        createProposalBlock(LIKE_BLOCK, like.toMap(), myPeer.publicKey.keyToBin())
+        Log.d("DeToks", "$like")
+    }
+
+    fun getLikes(vid: String, torrent: String): List<TrustChainBlock> {
+        return database.getBlocksWithType(LIKE_BLOCK).filter {
+            it.transaction["video"] == vid && it.transaction["torrent"] == torrent
+        }
+    }
+
+    fun getBlocksByAuthor(author: String): List<TrustChainBlock> {
+        val authorsBlocks =  database.getBlocksWithType(LIKE_BLOCK).filter {
+            it.transaction["author"] == author
+        }
+        if(authorsBlocks.isEmpty()) return authorsBlocks
+        return authorsBlocks.sortedWith(compareByDescending{(it.transaction["timestamp"] as String).toLong()})
+    }
+    fun getEarliestDate(vid: String, torrent: String):Long {
+        if(firstInstance(vid,torrent)) return Long.MAX_VALUE
+        return (getLikes(vid,torrent).sortedBy{(it.transaction["timestamp"] as String).toLong()}.get(0).transaction["timestamp"] as String).toLong()
+    }
+
+    fun userLikedVideo(vid: String, torrent: String, liker: String): Boolean {
+        return getLikes(vid, torrent).any { it.transaction["liker"] == liker }
+    }
+    fun firstInstance(vid: String, torrent: String): Boolean {
+        val exists = database.getBlocksWithType(LIKE_BLOCK).filter { it.transaction["video"] == vid && it.transaction["torrent"] == torrent }.size
+        if(exists == 0) return true
+        return false
+    }
+
+    fun getPostedVideos(author: String): List<Pair<String, Int>> {
+        // Create Key data class so we can group by two fields (torrent and video)
+        data class Key(val video: String, val torrent: String)
+        fun TrustChainBlock.toKey() = Key(transaction["video"] as String, transaction["torrent"] as String)
+            val likes = getBlocksByAuthor(author).groupBy { it.toKey() }
+        // no need to sort here as getblocksbyauthor already sorts
+        return likes.entries.map {
+            Pair(it.key.video, it.value.size)
+        }
+    }
+
+    fun listOfLikedVideosAndTorrents(person: String): List<Pair<String,String>> {
+        var iterato = database.getBlocksWithType(LIKE_BLOCK).filter {
+            it.transaction["liker"] == person
+        }
+        if(iterato.isEmpty()) return emptyList()
+        var iterator= iterato.sortedWith(compareByDescending{(it.transaction["timestamp"] as String).toLong()}).listIterator()
+        var likedVideos = ArrayList<Pair<String,String>>()
+        while(iterator.hasNext()) {
+            val block = iterator.next()
+            likedVideos.add(Pair(block.transaction.get("video") as String, block.transaction.get("torrentMagnet") as String))
+        }
+        return likedVideos;
+    }
+
     class Factory(
-        private val context: Context
+        private val context: Context,
+        private val settings: TrustChainSettings,
+        private val database: TrustChainStore,
+        private val crawler: TrustChainCrawler = TrustChainCrawler()
     ) : Overlay.Factory<DeToksCommunity>(DeToksCommunity::class.java) {
         override fun create(): DeToksCommunity {
-            return DeToksCommunity(context)
+            return DeToksCommunity(context, settings, database, crawler)
         }
     }
 }

detoks/src/main/java/nl/tudelft/trustchain/detoks/DeToksMainActivity.kt

@@ -5,8 +5,16 @@ import android.content.Context
 import android.content.Intent
 import android.content.ServiceConnection
 import android.os.Bundle
+import androidx.preference.PreferenceManager
+import nl.tudelft.ipv8.android.IPv8Android
+import nl.tudelft.ipv8.android.keyvault.AndroidCryptoProvider
 import android.os.IBinder
+import android.util.Log
 import nl.tudelft.trustchain.common.BaseActivity
+import nl.tudelft.ipv8.keyvault.PrivateKey
+import nl.tudelft.ipv8.keyvault.defaultCryptoProvider
+import nl.tudelft.ipv8.util.hexToBytes
+import nl.tudelft.ipv8.util.toHex
 
 class DeToksActivity : BaseActivity() {
     override val navigationGraph = R.navigation.nav_graph_detoks
@@ -15,12 +23,19 @@ class DeToksActivity : BaseActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         val actionBar = supportActionBar
+        defaultCryptoProvider = AndroidCryptoProvider
         actionBar!!.hide()
 
         Intent(this, GossiperService::class.java).also { intent ->
             startService(intent)
             bindService(intent, gossipConnection, Context.BIND_AUTO_CREATE)
         }
+
+        val community = IPv8Android.getInstance().getOverlay<DeToksCommunity>()!!
+        val peers = community.getPeers()
+        for (peer in peers) {
+            Log.d("DeToks", peer.mid)
+        }
     }
 
     private val gossipConnection = object : ServiceConnection {

detoks/src/main/java/nl/tudelft/trustchain/detoks/Like.kt

@@ -0,0 +1,53 @@
+package nl.tudelft.trustchain.detoks
+
+import nl.tudelft.ipv8.messaging.*
+
+class Like(val liker: String, val video: String, val torrent: String, val author: String, val timestamp: String, val torrentMagnet: String) : Serializable {
+    fun toMap(): Map<String, String> {
+        return mapOf(
+            "liker" to liker,
+            "video" to video,
+            "torrent" to torrent,
+            "author" to author,
+            "timestamp" to timestamp,
+            "torrentMagnet" to torrentMagnet
+        )
+    }
+    override fun serialize(): ByteArray {
+        return serializeVarLen(liker.toByteArray(Charsets.UTF_8)) +
+            serializeVarLen(video.toByteArray(Charsets.UTF_8)) +
+            serializeVarLen(torrent.toByteArray(Charsets.UTF_8)) +
+            serializeVarLen(author.toByteArray(Charsets.UTF_8)) +
+            serializeVarLen(timestamp.toByteArray(Charsets.UTF_8)) +
+            serializeVarLen(torrentMagnet.toByteArray(Charsets.UTF_8))
+    }
+
+    companion object Deserializer : Deserializable<Like> {
+        override fun deserialize(buffer: ByteArray, offset: Int): Pair<Like, Int> {
+            var localOffset = 0
+            val (liker, likerSize) = deserializeVarLen(buffer, offset + localOffset)
+            localOffset += likerSize
+            val (video, videoSize) = deserializeVarLen(buffer, offset + localOffset)
+            localOffset += videoSize
+            val (torrent, torrentSize) = deserializeVarLen(buffer, offset + localOffset)
+            localOffset += torrentSize
+            val (creator_name, cretorSize) = deserializeVarLen(buffer, offset + localOffset)
+            localOffset += cretorSize
+            val (timestamp, timestampSize) = deserializeVarLen(buffer, offset + localOffset)
+            localOffset += timestampSize
+            val (torrentMagnet, torrentMagnetSize) = deserializeVarLen(buffer, offset + localOffset)
+            localOffset += torrentMagnetSize
+            return Pair(
+                Like(
+                    liker.toString(Charsets.UTF_8),
+                    video.toString(Charsets.UTF_8),
+                    torrent.toString(Charsets.UTF_8),
+                    creator_name.toString(Charsets.UTF_8),
+                    timestamp.toString(Charsets.UTF_8),
+                    torrentMagnet.toString(Charsets.UTF_8)
+                ),
+                localOffset
+            )
+        }
+    }
+}