koel/app/Services/FileSynchronizer.php

363 lines
12 KiB
PHP
Raw Normal View History

2016-03-22 08:22:39 +00:00
<?php
namespace App\Services;
2016-03-22 08:22:39 +00:00
use App\Models\Album;
use App\Models\Artist;
use App\Models\Song;
2018-08-29 06:15:11 +00:00
use App\Repositories\SongRepository;
use getID3;
use getid3_lib;
use Illuminate\Contracts\Cache\Repository as Cache;
2018-08-29 09:42:11 +00:00
use InvalidArgumentException;
2016-03-22 08:22:39 +00:00
use SplFileInfo;
2016-08-07 10:31:19 +00:00
use Symfony\Component\Finder\Finder;
2020-12-22 20:11:22 +00:00
use Throwable;
2016-03-22 08:22:39 +00:00
class FileSynchronizer
2016-03-22 08:22:39 +00:00
{
2020-06-07 20:43:04 +00:00
public const SYNC_RESULT_SUCCESS = 1;
public const SYNC_RESULT_BAD_FILE = 2;
public const SYNC_RESULT_UNMODIFIED = 3;
2018-08-29 06:15:11 +00:00
private $getID3;
private $mediaMetadataService;
private $helperService;
private $songRepository;
private $cache;
private $finder;
2016-03-22 08:22:39 +00:00
2020-12-22 20:11:22 +00:00
/** @var SplFileInfo */
private $splFileInfo;
2016-03-22 08:22:39 +00:00
2020-12-22 20:11:22 +00:00
/** @var int */
private $fileModifiedTime;
2018-08-19 09:05:33 +00:00
2020-12-22 20:11:22 +00:00
/** @var string */
private $filePath;
2016-03-22 08:22:39 +00:00
/**
* A (MD5) hash of the file's path.
* This value is unique, and can be used to query a Song record.
2016-03-22 08:22:39 +00:00
*
* @var string
2016-03-22 08:22:39 +00:00
*/
private $fileHash;
2016-03-22 08:22:39 +00:00
/**
* The song model that's associated with the current file.
*
* @var Song|null
*/
private $song;
2020-12-22 20:11:22 +00:00
/** @var string|null */
private $syncError;
2018-08-29 06:15:11 +00:00
public function __construct(
getID3 $getID3,
MediaMetadataService $mediaMetadataService,
HelperService $helperService,
SongRepository $songRepository,
Cache $cache,
Finder $finder
2019-06-30 11:13:41 +00:00
) {
$this->getID3 = $getID3;
$this->mediaMetadataService = $mediaMetadataService;
$this->helperService = $helperService;
$this->songRepository = $songRepository;
$this->cache = $cache;
$this->finder = $finder;
}
2017-06-03 23:21:50 +00:00
2020-12-22 20:11:22 +00:00
/** @param string|SplFileInfo $path */
public function setFile($path): self
{
2016-04-05 07:38:10 +00:00
$this->splFileInfo = $path instanceof SplFileInfo ? $path : new SplFileInfo($path);
2017-12-09 02:24:09 +00:00
// Workaround for #344, where getMTime() fails for certain files with Unicode names on Windows.
try {
$this->fileModifiedTime = $this->splFileInfo->getMTime();
2020-12-22 20:11:22 +00:00
} catch (Throwable $e) {
// Not worth logging the error. Just use current stamp for mtime.
$this->fileModifiedTime = time();
}
$this->filePath = $this->splFileInfo->getPathname();
$this->fileHash = $this->helperService->getFileHash($this->filePath);
$this->song = $this->songRepository->getOneById($this->fileHash);
2018-08-29 06:15:11 +00:00
$this->syncError = null;
return $this;
2016-03-22 08:22:39 +00:00
}
/**
2019-06-30 13:35:56 +00:00
* Get all applicable info from the file.
2020-12-22 20:11:22 +00:00
*
* @return array<mixed>
2016-03-22 08:22:39 +00:00
*/
public function getFileInfo(): array
2016-03-22 08:22:39 +00:00
{
$info = $this->getID3->analyze($this->filePath);
2016-03-22 08:22:39 +00:00
2016-04-17 15:38:06 +00:00
if (isset($info['error']) || !isset($info['playtime_seconds'])) {
$this->syncError = isset($info['error']) ? $info['error'][0] : 'No playtime found';
2017-06-03 23:21:50 +00:00
return [];
2016-03-22 08:22:39 +00:00
}
// Copy the available tags over to comment.
// This is a helper from getID3, though it doesn't really work well.
// We'll still prefer getting ID3v2 tags directly later.
getid3_lib::CopyTagsToComments($info);
2016-03-22 08:22:39 +00:00
$props = [
'artist' => '',
'album' => '',
2019-08-07 08:17:30 +00:00
'albumartist' => '',
'compilation' => false,
2020-12-22 20:11:22 +00:00
'title' => basename($this->filePath, '.' . pathinfo($this->filePath, PATHINFO_EXTENSION)),
2016-03-22 08:22:39 +00:00
'length' => $info['playtime_seconds'],
2019-08-07 08:17:30 +00:00
'track' => $this->getTrackNumberFromInfo($info),
2019-06-30 11:13:41 +00:00
'disc' => (int) array_get($info, 'comments.part_of_a_set.0', 1),
2016-03-22 08:22:39 +00:00
'lyrics' => '',
'cover' => array_get($info, 'comments.picture', [null])[0],
'path' => $this->filePath,
'mtime' => $this->fileModifiedTime,
2016-03-22 08:22:39 +00:00
];
2020-12-22 20:11:22 +00:00
$comments = array_get($info, 'comments_html');
if (!$comments) {
2016-03-22 08:22:39 +00:00
return $props;
}
2019-06-30 13:35:56 +00:00
$this->gatherPropsFromTags($info, $comments, $props);
$props['compilation'] = (bool) $props['compilation'] || $this->isCompilation($props);
2017-04-23 16:01:02 +00:00
return $props;
2016-03-22 08:22:39 +00:00
}
2018-08-29 09:42:11 +00:00
2016-03-22 08:22:39 +00:00
/**
* Sync the song with all available media info against the database.
*
2020-12-22 20:11:22 +00:00
* @param array<string> $tags The (selective) tags to sync (if the song exists)
* @param bool $force Whether to force syncing, even if the file is unchanged
2016-03-22 08:22:39 +00:00
*/
public function sync(array $tags, bool $force = false): int
2016-03-22 08:22:39 +00:00
{
if (!$this->isFileNewOrChanged() && !$force) {
2017-06-03 23:21:50 +00:00
return self::SYNC_RESULT_UNMODIFIED;
2016-03-22 08:22:39 +00:00
}
2020-12-22 20:11:22 +00:00
$info = $this->getFileInfo();
if (!$info) {
2017-06-03 23:21:50 +00:00
return self::SYNC_RESULT_BAD_FILE;
2016-03-22 08:22:39 +00:00
}
2016-07-05 10:14:12 +00:00
// Fixes #366. If the file is new, we use all tags by simply setting $force to false.
if ($this->isFileNew()) {
2016-07-05 10:14:12 +00:00
$force = false;
}
if ($this->isFileChanged() || $force) {
2016-03-22 08:22:39 +00:00
// This is a changed file, or the user is forcing updates.
// In such a case, the user must have specified a list of tags to sync.
// A sample command could be: ./artisan koel:sync --force --tags=artist,album,lyrics
// We cater for these tags by removing those not specified.
2016-06-04 18:17:27 +00:00
// There's a special case with 'album' though.
// If 'compilation' tag is specified, 'album' must be counted in as well.
2016-06-04 18:17:27 +00:00
// But if 'album' isn't specified, we don't want to update normal albums.
// This variable is to keep track of this state.
$changeCompilationAlbumOnly = false;
2018-08-30 02:53:18 +00:00
2016-08-16 15:12:11 +00:00
if (in_array('compilation', $tags, true) && !in_array('album', $tags, true)) {
$tags[] = 'album';
2016-06-04 18:17:27 +00:00
$changeCompilationAlbumOnly = true;
}
2016-03-22 08:22:39 +00:00
$info = array_intersect_key($info, array_flip($tags));
// If the "artist" tag is specified, use it.
// Otherwise, re-use the existing model value.
$artist = isset($info['artist']) ? Artist::getOrCreate($info['artist']) : $this->song->album->artist;
// If the "album" tag is specified, use it.
// Otherwise, re-use the existing model value.
2016-06-04 18:17:27 +00:00
if (isset($info['album'])) {
$album = $changeCompilationAlbumOnly
? $this->song->album
: Album::getOrCreate($artist, $info['album'], array_get($info, 'compilation'));
2016-06-04 18:17:27 +00:00
} else {
$album = $this->song->album;
}
2016-03-22 08:22:39 +00:00
} else {
// The file is newly added.
$artist = Artist::getOrCreate($info['artist']);
$album = Album::getOrCreate($artist, $info['album'], array_get($info, 'compilation'));
2016-03-22 08:22:39 +00:00
}
if (!$album->has_cover) {
$this->generateAlbumCover($album, array_get($info, 'cover'));
}
2016-03-22 08:22:39 +00:00
2017-12-09 02:24:09 +00:00
$data = array_except($info, ['artist', 'albumartist', 'album', 'cover', 'compilation']);
$data['album_id'] = $album->id;
$data['artist_id'] = $artist->id;
$this->song = Song::updateOrCreate(['id' => $this->fileHash], $data);
2017-06-03 23:21:50 +00:00
return self::SYNC_RESULT_SUCCESS;
}
/**
* Try to generate a cover for an album based on extracted data, or use the cover file under the directory.
*
2020-12-22 20:11:22 +00:00
* @param array<mixed>|null $coverData
2017-06-03 23:21:50 +00:00
*/
2018-08-30 02:53:18 +00:00
private function generateAlbumCover(Album $album, ?array $coverData): void
2017-06-03 23:21:50 +00:00
{
// If the album has no cover, we try to get the cover image from existing tag data
if ($coverData) {
2018-08-19 09:05:33 +00:00
$extension = explode('/', $coverData['image_mime']);
2020-12-22 20:11:22 +00:00
$extension = $extension[1] ? 'png' : $extension[1];
2017-06-03 23:21:50 +00:00
2018-08-19 09:05:33 +00:00
$this->mediaMetadataService->writeAlbumCover($album, $coverData['data'], $extension);
return;
2017-06-03 23:21:50 +00:00
}
2016-03-22 08:22:39 +00:00
2017-06-03 23:21:50 +00:00
// Or, if there's a cover image under the same directory, use it.
2020-12-22 20:11:22 +00:00
$cover = $this->getCoverFileUnderSameDirectory();
if ($cover) {
$extension = pathinfo($cover, PATHINFO_EXTENSION);
$this->mediaMetadataService->writeAlbumCover($album, file_get_contents($cover), $extension);
2017-06-03 23:21:50 +00:00
}
2016-03-22 08:22:39 +00:00
}
/**
* Issue #380.
* Some albums have its own cover image under the same directory as cover|folder.jpg/png.
* We'll check if such a cover file is found, and use it if positive.
*
2018-08-19 09:05:33 +00:00
* @throws InvalidArgumentException
*/
2018-08-24 15:27:19 +00:00
private function getCoverFileUnderSameDirectory(): ?string
{
// As directory scanning can be expensive, we cache and reuse the result.
2020-12-22 20:11:22 +00:00
return $this->cache->remember(md5($this->filePath . '_cover'), 24 * 60, function (): ?string {
2020-03-10 10:16:55 +00:00
$matches = array_keys(
iterator_to_array(
$this->finder->create()
2020-12-22 20:11:22 +00:00
->depth(0)
->ignoreUnreadableDirs()
->files()
->followLinks()
->name('/(cov|fold)er\.(jpe?g|png)$/i')
->in(dirname($this->filePath))
)
2017-08-05 21:58:50 +00:00
);
2018-08-24 15:27:19 +00:00
$cover = $matches ? $matches[0] : null;
2018-08-19 09:05:33 +00:00
2019-06-30 13:35:56 +00:00
return $cover && $this->isImage($cover) ? $cover : null;
2017-08-05 21:58:50 +00:00
});
}
private function isImage(string $path): bool
{
try {
2019-06-30 11:13:41 +00:00
return (bool) exif_imagetype($path);
2020-12-22 20:11:22 +00:00
} catch (Throwable $e) {
return false;
}
}
/**
* Determine if the file is new (its Song record can't be found in the database).
*/
public function isFileNew(): bool
{
return !$this->song;
}
/**
* Determine if the file is changed (its Song record is found, but the timestamp is different).
*/
public function isFileChanged(): bool
2016-03-22 08:22:39 +00:00
{
return !$this->isFileNew() && $this->song->mtime !== $this->fileModifiedTime;
2016-03-22 08:22:39 +00:00
}
2018-08-19 09:05:33 +00:00
public function isFileNewOrChanged(): bool
2018-08-19 09:05:33 +00:00
{
return $this->isFileNew() || $this->isFileChanged();
2018-08-29 06:15:11 +00:00
}
public function getSyncError(): ?string
2018-08-29 06:15:11 +00:00
{
return $this->syncError;
2018-08-19 09:05:33 +00:00
}
2019-06-30 13:35:56 +00:00
private function getTrackNumberFromInfo(array $info): int
{
$track = 0;
// Apparently track numbers can be stored with different indices as the following.
$trackIndices = [
'comments.track',
'comments.tracknumber',
'comments.track_number',
];
2020-09-06 21:20:42 +00:00
for ($i = 0; $i < count($trackIndices) && $track === 0; ++$i) {
2019-06-30 13:35:56 +00:00
$track = (int) array_get($info, $trackIndices[$i], [0])[0];
}
return $track;
}
private function gatherPropsFromTags(array $info, array $comments, array &$props): void
{
$propertyMap = [
'artist' => 'artist',
'albumartist' => 'band',
'album' => 'album',
'title' => 'title',
2019-08-07 08:17:30 +00:00
'lyrics' => ['unsychronised_lyric', 'unsynchronised_lyric'],
2019-06-30 13:35:56 +00:00
'compilation' => 'part_of_a_compilation',
];
2019-08-07 08:17:30 +00:00
foreach ($propertyMap as $name => $tags) {
foreach ((array) $tags as $tag) {
$value = array_get($info, "tags.id3v2.$tag", [null])[0] ?: array_get($comments, $tag, [''])[0];
if ($value) {
$props[$name] = $value;
}
}
2019-06-30 13:35:56 +00:00
// Fixes #323, where tag names can be htmlentities()'ed
if (is_string($props[$name]) && $props[$name]) {
$props[$name] = trim(html_entity_decode($props[$name]));
}
}
}
private function isCompilation(array $props): bool
{
// A "compilation" property can be determined by:
// - "part_of_a_compilation" tag (used by iTunes), or
// - "albumartist" (used by non-retarded applications).
// Also, the latter is only valid if the value is NOT the same as "artist".
return $props['albumartist'] && $props['artist'] !== $props['albumartist'];
}
2020-06-07 20:43:04 +00:00
public function getSong(): ?Song
{
return $this->song;
}
2016-03-22 08:22:39 +00:00
}