forked from
tokono.ma/diffuse
A music player that connects to your cloud/distributed storage.
Fix late-night-programming issues
+75
-70
+70
-55
src/Applications/UI/Tracks/Covers.elm
+70
-55
src/Applications/UI/Tracks/Covers.elm
···
2
2
3
3
import Base64
4
4
import Conditional exposing (ifThenElse)
5
+
import Dict
5
6
import List.Extra as List
6
7
import Maybe.Extra as Maybe
7
8
import Tracks exposing (..)
···
13
14
14
15
generate :
15
16
SortBy
16
-
-> Maybe Cover
17
17
-> Tracks.Collection
18
-
-> { collection : CoverCollection, selectedCover : Maybe Cover }
19
-
generate sortBy previouslySelectedCover tracks =
18
+
-> CoverCollection
19
+
generate sortBy tracks =
20
20
let
21
21
groupFn =
22
22
coverGroup sortBy
···
40
40
if group /= gathering.previousGroup then
41
41
-- New group, make cover for previous group
42
42
let
43
-
{ collection, selectedCover } =
44
-
makeCoverFn gathering covers previouslySelectedCover
43
+
collection =
44
+
makeCoverFn gathering covers
45
45
in
46
46
{ gathering =
47
47
{ acc = [ identifiedTrack ]
48
48
, accIds = [ track.id ]
49
49
, previousGroup = group
50
50
, previousTrack = track
51
-
, selectedCover = selectedCover
52
51
53
52
--
54
53
, currentAlbumSequence = Just ( identifiedTrack, 1 )
···
73
72
, accIds = track.id :: gathering.accIds
74
73
, previousGroup = group
75
74
, previousTrack = track
76
-
, selectedCover = gathering.selectedCover
77
75
78
76
-- Album sequence
79
77
-----------------
···
146
144
, accIds = []
147
145
, previousGroup = ""
148
146
, previousTrack = emptyTrack
149
-
, selectedCover = Nothing
150
147
151
148
--
152
149
, currentAlbumSequence = Nothing
···
158
155
}
159
156
}
160
157
|> (\{ covers, gathering } ->
161
-
makeCoverFn gathering covers previouslySelectedCover
158
+
makeCoverFn gathering covers
162
159
)
163
-
|> (\{ collection, selectedCover } ->
164
-
{ collection = { arranged = collection, harvested = [] }
165
-
, selectedCover = selectedCover
166
-
}
160
+
|> (\collection ->
161
+
{ arranged = collection, harvested = [] }
167
162
)
168
163
169
164
170
-
harvest : SortBy -> Tracks.Collection -> CoverCollection -> List Cover
171
-
harvest sortBy tracks covers =
165
+
harvest :
166
+
Maybe Cover
167
+
-> SortBy
168
+
-> Tracks.Collection
169
+
-> CoverCollection
170
+
-> ( CoverCollection, Maybe Cover )
171
+
harvest previouslySelectedCover sortBy tracks covers =
172
172
let
173
173
groupFn =
174
174
coverGroup sortBy
175
175
176
-
( _, groups ) =
176
+
( _, groups, tracksPerGroup ) =
177
177
List.foldr
178
-
(\identifiedTrack ( previousGroup, acc ) ->
178
+
(\identifiedTrack ( previousGroup, acc, dict ) ->
179
179
let
180
180
group =
181
181
groupFn identifiedTrack
182
182
in
183
183
( group
184
+
--
184
185
, if group /= previousGroup then
185
186
group :: acc
186
187
187
188
else
188
189
acc
190
+
--
191
+
, Dict.update group
192
+
(Maybe.unwrap [ identifiedTrack ] ((::) identifiedTrack) >> Just)
193
+
dict
189
194
)
190
195
)
191
-
( "", [] )
196
+
( "", [], Dict.empty )
192
197
tracks.harvested
193
198
in
194
-
List.filter
195
-
(\cover -> List.member cover.group groups)
196
-
covers.arranged
199
+
covers.arranged
200
+
|> List.foldr
201
+
(\cover ( acc, sel ) ->
202
+
if List.member cover.group groups then
203
+
let
204
+
groupTracks =
205
+
Maybe.withDefault [] (Dict.get cover.group tracksPerGroup)
206
+
207
+
trackIds =
208
+
List.map (Tuple.second >> .id) groupTracks
209
+
210
+
harvestedCover =
211
+
{ cover | tracks = groupTracks, trackIds = trackIds }
212
+
in
213
+
case ( previouslySelectedCover, sel ) of
214
+
( Just pre, Nothing ) ->
215
+
( harvestedCover :: acc
216
+
, if pre.key == harvestedCover.key then
217
+
Just harvestedCover
218
+
219
+
else
220
+
Nothing
221
+
)
222
+
223
+
( Just _, Just s ) ->
224
+
( harvestedCover :: acc
225
+
, Just s
226
+
)
227
+
228
+
( Nothing, _ ) ->
229
+
( harvestedCover :: acc
230
+
, Nothing
231
+
)
232
+
233
+
else
234
+
( acc
235
+
, sel
236
+
)
237
+
)
238
+
( []
239
+
, Nothing
240
+
)
241
+
|> Tuple.mapFirst
242
+
(\h -> { covers | harvested = h })
197
243
198
244
199
245
···
232
278
tags.artist ++ " --- " ++ tags.album
233
279
234
280
235
-
makeCover sortBy_ gathering collection previouslySelectedCover =
281
+
makeCover sortBy_ gathering collection =
236
282
let
237
283
closedGathering =
238
284
{ gathering
···
256
302
in
257
303
case closedGathering.acc of
258
304
[] ->
259
-
{ collection = collection
260
-
, selectedCover = closedGathering.selectedCover
261
-
}
305
+
collection
262
306
263
307
fallback :: _ ->
264
-
let
265
-
cover =
266
-
makeCoverWithFallback sortBy_ closedGathering fallback
267
-
in
268
-
{ collection =
269
-
cover :: collection
270
-
, selectedCover =
271
-
case ( previouslySelectedCover, closedGathering.selectedCover ) of
272
-
( Nothing, _ ) ->
273
-
Nothing
274
-
275
-
( Just _, Just _ ) ->
276
-
closedGathering.selectedCover
277
-
278
-
( Just sc, Nothing ) ->
279
-
case sortBy_ of
280
-
Artist ->
281
-
if cover.group == sc.group then
282
-
Just cover
283
-
284
-
else
285
-
Nothing
286
-
287
-
_ ->
288
-
if cover.key == sc.key then
289
-
Just cover
290
-
291
-
else
292
-
Nothing
293
-
}
308
+
makeCoverWithFallback sortBy_ closedGathering fallback :: collection
294
309
295
310
296
311
makeCoverWithFallback sortBy_ gathering fallback =
+5
-15
src/Applications/UI/Tracks/State.elm
+5
-15
src/Applications/UI/Tracks/State.elm
···
318
318
generateCovers : Manager
319
319
generateCovers model =
320
320
model.tracks
321
-
|> Covers.generate
322
-
model.sortBy
323
-
model.selectedCover
324
-
|> (\{ collection, selectedCover } ->
325
-
{ model
326
-
| covers = collection
327
-
, selectedCover = selectedCover
328
-
}
329
-
)
321
+
|> Covers.generate model.sortBy
322
+
|> (\c -> { model | covers = c })
330
323
|> Return.singleton
331
324
332
325
···
363
356
364
357
harvestCovers : Manager
365
358
harvestCovers model =
366
-
let
367
-
covers =
368
-
model.covers
369
-
in
370
-
{ covers | harvested = Covers.harvest model.sortBy model.tracks covers }
371
-
|> (\c -> { model | covers = c })
359
+
model.covers
360
+
|> Covers.harvest model.selectedCover model.sortBy model.tracks
361
+
|> (\( c, s ) -> { model | covers = c, selectedCover = s })
372
362
|> Return.communicate
373
363
(Ports.loadAlbumCovers ())
374
364
|> andThen