Added global search and ACRA (crash reports send)

app/build.gradle

@@ -11,6 +11,10 @@ android {
         versionName "0.5-InDev"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
     buildTypes {
         release {
             minifyEnabled false
@@ -34,6 +38,10 @@ dependencies {
     //deezer
     compile 'com.deezer.sdk:deezer-sdk-0.11.2@aar'
 
+    //acra
+    compile "ch.acra:acra-http:5.1.3"
+    compile "ch.acra:acra-toast:5.1.3"
+
     //compat libs
     compile 'com.spotify.android:auth:1.0.0-alpha'
     compile 'com.github.kaaes:spotify-web-api-android:0.4.1'

app/libs/android-auth-1.0/build.gradle

@@ -24,7 +24,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.2.0'
+        classpath 'com.android.tools.build:gradle:2.3.0'
     }
 }
 

app/src/main/AndroidManifest.xml

@@ -4,11 +4,11 @@
 
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
-    <uses-permission android:name="android.permission.MEDIA_CONTENT_CONTROL"/>
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
     <uses-permission android:name="android.permission.INTERNET"/>
 
     <application
+            android:name=".BladeApplication"
             android:allowBackup="true"
             android:icon="@mipmap/ic_launcher"
             android:label="@string/app_name"

app/src/main/java/v/blade/BladeApplication.java

@@ -0,0 +1,33 @@
+package v.blade;
+
+import android.app.Application;
+import android.content.Context;
+import android.widget.Toast;
+import org.acra.ACRA;
+import org.acra.config.CoreConfigurationBuilder;
+import org.acra.config.HttpSenderConfigurationBuilder;
+import org.acra.config.ToastConfigurationBuilder;
+import org.acra.data.StringFormat;
+import org.acra.sender.HttpSender;
+
+public class BladeApplication extends Application
+{
+    @Override
+    protected void attachBaseContext(Context base)
+    {
+        super.attachBaseContext(base);
+        CoreConfigurationBuilder builder = new CoreConfigurationBuilder(this);
+        builder.setBuildConfigClass(BuildConfig.class)
+                .setReportFormat(StringFormat.JSON);
+        builder.getPluginConfigurationBuilder(ToastConfigurationBuilder.class)
+                .setResText(R.string.oncrash)
+                .setLength(Toast.LENGTH_LONG).setEnabled(true);
+        builder.getPluginConfigurationBuilder(HttpSenderConfigurationBuilder.class)
+                .setUri("http://valou3433.fr:5984/acra-blade/_design/acra-storage/_update/report")
+                .setBasicAuthLogin("REPORTER")
+                .setBasicAuthPassword("thereporterpassword")
+                .setHttpMethod(HttpSender.Method.PUT)
+                .setEnabled(true);
+        ACRA.init(this, builder);
+    }
+}

app/src/main/java/v/blade/library/LibraryService.java

@@ -12,6 +12,7 @@
 import android.graphics.BitmapFactory;
 import android.os.Build;
 import android.os.IBinder;
+import android.os.Looper;
 import android.provider.MediaStore;
 import android.support.annotation.NonNull;
 import android.support.v4.app.JobIntentService;
@@ -560,21 +561,21 @@ public void synchronizeLibrary()
         Notification currentNotification = notificationBuilder.build();
         startForeground(0x43, currentNotification);
 
-        /*new Thread()
+        new Thread()
         {
             public void run()
             {
                 Looper.prepare();
+                registerLocalSongs();
+                registerSpotifySongs();
+                registerDeezerSongs();
+                registerSongBetterSources();
+                sortLibrary();
+                synchronization = false;
+
+                stopForeground(true);
             }
-        }.start();*/
-        registerLocalSongs();
-        registerSpotifySongs();
-        registerDeezerSongs();
-        registerSongBetterSources();
-        sortLibrary();
-        synchronization = false;
-
-        stopForeground(true);
+        }.start();
     }
 
     /*
@@ -1179,6 +1180,147 @@ public static ArrayList<LibraryObject> query(String s)
         return tr;
     }
 
+    /*
+    * Query all web sources + local library for objects
+     */
+    public static ArrayList<LibraryObject> queryWeb(String s)
+    {
+        ArrayList<LibraryObject> tr = new ArrayList<>();
+        String q = s.toLowerCase();
+
+        // add results from spotify query
+        try
+        {
+            if(SongSources.SOURCE_SPOTIFY.isAvailable())
+            {
+                //request from spotify
+                TracksPager tracks = spotifyApi.getService().searchTracks(q);
+                AlbumsPager albums = spotifyApi.getService().searchAlbums(q);
+                ArtistsPager artists = spotifyApi.getService().searchArtists(q);
+
+                //handle returned data
+                for(Track t : tracks.tracks.items)
+                {
+                    Song song = getSongHandle(t.name, t.album.name, t.artists.get(0).name, t.duration_ms, new SongSources.SongSource(t.id, SongSources.SOURCE_SPOTIFY), t.track_number);
+                    tr.add(song);
+
+                    if(!song.getAlbum().hasAlbumArt())
+                    {
+                        if(t.album.images.get(0) != null)
+                            loadAlbumArt(song.getAlbum(), t.album.images.get(0).url, false);
+                    }
+                }
+                for(kaaes.spotify.webapi.android.models.AlbumSimple a : albums.albums.items)
+                {
+                    Album album = null;
+                    Pager<Track> albumTracks = spotifyApi.getService().getAlbumTracks(a.id);
+                    for(Track t : tracks.tracks.items)
+                    {
+                        Song currentSong = getSongHandle(t.name, t.album.name, t.artists.get(0).name, t.duration_ms, new SongSources.SongSource(t.id, SongSources.SOURCE_SPOTIFY), t.track_number);
+                        if(album == null) album = currentSong.getAlbum();
+                    }
+
+                    if(!album.hasAlbumArt())
+                    {
+                        if(a.images != null && a.images.size() >= 1)
+                        {
+                            Image albumImage = a.images.get(0);
+                            if(albumImage != null)
+                                loadAlbumArt(album, albumImage.url, false);
+                        }
+                    }
+                }
+            }
+        }
+        catch(RetrofitError e)
+        {
+            if(e.getResponse().getStatus() == 401)
+            {
+                refreshSpotifyToken();
+                return queryWeb(s);
+            }
+            e.printStackTrace();
+        }
+
+        // add results from deezer query
+        if(SongSources.SOURCE_DEEZER.isAvailable())
+        {
+            try
+            {
+                //request from deezer
+                List<com.deezer.sdk.model.Track> tracks = (List<com.deezer.sdk.model.Track>) JsonUtils.deserializeJson(deezerApi.requestSync(DeezerRequestFactory.requestSearchTracks(q)));
+                List<com.deezer.sdk.model.Album> albums = (List<com.deezer.sdk.model.Album>) JsonUtils.deserializeJson(deezerApi.requestSync(DeezerRequestFactory.requestSearchAlbums(q)));
+                List<com.deezer.sdk.model.Artist> artists = (List<com.deezer.sdk.model.Artist>) JsonUtils.deserializeJson(deezerApi.requestSync(DeezerRequestFactory.requestSearchArtists(q)));
+
+                //handle returned data
+                for(com.deezer.sdk.model.Track t : tracks)
+                {
+                    Song currentSong = getSongHandle(t.getTitle(), t.getAlbum().getTitle(), t.getArtist().getName(), t.getDuration()*1000, new SongSources.SongSource(t.getId(), SongSources.SOURCE_DEEZER), t.getTrackPosition());
+                    tr.add(currentSong);
+
+                    if(!currentSong.getAlbum().hasAlbumArt())
+                    {
+                        loadAlbumArt(currentSong.getAlbum(), t.getAlbum().getBigImageUrl(), false);
+                    }
+                }
+                for(com.deezer.sdk.model.Album alb : albums)
+                {
+                    Album album = null;
+                    List<com.deezer.sdk.model.Track> albTracks = (List<com.deezer.sdk.model.Track>) JsonUtils.deserializeJson(deezerApi.requestSync(DeezerRequestFactory.requestAlbumTracks(alb.getId())));
+                    for(com.deezer.sdk.model.Track t : albTracks)
+                    {
+                        Song currentSong = getSongHandle(t.getTitle(), t.getAlbum().getTitle(), t.getArtist().getName(), t.getDuration()*1000, new SongSources.SongSource(t.getId(), SongSources.SOURCE_DEEZER), t.getTrackPosition());
+                        if(album == null) album = currentSong.getAlbum();
+                    }
+
+                    if(!album.hasAlbumArt())
+                    {
+                        loadAlbumArt(album, alb.getBigImageUrl(), false);
+                    }
+                }
+            }
+            catch(Exception e) {}
+        }
+
+        // add results from local query
+        tr.addAll(query(s));
+
+        //remove doublons (oh my god n*m)
+        ArrayList<LibraryObject> trfinal = new ArrayList<>();
+        for(LibraryObject libraryObject : tr)
+        {
+            if(!trfinal.contains(libraryObject)) trfinal.add(libraryObject);
+        }
+
+        //sort (songs first, then albums, then artists)
+        Collections.sort(trfinal, new Comparator<LibraryObject>()
+        {
+            @Override
+            public int compare(LibraryObject o1, LibraryObject o2)
+            {
+                if(o1 instanceof Song && o2 instanceof Song)
+                {
+                    return o2.getSources().getSourceByPriority(0).getSource().getPriority() - o1.getSources().getSourceByPriority(0).getSource().getPriority();
+                }
+                else if(o1 instanceof Song && o2 instanceof Album)
+                {
+                    return -2;
+                }
+                else if(o1 instanceof Song && o2 instanceof Artist)
+                {
+                    return -3;
+                }
+                else if(o1 instanceof Album && o2 instanceof Song)
+                {
+                    return 2;
+                }
+                return 0;
+            }
+        });
+
+        return trfinal;
+    }
+
     private static Song getSongHandle(String name, String album, String artist, long duration, SongSources.SongSource source, int track)
     {
         //if song is already registered, return song from library

app/src/main/java/v/blade/player/PlayerMediaPlayer.java

@@ -189,10 +189,7 @@ public void onPlaybackError(Error error)
                     @Override
                     public void onLoggedOut() {}
                     @Override
-                    public void onLoginFailed(Error error)
-                    {
-                        spotifyPlayerError = WEBPLAYER_ERROR_LOGIN;
-                    }
+                    public void onLoginFailed(Error error) {spotifyPlayerError = WEBPLAYER_ERROR_LOGIN;}
                     @Override
                     public void onTemporaryError() {}
                     @Override

app/src/main/java/v/blade/player/PlayerService.java

@@ -79,6 +79,13 @@ else if((repeatMode == PlaybackStateCompat.REPEAT_MODE_ALL) || (currentPosition
             MediaMetadataCompat metadata = builder.build();
             mSession.setMetadata(metadata);
 
+            //kill notification on MediaPlayer STOP
+            if(mPlayer.getCurrentState() == PlayerMediaPlayer.PLAYER_STATE_STOPPED)
+            {
+                stopForeground(true);
+                return;
+            }
+
             /* update notification */
             if(mNotification == null)
             {