refactoring, remove logs

app/src/main/java/com/biganto/visual/roompark/data/repository/api/retrofit/di/RetrofitModule.kt

@@ -36,7 +36,7 @@ private const val TIMEOUT_SECONDS=120L
 private const val WRITE_SECONDS=120L
 private const val READ_SECONDS=120L
 
-val INTERCEPT_LOG_LEVEL = HttpLoggingInterceptor.Level.HEADERS
+val INTERCEPT_LOG_LEVEL = HttpLoggingInterceptor.Level.NONE
 
 @Module
 class RetrofitModule{

app/src/main/java/com/biganto/visual/roompark/data/repository/file/FileModule.kt

@@ -60,7 +60,6 @@ class FileModule @Inject constructor(val context: Application) {
 
     fun saveFileToDisk(file:File,content: String){
         Timber.d("write to : $file")
-        Timber.d("write to : ${file.name}")
 //        file.createNewFile()
         file.parentFile.mkdirs()
         file.writeText(content) //to json array because core unity method parse data like TourData[] Estate[] etc..

app/src/main/java/com/biganto/visual/roompark/data/service/download/TourDownloadService.kt

@@ -175,7 +175,7 @@ class DownloadManagerService @Inject constructor(
                 val sink = Okio.buffer(Okio.appendingSink(fileStorage))
                 val buffer = sink.buffer()
                 var read = 0L
-                val step = 4096
+                val step = 8192
                 val source = response.source()
                 var timer = System.currentTimeMillis()
                 var stop: Boolean = false
@@ -194,7 +194,6 @@ class DownloadManagerService @Inject constructor(
                         }
                 }
 
-
                 model.isDownloaded = (source.exhausted()
                         && (model.fileDownloadedSize == model.tempOverallFileSize
                         || model.tempOverallFileSize == 0L))
@@ -268,9 +267,10 @@ class DownloadManagerService @Inject constructor(
 
                 mergeFiles(fileEntities)
                 val jlist = db.getTourFilesJunction(tour.id).toList()
+                Timber.d("jlist:: ${jlist?.size} start ${jlist?.firstOrNull()?.id}")
                 val junctionList = fileEntities
                     .map {file ->
-                        val entity = jlist.firstOrNull{it.tour == tour.id && it.file == file.uri}
+                        val entity = jlist.firstOrNull{it.tour == tour.id && it.file.uri() == file.uri.uri()}
                             ?: TourFileJunctionEntity().apply {
                                 setTour(tour.id)
                                 setFile(file.uri)
@@ -279,8 +279,8 @@ class DownloadManagerService @Inject constructor(
                         totalSize += file.totalSize
                         entity
                     }
-                Timber.w("fffff $downloadedSize $totalSize")
 
+                Timber.d("junctionList:: ${junctionList.size} start ${junctionList.first().id}")
                 setDownloadInfo(
                     raw.id.toString()
                     , tempLoadedFiles = 0
@@ -337,7 +337,6 @@ class DownloadManagerService @Inject constructor(
             .observeOn(Schedulers.computation())
 //            .doOnNext{Timber.d("7 ${it}")}
             .flatMap { model ->
-                Timber.d(" model __ ${model}")
                 setDownloadInfo(
                     model.tourId
                     , totalSizedDiffSize = model.tempTourTotalDiff
@@ -377,10 +376,13 @@ class DownloadManagerService @Inject constructor(
 
     private fun downloadTourFromQueue(): Observable<String> =
         Observable.fromCallable { activeDownloading.set(true);downloadQueue.poll() }
+            .doOnNext { Timber.d("to load tour: ${it}") }
             .flatMap { db.getTourPreview(it).observable() }
             .filter {
+                Timber.d("to load tour: ${it.isDownloaded} ${it.id}")
                 val forward = it.isDownloaded != DownloadState.Downloaded
                 activeDownloading.set(forward)
+                Timber.d("to load tour: $forward")
                 if (!forward)
                     notifyDownloadProgress()
                 forward
@@ -519,6 +521,7 @@ class DownloadManagerService @Inject constructor(
         disposable.add(
             toursToDownloadObserver
             .flatMap { db.getTourPreview(it).observable() }
+            .filter { it.isDownloaded != DownloadState.Downloaded }
             .doOnNext {
                 it.isDownloaded = DownloadState.Downloading
                 it.downloadedFiles = 0
@@ -531,18 +534,20 @@ class DownloadManagerService @Inject constructor(
             .subscribeOn(Schedulers.io())
             .doOnError(Timber::e)
             .subscribe { downloadQueue.add(it) }
+
         )
     }
 
     private fun getMeta(tour: TourPreviewEntity): Observable<String> =
         api.getTourMetaAsString(tour.id)
-        .doOnNext { meta ->
-            tour.let {
+        .map { meta ->
+            tour.apply {
                 val metaUri = RevisionString("$META_PREDICTION${tour.id}$META_FILE_TYPE")
-                it.setMetaFileEntityId(metaUri)
+                setMetaFileEntityId(metaUri)
                 fileModule.saveFileToDisk(fileModule.getFile(metaUri.uri()), meta)
             }
         }
+            .flatMap { db.upsertTourPreview(it) }
         .map { tour.id }
         .onErrorReturn {
             setTourStatus(tour.id,DownloadState.Crushed)

app/src/main/java/com/biganto/visual/roompark/domain/use_case/DownloadUseCase.kt

@@ -63,7 +63,7 @@ class DownloadUseCase @Inject constructor(
                     else  Okio.buffer(Okio.sink(fileStorage))
                 val buffer = sink.buffer()
                 var read = 0L
-                val step = 4096
+                val step = 8192
                 val source = response.source()
                 var stop: Boolean = token.isCancelled
                 sink.use {
@@ -161,7 +161,7 @@ class DownloadUseCase @Inject constructor(
                 val jlist = db.getTourFilesJunction(tour.id).toList()
                 val junctionList = fileEntities
                     .map {file ->
-                        val entity = jlist.firstOrNull{it.tour == tour.id && it.file == file.uri}
+                        val entity = jlist.firstOrNull{it.tour == tour.id && it.file.uri() == file.uri.uri()}
                             ?: TourFileJunctionEntity()
                         entity.setTour(tour.id)
                         entity.setFile(file.uri)

app/src/main/java/com/biganto/visual/roompark/domain/use_case/toures.kt

@@ -33,12 +33,16 @@ class TourPreviewsUseCase @Inject constructor(
     ,private val tours:TourContract
 ) {
 
-    fun getTourById(tourId:String):Observable<DownloadTourByIdResult> {
+    fun getTourById(tourId: String): Observable<DownloadTourByIdResult> {
         val tour = retrieveTour(tourId)
         Timber.d("retrieveTour $tourId / $tour")
         if (tour != null) {
             if (tour.downloadState == DownloadState.Downloaded)
-                return Observable.just<DownloadTourByIdResult>(DownloadTourByIdResult.ReadyToPlay(tour))
+                return Observable.just<DownloadTourByIdResult>(
+                    DownloadTourByIdResult.ReadyToPlay(
+                        tour
+                    )
+                )
 
             return setTourState(tour.tour_id, DownloadState.DownloadQueue)
                 .map<DownloadTourByIdResult> { DownloadTourByIdResult.DownloadStarted(tour) }
@@ -50,21 +54,21 @@ class TourPreviewsUseCase @Inject constructor(
     }
 
     fun retrieveTour(tourId: String) =
-            db.getTourPreview(tourId)
-                .asSequence()
-                .map ( ::fromEntity)
-                .firstOrNull()
+        db.getTourPreview(tourId)
+            .asSequence()
+            .map(::fromEntity)
+            .firstOrNull()
 
-    private fun setTourState(tourId:String, state: DownloadState): Observable<Boolean> =
-                    db.getTourPreview(tourId)
-                        .observable()
-                        .doOnNext{ it.isDownloaded=state }
-                        .flatMap { db.upsertTourPreview(it).map{true} }
+    private fun setTourState(tourId: String, state: DownloadState): Observable<Boolean> =
+        db.getTourPreview(tourId)
+            .observable()
+            .doOnNext { it.isDownloaded = state }
+            .flatMap { db.upsertTourPreview(it).map { true } }
 
-    private fun syncTour(tourId:String, parentId:Int):Observable<TourModel> =
-        syncTour(tourId,parentId,calcTargetResolution())
+    private fun syncTour(tourId: String, parentId: Int): Observable<TourModel> =
+        syncTour(tourId, parentId, calcTargetResolution())
 
-    private fun syncTour(tourId:String, estateId: Int, targetResolution:Int)
+    private fun syncTour(tourId: String, estateId: Int, targetResolution: Int)
             : Observable<TourModel> {
         val request = ToursRemoteByIdRequestModel(
             arrayListOf(tourId)
@@ -76,15 +80,16 @@ class TourPreviewsUseCase @Inject constructor(
             .map {
                 if (it.isNullOrEmpty())
                     throw CustomApiException.TourByIdNotFoundException()
-                it.first() }
+                it.first()
+            }
             .doOnNext { it.isDownloaded = DownloadState.DownloadQueue }
-            .flatMap {db.upsertTourPreview(it)}
+            .flatMap { db.upsertTourPreview(it) }
             .map(::fromEntity)
             .doOnError(Timber::e)
     }
 
 
-    private fun calcTargetResolution():Int{
+    private fun calcTargetResolution(): Int {
         val w = Resources.getSystem().displayMetrics.widthPixels
         val h = Resources.getSystem().displayMetrics.heightPixels
         return w.coerceAtLeast(h)
@@ -93,10 +98,13 @@ class TourPreviewsUseCase @Inject constructor(
     private fun forceTourUpdate(requestModel: ToursRemoteByIdRequestModel): Observable<List<TourPreviewEntity>> =
         api.getToursPreviewById(requestModel.ids)
             .subscribeOn(Schedulers.io())
-            .map { fromRaw(it
-                , requestModel.estateId
-                , api.provideHttpUrl().toString()
-                , requestModel.targetResolution)
+            .map {
+                fromRaw(
+                    it
+                    , requestModel.estateId
+                    , api.provideHttpUrl().toString()
+                    , requestModel.targetResolution
+                )
             }
 
 
@@ -104,56 +112,60 @@ class TourPreviewsUseCase @Inject constructor(
         db.getEstateTourPreviews(estateId)
             .filter { !it.isNullOrEmpty() }
 
-    private fun fetchApiTourList(multitourId:Int,estateId: Int) =
+    private fun fetchApiTourList(multitourId: Int, estateId: Int) =
         auth.currentUser()
-            .doOnNext { Timber.d("user on next: $it") }
             .map { it.targetResolution }
             .flatMap { res ->
-            Timber.d("user: $res")
-            api.getOfferTours(multitourId)
-                .doOnError { Timber.e(it) }
-                .map {
-                    mergeRaw(it, TourRemoteRequestModel(
-                            estateId,
-                            api.provideHttpUrl().toString(),
-                            res
+                api.getOfferTours(multitourId)
+                    .doOnError { Timber.e(it) }
+                    .map {
+                        mergeRaw(
+                            it, TourRemoteRequestModel(
+                                estateId,
+                                api.provideHttpUrl().toString(),
+                                res
+                            )
                         )
-                    )
-                }
-                .map { it }
-                .doOnNext { db.blockingUpsert(it) }
-        }
+                    }
+                    .map { it }
+                    .doOnNext { db.blockingUpsert(it) }
+            }
 
-    fun fetchTourOffer(multitourId:Int,parent:Int) =
+    fun fetchTourOffer(multitourId: Int, parent: Int): Observable<List<TourModel>> =
         Observable.mergeDelayError(
-            arrayListOf(fetchDbTourList(parent),fetchApiTourList(multitourId,parent))
+            arrayListOf(fetchDbTourList(parent), fetchApiTourList(multitourId, parent))
         )
             .take(1)
             .doOnError { Timber.e(it) }
-            .map (::fromEntity)
+            .map(::fromEntity)
             .subscribeOn(Schedulers.io())
 
 
     private fun mergeRaw(raw: List<TourPreviewRaw>, requestRequestModel: TourRemoteRequestModel) =
-        raw.map{ mergeRaw(it, requestRequestModel) }
+        raw.map { mergeRaw(it, requestRequestModel) }
 
     private fun mergeRaw(raw: TourPreviewRaw, requestRequestModel: TourRemoteRequestModel)
             : TourPreviewEntity {
         Timber.d("got raw: $raw")
         val entity = db.getTourPreview(raw.id.toString()).firstOrNull()
-            ?: return fromRaw(raw
+            ?: return fromRaw(
+                raw
                 , requestRequestModel.estateId
                 , api.provideHttpUrl().toString()
-                , requestRequestModel.targetResolution)
+                , requestRequestModel.targetResolution
+            )
 
 
-        val fromApi = fromRaw(raw
+        val fromApi = fromRaw(
+            raw
             , requestRequestModel.estateId
             , api.provideHttpUrl().toString()
-            , requestRequestModel.targetResolution)
+            , requestRequestModel.targetResolution
+        )
 
         if (fromApi.updated > entity.updated
-            && entity.isDownloaded == DownloadState.Downloaded) {
+            && entity.isDownloaded == DownloadState.Downloaded
+        ) {
             entity.isDownloaded =
                 DownloadState.NotSynced//maxState(entity.isDownloaded, fromApi.isDownloaded)
             return entity
@@ -163,19 +175,18 @@ class TourPreviewsUseCase @Inject constructor(
 //        if (fromApi.estate.id!=requestRequestModel.estateId)
 //            entity.estate=fromApi.estate
         fromApi.setMetaFileEntityId(entity.metaFileEntityId)
-        fromApi.targetResolution=entity.targetResolution
-        fromApi.isDownloaded=entity.isDownloaded
-        fromApi.overallSize=entity.overallSize
-        fromApi.downloadedSize=entity.downloadedSize
-        fromApi.tempSize=entity.tempSize
-        fromApi.overallFiles=entity.overallFiles
-        fromApi.downloadedFiles=entity.downloadedFiles
+        fromApi.targetResolution = entity.targetResolution
+        fromApi.isDownloaded = entity.isDownloaded
+        fromApi.overallSize = entity.overallSize
+        fromApi.downloadedSize = entity.downloadedSize
+        fromApi.tempSize = entity.tempSize
+        fromApi.overallFiles = entity.overallFiles
+        fromApi.downloadedFiles = entity.downloadedFiles
 
         return fromApi
     }
 
-    private fun getUserEstates(user:UserEntity)
-    = user.deals?.map { it.estate }?.plus(
+    private fun getUserEstates(user: UserEntity) = user.deals?.map { it.estate }?.plus(
         user.estates
             ?.asSequence()
             ?.filter { it.favorite }
@@ -185,18 +196,15 @@ class TourPreviewsUseCase @Inject constructor(
 
     fun fetchToursSizes(): Observable<Long> =
         auth.currentUser()
-            .map (::getUserEstates)
-            .map { it.filter { estates -> estates.multitourId!=null  }.toList() }
+            .map(::getUserEstates)
+            .map { it.filter { estates -> estates.multitourId != null }.toList() }
             .map { estates ->
                 val toursOffersToLoad = mutableListOf<Int>()
-                estates.forEach{
+                estates.forEach {
                     if (it.tours.isNullOrEmpty())
                         toursOffersToLoad.add(it.multitourId!!)
                 }
-                Timber.d(" targer estates : " +
-                        "${estates.map { it.tours?.size }} " )
-                Timber.d(" targer toursOffersToLoad : $toursOffersToLoad " )
-                Pair(estates,toursOffersToLoad)
+                Pair(estates, toursOffersToLoad)
             }
             .flatMap { pair ->
                 if (pair.second.isNotEmpty()) {
@@ -206,51 +214,45 @@ class TourPreviewsUseCase @Inject constructor(
                             fetchTourOffer(
                                 it, pair.first.first { estete -> estete.multitourId == it }.id
                             ).doOnError { Timber.e(it) }
-                                .doOnNext { tours -> loadedIds.addAll(tours.map{ t -> t.tour_id }) }
+                                .doOnNext { tours -> loadedIds.addAll(tours.map { t -> t.tour_id }) }
                         }
                     ).takeLast(1)
                         .doOnNext { db.refreshEntities(pair.first) }
-                        .map { Pair(pair.first,loadedIds )}
-                }
-                else return@flatMap Observable.just(Pair(pair.first,null))
+                        .map { Pair(pair.first, loadedIds) }
+                } else return@flatMap Observable.just(Pair(pair.first, null))
             }
-            .doOnNext { Timber.d(" HERER ") }
             .flatMap { pair ->
                 val estates = pair.first
-                for (estate in estates) {
-                    Timber.d(" targer estates : ${estate.user} " )
-                }
 
                 val r = (estates.first().user as UserEntity).targetResolution
-                Timber.d(" targer R : $r " )
+
                 var knownSize =
                     estates.flatMap {
-                        it.tours?.map {t -> t as TourPreviewEntity}
-                            ?.asIterable()?: arrayListOf()
-                    }.filter{t -> t.overallSize > 0L }
-                        .onEach { Timber.d("it.overallSize - it.downloadedSize " +
-                                "${it.overallSize}/${it.downloadedSize}")  }
+                        it.tours?.map { t -> t as TourPreviewEntity }
+                            ?.asIterable() ?: arrayListOf()
+                    }
+                        .filter { t -> t.overallSize > 0L }
                         .sumByLong { it.overallSize - it.downloadedSize }
-                Timber.d(" targer knownSize : $knownSize " )
+
                 val toursToLoadSize =
                     estates.flatMap {
-                        it.tours?.map {t -> t as TourPreviewEntity}
-                            ?.asIterable()?: arrayListOf()
-                    }.filter{t -> t.overallSize < 1L }
-
-                Timber.d(" targer toursToLoadSize : $toursToLoadSize " )
-                val listIds = toursToLoadSize.map { it.id }.toMutableList()
-                pair.second?.let { listIds.addAll(it)}
-                Timber.d(" targer estates : ${listIds} " )
-                if (listIds.isNullOrEmpty()) return@flatMap Observable.just(knownSize)
+                        it.tours?.map { t -> t as TourPreviewEntity }
+                            ?.asIterable() ?: arrayListOf()
+                    }
+                        .filter { t -> t.overallSize < 1L }
+                        .map { it.id }.toMutableList()
+
+                pair.second?.let { toursToLoadSize.addAll(it) }
+
+                if (toursToLoadSize.isNullOrEmpty()) return@flatMap Observable.just(knownSize)
                 else return@flatMap api.getTourFilesSizes(
-                    listIds,r.toString()
+                    toursToLoadSize, r.toString()
                 )
                     .flatMapIterable { it }
                     .flatMap { rawSize ->
                         db.getTourPreview(rawSize.id.toString())
                             .observable()
-                            .map {entity ->
+                            .map { entity ->
                                 knownSize += rawSize.total_size
                                 entity.apply {
                                     overallSize = rawSize.total_size
@@ -258,7 +260,7 @@ class TourPreviewsUseCase @Inject constructor(
                                 }
                                 entity
                             }
-                            .doOnNext{ db.upsert(it).blockingGet() }
+                            .doOnNext { db.upsert(it).blockingGet() }
                     }.map { knownSize }
             }
             .subscribeOn(Schedulers.io())
@@ -276,7 +278,6 @@ class TourPreviewsUseCase @Inject constructor(
         auth.currentUser()
             .map { user ->
                 val estatesList = getUserEstates(user)
-
                 estatesList
                     ?.asSequence()
                     ?.filter { it.multitourId != null }
@@ -291,26 +292,17 @@ class TourPreviewsUseCase @Inject constructor(
                         )
                     }
             }
-            .doOnNext { Timber.d("merged list:${it?.size}") }
             .map { list ->
                 list.map { pair ->
                     api.getOfferTours(pair.first)
-                        .doOnNext { Timber.d(" gonna merge") }
                         .map {
-                            mergeRaw(
-                                it
-                                , pair.second
-                            )
+                            mergeRaw(it, pair.second)
                         }
                         .map { it }
-                        .doOnNext { Timber.d("merged list:${it.size}") }
                         .blockingFirst()
-                }
+                    }
                     .flatten()
             }
-//            .map { it.flatten() }
-
-            .doOnNext { Timber.d("merged flatten list:${it.size}") }
             .flatMap { db.upsertTourPreview(it) }
             .subscribeOn(Schedulers.io())
 }

app/src/main/java/com/biganto/visual/roompark/presentation/screen/settings/ScreenController.kt

@@ -208,11 +208,6 @@ class SettingsScreenController :
     @SuppressLint("SetTextI18n")
     private fun render(viewState: SettingsScreenViewState.LoadSettingsList){
 
-        toursDownloaderTitle.text = viewState.settings.offlineStoreData[0].title +
-        "(${viewState.settings.offlineStoreData[0].amountBytes.bytesToSize()})"
-
-        flatDownloaderTitle.text = viewState.settings.offlineStoreData[1].title +
-                "(${viewState.settings.offlineStoreData[1].amountBytes.bytesToSize()})"
     }
 
     private fun getComponent() = DaggerSettingsScreenComponent.factory()