185 lines
5.4 KiB
Dart
185 lines
5.4 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:freezer/api/deezer.dart';
|
|
import 'package:freezer/api/download.dart';
|
|
import 'package:freezer/api/definitions.dart';
|
|
import 'package:freezer/settings.dart';
|
|
import 'package:html/parser.dart';
|
|
import 'package:html/dom.dart' as dom;
|
|
import 'package:http/http.dart' as http;
|
|
|
|
import 'dart:convert';
|
|
import 'dart:async';
|
|
|
|
|
|
SpotifyAPI spotify = SpotifyAPI();
|
|
|
|
class SpotifyAPI {
|
|
|
|
SpotifyPlaylist importingSpotifyPlaylist;
|
|
StreamController importingStream = StreamController.broadcast();
|
|
bool doneImporting;
|
|
|
|
//Parse spotify URL to URI (spotify:track:1234)
|
|
String parseUrl(String url) {
|
|
Uri uri = Uri.parse(url);
|
|
if (uri.pathSegments.length > 3) return null; //Invalid URL
|
|
if (uri.pathSegments.length == 3) return 'spotify:${uri.pathSegments[1]}:${uri.pathSegments[2]}';
|
|
if (uri.pathSegments.length == 2) return 'spotify:${uri.pathSegments[0]}:${uri.pathSegments[1]}';
|
|
return null;
|
|
}
|
|
|
|
//Get spotify embed url from uri
|
|
String getEmbedUrl(String uri) => 'https://embed.spotify.com/?uri=$uri';
|
|
|
|
//https://link.tospotify.com/ or https://spotify.app.link/
|
|
Future resolveLinkUrl(String url) async {
|
|
http.Response response = await http.get(Uri.parse(url));
|
|
Match match = RegExp(r'window\.top\.location = validate\("(.+)"\);').firstMatch(response.body);
|
|
return match.group(1);
|
|
}
|
|
|
|
Future resolveUrl(String url) async {
|
|
if (url.contains("link.tospotify") || url.contains("spotify.app.link")) {
|
|
return parseUrl(await resolveLinkUrl(url));
|
|
}
|
|
return parseUrl(url);
|
|
}
|
|
|
|
//Extract JSON data form spotify embed page
|
|
Future<Map> getEmbedData(String url) async {
|
|
//Fetch
|
|
http.Response response = await http.get(url);
|
|
//Parse
|
|
dom.Document document = parse(response.body);
|
|
dom.Element element = document.getElementById('resource');
|
|
|
|
//Some are URL encoded
|
|
try {
|
|
return jsonDecode(element.innerHtml);
|
|
} catch (e) {
|
|
return jsonDecode(Uri.decodeComponent(element.innerHtml));
|
|
}
|
|
}
|
|
|
|
Future<SpotifyPlaylist> playlist(String uri) async {
|
|
//Load data
|
|
String url = getEmbedUrl(uri);
|
|
Map data = await getEmbedData(url);
|
|
//Parse
|
|
SpotifyPlaylist playlist = SpotifyPlaylist.fromJson(data);
|
|
return playlist;
|
|
}
|
|
|
|
//Get Deezer track ID from Spotify URI
|
|
Future<String> convertTrack(String uri) async {
|
|
Map data = await getEmbedData(getEmbedUrl(uri));
|
|
SpotifyTrack track = SpotifyTrack.fromJson(data);
|
|
Map deezer = await deezerAPI.callPublicApi('track/isrc:' + track.isrc);
|
|
return deezer['id'].toString();
|
|
}
|
|
|
|
//Get Deezer album ID by UPC
|
|
Future<String> convertAlbum(String uri) async {
|
|
Map data = await getEmbedData(getEmbedUrl(uri));
|
|
SpotifyAlbum album = SpotifyAlbum.fromJson(data);
|
|
Map deezer = await deezerAPI.callPublicApi('album/upc:' + album.upc);
|
|
return deezer['id'].toString();
|
|
}
|
|
|
|
Future convertPlaylist(SpotifyPlaylist playlist, {bool downloadOnly = false, BuildContext context, AudioQuality quality}) async {
|
|
doneImporting = false;
|
|
importingSpotifyPlaylist = playlist;
|
|
|
|
//Create Deezer playlist
|
|
String playlistId;
|
|
if (!downloadOnly)
|
|
playlistId = await deezerAPI.createPlaylist(playlist.name, description: playlist.description);
|
|
|
|
//Search for tracks
|
|
List<Track> downloadTracks = [];
|
|
for (SpotifyTrack track in playlist.tracks) {
|
|
Map deezer;
|
|
try {
|
|
//Search
|
|
deezer = await deezerAPI.callPublicApi('track/isrc:' + track.isrc);
|
|
if (deezer.containsKey('error')) throw Exception();
|
|
String id = deezer['id'].toString();
|
|
//Add
|
|
if (!downloadOnly)
|
|
await deezerAPI.addToPlaylist(id, playlistId);
|
|
if (downloadOnly)
|
|
downloadTracks.add(Track(id: id));
|
|
track.state = TrackImportState.OK;
|
|
} catch (e) {
|
|
//On error
|
|
track.state = TrackImportState.ERROR;
|
|
}
|
|
|
|
//Download
|
|
if (downloadOnly)
|
|
await downloadManager.addOfflinePlaylist(
|
|
Playlist(trackCount: downloadTracks.length, tracks: downloadTracks, title: playlist.name),
|
|
private: false,
|
|
quality: quality
|
|
);
|
|
|
|
//Add playlist id to stream, stream is for updating ui only
|
|
importingStream.add(playlistId);
|
|
importingSpotifyPlaylist = playlist;
|
|
}
|
|
doneImporting = true;
|
|
//Return DEEZER playlist id
|
|
return playlistId;
|
|
}
|
|
|
|
}
|
|
|
|
class SpotifyTrack {
|
|
String title;
|
|
String artists;
|
|
String isrc;
|
|
TrackImportState state = TrackImportState.NONE;
|
|
|
|
SpotifyTrack({this.title, this.artists, this.isrc});
|
|
|
|
//JSON
|
|
factory SpotifyTrack.fromJson(Map json) => SpotifyTrack(
|
|
title: json['name'],
|
|
artists: json['artists'].map((j) => j['name']).toList().join(', '),
|
|
isrc: json['external_ids']['isrc']
|
|
);
|
|
}
|
|
|
|
class SpotifyPlaylist {
|
|
String name;
|
|
String description;
|
|
List<SpotifyTrack> tracks;
|
|
String image;
|
|
|
|
SpotifyPlaylist({this.name, this.description, this.tracks, this.image});
|
|
|
|
//JSON
|
|
factory SpotifyPlaylist.fromJson(Map json) => SpotifyPlaylist(
|
|
name: json['name'],
|
|
description: json['description'],
|
|
image: (json['images'].length > 0) ? json['images'][0]['url'] : null,
|
|
tracks: json['tracks']['items'].map<SpotifyTrack>((j) => SpotifyTrack.fromJson(j['track'])).toList()
|
|
);
|
|
}
|
|
|
|
class SpotifyAlbum {
|
|
String upc;
|
|
|
|
SpotifyAlbum({this.upc});
|
|
|
|
//JSON
|
|
factory SpotifyAlbum.fromJson(Map json) => SpotifyAlbum(
|
|
upc: json['external_ids']['upc']
|
|
);
|
|
}
|
|
|
|
enum TrackImportState {
|
|
NONE,
|
|
ERROR,
|
|
OK
|
|
} |