Move reusable code from mobile to common

This will be useful for a future desktop application.

common/lib/src/library.dart

@@ -0,0 +1,187 @@
+import 'dart:convert';
+
+import 'platform.dart';
+
+/// Bundles a [Track] with information on how to find the corresponding file.
+class InternalTrack {
+  /// The represented track.
+  final Track track;
+
+  /// A string identifying the track for playback.
+  ///
+  /// This will be the result of calling the platform objects getIdentifier()
+  /// function with the file name of the track.
+  final String identifier;
+
+  InternalTrack({
+    this.track,
+    this.identifier,
+  });
+
+  factory InternalTrack.fromJson(Map<String, dynamic> json) => InternalTrack(
+        track: Track.fromJson(json['track']),
+        identifier: json['identifier'],
+      );
+
+  Map<String, dynamic> toJson() => {
+        'track': track.toJson(),
+        'identifier': identifier,
+      };
+}
+
+/// Description of a concrete audio file.
+///
+/// This gets stored in the folder of the audio file and links the audio file
+/// to a recording in the database.
+class Track {
+  /// The name of the file that contains the track's audio.
+  ///
+  /// This corresponds to a document ID in terms of the Android Storage Access
+  /// Framework.
+  final String fileName;
+
+  /// Index within the list of tracks for the corresponding recording.
+  final int index;
+
+  /// Of which recording this track is a part of.
+  final int recordingId;
+
+  /// Which work parts of the recorded work are contained in this track.
+  final List<int> partIds;
+
+  Track({
+    this.fileName,
+    this.index,
+    this.recordingId,
+    this.partIds,
+  });
+
+  factory Track.fromJson(Map<String, dynamic> json) => Track(
+        fileName: json['fileName'],
+        index: json['index'],
+        recordingId: json['recording'],
+        partIds: List.from(json['parts']),
+      );
+
+  Map<String, dynamic> toJson() => {
+        'fileName': fileName,
+        'index': index,
+        'recording': recordingId,
+        'parts': partIds,
+      };
+}
+
+/// Representation of all tracked audio files in one folder.
+class MusicusFile {
+  /// Current version of the Musicus file format.
+  ///
+  /// If incompatible changes are made, this will be increased by one.
+  static const currentVersion = 0;
+
+  /// Musicus file format version in use.
+  ///
+  /// This will be used in the future, if incompatible changes are made.
+  final int version;
+
+  /// List of [Track] objects.
+  final List<Track> tracks;
+
+  MusicusFile({
+    this.version = currentVersion,
+    List<Track> tracks,
+  }) : tracks = tracks ?? [];
+
+  factory MusicusFile.fromJson(Map<String, dynamic> json) => MusicusFile(
+        version: json['version'],
+        tracks: json['tracks']
+            .map<Track>((trackJson) => Track.fromJson(trackJson))
+            .toList(growable: true),
+      );
+
+  Map<String, dynamic> toJson() => {
+        'version': version,
+        'tracks': tracks.map((t) => t.toJson()).toList(),
+      };
+}
+
+/// Manager for all available tracks and their representation on disk.
+class MusicusLibrary {
+  /// String representing the music library base path.
+  final String basePath;
+
+  /// Access to platform dependent functionality.
+  final MusicusPlatform platform;
+
+  /// Map of all available tracks by recording ID.
+  ///
+  /// These are [InternalTrack] objects to store the URI of the corresponding
+  /// audio file alongside the real [Track] object.
+  final Map<int, List<InternalTrack>> tracks = {};
+
+  MusicusLibrary(this.basePath, this.platform);
+
+  /// Load all available tracks.
+  ///
+  /// This recursively searches through the whole music library, reads the
+  /// content of all files called musicus.json and stores all track information
+  /// that it found.
+  Future<void> load() async {
+    // TODO: Consider capping the recursion somewhere.
+    Future<void> recurse([String parentId]) async {
+      final children = await platform.getChildren(parentId);
+
+      for (final child in children) {
+        if (child.isDirectory) {
+          recurse(child.id);
+        } else if (child.name == 'musicus.json') {
+          final content = await platform.readDocument(child.id);
+          final musicusFile = MusicusFile.fromJson(jsonDecode(content));
+          for (final track in musicusFile.tracks) {
+            _indexTrack(parentId, track);
+          }
+        }
+      }
+    }
+
+    await recurse();
+  }
+
+  /// Add a list of new tracks to the music library.
+  ///
+  /// They are stored in this instance and on disk in the directory denoted by
+  /// [parentId].
+  Future<void> addTracks(String parentId, List<Track> newTracks) async {
+    MusicusFile musicusFile;
+
+    final oldContent =
+        await platform.readDocumentByName(parentId, 'musicus.json');
+
+    if (oldContent != null) {
+      musicusFile = MusicusFile.fromJson(jsonDecode(oldContent));
+    } else {
+      musicusFile = MusicusFile();
+    }
+
+    for (final track in newTracks) {
+      _indexTrack(parentId, track);
+      musicusFile.tracks.add(track);
+    }
+
+    await platform.writeDocumentByName(
+        parentId, 'musicus.json', jsonEncode(musicusFile.toJson()));
+  }
+
+  /// Add a track to the map of available tracks.
+  Future<void> _indexTrack(String parentId, Track track) async {
+    final iTrack = InternalTrack(
+      track: track,
+      identifier: await platform.getIdentifier(parentId, track.fileName),
+    );
+
+    if (tracks.containsKey(track.recordingId)) {
+      tracks[track.recordingId].add(iTrack);
+    } else {
+      tracks[track.recordingId] = [iTrack];
+    }
+  }
+}