public static void rebuildStats(Context context, String localId) {
Realm realm = Realm.getInstance(Migration.getConfig(context));
RealmResults<TrackStats> statsRes =
realm.where(TrackStats.class).equalTo("local_id", localId).findAll();
if (!statsRes.isEmpty()) {
/*
Log.d(TAG, "hi5");
Log.d(TAG, "==================");
Log.d(TAG, "track.getTitle(): " + track.getTitle());
Log.d(TAG, "track.getCompletedCount(): " + track.getCompletedCount());
Log.d(TAG, "track.getSkippedCount(): " + track.getSkippedCount());
Log.d(TAG, "track.getLikedCount(): " + track.getLikedCount());
Log.d(TAG, "track.getDislikedCount(): " + track.getDislikedCount());
res.where().equalTo("type", TrackStats.SONG_SELECTED) //TODO not implemented yet
*/
int completedCount = 0;
int skippedCount = 0;
int likedCount = 0;
int dislikedCount = 0;
int halfPlayedCount = 0;
int selectedCount = 0;
for (TrackStats ts : statsRes) {
switch (ts.getType()) {
case TrackStats.SONG_COMPLETED:
completedCount++;
break;
case TrackStats.SONG_HALF_PLAYED:
halfPlayedCount++;
break;
case TrackStats.SONG_SELECTED:
selectedCount++;
break;
case TrackStats.SONG_SKIPPED:
skippedCount++;
break;
case TrackStats.SONG_LIKED:
likedCount++;
break;
case TrackStats.SONG_DISLIKED:
dislikedCount++;
break;
}
}
Track track = realm.where(Track.class).equalTo("local_id", localId).findFirst();
realm.beginTransaction();
track.setCompletedCount(completedCount);
track.setHalfPlayedCount(halfPlayedCount);
track.setSelectedCount(selectedCount);
track.setSkippedCount(skippedCount);
track.setLikedCount(likedCount);
track.setDislikedCount(dislikedCount);
track.setStatsUpdatedAt(DateTime.now(Calendar.getInstance().getTimeZone()).toString());
realm.commitTransaction();
}
}
public static void updateLibrary(Context context, boolean rebuildStats) {
Log.d(TAG, "updateLibrary() start");
Realm realm = Realm.getInstance(Migration.getConfig(context));
realm.beginTransaction();
RealmResults<Track> res = realm.where(Track.class).findAll();
for (int x = 0; x < res.size(); x++) {
res.get(x).setIsAvailable(false);
}
realm.commitTransaction();
String where = MediaStore.Audio.Media.IS_MUSIC + " = 1";
String[] selectionArgs = null;
String orderBy = MediaStore.Audio.Media.DEFAULT_SORT_ORDER;
ContentResolver contentResolver = context.getContentResolver();
Cursor[] cursors = new Cursor[2];
cursors[0] =
contentResolver.query(
MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
TRACK_COLUMNS,
where,
selectionArgs,
orderBy);
cursors[1] =
contentResolver.query(
MediaStore.Audio.Media.INTERNAL_CONTENT_URI,
TRACK_COLUMNS,
where,
selectionArgs,
orderBy);
Cursor cursor = new MergeCursor(cursors);
int idColumn = cursor.getColumnIndex(MediaStore.Audio.Media._ID);
int displayNameColumn = cursor.getColumnIndex(MediaStore.Audio.Media.DISPLAY_NAME);
int titleColumn = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE);
int titleKeyColumn = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE_KEY);
int durationColumn = cursor.getColumnIndex(MediaStore.Audio.Media.DURATION);
int trackColumn = cursor.getColumnIndex(MediaStore.Audio.Media.TRACK);
int artistColumn = cursor.getColumnIndex(MediaStore.Audio.Media.ARTIST);
// int dateAddedColumn = cursor.getColumnIndex(MediaStore.Audio.Media.DATE_ADDED);
int dataColumn = cursor.getColumnIndex(MediaStore.Audio.Media.DATA);
int albumColumn = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM);
int albumIdColumn = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM_ID);
int albumKeyColumn = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM_KEY);
realm.beginTransaction();
while (cursor.moveToNext()) {
int minimumDurationToConsiderAsSong = 61500;
Track track = null;
String local_id =
Track.getLocalId(
cursor.getString(titleColumn),
cursor.getString(artistColumn),
cursor.getString(albumColumn));
Track res2 = realm.where(Track.class).equalTo("local_id", local_id).findFirst();
if (res2 != null) {
if (cursor.getInt(durationColumn) < minimumDurationToConsiderAsSong) {
res2.removeFromRealm();
} else {
track = res2;
track.setIsAvailable(true);
if (!track.isHidden()) {
if (rebuildStats) {
rebuildStats(context, track.getLocal_id());
}
}
}
} else {
if (cursor.getInt(durationColumn) > minimumDurationToConsiderAsSong) {
// Log.d(TAG, "hi6 - means its a new record");
// Log.d(TAG, "cursor.getString(titleColumn): " +
// cursor.getString(titleColumn));
// Log.d(TAG, "cursor.getString(artistColumn): " +
// cursor.getString(artistColumn));
// Log.d(TAG, "cursor.getString(albumColumn): " +
// cursor.getString(albumColumn));
track =
new Track(
cursor.getString(titleColumn),
cursor.getString(artistColumn),
cursor.getString(albumColumn),
cursor.getString(dataColumn));
track.setId(cursor.getLong(idColumn));
track.setDisplayName(cursor.getString(displayNameColumn));
track.setTitleKey(cursor.getString(titleKeyColumn));
track.setDuration(cursor.getInt(durationColumn));
track.setTrackNo(cursor.getInt(trackColumn));
track.setAlbumId(cursor.getString(albumIdColumn));
track.setAlbumKey(cursor.getString(albumKeyColumn));
track = realm.copyToRealm(track);
}
}
if (track != null) {
track.setPath(cursor.getString(dataColumn));
}
}
realm.commitTransaction();
cursor.close();
Log.d(TAG, "updateLibrary() end");
}
@Override
public void onCreate() {
super.onCreate();
android_id =
Settings.Secure.getString(
getApplicationContext().getContentResolver(), Settings.Secure.ANDROID_ID);
currentPlaylist = new ArrayList<Track>();
realm = Realm.getInstance(Migration.getConfig(this));
tracks =
realm.where(Track.class).equalTo("isHidden", false).equalTo("isAvailable", true).findAll();
mOnAudioFocusChangeListener =
new AudioManager.OnAudioFocusChangeListener() {
@Override
public void onAudioFocusChange(int focusChange) {
switch (focusChange) {
case AudioManager.AUDIOFOCUS_GAIN:
audioFocus = true;
mp.setVolume(1f, 1f);
if (wasPlaying) {
playPause();
}
break;
case AudioManager.AUDIOFOCUS_LOSS:
audioFocus = false;
wasPlaying = false;
if (mp.isPlaying()) {
mp.stop();
am.abandonAudioFocus(mOnAudioFocusChangeListener);
}
break;
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
audioFocus = false;
if (mp.isPlaying()) {
playPause();
}
break;
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
if (mp.isPlaying()) {
mp.setVolume(0.2f, 0.2f);
}
break;
}
}
};
am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
mp = new MediaPlayer();
mp.setOnPreparedListener(
new MediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(MediaPlayer mp) {
sendBroadcast(new Intent().setAction(INTENT_MP_READY));
Log.d(TAG, "mp.onPrepared!");
mStartTime = System.currentTimeMillis();
accumulatedPlaytimeForThisTrack = 0;
playPause();
}
});
mp.setOnCompletionListener(
new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
Log.d(
TAG,
"onCompletion is called! I want to monitor in the future to see if when i skip a song, will this method be played");
if (currentTrack != null) {
createTrackStats(currentTrack.getLocal_id(), TrackStats.SONG_COMPLETED);
prepNextSong();
}
}
});
mp.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
mReceiver =
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Log.d(TAG, "intent.getAction(): " + intent.getAction());
switch (intent.getAction()) {
case MainActivity.INTENT_PLAY_PAUSE:
playPause();
break;
case MainActivity.INTENT_NEXT:
checkIfRegisterAsSkip();
prepNextSong();
break;
case MainActivity.INTENT_LIKED:
if (currentTrack != null) {
createTrackStats(currentTrack.getLocal_id(), TrackStats.SONG_LIKED);
}
break;
case MainActivity.INTENT_DISLIKED:
if (currentTrack != null) {
createTrackStats(currentTrack.getLocal_id(), TrackStats.SONG_DISLIKED);
}
prepNextSong();
break;
case INTENT_SESSION_TRACKS_GENERATED:
prepNextSong();
break;
case INTENT_DISMISS_NOTIFICATION:
stopMediaPlayerService();
break;
case INTENT_THERE_IS_NO_SONGS:
stopMediaPlayerService();
break;
case AudioManager.ACTION_AUDIO_BECOMING_NOISY:
pause();
break;
case android.content.Intent.ACTION_HEADSET_PLUG:
int state = intent.getIntExtra("state", 4);
if (state == 0) {
// unplugged
pause();
} else if (state == 1) {
// plugged in
if (currentTrack != null) {
play();
}
} else {
// others??
}
break;
}
}
};
intentFilter = new IntentFilter();
intentFilter.addAction(MainActivity.INTENT_PLAY_PAUSE);
intentFilter.addAction(MainActivity.INTENT_NEXT);
intentFilter.addAction(MainActivity.INTENT_LIKED);
intentFilter.addAction(MainActivity.INTENT_DISLIKED);
intentFilter.addAction(INTENT_DISMISS_NOTIFICATION);
intentFilter.addAction(INTENT_THERE_IS_NO_SONGS);
intentFilter.addAction(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
intentFilter.addAction(android.content.Intent.ACTION_HEADSET_PLUG);
// intentFilter.addAction(INTENT_SESSION_TRACKS_GENERATED);
registerReceiver(mReceiver, intentFilter);
initNotification();
}