A cross platform Audiobookshelf client for Android and iOS
Dart
// ignore_for_file: close_sinks
import 'dart:isolate';
import 'package:audio_service/audio_service.dart';
import 'package:fake_async/fake_async.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:rxdart/rxdart.dart';
Isolate? isolate;
class Data {
static final playbackState = PlaybackState(
processingState: AudioProcessingState.buffering,
playing: true,
controls: [MediaControl.pause],
androidCompactActionIndices: [0],
systemActions: {MediaAction.seek},
updatePosition: const Duration(seconds: 30),
bufferedPosition: const Duration(seconds: 35),
speed: 1.5,
updateTime: DateTime.now(),
errorCode: 3,
errorMessage: 'error message',
repeatMode: AudioServiceRepeatMode.all,
shuffleMode: AudioServiceShuffleMode.all,
captioningEnabled: true,
queueIndex: 0,
);
static final playbackStates = [
PlaybackState(playing: true),
PlaybackState(processingState: AudioProcessingState.buffering),
PlaybackState(speed: 1.5),
];
static const query = 'query';
static final uri = Uri.parse('https://example.com/foo');
static const mediaId = '1';
static const mediaItem = MediaItem(id: '1', title: 'title1');
static final mediaItems = [
const MediaItem(id: '1', title: 'title1'),
const MediaItem(id: '2', title: 'title2'),
const MediaItem(id: '3', title: 'title3'),
];
static final remotePlaybackInfo = RemoteAndroidPlaybackInfo(
volumeControlType: AndroidVolumeControlType.absolute,
maxVolume: 10,
volume: 5,
);
}
void main() {
group('isolates', () {
late AudioHandler proxy;
late bool spawningIsolate;
setUp(() async {
if (spawningIsolate) {
await runIsolateHandler();
} else {
IsolatedAudioHandler(_MockAudioHandler());
}
proxy = await IsolatedAudioHandler.lookup();
});
tearDown(() async {
await proxy.unregister();
if (spawningIsolate) {
await killIsolate();
}
});
// We need to run the tests not only in different isolates but also in the
// same isolate since coverage is only collected by the main isolate:
// https://github.com/dart-lang/test/issues/1108
for (var differentIsolate in [true, false]) {
spawningIsolate = differentIsolate;
final isolateLabel =
differentIsolate ? ' (different isolate)' : ' (same isolate)';
test('init $isolateLabel', () async {
final playbackState = await proxy.playbackState.first;
fakeAsync((async) {
// ignore the updateTime
expect(playbackState.copyWith(), PlaybackState());
});
expect(await proxy.queue.first, const <MediaItem>[]);
expect(await proxy.queueTitle.first, '');
expect(await proxy.mediaItem.first, null);
expect(proxy.ratingStyle.hasValue, false);
expect(proxy.androidPlaybackInfo.hasValue, false);
expect(proxy.customState.hasValue, false);
});
test('method invocations $isolateLabel', () async {
Future<void> testMethod(String method, dynamic Function() function,
{dynamic expectedResult}) async {
final startCount = await proxy.count(method);
final dynamic result = await function();
expect(await proxy.count(method), startCount + 1);
if (expectedResult != null) {
expect(result, expectedResult);
}
}
await testMethod('prepare', () => proxy.prepare());
await testMethod('prepareFromMediaId',
() => proxy.prepareFromMediaId('1', <String, dynamic>{}));
await testMethod('prepareFromSearch',
() => proxy.prepareFromSearch(Data.query, <String, dynamic>{}));
await testMethod('prepareFromUri',
() => proxy.prepareFromUri(Data.uri, <String, dynamic>{}));
await testMethod('play', () => proxy.play());
await testMethod('playFromMediaId',
() => proxy.playFromMediaId(Data.mediaId, <String, dynamic>{}));
await testMethod('playFromSearch',
() => proxy.playFromSearch(Data.query, <String, dynamic>{}));
await testMethod('playFromUri',
() => proxy.playFromUri(Data.uri, <String, dynamic>{}));
await testMethod(
'playMediaItem', () => proxy.playMediaItem(Data.mediaItem));
await testMethod('pause', () => proxy.pause());
await testMethod('click', () => proxy.click());
await testMethod('stop', () => proxy.stop());
await testMethod(
'addQueueItem', () => proxy.addQueueItem(Data.mediaItem));
await testMethod(
'addQueueItems', () => proxy.addQueueItems(Data.mediaItems));
await testMethod(
'insertQueueItem', () => proxy.insertQueueItem(0, Data.mediaItem));
await testMethod(
'updateQueue', () => proxy.updateQueue(Data.mediaItems));
await testMethod(
'updateMediaItem', () => proxy.updateMediaItem(Data.mediaItem));
await testMethod(
'removeQueueItem', () => proxy.removeQueueItem(Data.mediaItem));
await testMethod('removeQueueItemAt', () => proxy.removeQueueItemAt(0));
await testMethod('skipToNext', () => proxy.skipToNext());
await testMethod('skipToPrevious', () => proxy.skipToPrevious());
await testMethod('fastForward', () => proxy.fastForward());
await testMethod('rewind', () => proxy.rewind());
await testMethod('skipToQueueItem', () => proxy.skipToQueueItem(0));
await testMethod('seek', () => proxy.seek(Duration.zero));
await testMethod(
'setRating',
() => proxy.setRating(
const Rating.newHeartRating(true), <String, dynamic>{}));
await testMethod(
'setCaptioningEnabled', () => proxy.setCaptioningEnabled(true));
await testMethod('setRepeatMode',
() => proxy.setRepeatMode(AudioServiceRepeatMode.all));
await testMethod('setShuffleMode',
() => proxy.setShuffleMode(AudioServiceShuffleMode.all));
await testMethod('seekBackward', () => proxy.seekBackward(true));
await testMethod('seekForward', () => proxy.seekForward(true));
await testMethod('setSpeed', () => proxy.setSpeed(1.5));
await testMethod('onTaskRemoved', () => proxy.onTaskRemoved());
await testMethod(
'onNotificationDeleted', () => proxy.onNotificationDeleted());
await testMethod('getChildren',
() => proxy.getChildren(Data.mediaId, <String, dynamic>{}),
expectedResult: Data.mediaItems);
await testMethod('subscribeToChildren',
() => proxy.subscribeToChildren(Data.mediaId));
await testMethod('getMediaItem', () => proxy.getMediaItem(Data.mediaId),
expectedResult: Data.mediaItem);
await testMethod(
'search', () => proxy.search(Data.query, <String, dynamic>{}),
expectedResult: Data.mediaItems);
await testMethod(
'androidSetRemoteVolume', () => proxy.androidSetRemoteVolume(3));
await testMethod(
'androidAdjustRemoteVolume',
() =>
proxy.androidAdjustRemoteVolume(AndroidVolumeDirection.raise));
await testMethod('customAction',
() => proxy.customAction('echo', <String, dynamic>{'arg': 'foo'}),
expectedResult: 'foo');
await testMethod('customAction',
() => proxy.customAction('echo', <String, dynamic>{'arg': 'bar'}),
expectedResult: 'bar');
});
test('stream values $isolateLabel', () async {
Future<void> testStream<T>(
String name, ValueStream<T> stream, T value) async {
await proxy.add(name, value);
expect(stream.nvalue, value);
}
await testStream(
'playbackState', proxy.playbackState, Data.playbackState);
await testStream('queue', proxy.queue, Data.mediaItems);
await testStream('queueTitle', proxy.queueTitle, 'Queue');
await testStream('androidPlaybackInfo', proxy.androidPlaybackInfo,
Data.remotePlaybackInfo);
await testStream('ratingStyle', proxy.ratingStyle, RatingStyle.heart);
await testStream<dynamic>('customState', proxy.customState, 'foo');
});
test('streams $isolateLabel', () async {
Future<void> testStream<T>(String name, Stream<T> stream,
bool skipFirst, List<T> values) async {
final actualValues = <T>[];
final subscription =
stream.skip(skipFirst ? 1 : 0).listen(actualValues.add);
for (var value in values) {
await proxy.add(name, value);
}
expect(actualValues, values);
subscription.cancel();
}
await testStream(
'playbackState', proxy.playbackState, true, Data.playbackStates);
await testStream('queue', proxy.queue, true, [
Data.mediaItems,
Data.mediaItems
.map((item) =>
item.copyWith(displayDescription: '${item.id} description'))
.toList(),
]);
await testStream('queueTitle', proxy.queueTitle, true, ['a', 'b', 'c']);
await testStream('mediaItem', proxy.mediaItem, true, Data.mediaItems);
await testStream(
'androidPlaybackInfo', proxy.androidPlaybackInfo, false, [
Data.remotePlaybackInfo,
LocalAndroidPlaybackInfo(),
]);
await testStream('ratingStyle', proxy.ratingStyle, false, [
RatingStyle.heart,
RatingStyle.percentage,
]);
await testStream<dynamic>(
'customEvent', proxy.customEvent, false, <dynamic>[
'a',
'b',
'c',
]);
await testStream<dynamic>(
'customState', proxy.customState, false, <dynamic>[
'a',
'b',
'c',
]);
});
}
});
}
Future<void> runIsolateHandler() async {
final receivePort = ReceivePort();
isolate = await Isolate.spawn(isolateEntryPoint, receivePort.sendPort);
final success = (await receivePort.first) as bool;
assert(success);
}
Future<void> killIsolate() async {
isolate!.kill();
isolate = null;
}
void isolateEntryPoint(SendPort sendPort) {
IsolatedAudioHandler(_MockAudioHandler());
sendPort.send(true);
}
class _MockAudioHandler implements BaseAudioHandler {
@override
final BehaviorSubject<PlaybackState> playbackState =
BehaviorSubject.seeded(PlaybackState());
@override
final BehaviorSubject<List<MediaItem>> queue =
BehaviorSubject.seeded(<MediaItem>[]);
@override
final BehaviorSubject<String> queueTitle = BehaviorSubject.seeded('');
@override
final BehaviorSubject<MediaItem?> mediaItem = BehaviorSubject.seeded(null);
@override
final BehaviorSubject<AndroidPlaybackInfo> androidPlaybackInfo =
BehaviorSubject();
@override
final BehaviorSubject<RatingStyle> ratingStyle = BehaviorSubject();
@override
final PublishSubject<dynamic> customEvent = PublishSubject<dynamic>();
@override
final BehaviorSubject<dynamic> customState = BehaviorSubject<dynamic>();
final Map<String, int> invocationCounts = {};
@override
dynamic noSuchMethod(Invocation invocation) {
final member = invocation.memberName.toString().split('"')[1];
if (invocation.isMethod) {
if (member != 'customAction' ||
invocation.positionalArguments[0] != 'count') {
// count invocations of everything except for 'count' itself.
invocationCounts[member] = (invocationCounts[member] ?? 0) + 1;
}
switch (member) {
case 'customAction':
return _handleCustomAction(invocation);
case 'getChildren':
case 'search':
return Future.value(Data.mediaItems);
case 'subscribeToChildren':
return BehaviorSubject.seeded(<String, dynamic>{});
case 'getMediaItem':
return Future.value(Data.mediaItem);
default:
return Future.value(null);
}
}
return super.noSuchMethod(invocation);
}
Future<dynamic> _handleCustomAction(Invocation invocation) async {
final args = invocation.positionalArguments;
final name = args[0] as String;
final extras = args[1] as Map<String, dynamic>?;
switch (name) {
case 'count':
final method = extras!['method'] as String;
return invocationCounts[method] ?? 0;
case 'echo':
return extras!['arg'] as String;
case 'add':
final streamName = extras!['stream'] as String;
final dynamic arg = extras['arg'];
<String, Subject<dynamic>>{
'playbackState': playbackState,
'queue': queue,
'queueTitle': queueTitle,
'mediaItem': mediaItem,
'androidPlaybackInfo': androidPlaybackInfo,
'ratingStyle': ratingStyle,
'customEvent': customEvent,
'customState': customState,
}[streamName]!
.add(arg);
break;
}
}
}
extension AudioHandlerExtension on AudioHandler {
Future<int> count(String method) async =>
(await customAction('count', <String, dynamic>{'method': method}) as int);
Future<String> echo(String arg) async =>
(await customAction('echo', <String, dynamic>{'arg': arg}) as String);
Future<void> add(String stream, dynamic arg) =>
customAction('add', <String, dynamic>{'stream': stream, 'arg': arg});
Future<void> unregister() => customAction('unregister');
}
/// Backwards compatible extensions on rxdart's ValueStream
extension _ValueStreamExtension<T> on ValueStream<T> {
/// Backwards compatible version of valueOrNull.
T? get nvalue => hasValue ? value : null;
}