private Bitmap createVideoThumbnail(String url) {
Bitmap bitmap = null;
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
int kind = MediaStore.Video.Thumbnails.MINI_KIND;
try {
if (Build.VERSION.SDK_INT >= 14) {
retriever.setDataSource(url, new HashMap<String, String>());
} else {
retriever.setDataSource(url);
}
bitmap = retriever.getFrameAtTime();
} catch (IllegalArgumentException ex) {
// Assume this is a corrupt video file
} catch (RuntimeException ex) {
// Assume this is a corrupt video file.
} finally {
try {
retriever.release();
} catch (RuntimeException ex) {
// Ignore failures while cleaning up.
}
}
if (kind == MediaStore.Images.Thumbnails.MICRO_KIND && bitmap != null) {
bitmap =
ThumbnailUtils.extractThumbnail(bitmap, 10, 10, ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
}
return bitmap;
}
private static Bitmap createVideoThumbnailBitmap(
String filePath, FileDescriptor fd, int targetWidth) {
Bitmap bitmap = null;
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
try {
if (filePath != null) {
retriever.setDataSource(filePath);
} else {
retriever.setDataSource(fd);
}
bitmap = retriever.getFrameAtTime(-1);
} catch (IllegalArgumentException ex) {
// Assume this is a corrupt video file
} catch (RuntimeException ex) {
// Assume this is a corrupt video file.
} finally {
try {
retriever.release();
} catch (RuntimeException ex) {
// Ignore failures while cleaning up.
}
}
if (bitmap == null) return null;
// Scale down the bitmap if it is bigger than we need.
int width = bitmap.getWidth();
int height = bitmap.getHeight();
if (width > targetWidth) {
float scale = (float) targetWidth / width;
int w = Math.round(scale * width);
int h = Math.round(scale * height);
bitmap = Bitmap.createScaledBitmap(bitmap, w, h, true);
}
return bitmap;
}
private int getDuration() {
Movie movie = mItems.get(mCurrentItem);
MediaMetadataRetriever mmr = new MediaMetadataRetriever();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
mmr.setDataSource(movie.getVideoUrl(), new HashMap<String, String>());
} else {
mmr.setDataSource(movie.getVideoUrl());
}
String time = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
long duration = Long.parseLong(time);
return (int) duration;
}
public UFile(String path) {
try {
file = new File(path);
this.path = file.getPath();
this.name = file.getName();
size = file.length();
thumbNail = null;
if (isMovie()) {
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
retriever.setDataSource(path);
String time = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
movieLength = Long.parseLong(time);
thumbNail =
ThumbnailUtils.createVideoThumbnail(
path, MediaStore.Video.Thumbnails.FULL_SCREEN_KIND);
} else if (isImage()) {
Bitmap temp = BitmapFactory.decodeFile(file.getPath());
float scale = context.getResources().getDisplayMetrics().densityDpi / 160f;
thumbNail =
ThumbnailUtils.extractThumbnail(temp, (int) (50f * scale), (int) (50f * scale));
} else if (file.isDirectory()) {
thumbNail = BitmapFactory.decodeResource(null, R.mipmap.docu);
}
} catch (Exception e) {
file = null;
}
}
/**
* @param sourceFile
* @throws IOException
*/
private final void handlePrepare(final String source_file) throws IOException {
if (DEBUG) Log.v(TAG, "handlePrepare:");
synchronized (mSync) {
if (mState != STATE_STOP) {
throw new RuntimeException("invalid state:" + mState);
}
}
final File src = new File(source_file);
if (TextUtils.isEmpty(source_file) || !src.canRead()) {
throw new FileNotFoundException("Unable to read " + source_file);
}
mVideoTrackIndex = -1;
mMetadata = new MediaMetadataRetriever();
mMetadata.setDataSource(source_file);
updateMovieInfo();
// preparation for video playback
mVideoTrackIndex = internal_prepare_video(source_file);
if (mVideoTrackIndex < 0) {
throw new RuntimeException("No video track found in " + source_file);
}
synchronized (mSync) {
mState = STATE_PREPARED;
}
mCallback.onPrepared();
}
public Bitmap getFrameAtTime(long time) {
if (retriever == null) {
retriever = new MediaMetadataRetriever();
retriever.setDataSource(filePath);
}
return retriever.getFrameAtTime(time * 1000, MediaMetadataRetriever.OPTION_CLOSEST);
}
private Dimensions getVideoDimensions(File file) throws NotAVideoFile {
MediaMetadataRetriever metadataRetriever = new MediaMetadataRetriever();
try {
metadataRetriever.setDataSource(file.getAbsolutePath());
} catch (Exception e) {
throw new NotAVideoFile();
}
String hasVideo =
metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO);
if (hasVideo == null) {
throw new NotAVideoFile();
}
int rotation = extractRotationFromMediaRetriever(metadataRetriever);
boolean rotated = rotation == 90 || rotation == 270;
int height;
try {
String h =
metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
height = Integer.parseInt(h);
} catch (Exception e) {
height = -1;
}
int width;
try {
String w = metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
width = Integer.parseInt(w);
} catch (Exception e) {
width = -1;
}
metadataRetriever.release();
Log.d(Config.LOGTAG, "extracted video dims " + width + "x" + height);
return rotated ? new Dimensions(width, height) : new Dimensions(height, width);
}
/**
* Sets the data source as a content Uri. Call this method before the rest of the methods in this
* class. This method may be time-consuming.
*
* @param context the Context to use when resolving the Uri
* @param uri the Content URI of the data you want to play
* @throws IllegalArgumentException if the Uri is invalid
* @throws SecurityException if the Uri cannot be used due to lack of permission.
*/
public void setDataSource(Context context, Uri uri)
throws IllegalArgumentException, SecurityException {
if (uri == null) {
throw new IllegalArgumentException();
}
String scheme = uri.getScheme();
if (scheme == null || scheme.equals("file")) {
setDataSource(uri.getPath());
return;
}
AssetFileDescriptor fd = null;
try {
ContentResolver resolver = context.getContentResolver();
try {
fd = resolver.openAssetFileDescriptor(uri, "r");
} catch (FileNotFoundException e) {
throw new IllegalArgumentException();
}
if (fd == null) {
throw new IllegalArgumentException();
}
FileDescriptor descriptor = fd.getFileDescriptor();
if (!descriptor.valid()) {
throw new IllegalArgumentException();
}
// Note: using getDeclaredLength so that our behavior is the same
// as previous versions when the content provider is returning
// a full file.
if (fd.getDeclaredLength() < 0) {
setDataSource(descriptor);
} else {
setDataSource(descriptor, fd.getStartOffset(), fd.getDeclaredLength());
}
return;
} catch (SecurityException ex) {
} finally {
try {
if (fd != null) {
fd.close();
}
} catch (IOException ioEx) {
}
}
setDataSource(uri.toString());
}
public static long getVideoDurationInMillis(String videoFile) {
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
retriever.setDataSource(videoFile);
String time = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
long timeInmillisec = Long.parseLong(time);
retriever.release();
return timeInmillisec;
}
/**
* 获取本地音乐缩略图的方法
*
* @param filePath
* @return
*/
@SuppressLint("NewApi")
public static Bitmap getLocalMusicBitmap(String filePath) {
Bitmap bitmap = null;
MediaMetadataRetriever mmr = new MediaMetadataRetriever();
mmr.setDataSource(filePath);
bitmap = Bytes2Bimap(mmr.getEmbeddedPicture());
return bitmap;
}
public void setVideoPath(String path) {
mediaMetadataRetriever = new MediaMetadataRetriever();
try {
mediaMetadataRetriever.setDataSource(path);
String duration =
mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
videoLength = Long.parseLong(duration);
} catch (Exception e) {
FileLog.e("tmessages", e);
}
}
public static void setAlbumArt(ImageView imageview, String file, boolean compress) {
String albumArtpath = allSongsList.getAlbumArt(file);
if (albumArtpath != null) {
File albumArtFile = new File(albumArtpath);
Bitmap bm = null;
InputStream iStream1 = null;
InputStream iStream2 = null;
try {
iStream1 = new BufferedInputStream(new FileInputStream(albumArtFile));
if (!compress) {
bm = BitmapFactory.decodeStream(iStream1);
} else {
iStream2 = new BufferedInputStream(new FileInputStream(albumArtFile));
bm = decodeFile2(iStream1, iStream2, 100, 100);
}
imageview.setImageBitmap(bm);
} catch (FileNotFoundException e) {
MediaMetadataRetriever md = new MediaMetadataRetriever();
md.setDataSource(file);
byte[] art = md.getEmbeddedPicture();
if (art != null) {
iStream1 = new ByteArrayInputStream(md.getEmbeddedPicture());
if (!compress) {
bm = BitmapFactory.decodeStream(iStream1);
} else {
iStream2 = new ByteArrayInputStream(md.getEmbeddedPicture());
bm = decodeFile2(iStream1, iStream2, 100, 100);
}
imageview.setImageBitmap(bm);
} else {
imageview.setImageDrawable(
imageview
.getContext()
.getResources()
.getDrawable(R.drawable.ic_expandplayer_placeholder));
}
}
} else {
imageview.setImageDrawable(
imageview
.getContext()
.getResources()
.getDrawable(R.drawable.ic_expandplayer_placeholder));
}
}
// @TargetApi(11)
private void calculateDuration(ContentValues map) throws IOException {
if (Utils.isGingerBreadMROrLater()) {
File videoFile = fileFromResourceMap(map);
MediaMetadataRetriever mmr = new MediaMetadataRetriever();
mmr.setDataSource(videoFile.toString());
String duration = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
if (!TextUtils.isEmpty(duration)) {
map.put(Resources.DURATION, Integer.valueOf(duration));
}
mmr.release();
}
}
public static Bitmap getBitmap(Context context, int id, boolean isImage) {
String filename = getDataFilepathForMedia(context.getContentResolver(), id, isImage);
/* ttt_installer:remove_line */ Log.d(GTG.TAG, "Loading bitmap for " + filename);
if (filename == null) return null;
if (isImage) return new BitmapDrawable(context.getResources(), filename).getBitmap();
MediaMetadataRetriever mmr = new MediaMetadataRetriever();
mmr.setDataSource(filename);
return mmr.getFrameAtTime();
}
// Verify result code, result data, and the duration.
private int verify(CameraActivity activity, Uri uri) throws Exception {
assertTrue(activity.isFinishing());
assertEquals(Activity.RESULT_OK, activity.getResultCode());
// Verify the video file
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
retriever.setDataSource(activity, uri);
String duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
assertNotNull(duration);
int durationValue = Integer.parseInt(duration);
Log.v(TAG, "Video duration is " + durationValue);
assertTrue(durationValue > 0);
return durationValue;
}
private void addSongToList(File file) {
if (file.getName().endsWith(".mp3")) {
DatabaseHandler db = new DatabaseHandler(Setting.this);
String songName = file.getName().substring(0, (file.getName().length() - 4));
String songPath = file.getPath();
MediaMetadataRetriever media = new MediaMetadataRetriever();
media.setDataSource(songPath);
byte[] data = media.getEmbeddedPicture();
String songArtist = media.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
String songAlbum = media.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);
media.release();
db.addSongData(new SongData(songName, songPath, songArtist, songAlbum, data, 0));
db.close();
}
}
// two extra methods for async-loading of images
public static Bitmap decodeAlbumArt(String file, boolean compress) {
Bitmap toReturn = null;
String albumArtpath = allSongsList.getAlbumArt(file);
if (albumArtpath != null) {
File albumArtFile = new File(albumArtpath);
Bitmap bm = null;
InputStream iStream1 = null;
InputStream iStream2 = null;
try {
iStream1 = new BufferedInputStream(new FileInputStream(albumArtFile));
if (!compress) {
bm = BitmapFactory.decodeStream(iStream1);
} else {
iStream2 = new BufferedInputStream(new FileInputStream(albumArtFile));
bm = decodeFile2(iStream1, iStream2, 100, 100);
}
} catch (FileNotFoundException e) {
MediaMetadataRetriever md = new MediaMetadataRetriever();
md.setDataSource(file);
byte[] art = md.getEmbeddedPicture();
if (art != null) {
iStream1 = new ByteArrayInputStream(md.getEmbeddedPicture());
if (!compress) {
bm = BitmapFactory.decodeStream(iStream1);
} else {
iStream2 = new ByteArrayInputStream(md.getEmbeddedPicture());
bm = decodeFile2(iStream1, iStream2, 100, 100);
}
}
}
toReturn = bm;
}
return toReturn;
}
private Bitmap getVideoPreview(File file, int size) {
MediaMetadataRetriever metadataRetriever = new MediaMetadataRetriever();
Bitmap frame;
try {
metadataRetriever.setDataSource(file.getAbsolutePath());
frame = metadataRetriever.getFrameAtTime(0);
metadataRetriever.release();
frame = resize(frame, size);
} catch (IllegalArgumentException | NullPointerException e) {
frame = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
frame.eraseColor(0xff000000);
}
Canvas canvas = new Canvas(frame);
Bitmap play =
BitmapFactory.decodeResource(mXmppConnectionService.getResources(), R.drawable.play_video);
float x = (frame.getWidth() - play.getWidth()) / 2.0f;
float y = (frame.getHeight() - play.getHeight()) / 2.0f;
canvas.drawBitmap(play, x, y, null);
return frame;
}
/**
* Returns a (possibly empty) Cursor for given file path
*
* @param path The path to the file to be queried
* @return A new Cursor object
*/
public static Cursor getCursorForFileQuery(String path) {
MatrixCursor matrixCursor = new MatrixCursor(Song.FILLED_PROJECTION);
MediaMetadataRetriever data = new MediaMetadataRetriever();
try {
data.setDataSource(path);
} catch (Exception e) {
Log.w("VanillaMusic", "Failed to extract metadata from " + path);
}
String title = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
String album = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);
String artist = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
String duration = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
if (duration != null) { // looks like we will be able to play this file
// Vanilla requires each file to be identified by its unique id in the media database.
// However: This file is not in the database, so we are going to roll our own
// using the negative crc32 sum of the path value. While this is not perfect
// (the same file may be accessed using various paths) it's the fastest method
// and far good enough.
CRC32 crc = new CRC32();
crc.update(path.getBytes());
Long songId =
(Long) (2 + crc.getValue())
* -1; // must at least be -2 (-1 defines Song-Object to be empty)
// Build minimal fake-database entry for this file
Object[] objData = new Object[] {songId, path, "", "", "", 0, 0, 0, 0};
if (title != null) objData[2] = title;
if (album != null) objData[3] = album;
if (artist != null) objData[4] = artist;
if (duration != null) objData[7] = Long.parseLong(duration, 10);
matrixCursor.addRow(objData);
}
return matrixCursor;
}
private void initMediaDuration(Uri uri) throws MmsException {
if (uri == null) {
throw new IllegalArgumentException("Uri may not be null.");
}
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
int duration = 0;
try {
retriever.setDataSource(mContext, uri);
String dur = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
if (dur != null) {
duration = Integer.parseInt(dur);
}
mDuration = duration;
Xlog.i(TAG, "Got audio duration:" + duration);
} catch (Exception ex) {
Xlog.e(TAG, "MediaMetadataRetriever failed to get duration for " + uri.getPath(), ex);
throw new MmsException(ex);
} finally {
retriever.release();
}
}
@Override
public Bitmap getBitmap(int position) {
MusicInfo musicInfo = (MusicInfo) getItem(position);
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
retriever.setDataSource(mContext, musicInfo.getUri());
byte[] albumArt = retriever.getEmbeddedPicture();
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 4; // 2의 배수
Bitmap bitmap;
if (null != albumArt) {
bitmap = BitmapFactory.decodeByteArray(albumArt, 0, albumArt.length, options);
} else {
bitmap = BitmapFactory.decodeResource(mContext.getResources(), R.mipmap.ic_no_image);
}
// id 로부터 bitmap 생성
return bitmap;
}
public void sendVideo(Peer peer, String fullFilePath, String fileName) {
try {
MediaMetadataRetriever retriever = new MediaMetadataRetriever();
retriever.setDataSource(fullFilePath);
int duration =
(int)
(Long.parseLong(
retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION))
/ 1000L);
Bitmap img = retriever.getFrameAtTime(0);
int width = img.getWidth();
int height = img.getHeight();
Bitmap smallThumb = ImageHelper.scaleFit(img, 90, 90);
byte[] smallThumbData = ImageHelper.save(smallThumb);
FastThumb thumb =
new FastThumb(smallThumb.getWidth(), smallThumb.getHeight(), smallThumbData);
sendVideo(peer, fileName, width, height, duration, thumb, fullFilePath);
} catch (Throwable e) {
e.printStackTrace();
}
}
private boolean RetrieverFile(String path, int nType) {
nVideoW = 0;
nVideoH = 0;
// 取得影片寬高
MediaMetadataRetriever metaRetriever = new MediaMetadataRetriever();
// --20150327-fix crash bug
try {
metaRetriever.setDataSource(path);
} catch (Exception e) {
e.printStackTrace();
metaRetriever.release();
Log.v(TAG, "PATH=" + path);
Log.e(TAG, "MediaMetadataRetriever setDataSource error");
return false;
} // !--20150327-fix crash bug
if (nType == 1) {
String temp = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
if (temp != null) {
try {
nVideoW = Integer.parseInt(temp);
} catch (Exception e) {
e.printStackTrace();
}
}
temp = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
if (temp != null) {
try {
nVideoH = Integer.parseInt(temp);
} catch (Exception e) {
e.printStackTrace();
}
}
}
metaRetriever.release();
return true;
}
public AlbumMetaData mediaMetaData(String file_path) {
AlbumMetaData albumMetaData = new AlbumMetaData();
try {
if (mmr == null) {
mmr = new MediaMetadataRetriever();
}
mmr.setDataSource(file_path);
albumMetaData.file_path = file_path;
albumMetaData.title = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
albumMetaData.album_artist =
mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUMARTIST);
albumMetaData.artist = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
albumMetaData.author = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_AUTHOR);
albumMetaData.genre = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_AUTHOR);
albumMetaData.duration = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
// albumMetaData.album_art = mmr.getEmbeddedPicture();
} catch (Exception ex) {
Log.e("Error: ", "Unable to get meta data");
}
if (albumMetaData.file_path == null || albumMetaData.file_path.isEmpty())
albumMetaData.file_path = "";
if (albumMetaData.album_artist == null || albumMetaData.album_artist.isEmpty())
albumMetaData.album_artist = "Unknown Album Artist";
if (albumMetaData.title == null || albumMetaData.title.isEmpty())
albumMetaData.title = "Unknown Title";
if (albumMetaData.artist == null || albumMetaData.artist.isEmpty())
albumMetaData.artist = "Unknown Artist";
if (albumMetaData.author == null || albumMetaData.author.isEmpty())
albumMetaData.author = "Unknown Author";
if (albumMetaData.genre == null || albumMetaData.genre.isEmpty())
albumMetaData.genre = "Unknown Genre";
if (albumMetaData.duration == null || albumMetaData.duration.isEmpty())
albumMetaData.duration = "-:-";
mmr.release();
return albumMetaData;
}
@Override
public void run() {
FeedMedia media = DBReader.getFeedMedia(DownloadService.this, request.getFeedfileId());
if (media == null) {
throw new IllegalStateException("Could not find downloaded media object in database");
}
boolean chaptersRead = false;
media.setDownloaded(true);
media.setFile_url(request.getDestination());
// Get duration
MediaMetadataRetriever mmr = null;
try {
mmr = new MediaMetadataRetriever();
mmr.setDataSource(media.getFile_url());
String durationStr = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
media.setDuration(Integer.parseInt(durationStr));
if (AppConfig.DEBUG) Log.d(TAG, "Duration of file is " + media.getDuration());
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (RuntimeException e) {
e.printStackTrace();
} finally {
if (mmr != null) {
mmr.release();
}
}
if (media.getItem().getChapters() == null) {
ChapterUtils.loadChaptersFromFileUrl(media);
if (media.getItem().getChapters() != null) {
chaptersRead = true;
}
}
try {
if (chaptersRead) {
DBWriter.setFeedItem(DownloadService.this, media.getItem()).get();
}
DBWriter.setFeedMedia(DownloadService.this, media).get();
if (!DBTasks.isInQueue(DownloadService.this, media.getItem().getId())) {
DBWriter.addQueueItem(DownloadService.this, media.getItem().getId()).get();
}
} catch (ExecutionException e) {
e.printStackTrace();
status =
new DownloadStatus(
media,
media.getEpisodeTitle(),
DownloadError.ERROR_DB_ACCESS_ERROR,
false,
e.getMessage());
} catch (InterruptedException e) {
e.printStackTrace();
status =
new DownloadStatus(
media,
media.getEpisodeTitle(),
DownloadError.ERROR_DB_ACCESS_ERROR,
false,
e.getMessage());
}
saveDownloadStatus(status);
sendDownloadHandledIntent();
numberOfDownloads.decrementAndGet();
queryDownloadsAsync();
}
private void CheckDir(String src) {
// http://www.exampledepot.com/egs/java.io/GetFiles.html
File rootNode = new File(src);
boolean folderHasAlbumArt = false;
try {
if (rootNode.list(hasAlbumArt).length > 0) {
folderHasAlbumArt = true;
}
for (String mp3 : rootNode.list(isMP3)) {
metaDataReader.setDataSource(src + mp3);
title = metaDataReader.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
String preFormat =
metaDataReader.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER);
String postFormat = "0";
String item;
boolean passed = false;
if (preFormat != null && preFormat != "") {
for (int i = 0; i < preFormat.length(); i++) {
item = preFormat.substring(i, i + 1);
if (item != "/" && passed != true) {
postFormat = postFormat + item;
} else {
passed = true;
}
}
try {
number = Integer.parseInt(postFormat);
} catch (NumberFormatException e) {
// TODO fill
}
} else {
number = 0;
}
artist = metaDataReader.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
album = metaDataReader.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);
length =
Double.parseDouble(
metaDataReader.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION));
if (title == null) {
title = "Unknown";
}
if (artist == null) {
artist = "Unknown";
}
if (album == null) {
album = "Unknown";
}
Track t = new Track(trackCount, title, number, artist, album, length, src + mp3);
t.SetAlbumArt(folderHasAlbumArt);
t.SetRootSrc(src);
AddTrack(t);
trackCount++;
}
for (String dir : rootNode.list(isDIR)) {
CheckDir(src + dir + "/");
}
} catch (NullPointerException e) {
// Probably No SD-Card
Log.v(preferences.GetTag(), e.getMessage());
}
}
/**
* Sets the data source (FileDescriptor) to use. It is the caller's responsibility to close the
* file descriptor. It is safe to do so as soon as this call returns. Call this method before the
* rest of the methods in this class. This method may be time-consuming.
*
* @param fd the FileDescriptor for the file you want to play
* @throws IllegalArgumentException if the FileDescriptor is invalid
*/
public void setDataSource(FileDescriptor fd) throws IllegalArgumentException {
// intentionally less than LONG_MAX
setDataSource(fd, 0, 0x7ffffffffffffffL);
}
@SuppressLint("NewApi")
public static Bitmap getLocalVideoBitmap(String filePath) {
MediaMetadataRetriever mmr = new MediaMetadataRetriever();
mmr.setDataSource(filePath);
return mmr.getFrameAtTime();
}
public void displaySongInfo(final MusicDirectory.Entry song) {
Integer bitrate = null;
String format = null;
long size = 0;
try {
DownloadFile downloadFile = new DownloadFile(SubsonicTabActivity.this, song, false);
File file = downloadFile.getCompleteFile();
if (file.exists()) {
MediaMetadataRetriever metadata = new MediaMetadataRetriever();
metadata.setDataSource(file.getAbsolutePath());
String tmp = metadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE);
bitrate = Integer.parseInt((tmp != null) ? tmp : "0") / 1000;
format = FileUtil.getExtension(file.getName());
size = file.length();
if (Util.isOffline(SubsonicTabActivity.this)) {
song.setGenre(metadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_GENRE));
String year = metadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_YEAR);
song.setYear(Integer.parseInt((year != null) ? year : "0"));
}
}
} catch (Exception e) {
Log.i(TAG, "Device doesn't properly support MediaMetadataRetreiver");
}
String msg = "";
if (!song.isVideo()) {
msg += "Artist: " + song.getArtist() + "\nAlbum: " + song.getAlbum();
}
if (song.getTrack() != null && song.getTrack() != 0) {
msg += "\nTrack: " + song.getTrack();
}
if (song.getGenre() != null && !"".equals(song.getGenre())) {
msg += "\nGenre: " + song.getGenre();
}
if (song.getYear() != null && song.getYear() != 0) {
msg += "\nYear: " + song.getYear();
}
if (!Util.isOffline(SubsonicTabActivity.this)) {
msg += "\nServer Format: " + song.getSuffix();
if (song.getBitRate() != null && song.getBitRate() != 0) {
msg += "\nServer Bitrate: " + song.getBitRate() + " kpbs";
}
}
if (format != null && !"".equals(format)) {
msg += "\nCached Format: " + format;
}
if (bitrate != null && bitrate != 0) {
msg += "\nCached Bitrate: " + bitrate + " kpbs";
}
if (size != 0) {
msg += "\nSize: " + Util.formatBytes(size);
}
if (song.getDuration() != null && song.getDuration() != 0) {
msg += "\nLength: " + Util.formatDuration(song.getDuration());
}
new AlertDialog.Builder(this)
.setIcon(android.R.drawable.ic_dialog_alert)
.setTitle(song.getTitle())
.setMessage(msg)
.show();
}
