Assets refactoring with public logs (#2047)

* Add basic assets storage test.

* Add few tests to AssetMetadataService.

* refactor: assets. Add audio metadata extraction.

* Add tests for RawAssetStorage.

* feat: Add Glide with stub data fetcher and basic transformations

* Add asset preview service and refactor asset detail service.

* feature assets: small improvements according to changed models

* feature: assets. renaming basic assets models.

* Fix compilation issues with the new assets engine

* Fix issues post rebasing;
Adapt data fetchers to new assets engine.

* Use new public asset ids and glide

* Fix set profile picture

* Increase Blur intensity

* Adapt video message part for new assets

* add asset policies

* Show video preview when downloading

* Add storage permissions when recording audio, we need it for the cache

* fix image compression. fix instrumentation tests.

* fix: Share assets with the new flow

* Use media recorder to record audio messages directly in mp4

* change ui to handle new assets upload cancellation flow.

* Add load file to the action button actions

* Correctly open the files externally

* Remove unused import

* Remove glide/okhttp integration since it was causing crashes

* remove public asset id and use user data picture instead.

* Bump SE

* stylish fixes.

* fix: Audio recorder on swipe should stop and send immediately

* Fix inconsistent class filename

* fix rebasing issues.

* Use new build numbers

* remove commented code

* fix WebLinkPartView.

* Fix audio recorder exception.

* Initial fixes after merging.

* Fix few errors.

* Fix more merge errors, add LogShow instances

* point to SE build

* Fix merge conflicts.

* Fix user profiles images loading in conversations list.

* Bump SE.

* In the middle of fixing collection view in conversation.

* Fixing collection view in conversation.

* Fix account picture in the settings screen.

* Refactor Glide usage.

* Fix asset file name while sharing.

* Fix asset file upload cancellation.

* Add basic helper classes for audio records.

* Enable audio filters again.

* Add AudioRecordingScreen. Add AudioService docs.

* Squash me.

* Squash me.

* Squash me.

* Squash me.

* Comment old tests. Fix LinearInterpolation.

* Fix WaveBinView. Reduce read buffer size for PCM recording.

* Fix WaveBinView audio level normalization.

* Squash me.

* Add pcm to mp4 conversion.

* fix: Recreating the old view of audio filters (#2148)

* Add audio recording sending.

* fix: Hide the wave view, the time label, and stop playing the sound if the user cancels it (#2151)

* Add permissions request on audio message button long press.

* Fix/audio recorder dispose (#2156)

* Fix wrong thread exceptions

* Stop recording when screen dismissed

* Prepare target file immediately before sending (#2158)

* Use API safe method (#2159)

* fix: Playing a sent audio message while recording one will freeze the record screen

* Bump SE version.

* Unwrap uri for glide (#2161)

* fix:image orientation (#2163)

* Correct image orientation

* Don't attempt to recode a non existent file (#2171)

* Bump SE

Author: CalumMcCall

LICENSE

@@ -671,4 +671,4 @@ into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

app/build.gradle

@@ -1,5 +1,6 @@
 apply plugin: 'com.android.application'
 apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
 apply plugin: 'jp.leafytree.android-scala'
 apply plugin: 'hugo'
 apply plugin: 'com.mutualmobile.gradle.plugins.dexinfo'
@@ -22,7 +23,7 @@ ext {
     playServicesVersion = '15.0.1'
     audioVersion = System.getenv("AUDIO_VERSION") ?: '1.209.0@aar'
     stethoVersion = '1.5.0'
-    zMessagingVersion = "141.0.2281"
+    zMessagingVersion = "142.0.2283"
     paging_version = "1.0.0"
 
     avsVersion = '4.9.12@aar'
@@ -350,6 +351,8 @@ dependencies {
     implementation "com.android.support:cardview-v7:$supportLibVersion"
     implementation 'com.android.support.constraint:constraint-layout:1.1.3'
     implementation "android.arch.paging:runtime:$paging_version"
+    implementation "com.android.support:exifinterface:$supportLibVersion"
+    implementation "com.android.support:support-media-compat:$supportLibVersion"
 
     // Play services
     implementation "com.google.android.gms:play-services-base:$playServicesVersion"
@@ -366,6 +369,8 @@ dependencies {
     implementation "android.arch.work:work-runtime:$work_version"
 
     //third party libraries
+    implementation 'io.reactivex.rxjava2:rxkotlin:2.3.0'
+    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
     implementation 'com.evernote:android-job:1.2.6'
     implementation 'com.jakewharton.timber:timber:4.7.0'
     implementation 'com.jakewharton.threetenabp:threetenabp:1.1.0'
@@ -375,6 +380,8 @@ dependencies {
     devImplementation "com.facebook.stetho:stetho:$stethoVersion"
     experimentalImplementation "com.facebook.stetho:stetho:$stethoVersion"
     internalImplementation "com.facebook.stetho:stetho:$stethoVersion"
+    implementation "com.github.bumptech.glide:glide:4.8.0"
+    annotationProcessor 'com.github.bumptech.glide:compiler:4.8.0'
 
     // Test dependencies
     testImplementation 'junit:junit:4.12'
@@ -399,6 +406,11 @@ dependencies {
     androidTestImplementation 'com.crittercism.dexmaker:dexmaker-mockito:1.4'
     androidTestImplementation "android.arch.work:work-testing:$work_version"
 
+    androidTestImplementation 'junit:junit:4.12'
+    androidTestImplementation 'org.mockito:mockito-core:1.10.19'
+    androidTestImplementation 'com.android.support.test:runner:1.0.2'
+    androidTestImplementation 'com.android.support.test:rules:1.0.2'
+
     ScalaCompileOptions.metaClass.daemonServer = true
     ScalaCompileOptions.metaClass.fork = true
     ScalaCompileOptions.metaClass.useAnt = false

app/proguard-rules.txt

@@ -128,3 +128,11 @@
 ## JNA classes for calling v3
 -keep class * extends com.sun.jna.** { *; }
 -keep class com.sun.jna.** { *; }
+
+# Glide
+-keep public class * implements com.bumptech.glide.module.GlideModule
+-keep public class * extends com.bumptech.glide.module.AppGlideModule
+-keep public enum com.bumptech.glide.load.ImageHeaderParser$** {
+  **[] $VALUES;
+  public *;
+}

app/src/androidTest/res/raw/test_audio.wav

@@ -0,0 +1,44 @@
+/**
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.waz.zclient
+
+import java.net.URI
+
+import android.content.Context
+
+import scala.concurrent.duration._
+import scala.concurrent.{Await, ExecutionException, Future}
+import scala.util.{Failure, Success, Try}
+
+object TestUtils {
+
+  val defaultTestTimeout: FiniteDuration = 3.minutes
+
+  def asyncTest(body: Future[_]): Unit = {
+    Try(Await.result(body, defaultTestTimeout)) match {
+      case Success(_) =>
+      case Failure(err: ExecutionException) => throw err.getCause
+      case Failure(err) => throw err
+    }
+  }
+
+  def getResourceUri(context: Context, resourceId: Int): URI = {
+    URI.create(s"android.resource://${context.getPackageName}/$resourceId")
+  }
+
+}

app/src/androidTest/res/raw/test_img.png

@@ -0,0 +1,139 @@
+/**
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.waz.zclient.assets2
+
+import java.io._
+
+import android.support.test.InstrumentationRegistry._
+import android.support.test.filters.MediumTest
+import android.support.test.rule.GrantPermissionRule
+import android.support.test.runner.AndroidJUnit4
+import com.waz.model.Mime
+import com.waz.model.errors._
+import com.waz.service.assets2.Asset.{Audio, Image, Video}
+import com.waz.service.assets2.Content
+import com.waz.utils.IoUtils
+import com.waz.zclient.TestUtils._
+import com.waz.zclient.dev.test.R
+import org.junit.Test
+import org.junit.runner.RunWith
+import android.Manifest
+import org.junit.Rule
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+@RunWith(classOf[AndroidJUnit4])
+@MediumTest
+class AssetDetailsServiceTest {
+
+  val uriHelper = new AndroidUriHelper(getContext)
+  val detailsService = new AssetDetailsServiceImpl(uriHelper)(getContext, global)
+
+  @Rule
+  def permissions: GrantPermissionRule =
+    GrantPermissionRule.grant(Manifest.permission.WRITE_EXTERNAL_STORAGE)
+
+  @Test
+  def extractForImageUri(): Unit = asyncTest {
+    val uri = getResourceUri(getContext, R.raw.test_img)
+    for {
+      errorOrDetails <- detailsService.extract(Mime.Image.Png, Content.Uri(uri)).modelToEither
+    } yield {
+      lazy val errorMsg = s"Extracted details: $errorOrDetails"
+      assert(errorOrDetails.isRight, errorMsg)
+      val details = errorOrDetails.right.get
+
+      assert(details.isInstanceOf[Image], errorMsg)
+      val imageDetails = details.asInstanceOf[Image]
+      assert(imageDetails.dimensions.width > 0 && imageDetails.dimensions.height > 0, errorMsg)
+    }
+  }
+
+  @Test
+  def extractForVideoUri(): Unit = asyncTest {
+    val uri = getResourceUri(getContext, R.raw.test_video)
+    for {
+      errorOrDetails <- detailsService.extract(Mime.Video.MP4, Content.Uri(uri)).modelToEither
+    } yield {
+      lazy val errorMsg = s"Extracted details: $errorOrDetails"
+      assert(errorOrDetails.isRight, errorMsg)
+      val details = errorOrDetails.right.get
+
+      assert(details.isInstanceOf[Video], errorMsg)
+      val videoDetails = details.asInstanceOf[Video]
+      assert(videoDetails.dimensions.width > 0 && videoDetails.dimensions.height > 0 && !videoDetails.duration.isZero, errorMsg)
+    }
+  }
+
+  @Test
+  def extractForVideoFile(): Unit = asyncTest {
+    val uri = getResourceUri(getContext, R.raw.test_video)
+    val file = new File(getContext.getExternalCacheDir, "test_video")
+    IoUtils.copy(uriHelper.openInputStream(uri).get,  new FileOutputStream(file))
+
+    for {
+      errorOrDetails <- detailsService.extract(Mime.Video.MP4, Content.File(Mime.Video.MP4, file)).modelToEither
+    } yield {
+      lazy val errorMsg = s"Extracted details: $errorOrDetails"
+      assert(errorOrDetails.isRight, errorMsg)
+      val details = errorOrDetails.right.get
+
+      assert(details.isInstanceOf[Video], errorMsg)
+      val videoDetails = details.asInstanceOf[Video]
+      assert(videoDetails.dimensions.width > 0 && videoDetails.dimensions.height > 0 && !videoDetails.duration.isZero, errorMsg)
+    }
+  }
+
+  @Test
+  def extractForAudioUri(): Unit = asyncTest {
+    val uri = getResourceUri(getContext, R.raw.test_audio)
+    for {
+      errorOrDetails <- detailsService.extract(Mime.Audio.WAV, Content.Uri(uri)).modelToEither
+    } yield {
+      lazy val errorMsg = s"Extracted details: $errorOrDetails"
+      assert(errorOrDetails.isRight, errorMsg)
+      val details = errorOrDetails.right.get
+
+      assert(details.isInstanceOf[Audio], errorMsg)
+      val audioDetails = details.asInstanceOf[Audio]
+      assert(audioDetails.loudness.levels.nonEmpty && !audioDetails.duration.isZero, errorMsg)
+    }
+  }
+
+  @Test
+  def extractForAudioFile(): Unit = asyncTest {
+    val uri = getResourceUri(getContext, R.raw.test_audio)
+    val testAudio = new File(getInstrumentation.getContext.getExternalCacheDir, "test_audio")
+    testAudio.createNewFile()
+    IoUtils.copy(uriHelper.openInputStream(uri).get, new FileOutputStream(testAudio))
+
+    for {
+      errorOrDetails <- detailsService.extract(Mime.Audio.WAV, Content.File(Mime.Audio.WAV, testAudio)).modelToEither
+    } yield {
+      lazy val errorMsg = s"Extracted details: ${errorOrDetails.left.get.cause.get.toString}"
+      assert(errorOrDetails.isRight, errorMsg)
+      val details = errorOrDetails.right.get
+
+      assert(details.isInstanceOf[Audio], errorMsg)
+      val audioDetails = details.asInstanceOf[Audio]
+      assert(audioDetails.loudness.levels.nonEmpty && !audioDetails.duration.isZero, errorMsg)
+    }
+  }
+
+
+}

app/src/androidTest/res/raw/test_video.mp4

@@ -0,0 +1,134 @@
+/**
+ * Wire
+ * Copyright (C) 2019 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.waz.zclient.assets2
+
+import java.io.File
+
+import android.Manifest
+import android.support.test.InstrumentationRegistry
+import android.support.test.InstrumentationRegistry.getContext
+import android.support.test.filters.MediumTest
+import android.support.test.rule.GrantPermissionRule
+import android.support.test.runner.AndroidJUnit4
+import com.waz.model.Mime
+import com.waz.service.assets2
+import com.waz.service.assets2.AssetStorageImpl.AssetDao
+import com.waz.service.assets2._
+import com.waz.sync.client.AssetClient2
+import com.waz.sync.client.AssetClient2.Retention
+import com.waz.threading.Threading
+import com.waz.utils.events.EventContext
+import com.waz.utils.wrappers.DB
+import com.waz.zclient.TestUtils.{asyncTest, getResourceUri}
+import com.waz.zclient.dev.test.R
+import com.waz.zclient.storage.GeneralStorageTest.TestSingleDaoDb
+import org.junit.runner.RunWith
+import org.junit.{After, Before, Rule, Test}
+import org.mockito.Mockito
+import com.waz.model.errors._
+import com.waz.sync.SyncServiceHandle
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration._
+import scala.util.Success
+
+@RunWith(classOf[AndroidJUnit4])
+@MediumTest
+class AssetServiceTest {
+
+  val assetsClient: AssetClient2 = Mockito.mock(classOf[AssetClient2], "assetsClient")
+  val uriHelper: UriHelper = Mockito.mock(classOf[AndroidUriHelper], "uriHelper")
+  val syncHandler: SyncServiceHandle = Mockito.mock(classOf[SyncServiceHandle], "syncHandler")
+
+  val lruCacheDirectory = new File(getContext.getCacheDir, s"assets_${System.currentTimeMillis()}")
+  val rawCacheDirectory = new File(getContext.getCacheDir, s"raw_assets_${System.currentTimeMillis()}")
+
+  val uriHelperImpl = new AndroidUriHelper(getContext)
+  val detailsService = new AssetDetailsServiceImpl(uriHelperImpl)(getContext, global)
+  val contentCache = new AssetContentCacheImpl(cacheDirectory = lruCacheDirectory, directorySizeThreshold = 1024 * 1024 * 200L, sizeCheckingInterval = 30.seconds)(Threading.BlockingIO, EventContext.Global)
+  val uploadContentCache = new UploadAssetContentCacheImpl(rawCacheDirectory)(Threading.BlockingIO)
+  val transformationsService = new AssetTransformationsServiceImpl(List(new ImageDownscalingCompressing(new AndroidImageRecoder)))
+  val restrictionsService = new AssetRestrictionsServiceImpl(uriHelperImpl, None)
+  val previewService = new AssetPreviewServiceImpl()(getContext, global)
+
+  lazy val assetService = new AssetServiceImpl(
+    assetStorage,
+    uploadAssetStorage,
+    downloadAssetStorage,
+    detailsService,
+    previewService,
+    transformationsService,
+    restrictionsService,
+    uriHelper,
+    contentCache,
+    uploadContentCache,
+    assetsClient,
+    syncHandler
+  )(global)
+
+  val DatabaseName = s"test_db_${System.currentTimeMillis()}"
+  var testDB: DB = _
+
+  var assetStorage: AssetStorage = _
+  var uploadAssetStorage: UploadAssetStorage = _
+  var downloadAssetStorage: DownloadAssetStorage = _
+
+  @Rule
+  def permissions: GrantPermissionRule =
+    GrantPermissionRule.grant(Manifest.permission.WRITE_EXTERNAL_STORAGE)
+
+  @Before
+  def initializeDB(): Unit = {
+    val context = InstrumentationRegistry.getTargetContext
+    testDB = new TestSingleDaoDb(context, DatabaseName, AssetDao).getWritableDatabase
+
+    downloadAssetStorage = new assets2.DownloadAssetStorageImpl(context, testDB)(Threading.BlockingIO)
+    uploadAssetStorage = new assets2.UploadAssetStorageImpl(context, testDB)(Threading.BlockingIO)
+    assetStorage = new assets2.AssetStorageImpl(context, testDB, Threading.BlockingIO)
+  }
+
+  @After
+  def removeDb(): Unit = {
+    val context = InstrumentationRegistry.getTargetContext
+    testDB.close()
+    context.deleteDatabase(DatabaseName)
+  }
+
+  @Test
+  def extractForImageUri(): Unit = asyncTest {
+    val uri = getResourceUri(getContext, R.raw.test_video_large_preview)
+    val content = ContentForUpload("test_video_large_preview.mp4", Content.Uri(uri))
+
+    Mockito.when(uriHelper.extractMime(uri)).thenReturn(Success(Mime.Video.MP4))
+    Mockito.when(uriHelper.openInputStream(uri)).thenCallRealMethod()
+
+    for {
+      videoAsset <- assetService.createAndSaveUploadAsset(content, NoEncryption, public = true, Retention.Volatile, None)
+      errorOrUpdatedAsset <- assetService.createAndSavePreview(videoAsset).modelToEither
+    } yield {
+      lazy val errorMsg = s"Updated asset: $errorOrUpdatedAsset"
+      assert(errorOrUpdatedAsset.isRight, errorMsg)
+//      val details = errorOrUpdatedAsset.right.get
+
+//      assert(details.isInstanceOf[Image], errorMsg)
+//      val imageDetails = details.asInstanceOf[Image]
+//      assert(imageDetails.dimensions.width > 0 && imageDetails.dimensions.height > 0, errorMsg)
+    }
+  }
+
+}