From 6eff64e7e147b5e5e5246e61c6e0e54f68dc0816 Mon Sep 17 00:00:00 2001 From: Antonio Cappiello Date: Fri, 20 Nov 2020 15:38:08 +0100 Subject: [PATCH] project upload --- .gitignore | 14 + .idea/.gitignore | 3 + .idea/compiler.xml | 6 + .idea/gradle.xml | 23 + .idea/jarRepositories.xml | 30 ++ .idea/misc.xml | 9 + .idea/vcs.xml | 6 + app/.gitignore | 1 + app/build.gradle | 63 +++ app/proguard-rules.pro | 21 + .../play/ExampleInstrumentedTest.java | 26 ++ app/src/main/AndroidManifest.xml | 30 ++ .../java/com/cappielloantonio/play/App.java | 65 +++ .../play/adapter/AlbumAdapter.java | 80 ++++ .../play/adapter/ArtistAdapter.java | 77 ++++ .../play/adapter/DiscoverSongAdapter.java | 64 +++ .../play/adapter/GenreAdapter.java | 77 ++++ .../play/adapter/PlaylistAdapter.java | 77 ++++ .../play/adapter/RecentMusicAdapter.java | 76 ++++ .../play/database/AppDatabase.java | 46 ++ .../play/database/dao/AlbumDao.java | 31 ++ .../play/database/dao/ArtistDao.java | 31 ++ .../play/database/dao/GenreDao.java | 31 ++ .../play/database/dao/PlaylistDao.java | 31 ++ .../play/database/dao/SongDao.java | 30 ++ .../play/glide/CustomGlideModule.java | 27 ++ .../play/helper/EventListenerHelper.java | 111 +++++ .../play/helper/ThemeHelper.java | 33 ++ .../play/interfaces/MediaCallback.java | 10 + .../cappielloantonio/play/model/Album.java | 193 ++++++++ .../cappielloantonio/play/model/Artist.java | 157 +++++++ .../cappielloantonio/play/model/Genre.java | 140 ++++++ .../cappielloantonio/play/model/Playlist.java | 119 +++++ .../com/cappielloantonio/play/model/Song.java | 415 ++++++++++++++++++ .../play/repository/AlbumRepository.java | 127 ++++++ .../play/repository/ArtistRepository.java | 128 ++++++ .../play/repository/GenreRepository.java | 128 ++++++ .../play/repository/PlaylistRepository.java | 128 ++++++ .../play/repository/SongRepository.java | 128 ++++++ .../play/ui/activities/MainActivity.java | 117 +++++ .../play/ui/activities/base/BaseActivity.java | 83 ++++ .../play/ui/fragment/HomeFragment.java | 91 ++++ .../play/ui/fragment/LandingFragment.java | 17 + .../play/ui/fragment/LibraryFragment.java | 101 +++++ .../play/ui/fragment/LoginFragment.java | 123 ++++++ .../play/ui/fragment/SearchFragment.java | 118 +++++ .../play/ui/fragment/SettingsFragment.java | 28 ++ .../play/ui/fragment/SyncFragment.java | 206 +++++++++ .../play/util/PreferenceUtil.java | 85 ++++ .../cappielloantonio/play/util/SyncUtil.java | 177 ++++++++ .../play/viewmodel/HomeViewModel.java | 41 ++ .../play/viewmodel/LibraryViewModel.java | 77 ++++ .../play/viewmodel/SongViewModel.java | 40 ++ .../main/res/drawable/bottom_nav_selector.xml | 6 + .../main/res/drawable/bottom_nav_shape.xml | 5 + app/src/main/res/drawable/ic_close.xml | 10 + app/src/main/res/drawable/ic_favorites.xml | 9 + app/src/main/res/drawable/ic_filter.xml | 9 + app/src/main/res/drawable/ic_graphic_eq.xml | 9 + app/src/main/res/drawable/ic_home.xml | 9 + app/src/main/res/drawable/ic_qr_code.xml | 9 + app/src/main/res/drawable/ic_search.xml | 9 + app/src/main/res/drawable/ic_settings.xml | 9 + app/src/main/res/font/bold.ttf | Bin 0 -> 100820 bytes .../main/res/font/open_sans_font_family.xml | 6 + app/src/main/res/font/regular.ttf | Bin 0 -> 96932 bytes app/src/main/res/layout/activity_main.xml | 31 ++ app/src/main/res/layout/fragment_home.xml | 194 ++++++++ app/src/main/res/layout/fragment_landing.xml | 7 + app/src/main/res/layout/fragment_library.xml | 262 +++++++++++ app/src/main/res/layout/fragment_login.xml | 101 +++++ app/src/main/res/layout/fragment_search.xml | 48 ++ app/src/main/res/layout/fragment_settings.xml | 6 + app/src/main/res/layout/fragment_sync.xml | 20 + .../main/res/layout/item_discover_song.xml | 39 ++ .../main/res/layout/item_library_album.xml | 40 ++ .../main/res/layout/item_library_artist.xml | 31 ++ .../main/res/layout/item_library_genre.xml | 45 ++ .../main/res/layout/item_library_playlist.xml | 37 ++ app/src/main/res/layout/item_recent_track.xml | 40 ++ app/src/main/res/menu/bottom_nav_menu.xml | 19 + app/src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 4288 bytes app/src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 2369 bytes app/src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 5875 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 10864 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 14838 bytes app/src/main/res/navigation/nav_graph.xml | 85 ++++ app/src/main/res/values-night-v27/styles.xml | 28 ++ app/src/main/res/values-night/colors.xml | 37 ++ app/src/main/res/values-night/styles.xml | 25 ++ app/src/main/res/values-v27/styles.xml | 28 ++ app/src/main/res/values/arrays.xml | 134 ++++++ app/src/main/res/values/colors.xml | 37 ++ app/src/main/res/values/dimens.xml | 8 + app/src/main/res/values/strings.xml | 35 ++ app/src/main/res/values/styles.xml | 27 ++ app/src/main/res/xml/global_preferences.xml | 30 ++ .../play/ExampleUnitTest.java | 17 + build.gradle | 27 ++ gradle.properties | 19 + gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 54329 bytes gradle/wrapper/gradle-wrapper.properties | 6 + gradlew | 172 ++++++++ gradlew.bat | 84 ++++ settings.gradle | 2 + 105 files changed, 5907 insertions(+) create mode 100644 .gitignore create mode 100644 .idea/.gitignore create mode 100644 .idea/compiler.xml create mode 100644 .idea/gradle.xml create mode 100644 .idea/jarRepositories.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/vcs.xml create mode 100644 app/.gitignore create mode 100644 app/build.gradle create mode 100644 app/proguard-rules.pro create mode 100644 app/src/androidTest/java/com/cappielloantonio/play/ExampleInstrumentedTest.java create mode 100644 app/src/main/AndroidManifest.xml create mode 100644 app/src/main/java/com/cappielloantonio/play/App.java create mode 100644 app/src/main/java/com/cappielloantonio/play/adapter/AlbumAdapter.java create mode 100644 app/src/main/java/com/cappielloantonio/play/adapter/ArtistAdapter.java create mode 100644 app/src/main/java/com/cappielloantonio/play/adapter/DiscoverSongAdapter.java create mode 100644 app/src/main/java/com/cappielloantonio/play/adapter/GenreAdapter.java create mode 100644 app/src/main/java/com/cappielloantonio/play/adapter/PlaylistAdapter.java create mode 100644 app/src/main/java/com/cappielloantonio/play/adapter/RecentMusicAdapter.java create mode 100644 app/src/main/java/com/cappielloantonio/play/database/AppDatabase.java create mode 100644 app/src/main/java/com/cappielloantonio/play/database/dao/AlbumDao.java create mode 100644 app/src/main/java/com/cappielloantonio/play/database/dao/ArtistDao.java create mode 100644 app/src/main/java/com/cappielloantonio/play/database/dao/GenreDao.java create mode 100644 app/src/main/java/com/cappielloantonio/play/database/dao/PlaylistDao.java create mode 100644 app/src/main/java/com/cappielloantonio/play/database/dao/SongDao.java create mode 100644 app/src/main/java/com/cappielloantonio/play/glide/CustomGlideModule.java create mode 100644 app/src/main/java/com/cappielloantonio/play/helper/EventListenerHelper.java create mode 100644 app/src/main/java/com/cappielloantonio/play/helper/ThemeHelper.java create mode 100644 app/src/main/java/com/cappielloantonio/play/interfaces/MediaCallback.java create mode 100644 app/src/main/java/com/cappielloantonio/play/model/Album.java create mode 100644 app/src/main/java/com/cappielloantonio/play/model/Artist.java create mode 100644 app/src/main/java/com/cappielloantonio/play/model/Genre.java create mode 100644 app/src/main/java/com/cappielloantonio/play/model/Playlist.java create mode 100644 app/src/main/java/com/cappielloantonio/play/model/Song.java create mode 100644 app/src/main/java/com/cappielloantonio/play/repository/AlbumRepository.java create mode 100644 app/src/main/java/com/cappielloantonio/play/repository/ArtistRepository.java create mode 100644 app/src/main/java/com/cappielloantonio/play/repository/GenreRepository.java create mode 100644 app/src/main/java/com/cappielloantonio/play/repository/PlaylistRepository.java create mode 100644 app/src/main/java/com/cappielloantonio/play/repository/SongRepository.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/activities/MainActivity.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/activities/base/BaseActivity.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/fragment/HomeFragment.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/fragment/LandingFragment.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/fragment/LibraryFragment.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/fragment/LoginFragment.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/fragment/SearchFragment.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/fragment/SettingsFragment.java create mode 100644 app/src/main/java/com/cappielloantonio/play/ui/fragment/SyncFragment.java create mode 100644 app/src/main/java/com/cappielloantonio/play/util/PreferenceUtil.java create mode 100644 app/src/main/java/com/cappielloantonio/play/util/SyncUtil.java create mode 100644 app/src/main/java/com/cappielloantonio/play/viewmodel/HomeViewModel.java create mode 100644 app/src/main/java/com/cappielloantonio/play/viewmodel/LibraryViewModel.java create mode 100644 app/src/main/java/com/cappielloantonio/play/viewmodel/SongViewModel.java create mode 100644 app/src/main/res/drawable/bottom_nav_selector.xml create mode 100644 app/src/main/res/drawable/bottom_nav_shape.xml create mode 100644 app/src/main/res/drawable/ic_close.xml create mode 100644 app/src/main/res/drawable/ic_favorites.xml create mode 100644 app/src/main/res/drawable/ic_filter.xml create mode 100644 app/src/main/res/drawable/ic_graphic_eq.xml create mode 100644 app/src/main/res/drawable/ic_home.xml create mode 100644 app/src/main/res/drawable/ic_qr_code.xml create mode 100644 app/src/main/res/drawable/ic_search.xml create mode 100644 app/src/main/res/drawable/ic_settings.xml create mode 100644 app/src/main/res/font/bold.ttf create mode 100644 app/src/main/res/font/open_sans_font_family.xml create mode 100644 app/src/main/res/font/regular.ttf create mode 100644 app/src/main/res/layout/activity_main.xml create mode 100644 app/src/main/res/layout/fragment_home.xml create mode 100644 app/src/main/res/layout/fragment_landing.xml create mode 100644 app/src/main/res/layout/fragment_library.xml create mode 100644 app/src/main/res/layout/fragment_login.xml create mode 100644 app/src/main/res/layout/fragment_search.xml create mode 100644 app/src/main/res/layout/fragment_settings.xml create mode 100644 app/src/main/res/layout/fragment_sync.xml create mode 100644 app/src/main/res/layout/item_discover_song.xml create mode 100644 app/src/main/res/layout/item_library_album.xml create mode 100644 app/src/main/res/layout/item_library_artist.xml create mode 100644 app/src/main/res/layout/item_library_genre.xml create mode 100644 app/src/main/res/layout/item_library_playlist.xml create mode 100644 app/src/main/res/layout/item_recent_track.xml create mode 100644 app/src/main/res/menu/bottom_nav_menu.xml create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 app/src/main/res/navigation/nav_graph.xml create mode 100644 app/src/main/res/values-night-v27/styles.xml create mode 100644 app/src/main/res/values-night/colors.xml create mode 100644 app/src/main/res/values-night/styles.xml create mode 100644 app/src/main/res/values-v27/styles.xml create mode 100644 app/src/main/res/values/arrays.xml create mode 100644 app/src/main/res/values/colors.xml create mode 100644 app/src/main/res/values/dimens.xml create mode 100644 app/src/main/res/values/strings.xml create mode 100644 app/src/main/res/values/styles.xml create mode 100644 app/src/main/res/xml/global_preferences.xml create mode 100644 app/src/test/java/com/cappielloantonio/play/ExampleUnitTest.java create mode 100644 build.gradle create mode 100644 gradle.properties create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100644 gradlew create mode 100644 gradlew.bat create mode 100644 settings.gradle diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..603b1407 --- /dev/null +++ b/.gitignore @@ -0,0 +1,14 @@ +*.iml +.gradle +/local.properties +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 00000000..26d33521 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 00000000..61a9130c --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 00000000..b617266a --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,23 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml new file mode 100644 index 00000000..eb2873e7 --- /dev/null +++ b/.idea/jarRepositories.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 00000000..d5d35ec4 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,9 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 00000000..35eb1ddf --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 00000000..42afabfd --- /dev/null +++ b/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/app/build.gradle b/app/build.gradle new file mode 100644 index 00000000..f47d0b27 --- /dev/null +++ b/app/build.gradle @@ -0,0 +1,63 @@ +apply plugin: 'com.android.application' +apply plugin: 'kotlin-android' +apply plugin: 'kotlin-android-extensions' + + +android { + compileSdkVersion 30 + buildToolsVersion "29.0.3" + + defaultConfig { + applicationId "com.cappielloantonio.play" + minSdkVersion 26 + targetSdkVersion 30 + versionCode 1 + versionName "1.1" + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + + compileOptions { + sourceCompatibility 1.8 + targetCompatibility 1.8 + } + + buildFeatures { + viewBinding = true + } +} + +dependencies { + implementation fileTree(dir: "libs", include: ["*.jar"]) + implementation 'androidx.core:core-ktx:1.3.2' + implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.4.10' + + implementation 'androidx.appcompat:appcompat:1.2.0' + implementation 'androidx.constraintlayout:constraintlayout:2.0.4' + implementation "androidx.coordinatorlayout:coordinatorlayout:1.1.0" + implementation 'pub.devrel:easypermissions:3.0.0' + implementation 'androidx.preference:preference-ktx:1.1.1' + implementation 'com.android.volley:volley:1.1.1' + implementation "com.paulrybitskyi.persistentsearchview:persistentsearchview:1.1.3" + implementation 'com.google.android.material:material:1.2.1' + implementation 'androidx.navigation:navigation-fragment-ktx:2.3.1' + implementation 'androidx.navigation:navigation-ui-ktx:2.3.1' + implementation 'androidx.recyclerview:recyclerview:1.1.0' + implementation 'com.github.bumptech.glide:glide:4.11.0' + implementation "androidx.room:room-runtime:2.2.5" + implementation 'com.github.jellyfin.jellyfin-apiclient-java:android:0.7.7' + implementation "androidx.cardview:cardview:1.0.0" + annotationProcessor 'com.github.bumptech.glide:compiler:4.11.0' + annotationProcessor "androidx.room:room-compiler:2.2.5" + testImplementation 'junit:junit:4.13.1' + androidTestImplementation 'androidx.test.ext:junit:1.1.2' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0' + debugImplementation 'com.amitshekhar.android:debug-db:1.0.6' +} \ No newline at end of file diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro new file mode 100644 index 00000000..481bb434 --- /dev/null +++ b/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/app/src/androidTest/java/com/cappielloantonio/play/ExampleInstrumentedTest.java b/app/src/androidTest/java/com/cappielloantonio/play/ExampleInstrumentedTest.java new file mode 100644 index 00000000..12c9bc2e --- /dev/null +++ b/app/src/androidTest/java/com/cappielloantonio/play/ExampleInstrumentedTest.java @@ -0,0 +1,26 @@ +package com.cappielloantonio.play; + +import android.content.Context; + +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import static org.junit.Assert.*; + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class ExampleInstrumentedTest { + @Test + public void useAppContext() { + // Context of the app under test. + Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); + assertEquals("com.cappielloantonio.libr", appContext.getPackageName()); + } +} \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 00000000..89e292aa --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/App.java b/app/src/main/java/com/cappielloantonio/play/App.java new file mode 100644 index 00000000..80c65746 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/App.java @@ -0,0 +1,65 @@ +package com.cappielloantonio.play; + +import android.app.Application; +import android.content.Context; +import android.content.SharedPreferences; + +import androidx.preference.PreferenceManager; + +import com.android.volley.RequestQueue; +import com.android.volley.toolbox.Volley; +import com.cappielloantonio.play.helper.ThemeHelper; +import com.cappielloantonio.play.util.PreferenceUtil; + +import org.jellyfin.apiclient.AppInfo; +import org.jellyfin.apiclient.Jellyfin; +import org.jellyfin.apiclient.JellyfinAndroidKt; +import org.jellyfin.apiclient.JellyfinOptions; +import org.jellyfin.apiclient.interaction.AndroidDevice; +import org.jellyfin.apiclient.interaction.ApiClient; +import org.jellyfin.apiclient.interaction.ApiEventListener; +import org.jellyfin.apiclient.logging.NullLogger; + +public class App extends Application { + private static final String TAG = "App"; + private static App instance; + private static ApiClient apiClient; + + @Override + public void onCreate() { + super.onCreate(); + + ThemeHelper.applyTheme(PreferenceUtil.getInstance(getApplicationContext()).getTheme()); + } + + public static App getInstance() { + if (instance == null) { + instance = new App(); + } + return instance; + } + + public static ApiClient getApiClientInstance(Context context) { + if (apiClient == null) { + apiClient = getApiClient(context); + } + return apiClient; + } + + public RequestQueue getRequestQueue(Context context) { + return Volley.newRequestQueue(context); + } + + private static ApiClient getApiClient(Context context) { + String server = PreferenceUtil.getInstance(context).getServer(); + + JellyfinOptions.Builder options = new JellyfinOptions.Builder(); + options.setLogger(new NullLogger()); + options.setAppInfo(new AppInfo(context.getString(R.string.app_name), BuildConfig.VERSION_NAME)); + JellyfinAndroidKt.android(options, context); + + Jellyfin jellyfin = new Jellyfin(options.build()); + + return jellyfin.createApi(server, null, AndroidDevice.fromContext(context), new ApiEventListener()); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/adapter/AlbumAdapter.java b/app/src/main/java/com/cappielloantonio/play/adapter/AlbumAdapter.java new file mode 100644 index 00000000..1ef23c54 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/adapter/AlbumAdapter.java @@ -0,0 +1,80 @@ +package com.cappielloantonio.play.adapter; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.recyclerview.widget.RecyclerView; + +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Genre; + +import java.util.List; + +public class AlbumAdapter extends RecyclerView.Adapter { + private static final String TAG = "RecentMusicAdapter"; + private List albums; + private LayoutInflater mInflater; + private Context context; + private ItemClickListener itemClickListener; + + public AlbumAdapter(Context context, List albums) { + this.context = context; + this.mInflater = LayoutInflater.from(context); + this.albums = albums; + } + + @Override + public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { + View view = mInflater.inflate(R.layout.item_library_album, parent, false); + return new ViewHolder(view); + } + + @Override + public void onBindViewHolder(ViewHolder holder, int position) { + Album album = albums.get(position); + + holder.textAlbumName.setText(album.getTitle()); + holder.textArtistName.setText(album.getArtistName()); + } + + @Override + public int getItemCount() { + return albums.size(); + } + + public class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener { + TextView textAlbumName; + TextView textArtistName; + + ViewHolder(View itemView) { + super(itemView); + + textAlbumName = itemView.findViewById(R.id.album_name_label); + textArtistName = itemView.findViewById(R.id.artist_name_label); + + itemView.setOnClickListener(this); + } + + @Override + public void onClick(View view) { + if (itemClickListener != null) itemClickListener.onItemClick(view, getAdapterPosition()); + } + } + + public void setItems(List albums) { + this.albums = albums; + notifyDataSetChanged(); + } + + public void setClickListener(ItemClickListener itemClickListener) { + this.itemClickListener = itemClickListener; + } + + public interface ItemClickListener { + void onItemClick(View view, int position); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/adapter/ArtistAdapter.java b/app/src/main/java/com/cappielloantonio/play/adapter/ArtistAdapter.java new file mode 100644 index 00000000..72e28376 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/adapter/ArtistAdapter.java @@ -0,0 +1,77 @@ +package com.cappielloantonio.play.adapter; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.recyclerview.widget.RecyclerView; + +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Artist; + +import java.util.List; + +public class ArtistAdapter extends RecyclerView.Adapter { + private static final String TAG = "ArtistAdapter"; + private List artists; + private LayoutInflater mInflater; + private Context context; + private ItemClickListener itemClickListener; + + public ArtistAdapter(Context context, List artists) { + this.context = context; + this.mInflater = LayoutInflater.from(context); + this.artists = artists; + } + + @Override + public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { + View view = mInflater.inflate(R.layout.item_library_artist, parent, false); + return new ViewHolder(view); + } + + @Override + public void onBindViewHolder(ViewHolder holder, int position) { + Artist artist = artists.get(position); + + holder.textArtistName.setText(artist.getName()); + } + + @Override + public int getItemCount() { + return artists.size(); + } + + public class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener { + TextView textArtistName; + + ViewHolder(View itemView) { + super(itemView); + + textArtistName = itemView.findViewById(R.id.artist_name_label); + + itemView.setOnClickListener(this); + } + + @Override + public void onClick(View view) { + if (itemClickListener != null) itemClickListener.onItemClick(view, getAdapterPosition()); + } + } + + public void setItems(List artists) { + this.artists = artists; + notifyDataSetChanged(); + } + + public void setClickListener(ItemClickListener itemClickListener) { + this.itemClickListener = itemClickListener; + } + + public interface ItemClickListener { + void onItemClick(View view, int position); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/adapter/DiscoverSongAdapter.java b/app/src/main/java/com/cappielloantonio/play/adapter/DiscoverSongAdapter.java new file mode 100644 index 00000000..98df9a48 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/adapter/DiscoverSongAdapter.java @@ -0,0 +1,64 @@ +package com.cappielloantonio.play.adapter; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; +import android.widget.Toast; + +import androidx.annotation.NonNull; +import androidx.viewpager.widget.PagerAdapter; + +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.model.Song; + +import java.util.List; + +public class DiscoverSongAdapter extends PagerAdapter { + + private List songs; + private LayoutInflater layoutInflater; + private Context context; + + public DiscoverSongAdapter(Context context, List models) { + this.context = context; + this.songs = models; + } + + @Override + public int getCount() { + return songs.size(); + } + + @Override + public boolean isViewFromObject(@NonNull View view, @NonNull Object object) { + return view.equals(object); + } + + @NonNull + @Override + public Object instantiateItem(@NonNull ViewGroup container, final int position) { + layoutInflater = LayoutInflater.from(context); + View view = layoutInflater.inflate(R.layout.item_discover_song, container, false); + + TextView title; + TextView desc; + + title = view.findViewById(R.id.title_discover_song_label); + desc = view.findViewById(R.id.artist_discover_song_label); + + title.setText(songs.get(position).getTitle()); + desc.setText(songs.get(position).getAlbumName()); + + view.setOnClickListener(v -> Toast.makeText(context, songs.get(position).getTitle(), Toast.LENGTH_SHORT).show()); + + container.addView(view, 0); + return view; + } + + @Override + public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) { + container.removeView((View)object); + } +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/adapter/GenreAdapter.java b/app/src/main/java/com/cappielloantonio/play/adapter/GenreAdapter.java new file mode 100644 index 00000000..50a0366a --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/adapter/GenreAdapter.java @@ -0,0 +1,77 @@ +package com.cappielloantonio.play.adapter; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.recyclerview.widget.RecyclerView; + +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.model.Genre; + +import java.util.List; + +public class GenreAdapter extends RecyclerView.Adapter { + private static final String TAG = "GenreAdapter"; + private List genres; + private LayoutInflater mInflater; + private Context context; + private ItemClickListener itemClickListener; + + public GenreAdapter(Context context, List genres) { + this.context = context; + this.mInflater = LayoutInflater.from(context); + this.genres = genres; + } + + // inflates the row layout from xml when needed + @Override + public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { + View view = mInflater.inflate(R.layout.item_library_genre, parent, false); + return new ViewHolder(view); + } + + @Override + public void onBindViewHolder(ViewHolder holder, int position) { + Genre genre = genres.get(position); + + holder.textGenre.setText(genre.getName()); + } + + @Override + public int getItemCount() { + return genres.size(); + } + + public class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener { + TextView textGenre; + + ViewHolder(View itemView) { + super(itemView); + + textGenre = itemView.findViewById(R.id.genre_label); + + itemView.setOnClickListener(this); + } + + @Override + public void onClick(View view) { + if (itemClickListener != null) itemClickListener.onItemClick(view, getAdapterPosition()); + } + } + + public void setItems(List genres) { + this.genres = genres; + notifyDataSetChanged(); + } + + public void setClickListener(ItemClickListener itemClickListener) { + this.itemClickListener = itemClickListener; + } + + public interface ItemClickListener { + void onItemClick(View view, int position); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/adapter/PlaylistAdapter.java b/app/src/main/java/com/cappielloantonio/play/adapter/PlaylistAdapter.java new file mode 100644 index 00000000..c2381ab4 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/adapter/PlaylistAdapter.java @@ -0,0 +1,77 @@ +package com.cappielloantonio.play.adapter; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.recyclerview.widget.RecyclerView; + +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.model.Artist; +import com.cappielloantonio.play.model.Playlist; + +import java.util.List; + +public class PlaylistAdapter extends RecyclerView.Adapter { + private static final String TAG = "PlaylistAdapter"; + private List playlists; + private LayoutInflater mInflater; + private Context context; + private ItemClickListener itemClickListener; + + public PlaylistAdapter(Context context, List playlists) { + this.context = context; + this.mInflater = LayoutInflater.from(context); + this.playlists = playlists; + } + + @Override + public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { + View view = mInflater.inflate(R.layout.item_library_playlist, parent, false); + return new ViewHolder(view); + } + + @Override + public void onBindViewHolder(ViewHolder holder, int position) { + Playlist playlist = playlists.get(position); + + holder.textPlaylistName.setText(playlist.getName()); + } + + @Override + public int getItemCount() { + return playlists.size(); + } + + public class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener { + TextView textPlaylistName; + + ViewHolder(View itemView) { + super(itemView); + + textPlaylistName = itemView.findViewById(R.id.playlist_name_text); + + itemView.setOnClickListener(this); + } + + @Override + public void onClick(View view) { + if (itemClickListener != null) itemClickListener.onItemClick(view, getAdapterPosition()); + } + } + + public void setItems(List playlists) { + this.playlists = playlists; + notifyDataSetChanged(); + } + + public void setClickListener(ItemClickListener itemClickListener) { + this.itemClickListener = itemClickListener; + } + + public interface ItemClickListener { + void onItemClick(View view, int position); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/adapter/RecentMusicAdapter.java b/app/src/main/java/com/cappielloantonio/play/adapter/RecentMusicAdapter.java new file mode 100644 index 00000000..6b4958d2 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/adapter/RecentMusicAdapter.java @@ -0,0 +1,76 @@ +package com.cappielloantonio.play.adapter; + +import android.content.Context; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.recyclerview.widget.RecyclerView; + +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.model.Song; + +import java.util.List; + +public class RecentMusicAdapter extends RecyclerView.Adapter { + private static final String TAG = "RecentMusicAdapter"; + private List songs; + private LayoutInflater mInflater; + private Context context; + private ItemClickListener itemClickListener; + + public RecentMusicAdapter(Context context, List songs) { + this.context = context; + this.mInflater = LayoutInflater.from(context); + this.songs = songs; + } + + // inflates the row layout from xml when needed + @Override + public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { + View view = mInflater.inflate(R.layout.item_recent_track, parent, false); + return new ViewHolder(view); + } + + @Override + public void onBindViewHolder(ViewHolder holder, int position) { + Song song = songs.get(position); + + holder.textTitle.setText(song.getTitle()); + holder.textArtist.setText(song.getAlbumName()); + } + + @Override + public int getItemCount() { + return songs.size(); + } + + public class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener { + TextView textTitle; + TextView textArtist; + + ViewHolder(View itemView) { + super(itemView); + + textTitle = itemView.findViewById(R.id.title_track_label); + textArtist = itemView.findViewById(R.id.artist_track_label); + + itemView.setOnClickListener(this); + } + + @Override + public void onClick(View view) { + if (itemClickListener != null) itemClickListener.onItemClick(view, getAdapterPosition()); + } + } + + public void setClickListener(ItemClickListener itemClickListener) { + this.itemClickListener = itemClickListener; + } + + public interface ItemClickListener { + void onItemClick(View view, int position); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/database/AppDatabase.java b/app/src/main/java/com/cappielloantonio/play/database/AppDatabase.java new file mode 100644 index 00000000..5221a51a --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/database/AppDatabase.java @@ -0,0 +1,46 @@ +package com.cappielloantonio.play.database; + +import android.content.Context; + +import androidx.room.Database; +import androidx.room.Room; +import androidx.room.RoomDatabase; + +import com.cappielloantonio.play.database.dao.AlbumDao; +import com.cappielloantonio.play.database.dao.ArtistDao; +import com.cappielloantonio.play.database.dao.GenreDao; +import com.cappielloantonio.play.database.dao.PlaylistDao; +import com.cappielloantonio.play.database.dao.SongDao; +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Artist; +import com.cappielloantonio.play.model.Genre; +import com.cappielloantonio.play.model.Playlist; +import com.cappielloantonio.play.model.Song; + +@Database(entities = {Album.class, Artist.class, Genre.class, Playlist.class, Song.class}, version = 2, exportSchema = false) +public abstract class AppDatabase extends RoomDatabase { + private static final String TAG = "AppDatabase"; + + private static AppDatabase instance; + private final static String DB_NAME = "play_db"; + + public static synchronized AppDatabase getInstance(Context context) { + + if (instance == null) { + instance = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, DB_NAME) + .fallbackToDestructiveMigration() + .build(); + } + return instance; + } + + public abstract AlbumDao albumDao(); + + public abstract ArtistDao artistDao(); + + public abstract GenreDao genreDao(); + + public abstract PlaylistDao playlistDao(); + + public abstract SongDao songDao(); +} diff --git a/app/src/main/java/com/cappielloantonio/play/database/dao/AlbumDao.java b/app/src/main/java/com/cappielloantonio/play/database/dao/AlbumDao.java new file mode 100644 index 00000000..6d6fe712 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/database/dao/AlbumDao.java @@ -0,0 +1,31 @@ +package com.cappielloantonio.play.database.dao; + +import androidx.lifecycle.LiveData; +import androidx.room.Dao; +import androidx.room.Delete; +import androidx.room.Insert; +import androidx.room.OnConflictStrategy; +import androidx.room.Query; + +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Song; + +import java.util.List; + +@Dao +public interface AlbumDao { + @Query("SELECT * FROM album") + LiveData> getAll(); + + @Query("SELECT EXISTS(SELECT * FROM album WHERE id = :id)") + boolean exist(String id); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insert(Album album); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insertAll(List albums); + + @Delete + void delete(Album album); +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/database/dao/ArtistDao.java b/app/src/main/java/com/cappielloantonio/play/database/dao/ArtistDao.java new file mode 100644 index 00000000..10a847fa --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/database/dao/ArtistDao.java @@ -0,0 +1,31 @@ +package com.cappielloantonio.play.database.dao; + +import androidx.lifecycle.LiveData; +import androidx.room.Dao; +import androidx.room.Delete; +import androidx.room.Insert; +import androidx.room.OnConflictStrategy; +import androidx.room.Query; + +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Artist; + +import java.util.List; + +@Dao +public interface ArtistDao { + @Query("SELECT * FROM artist") + LiveData> getAll(); + + @Query("SELECT EXISTS(SELECT * FROM artist WHERE id = :id)") + boolean exist(String id); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insert(Artist artist); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insertAll(List artists); + + @Delete + void delete(Artist artist); +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/database/dao/GenreDao.java b/app/src/main/java/com/cappielloantonio/play/database/dao/GenreDao.java new file mode 100644 index 00000000..b9fba993 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/database/dao/GenreDao.java @@ -0,0 +1,31 @@ +package com.cappielloantonio.play.database.dao; + +import androidx.lifecycle.LiveData; +import androidx.room.Dao; +import androidx.room.Delete; +import androidx.room.Insert; +import androidx.room.OnConflictStrategy; +import androidx.room.Query; + +import com.cappielloantonio.play.model.Artist; +import com.cappielloantonio.play.model.Genre; + +import java.util.List; + +@Dao +public interface GenreDao { + @Query("SELECT * FROM genre") + LiveData> getAll(); + + @Query("SELECT EXISTS(SELECT * FROM genre WHERE id = :id)") + boolean exist(String id); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insert(Genre genre); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insertAll(List genres); + + @Delete + void delete(Genre genre); +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/database/dao/PlaylistDao.java b/app/src/main/java/com/cappielloantonio/play/database/dao/PlaylistDao.java new file mode 100644 index 00000000..499ca1e9 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/database/dao/PlaylistDao.java @@ -0,0 +1,31 @@ +package com.cappielloantonio.play.database.dao; + +import androidx.lifecycle.LiveData; +import androidx.room.Dao; +import androidx.room.Delete; +import androidx.room.Insert; +import androidx.room.OnConflictStrategy; +import androidx.room.Query; + +import com.cappielloantonio.play.model.Artist; +import com.cappielloantonio.play.model.Playlist; + +import java.util.List; + +@Dao +public interface PlaylistDao { + @Query("SELECT * FROM playlist") + LiveData> getAll(); + + @Query("SELECT EXISTS(SELECT * FROM playlist WHERE id = :id)") + boolean exist(String id); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insert(Playlist playlist); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insertAll(List playlists); + + @Delete + void delete(Playlist playlist); +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/database/dao/SongDao.java b/app/src/main/java/com/cappielloantonio/play/database/dao/SongDao.java new file mode 100644 index 00000000..038a1809 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/database/dao/SongDao.java @@ -0,0 +1,30 @@ +package com.cappielloantonio.play.database.dao; + +import androidx.lifecycle.LiveData; +import androidx.room.Dao; +import androidx.room.Delete; +import androidx.room.Insert; +import androidx.room.OnConflictStrategy; +import androidx.room.Query; + +import com.cappielloantonio.play.model.Song; + +import java.util.List; + +@Dao +public interface SongDao { + @Query("SELECT * FROM song") + LiveData> getAll(); + + @Query("SELECT EXISTS(SELECT * FROM song WHERE id = :id)") + boolean exist(String id); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insert(Song song); + + @Insert(onConflict = OnConflictStrategy.REPLACE) + void insertAll(List songs); + + @Delete + void delete(Song song); +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/glide/CustomGlideModule.java b/app/src/main/java/com/cappielloantonio/play/glide/CustomGlideModule.java new file mode 100644 index 00000000..83715018 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/glide/CustomGlideModule.java @@ -0,0 +1,27 @@ +package com.cappielloantonio.play.glide; + +import android.content.Context; + +import androidx.annotation.NonNull; + +import com.bumptech.glide.GlideBuilder; +import com.bumptech.glide.annotation.GlideModule; +import com.bumptech.glide.load.DecodeFormat; +import com.bumptech.glide.load.engine.cache.DiskLruCacheFactory; +import com.bumptech.glide.module.AppGlideModule; +import com.bumptech.glide.request.RequestOptions; +import com.cappielloantonio.play.util.PreferenceUtil; + +import java.io.File; + +@GlideModule +public class CustomGlideModule extends AppGlideModule { + @Override + public void applyOptions(@NonNull Context context, GlideBuilder builder) { + File file = new File(context.getCacheDir() + "glide"); + int size = PreferenceUtil.getInstance(context).getImageCacheSize(); + + builder.setDiskCache(new DiskLruCacheFactory(() -> file, size)); + builder.setDefaultRequestOptions(new RequestOptions().format(DecodeFormat.PREFER_RGB_565)); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/helper/EventListenerHelper.java b/app/src/main/java/com/cappielloantonio/play/helper/EventListenerHelper.java new file mode 100644 index 00000000..0c9ec0f9 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/helper/EventListenerHelper.java @@ -0,0 +1,111 @@ +package com.cappielloantonio.play.helper; + +import android.util.Log; + +import org.jellyfin.apiclient.interaction.ApiClient; +import org.jellyfin.apiclient.interaction.ApiEventListener; +import org.jellyfin.apiclient.model.apiclient.RemoteLogoutReason; +import org.jellyfin.apiclient.model.apiclient.SessionUpdatesEventArgs; +import org.jellyfin.apiclient.model.dto.UserDto; +import org.jellyfin.apiclient.model.entities.LibraryUpdateInfo; +import org.jellyfin.apiclient.model.session.BrowseRequest; +import org.jellyfin.apiclient.model.session.GeneralCommand; +import org.jellyfin.apiclient.model.session.MessageCommand; +import org.jellyfin.apiclient.model.session.PlayRequest; +import org.jellyfin.apiclient.model.session.PlaystateRequest; +import org.jellyfin.apiclient.model.session.SessionInfoDto; +import org.jellyfin.apiclient.model.session.UserDataChangeInfo; + +public class EventListenerHelper extends ApiEventListener { + private static final String TAG = "EventListenerHelper"; + + @Override + public void onRemoteLoggedOut(ApiClient client, RemoteLogoutReason reason) { + Log.i(TAG, "onRemoteLoggedOut: " + reason); + } + + @Override + public void onUserUpdated(ApiClient client, UserDto userDto) { + Log.i(TAG, "onUserUpdated: " + userDto.getName()); + } + + @Override + public void onLibraryChanged(ApiClient client, LibraryUpdateInfo info) { + Log.i(TAG, "onLibraryChanged"); + } + + @Override + public void onUserConfigurationUpdated(ApiClient client, UserDto userDto) { + Log.i(TAG, "onUserConfigurationUpdated"); + } + + @Override + public void onBrowseCommand(ApiClient client, BrowseRequest command) { + Log.i(TAG, "onBrowseCommand: " + command.getItemName()); + } + + @Override + public void onPlayCommand(ApiClient client, PlayRequest command) { + Log.i(TAG, "onPlayCommand: " + command.getPlayCommand()); + } + + @Override + public void onPlaystateCommand(ApiClient client, PlaystateRequest command) { + Log.i(TAG, "onPlayStateCommand"); + } + + @Override + public void onMessageCommand(ApiClient client, MessageCommand command) { + Log.i(TAG, "onMessageCommand"); + } + + @Override + public void onGeneralCommand(ApiClient client, GeneralCommand command) { + Log.i(TAG, "onGeneralCommand: " + command.getName()); + } + + @Override + public void onSendStringCommand(ApiClient client, String value) { + Log.i(TAG, "onSendStringCommand"); + } + + @Override + public void onSetVolumeCommand(ApiClient client, int value) { + Log.i(TAG, "onSetVolumeCommand"); + } + + @Override + public void onSetAudioStreamIndexCommand(ApiClient client, int value) { + Log.i(TAG, "onSetAudioStreamIndexCommand"); + } + + @Override + public void onSetSubtitleStreamIndexCommand(ApiClient client, int value) { + Log.i(TAG, "onSetSubtitleStreamIndexCommand"); + } + + @Override + public void onUserDataChanged(ApiClient client, UserDataChangeInfo info) { + Log.i(TAG, "onUserDataChanged"); + } + + @Override + public void onSessionsUpdated(ApiClient client, SessionUpdatesEventArgs args) { + Log.i(TAG, "onSessionsUpdated"); + } + + @Override + public void onPlaybackStart(ApiClient client, SessionInfoDto info) { + Log.i(TAG, "onPlaybackStart"); + } + + @Override + public void onPlaybackStopped(ApiClient client, SessionInfoDto info) { + Log.i(TAG, "onPlaybackStopped"); + } + + @Override + public void onSessionEnded(ApiClient client, SessionInfoDto info) { + Log.i(TAG, "onSessionEnded"); + } +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/helper/ThemeHelper.java b/app/src/main/java/com/cappielloantonio/play/helper/ThemeHelper.java new file mode 100644 index 00000000..0ffd264f --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/helper/ThemeHelper.java @@ -0,0 +1,33 @@ +package com.cappielloantonio.play.helper; + +import android.os.Build; + +import androidx.annotation.NonNull; +import androidx.appcompat.app.AppCompatDelegate; + +public class ThemeHelper { + public static final String LIGHT_MODE = "light"; + public static final String DARK_MODE = "dark"; + public static final String DEFAULT_MODE = "default"; + + public static void applyTheme(@NonNull String themePref) { + switch (themePref) { + case LIGHT_MODE: { + AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO); + break; + } + case DARK_MODE: { + AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES); + break; + } + default: { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { + AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM); + } else { + AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_AUTO_BATTERY); + } + break; + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/interfaces/MediaCallback.java b/app/src/main/java/com/cappielloantonio/play/interfaces/MediaCallback.java new file mode 100644 index 00000000..67417917 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/interfaces/MediaCallback.java @@ -0,0 +1,10 @@ +package com.cappielloantonio.play.interfaces; + +import com.android.volley.VolleyError; + +import java.util.List; + +public interface MediaCallback { + void onError(Exception exception); + void onLoadMedia(List media); +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/model/Album.java b/app/src/main/java/com/cappielloantonio/play/model/Album.java new file mode 100644 index 00000000..3c30019d --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/model/Album.java @@ -0,0 +1,193 @@ +package com.cappielloantonio.play.model; + +import android.os.Parcel; +import android.os.Parcelable; + +import androidx.annotation.NonNull; +import androidx.room.ColumnInfo; +import androidx.room.Entity; +import androidx.room.Ignore; +import androidx.room.PrimaryKey; + +import org.jellyfin.apiclient.model.dto.BaseItemDto; +import org.jellyfin.apiclient.model.entities.ImageType; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +@Entity(tableName = "album") +public class Album implements Parcelable { + @Ignore + public List songs; + + @NonNull + @PrimaryKey + @ColumnInfo(name = "id") + public String id; + + @ColumnInfo(name = "title") + public String title; + + @ColumnInfo(name = "year") + public int year; + + @ColumnInfo(name = "artistId") + public String artistId; + + @ColumnInfo(name = "artistName") + public String artistName; + + @ColumnInfo(name = "primary") + public String primary; + + @ColumnInfo(name = "blurHash") + public String blurHash; + + public Album(@NonNull String id, String title, int year, String artistId, String artistName, String primary, String blurHash) { + this.id = id; + this.title = title; + this.year = year; + this.artistId = artistId; + this.artistName = artistName; + this.primary = primary; + this.blurHash = blurHash; + } + + @Ignore + public Album(BaseItemDto itemDto) { + this.id = itemDto.getId(); + this.title = itemDto.getName(); + this.year = itemDto.getProductionYear() != null ? itemDto.getProductionYear() : 0; + + if (itemDto.getAlbumArtists().size() != 0) { + this.artistId = itemDto.getAlbumArtists().get(0).getId(); + this.artistName = itemDto.getAlbumArtists().get(0).getName(); + } else if (itemDto.getArtistItems().size() != 0) { + this.artistId = itemDto.getArtistItems().get(0).getId(); + this.artistName = itemDto.getArtistItems().get(0).getName(); + } + + this.primary = itemDto.getImageTags().containsKey(ImageType.Primary) ? id : null; + if (itemDto.getImageBlurHashes() != null && itemDto.getImageBlurHashes().get(ImageType.Primary) != null) { + this.blurHash = (String) itemDto.getImageBlurHashes().get(ImageType.Primary).values().toArray()[0]; + } + + this.songs = new ArrayList<>(); + } + + @NonNull + public String getId() { + return id; + } + + public void setId(@NonNull String id) { + this.id = id; + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + this.title = title; + } + + public int getYear() { + return year; + } + + public void setYear(int year) { + this.year = year; + } + + public String getArtistId() { + return artistId; + } + + public void setArtistId(String artistId) { + this.artistId = artistId; + } + + public String getArtistName() { + return artistName; + } + + public void setArtistName(String artistName) { + this.artistName = artistName; + } + + public String getPrimary() { + return primary; + } + + public void setPrimary(String primary) { + this.primary = primary; + } + + public String getBlurHash() { + return blurHash; + } + + public void setBlurHash(String blurHash) { + this.blurHash = blurHash; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Album album = (Album) o; + return id.equals(album.id); + } + + @Override + public int hashCode() { + return id.hashCode(); + } + + @NonNull + @Override + public String toString() { + return id; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(id); + dest.writeString(title); + dest.writeInt(year); + dest.writeString(artistId); + dest.writeString(artistName); + dest.writeString(primary); + dest.writeString(blurHash); + } + + protected Album(Parcel in) { + this.songs = new ArrayList<>(); + + this.id = in.readString(); + this.title = in.readString(); + this.year = in.readInt(); + this.artistId = in.readString(); + this.artistName = in.readString(); + this.primary = in.readString(); + this.blurHash = in.readString(); + } + + public static final Creator CREATOR = new Creator() { + public Album createFromParcel(Parcel source) { + return new Album(source); + } + + public Album[] newArray(int size) { + return new Album[size]; + } + }; +} diff --git a/app/src/main/java/com/cappielloantonio/play/model/Artist.java b/app/src/main/java/com/cappielloantonio/play/model/Artist.java new file mode 100644 index 00000000..7c318c32 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/model/Artist.java @@ -0,0 +1,157 @@ +package com.cappielloantonio.play.model; + +import android.os.Parcel; +import android.os.Parcelable; + +import androidx.annotation.NonNull; +import androidx.room.ColumnInfo; +import androidx.room.Entity; +import androidx.room.Ignore; +import androidx.room.PrimaryKey; + +import org.jellyfin.apiclient.model.dto.BaseItemDto; +import org.jellyfin.apiclient.model.dto.GenreDto; +import org.jellyfin.apiclient.model.entities.ImageType; + +import java.util.ArrayList; +import java.util.List; + +@Entity(tableName = "artist") +public class Artist implements Parcelable { + @Ignore + public List genres; + @Ignore + public List albums; + @Ignore + public List songs; + + @NonNull + @PrimaryKey + @ColumnInfo(name = "id") + public String id; + + @ColumnInfo(name = "name") + public String name; + + @ColumnInfo(name = "primary") + public String primary; + + @ColumnInfo(name = "blurHash") + public String blurHash; + + public Artist(@NonNull String id, String name, String primary, String blurHash) { + this.id = id; + this.name = name; + this.primary = primary; + this.blurHash = blurHash; + } + + @Ignore + public Artist(BaseItemDto itemDto) { + this.id = itemDto.getId(); + this.name = itemDto.getName(); + + this.primary = itemDto.getImageTags().containsKey(ImageType.Primary) ? id : null; + if (itemDto.getImageBlurHashes() != null && itemDto.getImageBlurHashes().get(ImageType.Primary) != null) { + this.blurHash = (String) itemDto.getImageBlurHashes().get(ImageType.Primary).values().toArray()[0]; + } + + this.genres = new ArrayList<>(); + this.albums = new ArrayList<>(); + this.songs = new ArrayList<>(); + + if (itemDto.getGenreItems() != null) { + for (GenreDto genre : itemDto.getGenreItems()) { + genres.add(new Genre(genre)); + } + } + } + + @NonNull + public String getId() { + return id; + } + + public void setId(@NonNull String id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getPrimary() { + return primary; + } + + public void setPrimary(String primary) { + this.primary = primary; + } + + public String getBlurHash() { + return blurHash; + } + + public void setBlurHash(String blurHash) { + this.blurHash = blurHash; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Artist artist = (Artist) o; + return id.equals(artist.id); + } + + @Override + public int hashCode() { + return id.hashCode(); + } + + @NonNull + @Override + public String toString() { + return id; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(id); + dest.writeString(name); + dest.writeString(primary); + dest.writeString(blurHash); + } + + protected Artist(Parcel in) { + this.genres = new ArrayList<>(); + this.albums = new ArrayList<>(); + this.songs = new ArrayList<>(); + this.id = in.readString(); + this.name = in.readString(); + this.primary = in.readString(); + this.blurHash = in.readString(); + } + + public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { + @Override + public Artist createFromParcel(Parcel source) { + return new Artist(source); + } + + @Override + public Artist[] newArray(int size) { + return new Artist[size]; + } + }; +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/model/Genre.java b/app/src/main/java/com/cappielloantonio/play/model/Genre.java new file mode 100644 index 00000000..6f73e83d --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/model/Genre.java @@ -0,0 +1,140 @@ +package com.cappielloantonio.play.model; + +import android.os.Parcel; +import android.os.Parcelable; + +import androidx.annotation.NonNull; +import androidx.room.ColumnInfo; +import androidx.room.Entity; +import androidx.room.Ignore; +import androidx.room.PrimaryKey; + +import org.jellyfin.apiclient.model.dto.BaseItemDto; +import org.jellyfin.apiclient.model.dto.GenreDto; +import org.jellyfin.apiclient.model.entities.ImageType; + +import java.util.UUID; + +@Entity(tableName = "genre") +public class Genre implements Parcelable { + @NonNull + @PrimaryKey + @ColumnInfo(name = "id") + public String id; + + @ColumnInfo(name = "name") + public String name; + + @ColumnInfo(name = "songCount") + public int songCount; + + @ColumnInfo(name = "primary") + public String primary; + + @ColumnInfo(name = "blurHash") + public String blurHash; + + public Genre(@NonNull String id, String name, int songCount, String primary, String blurHash) { + this.id = id; + this.name = name; + this.songCount = songCount; + this.primary = primary; + this.blurHash = blurHash; + } + + @Ignore + public Genre(GenreDto genreDto) { + this.id = genreDto.getId(); + this.name = genreDto.getName(); + this.songCount = 0; + } + + @Ignore + public Genre(BaseItemDto itemDto) { + this.id = itemDto.getId(); + this.name = itemDto.getName(); + this.songCount = itemDto.getSongCount() != null ? itemDto.getSongCount() : 0; + + this.primary = itemDto.getImageTags().containsKey(ImageType.Primary) ? id : null; + if (itemDto.getImageBlurHashes() != null && itemDto.getImageBlurHashes().get(ImageType.Primary) != null) { + this.blurHash = (String) itemDto.getImageBlurHashes().get(ImageType.Primary).values().toArray()[0]; + } + } + + @NonNull + public String getId() { + return id; + } + + public String getName() { + return name; + } + + public int getSongCount() { + return songCount; + } + + public String getPrimary() { + return primary; + } + + public void setPrimary(String primary) { + this.primary = primary; + } + + public String getBlurHash() { + return blurHash; + } + + public void setBlurHash(String blurHash) { + this.blurHash = blurHash; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Genre genre = (Genre) o; + return id.equals(genre.id); + } + + @Override + public int hashCode() { + return id.hashCode(); + } + + @NonNull + @Override + public String toString() { + return id; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(this.id); + dest.writeString(this.name); + dest.writeInt(this.songCount); + } + + protected Genre(Parcel in) { + this.id = in.readString(); + this.name = in.readString(); + this.songCount = in.readInt(); + } + + public static final Creator CREATOR = new Creator() { + public Genre createFromParcel(Parcel source) { + return new Genre(source); + } + + public Genre[] newArray(int size) { + return new Genre[size]; + } + }; +} diff --git a/app/src/main/java/com/cappielloantonio/play/model/Playlist.java b/app/src/main/java/com/cappielloantonio/play/model/Playlist.java new file mode 100644 index 00000000..7314aee0 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/model/Playlist.java @@ -0,0 +1,119 @@ +package com.cappielloantonio.play.model; + +import android.os.Parcel; +import android.os.Parcelable; + +import androidx.annotation.NonNull; +import androidx.room.ColumnInfo; +import androidx.room.Entity; +import androidx.room.Ignore; +import androidx.room.PrimaryKey; + +import org.jellyfin.apiclient.model.dto.BaseItemDto; +import org.jellyfin.apiclient.model.entities.ImageType; + +@Entity(tableName = "playlist") +public class Playlist implements Parcelable { + @NonNull + @PrimaryKey + @ColumnInfo(name = "id") + public String id; + + @ColumnInfo(name = "name") + public String name; + + @ColumnInfo(name = "primary") + public String primary; + + @ColumnInfo(name = "blurHash") + public String blurHash; + + public Playlist(@NonNull String id, String name, String primary, String blurHash) { + this.id = id; + this.name = name; + this.primary = primary; + this.blurHash = blurHash; + } + + @Ignore + public Playlist(BaseItemDto itemDto) { + this.id = itemDto.getId(); + this.name = itemDto.getName(); + + this.primary = itemDto.getImageTags().containsKey(ImageType.Primary) ? id : null; + if (itemDto.getImageBlurHashes() != null && itemDto.getImageBlurHashes().get(ImageType.Primary) != null) { + this.blurHash = (String) itemDto.getImageBlurHashes().get(ImageType.Primary).values().toArray()[0]; + } + } + + @NonNull + public String getId() { + return id; + } + + public String getName() { + return name; + } + + public String getPrimary() { + return primary; + } + + public void setPrimary(String primary) { + this.primary = primary; + } + + public String getBlurHash() { + return blurHash; + } + + public void setBlurHash(String blurHash) { + this.blurHash = blurHash; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Playlist playlist = (Playlist) o; + return id.equals(playlist.id); + } + + @Override + public int hashCode() { + return id.hashCode(); + } + + @NonNull + @Override + public String toString() { + return id; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(this.id); + dest.writeString(this.name); + } + + protected Playlist(Parcel in) { + this.id = in.readString(); + this.name = in.readString(); + } + + public static final Creator CREATOR = new Creator() { + public Playlist createFromParcel(Parcel source) { + return new Playlist(source); + } + + public Playlist[] newArray(int size) { + return new Playlist[size]; + } + }; +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/model/Song.java b/app/src/main/java/com/cappielloantonio/play/model/Song.java new file mode 100644 index 00000000..94f04380 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/model/Song.java @@ -0,0 +1,415 @@ +package com.cappielloantonio.play.model; + +import android.os.Parcel; +import android.os.Parcelable; + +import androidx.annotation.NonNull; +import androidx.room.ColumnInfo; +import androidx.room.Entity; +import androidx.room.Ignore; +import androidx.room.PrimaryKey; + +import org.jellyfin.apiclient.model.dto.BaseItemDto; +import org.jellyfin.apiclient.model.dto.MediaSourceInfo; +import org.jellyfin.apiclient.model.entities.ImageType; +import org.jellyfin.apiclient.model.entities.MediaStream; + +import java.util.UUID; + +@Entity(tableName = "song") +public class Song implements Parcelable { + @NonNull + @PrimaryKey + @ColumnInfo(name = "id") + private String id; + + @ColumnInfo(name = "title") + private String title; + + @ColumnInfo(name = "trackNumber") + private int trackNumber; + + @ColumnInfo(name = "discNumber") + private int discNumber; + + @ColumnInfo(name = "year") + private int year; + + @ColumnInfo(name = "duration") + private long duration; + + @ColumnInfo(name = "albumId") + private String albumId; + + @ColumnInfo(name = "albumName") + private String albumName; + + @ColumnInfo(name = "artistId") + private String artistId; + + @ColumnInfo(name = "artistName") + private String artistName; + + @ColumnInfo(name = "primary") + private String primary; + + @ColumnInfo(name = "blurHash") + private String blurHash; + + @ColumnInfo(name = "favorite") + private boolean favorite; + + @ColumnInfo(name = "path") + private String path; + + @ColumnInfo(name = "size") + private long size; + + @ColumnInfo(name = "container") + private String container; + + @ColumnInfo(name = "codec") + private String codec; + + @ColumnInfo(name = "sampleRate") + private int sampleRate; + + @ColumnInfo(name = "bitRate") + private int bitRate; + + @ColumnInfo(name = "bitDepth") + private int bitDepth; + + @ColumnInfo(name = "channels") + private int channels; + + public Song(@NonNull String id, String title, int trackNumber, int discNumber, int year, long duration, String albumId, String albumName, String artistId, String artistName, String primary, String blurHash, boolean favorite, String path, long size, String container, String codec, int sampleRate, int bitRate, int bitDepth, int channels) { + this.id = id; + this.title = title; + this.trackNumber = trackNumber; + this.discNumber = discNumber; + this.year = year; + this.duration = duration; + this.albumId = albumId; + this.albumName = albumName; + this.artistId = artistId; + this.artistName = artistName; + this.primary = primary; + this.blurHash = blurHash; + this.favorite = favorite; + this.path = path; + this.size = size; + this.container = container; + this.codec = codec; + this.sampleRate = sampleRate; + this.bitRate = bitRate; + this.bitDepth = bitDepth; + this.channels = channels; + } + + @Ignore + public Song(BaseItemDto itemDto) { + this.id = itemDto.getId(); + this.title = itemDto.getName(); + this.trackNumber = itemDto.getIndexNumber() != null ? itemDto.getIndexNumber() : 0; + this.discNumber = itemDto.getParentIndexNumber() != null ? itemDto.getParentIndexNumber() : 0; + this.year = itemDto.getProductionYear() != null ? itemDto.getProductionYear() : 0; + this.duration = itemDto.getRunTimeTicks() != null ? itemDto.getRunTimeTicks() / 10000 : 0; + + this.albumId = itemDto.getAlbumId(); + this.albumName = itemDto.getAlbum(); + + if (itemDto.getAlbumArtists().size() != 0) { + this.artistId = itemDto.getAlbumArtists().get(0).getId(); + this.artistName = itemDto.getAlbumArtists().get(0).getName(); + } else if (itemDto.getArtistItems().size() != 0) { + this.artistId = itemDto.getArtistItems().get(0).getId(); + this.artistName = itemDto.getArtistItems().get(0).getName(); + } + + this.primary = itemDto.getAlbumPrimaryImageTag() != null ? albumId : null; + if (itemDto.getImageBlurHashes() != null && itemDto.getImageBlurHashes().get(ImageType.Primary) != null) { + this.blurHash = (String) itemDto.getImageBlurHashes().get(ImageType.Primary).values().toArray()[0]; + } + + this.favorite = itemDto.getUserData() != null && itemDto.getUserData().getIsFavorite(); + + if (itemDto.getMediaSources() != null && itemDto.getMediaSources().get(0) != null) { + MediaSourceInfo source = itemDto.getMediaSources().get(0); + + this.path = source.getPath(); + this.size = source.getSize() != null ? source.getSize() : 0; + + this.container = source.getContainer(); + this.bitRate = source.getBitrate() != null ? source.getBitrate() : 0; + + if (source.getMediaStreams() != null && source.getMediaStreams().size() != 0) { + MediaStream stream = source.getMediaStreams().get(0); + + this.codec = stream.getCodec(); + this.sampleRate = stream.getSampleRate() != null ? stream.getSampleRate() : 0; + this.bitDepth = stream.getBitDepth() != null ? stream.getBitDepth() : 0; + this.channels = stream.getChannels() != null ? stream.getChannels() : 0; + } + } + } + + @Ignore + public Song(String title, String albumName) { + this.id = UUID.randomUUID().toString(); + this.title = title; + this.albumName = albumName; + } + + @NonNull + public String getId() { + return id; + } + + public String getTitle() { + return title; + } + + public int getTrackNumber() { + return trackNumber; + } + + public int getDiscNumber() { + return discNumber; + } + + public int getYear() { + return year; + } + + public long getDuration() { + return duration; + } + + public String getAlbumId() { + return albumId; + } + + public String getAlbumName() { + return albumName; + } + + public String getArtistId() { + return artistId; + } + + public String getArtistName() { + return artistName; + } + + public String getPrimary() { + return primary; + } + + public String getBlurHash() { + return blurHash; + } + + public boolean isFavorite() { + return favorite; + } + + public String getPath() { + return path; + } + + public long getSize() { + return size; + } + + public String getContainer() { + return container; + } + + public String getCodec() { + return codec; + } + + public int getSampleRate() { + return sampleRate; + } + + public int getBitRate() { + return bitRate; + } + + public int getBitDepth() { + return bitDepth; + } + + public int getChannels() { + return channels; + } + + public void setId(@NonNull String id) { + this.id = id; + } + + public void setTitle(String title) { + this.title = title; + } + + public void setTrackNumber(int trackNumber) { + this.trackNumber = trackNumber; + } + + public void setDiscNumber(int discNumber) { + this.discNumber = discNumber; + } + + public void setYear(int year) { + this.year = year; + } + + public void setDuration(long duration) { + this.duration = duration; + } + + public void setAlbumId(String albumId) { + this.albumId = albumId; + } + + public void setAlbumName(String albumName) { + this.albumName = albumName; + } + + public void setArtistId(String artistId) { + this.artistId = artistId; + } + + public void setArtistName(String artistName) { + this.artistName = artistName; + } + + public void setPrimary(String primary) { + this.primary = primary; + } + + public void setBlurHash(String blurHash) { + this.blurHash = blurHash; + } + + public void setFavorite(boolean favorite) { + this.favorite = favorite; + } + + public void setPath(String path) { + this.path = path; + } + + public void setSize(long size) { + this.size = size; + } + + public void setContainer(String container) { + this.container = container; + } + + public void setCodec(String codec) { + this.codec = codec; + } + + public void setSampleRate(int sampleRate) { + this.sampleRate = sampleRate; + } + + public void setBitRate(int bitRate) { + this.bitRate = bitRate; + } + + public void setBitDepth(int bitDepth) { + this.bitDepth = bitDepth; + } + + public void setChannels(int channels) { + this.channels = channels; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Song song = (Song) o; + return id.equals(song.id); + } + + @Override + public int hashCode() { + return id.hashCode(); + } + + @Override + public String toString() { + return id; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(this.id); + dest.writeString(this.title); + dest.writeInt(this.trackNumber); + dest.writeInt(this.discNumber); + dest.writeInt(this.year); + dest.writeLong(this.duration); + dest.writeString(this.albumId); + dest.writeString(this.albumName); + dest.writeString(this.artistId); + dest.writeString(this.artistName); + dest.writeString(this.primary); + dest.writeString(Boolean.toString(favorite)); + dest.writeString(this.blurHash); + dest.writeString(this.path); + dest.writeLong(this.size); + dest.writeString(this.container); + dest.writeString(this.codec); + dest.writeInt(this.sampleRate); + dest.writeInt(this.bitRate); + dest.writeInt(this.bitDepth); + dest.writeInt(this.channels); + } + + protected Song(Parcel in) { + this.id = in.readString(); + this.title = in.readString(); + this.trackNumber = in.readInt(); + this.discNumber = in.readInt(); + this.year = in.readInt(); + this.duration = in.readLong(); + this.albumId = in.readString(); + this.albumName = in.readString(); + this.artistId = in.readString(); + this.artistName = in.readString(); + this.primary = in.readString(); + this.favorite = Boolean.parseBoolean(in.readString()); + this.blurHash = in.readString(); + this.path = in.readString(); + this.size = in.readLong(); + this.container = in.readString(); + this.codec = in.readString(); + this.sampleRate = in.readInt(); + this.bitRate = in.readInt(); + this.bitDepth = in.readInt(); + this.channels = in.readInt(); + } + + public static final Creator CREATOR = new Creator() { + public Song createFromParcel(Parcel source) { + return new Song(source); + } + + public Song[] newArray(int size) { + return new Song[size]; + } + }; +} diff --git a/app/src/main/java/com/cappielloantonio/play/repository/AlbumRepository.java b/app/src/main/java/com/cappielloantonio/play/repository/AlbumRepository.java new file mode 100644 index 00000000..906dc45d --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/repository/AlbumRepository.java @@ -0,0 +1,127 @@ +package com.cappielloantonio.play.repository; + +import android.app.Application; + +import androidx.lifecycle.LiveData; + +import com.cappielloantonio.play.database.AppDatabase; +import com.cappielloantonio.play.database.dao.AlbumDao; +import com.cappielloantonio.play.model.Album; + +import java.util.ArrayList; +import java.util.List; + +public class AlbumRepository { + private AlbumDao albumDao; + private LiveData> listLiveAlbums; + + public AlbumRepository(Application application) { + AppDatabase database = AppDatabase.getInstance(application); + albumDao = database.albumDao(); + listLiveAlbums = albumDao.getAll(); + } + + public LiveData> getListLiveAlbums() { + return listLiveAlbums; + } + + public boolean exist(Album album) { + boolean exist = false; + + ExistThreadSafe existThread = new ExistThreadSafe(albumDao, album); + Thread thread = new Thread(existThread); + thread.start(); + + try { + thread.join(); + exist = existThread.exist(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + return exist; + } + + public void insert(Album album) { + InsertThreadSafe insert = new InsertThreadSafe(albumDao, album); + Thread thread = new Thread(insert); + thread.start(); + } + + public void insertAll(ArrayList albums) { + InsertAllThreadSafe insertAll = new InsertAllThreadSafe(albumDao, albums); + Thread thread = new Thread(insertAll); + thread.start(); + } + + public void delete(Album album) { + DeleteThreadSafe delete = new DeleteThreadSafe(albumDao, album); + Thread thread = new Thread(delete); + thread.start(); + } + + private static class ExistThreadSafe implements Runnable { + private AlbumDao albumDao; + private Album album; + private boolean exist = false; + + public ExistThreadSafe(AlbumDao albumDao, Album album) { + this.albumDao = albumDao; + this.album = album; + } + + @Override + public void run() { + exist = albumDao.exist(album.getId()); + } + + public boolean exist() { + return exist; + } + } + + private static class InsertThreadSafe implements Runnable { + private AlbumDao albumDao; + private Album album; + + public InsertThreadSafe(AlbumDao albumDao, Album album) { + this.albumDao = albumDao; + this.album = album; + } + + @Override + public void run() { + albumDao.insert(album); + } + } + + private static class InsertAllThreadSafe implements Runnable { + private AlbumDao albumDao; + private ArrayList albums; + + public InsertAllThreadSafe(AlbumDao albumDao, ArrayList albums) { + this.albumDao = albumDao; + this.albums = albums; + } + + @Override + public void run() { + albumDao.insertAll(albums); + } + } + + private static class DeleteThreadSafe implements Runnable { + private AlbumDao albumDao; + private Album album; + + public DeleteThreadSafe(AlbumDao albumDao, Album album) { + this.albumDao = albumDao; + this.album = album; + } + + @Override + public void run() { + albumDao.delete(album); + } + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/repository/ArtistRepository.java b/app/src/main/java/com/cappielloantonio/play/repository/ArtistRepository.java new file mode 100644 index 00000000..cb531828 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/repository/ArtistRepository.java @@ -0,0 +1,128 @@ +package com.cappielloantonio.play.repository; + +import android.app.Application; + +import androidx.lifecycle.LiveData; + +import com.cappielloantonio.play.database.AppDatabase; +import com.cappielloantonio.play.database.dao.ArtistDao; +import com.cappielloantonio.play.model.Artist; + +import java.util.ArrayList; +import java.util.List; + +public class ArtistRepository { + private ArtistDao artistDao; + private LiveData> listLiveArtists; + + public ArtistRepository(Application application) { + AppDatabase database = AppDatabase.getInstance(application); + artistDao = database.artistDao(); + listLiveArtists = artistDao.getAll(); + } + + public LiveData> getListLiveArtists() { + return listLiveArtists; + } + + public boolean exist(Artist artist) { + boolean exist = false; + + ExistThreadSafe existThread = new ExistThreadSafe(artistDao, artist); + Thread thread = new Thread(existThread); + thread.start(); + + try { + thread.join(); + exist = existThread.exist(); + } + catch (InterruptedException e) { + e.printStackTrace(); + } + + return exist; + } + + public void insert(Artist artist) { + InsertThreadSafe insert = new InsertThreadSafe(artistDao, artist); + Thread thread = new Thread(insert); + thread.start(); + } + + public void insertAll(ArrayList artists) { + InsertAllThreadSafe insertAll = new InsertAllThreadSafe(artistDao, artists); + Thread thread = new Thread(insertAll); + thread.start(); + } + + public void delete(Artist artist) { + DeleteThreadSafe delete = new DeleteThreadSafe(artistDao, artist); + Thread thread = new Thread(delete); + thread.start(); + } + + private static class ExistThreadSafe implements Runnable { + private ArtistDao artistDao; + private Artist artist; + private boolean exist = false; + + public ExistThreadSafe(ArtistDao artistDao, Artist artist) { + this.artistDao = artistDao; + this.artist = artist; + } + + @Override + public void run() { + exist = artistDao.exist(artist.getId()); + } + + public boolean exist() { + return exist; + } + } + + private static class InsertThreadSafe implements Runnable { + private ArtistDao artistDao; + private Artist artist; + + public InsertThreadSafe(ArtistDao artistDao, Artist artist) { + this.artistDao = artistDao; + this.artist = artist; + } + + @Override + public void run() { + artistDao.insert(artist); + } + } + + private static class InsertAllThreadSafe implements Runnable { + private ArtistDao artistDao; + private ArrayList artists; + + public InsertAllThreadSafe(ArtistDao artistDao, ArrayList artists) { + this.artistDao = artistDao; + this.artists = artists; + } + + @Override + public void run() { + artistDao.insertAll(artists); + } + } + + private static class DeleteThreadSafe implements Runnable { + private ArtistDao artistDao; + private Artist artist; + + public DeleteThreadSafe(ArtistDao artistDao, Artist artist) { + this.artistDao = artistDao; + this.artist = artist; + } + + @Override + public void run() { + artistDao.delete(artist); + } + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/repository/GenreRepository.java b/app/src/main/java/com/cappielloantonio/play/repository/GenreRepository.java new file mode 100644 index 00000000..f3d8a1f1 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/repository/GenreRepository.java @@ -0,0 +1,128 @@ +package com.cappielloantonio.play.repository; + +import android.app.Application; + +import androidx.lifecycle.LiveData; + +import com.cappielloantonio.play.database.AppDatabase; +import com.cappielloantonio.play.database.dao.GenreDao; +import com.cappielloantonio.play.model.Genre; + +import java.util.ArrayList; +import java.util.List; + +public class GenreRepository { + private GenreDao genreDao; + private LiveData> listLiveGenres; + + public GenreRepository(Application application) { + AppDatabase database = AppDatabase.getInstance(application); + genreDao = database.genreDao(); + listLiveGenres = genreDao.getAll(); + } + + public LiveData> getListLiveGenres() { + return listLiveGenres; + } + + public boolean exist(Genre genre) { + boolean exist = false; + + ExistThreadSafe existThread = new ExistThreadSafe(genreDao, genre); + Thread thread = new Thread(existThread); + thread.start(); + + try { + thread.join(); + exist = existThread.exist(); + } + catch (InterruptedException e) { + e.printStackTrace(); + } + + return exist; + } + + public void insert(Genre genre) { + InsertThreadSafe insert = new InsertThreadSafe(genreDao, genre); + Thread thread = new Thread(insert); + thread.start(); + } + + public void insertAll(ArrayList genres) { + InsertAllThreadSafe insertAll = new InsertAllThreadSafe(genreDao, genres); + Thread thread = new Thread(insertAll); + thread.start(); + } + + public void delete(Genre genre) { + DeleteThreadSafe delete = new DeleteThreadSafe(genreDao, genre); + Thread thread = new Thread(delete); + thread.start(); + } + + private static class ExistThreadSafe implements Runnable { + private GenreDao genreDao; + private Genre genre; + private boolean exist = false; + + public ExistThreadSafe(GenreDao genreDao, Genre genre) { + this.genreDao = genreDao; + this.genre = genre; + } + + @Override + public void run() { + exist = genreDao.exist(genre.getId()); + } + + public boolean exist() { + return exist; + } + } + + private static class InsertThreadSafe implements Runnable { + private GenreDao genreDao; + private Genre genre; + + public InsertThreadSafe(GenreDao genreDao, Genre genre) { + this.genreDao = genreDao; + this.genre = genre; + } + + @Override + public void run() { + genreDao.insert(genre); + } + } + + private static class InsertAllThreadSafe implements Runnable { + private GenreDao genreDao; + private ArrayList genres; + + public InsertAllThreadSafe(GenreDao genreDao, ArrayList genres) { + this.genreDao = genreDao; + this.genres = genres; + } + + @Override + public void run() { + genreDao.insertAll(genres); + } + } + + private static class DeleteThreadSafe implements Runnable { + private GenreDao genreDao; + private Genre genre; + + public DeleteThreadSafe(GenreDao genreDao, Genre genre) { + this.genreDao = genreDao; + this.genre = genre; + } + + @Override + public void run() { + genreDao.delete(genre); + } + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/repository/PlaylistRepository.java b/app/src/main/java/com/cappielloantonio/play/repository/PlaylistRepository.java new file mode 100644 index 00000000..b76e9ca9 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/repository/PlaylistRepository.java @@ -0,0 +1,128 @@ +package com.cappielloantonio.play.repository; + +import android.app.Application; + +import androidx.lifecycle.LiveData; + +import com.cappielloantonio.play.database.AppDatabase; +import com.cappielloantonio.play.database.dao.PlaylistDao; +import com.cappielloantonio.play.model.Playlist; + +import java.util.ArrayList; +import java.util.List; + +public class PlaylistRepository { + private PlaylistDao playlistDao; + private LiveData> listLivePlaylists; + + public PlaylistRepository(Application application) { + AppDatabase database = AppDatabase.getInstance(application); + playlistDao = database.playlistDao(); + listLivePlaylists = playlistDao.getAll(); + } + + public LiveData> getListLivePlaylists() { + return listLivePlaylists; + } + + public boolean exist(Playlist playlist) { + boolean exist = false; + + ExistThreadSafe existThread = new ExistThreadSafe(playlistDao, playlist); + Thread thread = new Thread(existThread); + thread.start(); + + try { + thread.join(); + exist = existThread.exist(); + } + catch (InterruptedException e) { + e.printStackTrace(); + } + + return exist; + } + + public void insert(Playlist playlist) { + InsertThreadSafe insert = new InsertThreadSafe(playlistDao, playlist); + Thread thread = new Thread(insert); + thread.start(); + } + + public void insertAll(ArrayList playlists) { + InsertAllThreadSafe insertAll = new InsertAllThreadSafe(playlistDao, playlists); + Thread thread = new Thread(insertAll); + thread.start(); + } + + public void delete(Playlist playlist) { + DeleteThreadSafe delete = new DeleteThreadSafe(playlistDao, playlist); + Thread thread = new Thread(delete); + thread.start(); + } + + private static class ExistThreadSafe implements Runnable { + private PlaylistDao playlistDao; + private Playlist playlist; + private boolean exist = false; + + public ExistThreadSafe(PlaylistDao playlistDao, Playlist playlist) { + this.playlistDao = playlistDao; + this.playlist = playlist; + } + + @Override + public void run() { + exist = playlistDao.exist(playlist.getId()); + } + + public boolean exist() { + return exist; + } + } + + private static class InsertThreadSafe implements Runnable { + private PlaylistDao playlistDao; + private Playlist playlist; + + public InsertThreadSafe(PlaylistDao playlistDao, Playlist playlist) { + this.playlistDao = playlistDao; + this.playlist = playlist; + } + + @Override + public void run() { + playlistDao.insert(playlist); + } + } + + private static class InsertAllThreadSafe implements Runnable { + private PlaylistDao playlistDao; + private ArrayList playlists; + + public InsertAllThreadSafe(PlaylistDao playlistDao, ArrayList playlists) { + this.playlistDao = playlistDao; + this.playlists = playlists; + } + + @Override + public void run() { + playlistDao.insertAll(playlists); + } + } + + private static class DeleteThreadSafe implements Runnable { + private PlaylistDao playlistDao; + private Playlist playlist; + + public DeleteThreadSafe(PlaylistDao playlistDao, Playlist playlist) { + this.playlistDao = playlistDao; + this.playlist = playlist; + } + + @Override + public void run() { + playlistDao.delete(playlist); + } + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/repository/SongRepository.java b/app/src/main/java/com/cappielloantonio/play/repository/SongRepository.java new file mode 100644 index 00000000..bdcf8272 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/repository/SongRepository.java @@ -0,0 +1,128 @@ +package com.cappielloantonio.play.repository; + +import android.app.Application; + +import androidx.lifecycle.LiveData; + +import com.cappielloantonio.play.database.AppDatabase; +import com.cappielloantonio.play.database.dao.SongDao; +import com.cappielloantonio.play.model.Song; + +import java.util.ArrayList; +import java.util.List; + +public class SongRepository { + private SongDao songDao; + private LiveData> listLiveSongs; + + public SongRepository(Application application) { + AppDatabase database = AppDatabase.getInstance(application); + songDao = database.songDao(); + listLiveSongs = songDao.getAll(); + } + + public LiveData> getListLiveSongs() { + return listLiveSongs; + } + + public boolean exist(Song song) { + boolean exist = false; + + ExistThreadSafe existThread = new ExistThreadSafe(songDao, song); + Thread thread = new Thread(existThread); + thread.start(); + + try { + thread.join(); + exist = existThread.exist(); + } + catch (InterruptedException e) { + e.printStackTrace(); + } + + return exist; + } + + public void insert(Song song) { + InsertThreadSafe insert = new InsertThreadSafe(songDao, song); + Thread thread = new Thread(insert); + thread.start(); + } + + public void insertAll(ArrayList songs) { + InsertAllThreadSafe insertAll = new InsertAllThreadSafe(songDao, songs); + Thread thread = new Thread(insertAll); + thread.start(); + } + + public void delete(Song song) { + DeleteThreadSafe delete = new DeleteThreadSafe(songDao, song); + Thread thread = new Thread(delete); + thread.start(); + } + + private static class ExistThreadSafe implements Runnable { + private SongDao songDao; + private Song song; + private boolean exist = false; + + public ExistThreadSafe(SongDao songDao, Song song) { + this.songDao = songDao; + this.song = song; + } + + @Override + public void run() { + exist = songDao.exist(song.getId()); + } + + public boolean exist() { + return exist; + } + } + + private static class InsertThreadSafe implements Runnable { + private SongDao songDao; + private Song song; + + public InsertThreadSafe(SongDao songDao, Song song) { + this.songDao = songDao; + this.song = song; + } + + @Override + public void run() { + songDao.insert(song); + } + } + + private static class InsertAllThreadSafe implements Runnable { + private SongDao songDao; + private ArrayList songs; + + public InsertAllThreadSafe(SongDao songDao, ArrayList songs) { + this.songDao = songDao; + this.songs = songs; + } + + @Override + public void run() { + songDao.insertAll(songs); + } + } + + private static class DeleteThreadSafe implements Runnable { + private SongDao songDao; + private Song song; + + public DeleteThreadSafe(SongDao songDao, Song song) { + this.songDao = songDao; + this.song = song; + } + + @Override + public void run() { + songDao.delete(song); + } + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/ui/activities/MainActivity.java b/app/src/main/java/com/cappielloantonio/play/ui/activities/MainActivity.java new file mode 100644 index 00000000..39042ab1 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/activities/MainActivity.java @@ -0,0 +1,117 @@ +package com.cappielloantonio.play.ui.activities; + +import android.os.Bundle; +import android.view.View; + +import androidx.fragment.app.FragmentManager; +import androidx.navigation.NavController; +import androidx.navigation.fragment.NavHostFragment; +import androidx.navigation.ui.NavigationUI; + +import com.cappielloantonio.play.App; +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.databinding.ActivityMainBinding; +import com.cappielloantonio.play.ui.activities.base.BaseActivity; +import com.cappielloantonio.play.util.PreferenceUtil; +import com.google.android.material.bottomnavigation.BottomNavigationView; + +import org.jellyfin.apiclient.interaction.EmptyResponse; +import org.jellyfin.apiclient.interaction.Response; +import org.jellyfin.apiclient.model.session.ClientCapabilities; +import org.jellyfin.apiclient.model.system.SystemInfo; + +import java.util.Objects; + +public class MainActivity extends BaseActivity { + private static final String TAG = "MainActivity"; + + private ActivityMainBinding activityMainBinding; + + private FragmentManager fragmentManager; + private NavHostFragment navHostFragment; + private BottomNavigationView bottomNavigationView; + public NavController navController; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + activityMainBinding = ActivityMainBinding.inflate(getLayoutInflater()); + View view = activityMainBinding.getRoot(); + setContentView(view); + + init(); + } + + public void init() { + fragmentManager = getSupportFragmentManager(); + bottomNavigationView = findViewById(R.id.bottom_navigation); + + navHostFragment = (NavHostFragment) fragmentManager.findFragmentById(R.id.nav_host_fragment); + navController = navHostFragment.getNavController(); + NavigationUI.setupWithNavController(bottomNavigationView, navController); + + if (PreferenceUtil.getInstance(this).getToken() != null) { + checkPreviousSession(); + } else { + goToLogin(); + } + } + + private void checkPreviousSession() { + App.getApiClientInstance(getApplicationContext()).ChangeServerLocation(PreferenceUtil.getInstance(this).getServer()); + App.getApiClientInstance(getApplicationContext()).SetAuthenticationInfo(PreferenceUtil.getInstance(this).getToken(), PreferenceUtil.getInstance(this).getUser()); + App.getApiClientInstance(getApplicationContext()).GetSystemInfoAsync(new Response() { + @Override + public void onResponse(SystemInfo result) { + ClientCapabilities clientCapabilities = new ClientCapabilities(); + clientCapabilities.setSupportsMediaControl(true); + clientCapabilities.setSupportsPersistentIdentifier(true); + + App.getApiClientInstance(getApplicationContext()).ensureWebSocket(); + App.getApiClientInstance(getApplicationContext()).ReportCapabilities(clientCapabilities, new EmptyResponse()); + + goFromLogin(); + } + + @Override + public void onError(Exception exception) { + goToLogin(); + } + }); + } + + public void goToLogin() { + if (Objects.requireNonNull(navController.getCurrentDestination()).getId() == R.id.landingFragment) + navController.navigate(R.id.action_landingFragment_to_loginFragment); + } + + public void goToSync() { + if (Objects.requireNonNull(navController.getCurrentDestination()).getId() == R.id.landingFragment) { + navController.navigate(R.id.action_landingFragment_to_syncFragment); + } else if (Objects.requireNonNull(navController.getCurrentDestination()).getId() == R.id.loginFragment) { + navController.navigate(R.id.action_loginFragment_to_syncFragment); + } else if (Objects.requireNonNull(navController.getCurrentDestination()).getId() == R.id.homeFragment) { + navController.navigate(R.id.action_homeFragment_to_syncFragment); + } + } + + public void goToHome() { + bottomNavigationView.setVisibility(View.VISIBLE); + + if (Objects.requireNonNull(navController.getCurrentDestination()).getId() == R.id.landingFragment) { + navController.navigate(R.id.action_landingFragment_to_homeFragment); + } else if (Objects.requireNonNull(navController.getCurrentDestination()).getId() == R.id.syncFragment) { + navController.navigate(R.id.action_syncFragment_to_homeFragment); + } else if (Objects.requireNonNull(navController.getCurrentDestination()).getId() == R.id.loginFragment) { + navController.navigate(R.id.action_loginFragment_to_homeFragment); + } + } + + public void goFromLogin() { + if (PreferenceUtil.getInstance(getApplicationContext()).getSync()) { + goToHome(); + } else { + goToSync(); + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/ui/activities/base/BaseActivity.java b/app/src/main/java/com/cappielloantonio/play/ui/activities/base/BaseActivity.java new file mode 100644 index 00000000..b4868a95 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/activities/base/BaseActivity.java @@ -0,0 +1,83 @@ +package com.cappielloantonio.play.ui.activities.base; + +import android.Manifest; +import android.content.Intent; +import android.os.PowerManager; +import android.provider.Settings; + +import androidx.annotation.NonNull; +import androidx.appcompat.app.AlertDialog; +import androidx.appcompat.app.AppCompatActivity; + +import com.cappielloantonio.play.R; + +import java.util.List; + +import pub.devrel.easypermissions.AppSettingsDialog; +import pub.devrel.easypermissions.EasyPermissions; + +public class BaseActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks { + public static final int REQUEST_PERM_ACCESS = 1; + + @Override + protected void onResume() { + super.onResume(); + checkPermissions(); +// checkBatteryOptimization(); + } + + private void checkBatteryOptimization() { + if (detectBatteryOptimization()) { + showBatteryOptimizationDialog(); + } + } + + private boolean detectBatteryOptimization() { + String packageName = getPackageName(); + PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE); + return !powerManager.isIgnoringBatteryOptimizations(packageName); + } + + private void showBatteryOptimizationDialog() { + AlertDialog.Builder builder = new AlertDialog.Builder(this); + builder.setMessage(R.string.battery_optimizations_message) + .setTitle(R.string.battery_optimizations_title) + .setNegativeButton(R.string.ignore, null) + .setPositiveButton(R.string.disable, (dialog, id) -> openPowerSettings()) + .show(); + } + + private void openPowerSettings() { + Intent intent = new Intent(); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.setAction(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS); + startActivity(intent); + } + + private void checkPermissions() { + String[] permissions = {Manifest.permission.WRITE_EXTERNAL_STORAGE}; + + if (!EasyPermissions.hasPermissions(this, permissions)) { + EasyPermissions.requestPermissions(this, getString(R.string.storage_permission_rationale), REQUEST_PERM_ACCESS, permissions); + } + } + + @Override + public void onPermissionsGranted(int requestCode, @NonNull List perms) { + + } + + @Override + public void onPermissionsDenied(int requestCode, @NonNull List perms) { + if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) { + new AppSettingsDialog.Builder(this).build().show(); + } + } + + @Override + public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { + super.onRequestPermissionsResult(requestCode, permissions, grantResults); + + EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/ui/fragment/HomeFragment.java b/app/src/main/java/com/cappielloantonio/play/ui/fragment/HomeFragment.java new file mode 100644 index 00000000..4e3e69e3 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/fragment/HomeFragment.java @@ -0,0 +1,91 @@ +package com.cappielloantonio.play.ui.fragment; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Toast; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.LinearLayoutManager; + +import com.cappielloantonio.play.adapter.DiscoverSongAdapter; +import com.cappielloantonio.play.adapter.RecentMusicAdapter; +import com.cappielloantonio.play.databinding.FragmentHomeBinding; +import com.cappielloantonio.play.ui.activities.MainActivity; +import com.cappielloantonio.play.util.PreferenceUtil; +import com.cappielloantonio.play.viewmodel.HomeViewModel; + +public class HomeFragment extends Fragment implements RecentMusicAdapter.ItemClickListener { + private static final String TAG = "CategoriesFragment"; + + private FragmentHomeBinding bind; + private MainActivity activity; + private HomeViewModel homeViewModel; + + private DiscoverSongAdapter discoverSongAdapter; + private RecentMusicAdapter recentMusicAdapter; + private RecentMusicAdapter mostPlayedMusicAdapter; + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + activity = (MainActivity) getActivity(); + + bind = FragmentHomeBinding.inflate(inflater, container, false); + View view = bind.getRoot(); + homeViewModel = new ViewModelProvider(requireActivity()).get(HomeViewModel.class); + + init(); + initDiscoverSongSlideView(); + initRecentPlayedSongView(); + initMostPlayedSongView(); + + return view; + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + bind = null; + } + + private void init() { + bind.resyncButton.setOnClickListener(v -> { + PreferenceUtil.getInstance(requireContext()).setSync(false); + activity.goToSync(); + }); + } + + private void initDiscoverSongSlideView() { + discoverSongAdapter = new DiscoverSongAdapter(requireContext(), homeViewModel.getDiscoverSongList()); + bind.discoverSongViewPager.setAdapter(discoverSongAdapter); + bind.discoverSongViewPager.setPageMargin(20); + } + + private void initRecentPlayedSongView() { + bind.recentlyPlayedTracksRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext(), LinearLayoutManager.HORIZONTAL, false)); + bind.recentlyPlayedTracksRecyclerView.setHasFixedSize(true); + + recentMusicAdapter = new RecentMusicAdapter(requireContext(), homeViewModel.getRecentSongList()); + recentMusicAdapter.setClickListener(this); + bind.recentlyPlayedTracksRecyclerView.setAdapter(recentMusicAdapter); + } + + private void initMostPlayedSongView() { + bind.mostPlayedTracksRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext(), LinearLayoutManager.HORIZONTAL, false)); + bind.mostPlayedTracksRecyclerView.setHasFixedSize(true); + + mostPlayedMusicAdapter = new RecentMusicAdapter(requireContext(), homeViewModel.getMostPlayedSongList()); + mostPlayedMusicAdapter.setClickListener(this); + bind.mostPlayedTracksRecyclerView.setAdapter(mostPlayedMusicAdapter); + } + + @Override + public void onItemClick(View view, int position) { + Toast.makeText(requireContext(), "Click: " + position, Toast.LENGTH_SHORT).show(); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/ui/fragment/LandingFragment.java b/app/src/main/java/com/cappielloantonio/play/ui/fragment/LandingFragment.java new file mode 100644 index 00000000..f517290e --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/fragment/LandingFragment.java @@ -0,0 +1,17 @@ +package com.cappielloantonio.play.ui.fragment; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.fragment.app.Fragment; + +import com.cappielloantonio.play.R; + +public class LandingFragment extends Fragment { + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + return inflater.inflate(R.layout.fragment_landing, container, false); + } +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/ui/fragment/LibraryFragment.java b/app/src/main/java/com/cappielloantonio/play/ui/fragment/LibraryFragment.java new file mode 100644 index 00000000..020710ab --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/fragment/LibraryFragment.java @@ -0,0 +1,101 @@ +package com.cappielloantonio.play.ui.fragment; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Toast; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.GridLayoutManager; +import androidx.recyclerview.widget.LinearLayoutManager; + +import com.cappielloantonio.play.adapter.AlbumAdapter; +import com.cappielloantonio.play.adapter.ArtistAdapter; +import com.cappielloantonio.play.adapter.GenreAdapter; +import com.cappielloantonio.play.adapter.PlaylistAdapter; +import com.cappielloantonio.play.databinding.FragmentLibraryBinding; +import com.cappielloantonio.play.model.Genre; +import com.cappielloantonio.play.model.Playlist; +import com.cappielloantonio.play.ui.activities.MainActivity; +import com.cappielloantonio.play.viewmodel.LibraryViewModel; + +import java.util.ArrayList; +import java.util.List; + +public class LibraryFragment extends Fragment { + private static final String TAG = "LibraryFragment"; + + private FragmentLibraryBinding bind; + private MainActivity activity; + private LibraryViewModel libraryViewModel; + + private AlbumAdapter albumAdapter; + private ArtistAdapter artistAdapter; + private GenreAdapter genreAdapter; + private PlaylistAdapter playlistAdapter; + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + activity = (MainActivity) getActivity(); + + bind = FragmentLibraryBinding.inflate(inflater, container, false); + View view = bind.getRoot(); + libraryViewModel = new ViewModelProvider(requireActivity()).get(LibraryViewModel.class); + + initAlbumView(); + initArtistView(); + initGenreView(); + initPlaylistView(); + + return view; + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + bind = null; + } + + private void initAlbumView() { + bind.albumRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext(), LinearLayoutManager.HORIZONTAL, false)); + bind.albumRecyclerView.setHasFixedSize(true); + + albumAdapter = new AlbumAdapter(requireContext(), libraryViewModel.getAlbumSample()); + albumAdapter.setClickListener((view, position) -> Toast.makeText(requireContext(), "Album: " + position, Toast.LENGTH_SHORT).show()); + bind.albumRecyclerView.setAdapter(albumAdapter); + } + + private void initArtistView() { + bind.artistRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext(), LinearLayoutManager.HORIZONTAL, false)); + bind.artistRecyclerView.setHasFixedSize(true); + + artistAdapter = new ArtistAdapter(requireContext(), libraryViewModel.getArtistSample()); + artistAdapter.setClickListener((view, position) -> Toast.makeText(requireContext(), "Artist: " + position, Toast.LENGTH_SHORT).show()); + bind.artistRecyclerView.setAdapter(artistAdapter); + } + + private void initGenreView() { + bind.genreRecyclerView.setLayoutManager(new GridLayoutManager(requireContext(), 3, GridLayoutManager.HORIZONTAL, false)); + bind.genreRecyclerView.setHasFixedSize(true); + + genreAdapter = new GenreAdapter(requireContext(), new ArrayList<>()); + genreAdapter.setClickListener((view, position) -> Toast.makeText(requireContext(), "Genre: " + position, Toast.LENGTH_SHORT).show()); + bind.genreRecyclerView.setAdapter(genreAdapter); + libraryViewModel.getGenreList().observe(requireActivity(), genres -> genreAdapter.setItems(genres)); + } + + private void initPlaylistView() { + bind.playlistRecyclerView.setLayoutManager(new GridLayoutManager(requireContext(), 2)); + bind.playlistRecyclerView.setHasFixedSize(true); + + playlistAdapter = new PlaylistAdapter(requireContext(), libraryViewModel.getPlaylist()); + playlistAdapter.setClickListener((view, position) -> Toast.makeText(requireContext(), "Playlist: " + position, Toast.LENGTH_SHORT).show()); + bind.playlistRecyclerView.setAdapter(playlistAdapter); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/ui/fragment/LoginFragment.java b/app/src/main/java/com/cappielloantonio/play/ui/fragment/LoginFragment.java new file mode 100644 index 00000000..5fea757e --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/fragment/LoginFragment.java @@ -0,0 +1,123 @@ +package com.cappielloantonio.play.ui.fragment; + +import android.os.Bundle; +import android.text.TextUtils; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Toast; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.cappielloantonio.play.App; +import com.cappielloantonio.play.databinding.FragmentLoginBinding; +import com.cappielloantonio.play.ui.activities.MainActivity; +import com.cappielloantonio.play.util.PreferenceUtil; + +import org.jellyfin.apiclient.interaction.Response; +import org.jellyfin.apiclient.model.system.SystemInfo; +import org.jellyfin.apiclient.model.users.AuthenticationResult; + +public class LoginFragment extends Fragment { + private static final String TAG = "LoginFragment"; + + private FragmentLoginBinding bind; + private MainActivity activity; + + // private TextView usernameTextView; +// private TextView passwordTextView; +// private TextView serverTextView; + private String username; + private String password; + private String server; + +// private Button loginButton; + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + activity = (MainActivity) getActivity(); + + bind = FragmentLoginBinding.inflate(inflater, container, false); + View view = bind.getRoot(); + init(); + + return view; + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + bind = null; + } + + private void init() { + bind.loginButton.setOnClickListener(v -> { + if (validateInput()) { + saveServerPreference(username, server); + authenticate(); + } + }); + } + + private boolean validateInput() { + username = bind.usernameTextView.getText().toString().trim(); + password = bind.passwordTextView.getText().toString().trim(); + server = bind.serverTextView.getText().toString().trim(); + + if (TextUtils.isEmpty(username)) { + Toast.makeText(requireContext(), "Empty username", Toast.LENGTH_SHORT).show(); + return false; + } + + if (TextUtils.isEmpty(server)) { + Toast.makeText(requireContext(), "Empty server", Toast.LENGTH_SHORT).show(); + return false; + } + + return true; + } + + private void saveServerPreference(String user, String server) { + PreferenceUtil.getInstance(requireContext()).setUser(user); + PreferenceUtil.getInstance(requireContext()).setServer(server); + } + + private void authenticate() { + App.getApiClientInstance(requireContext()).ChangeServerLocation(server); + App.getApiClientInstance(requireContext()).AuthenticateUserAsync(username, password, new Response() { + @Override + public void onResponse(AuthenticationResult result) { + if (result.getAccessToken() == null) return; + enter(result.getUser().getId(), result.getAccessToken()); + } + + @Override + public void onError(Exception exception) { + if (exception.getMessage().contains("AuthFailureError")) { + Toast.makeText(requireContext(), "Fail to authenticate", Toast.LENGTH_SHORT).show(); + } else { + Toast.makeText(requireContext(), "Server unreachable", Toast.LENGTH_SHORT).show(); + } + } + }); + } + + private void enter(String user, String token) { + App.getApiClientInstance(requireContext()).GetSystemInfoAsync(new Response() { + @Override + public void onResponse(SystemInfo result) { + if (result.getVersion().charAt(0) == '1') { + PreferenceUtil.getInstance(requireContext()).setUser(user); + PreferenceUtil.getInstance(requireContext()).setToken(token); + + activity.goFromLogin(); + } else { + Toast.makeText(requireContext(), "Error version", Toast.LENGTH_SHORT).show(); + } + } + }); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/ui/fragment/SearchFragment.java b/app/src/main/java/com/cappielloantonio/play/ui/fragment/SearchFragment.java new file mode 100644 index 00000000..c608a3f5 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/fragment/SearchFragment.java @@ -0,0 +1,118 @@ +package com.cappielloantonio.play.ui.fragment; + +import android.app.Activity; +import android.content.Intent; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.LinearLayout; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.cappielloantonio.play.databinding.FragmentSearchBinding; +import com.cappielloantonio.play.ui.activities.MainActivity; +import com.paulrybitskyi.persistentsearchview.utils.VoiceRecognitionDelegate; + +public class SearchFragment extends Fragment { + private static final String TAG = "SearchFragment"; + public static final int REQUEST_CODE = 64545; + + private FragmentSearchBinding bind; + private MainActivity activity; + + protected LinearLayout emptyLinearLayout; + + protected String query = ""; + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + activity = (MainActivity) getActivity(); + + bind = FragmentSearchBinding.inflate(inflater, container, false); + View view = bind.getRoot(); + + searchInit(); + + return view; + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + bind = null; + } + + @Override + public void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) { + super.onActivityResult(requestCode, resultCode, data); + + if (requestCode == REQUEST_CODE) { + if (resultCode == Activity.RESULT_OK) { + String code = data.getStringExtra("result"); + search(code); + } + } + + VoiceRecognitionDelegate.handleResult(bind.persistentSearchView, requestCode, resultCode, data); + } + + private void searchInit() { + bind.persistentSearchView.showRightButton(); + + bind.persistentSearchView.setOnSearchQueryChangeListener((searchView, oldQuery, newQuery) -> { + }); + + bind.persistentSearchView.setOnLeftBtnClickListener(view -> { + }); + + bind.persistentSearchView.setOnRightBtnClickListener(view -> { + }); + + bind.persistentSearchView.setVoiceRecognitionDelegate(new VoiceRecognitionDelegate(this)); + + bind.persistentSearchView.setOnSearchConfirmedListener((searchView, query) -> { + if (!query.equals("")) { + searchView.collapse(); + search(query); + } + }); + + bind.persistentSearchView.setSuggestionsDisabled(true); + } + + public void search(String query) { + emptyScreen(); + this.query = query; + + bind.persistentSearchView.setInputQuery(query); + performSearch(query); + } + + private void performSearch(String query) { + + } + + private void loadMoreItemSearch(String query, int page) { + manageProgressBar(true); + + } + + private void emptyScreen() { + emptyLinearLayout.setVisibility(View.GONE); + } + + + private void manageProgressBar(boolean show) { + if (show) { + bind.persistentSearchView.hideLeftButton(); + bind.persistentSearchView.showProgressBar(true); + } else { + bind.persistentSearchView.showLeftButton(); + bind.persistentSearchView.hideProgressBar(true); + } + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/ui/fragment/SettingsFragment.java b/app/src/main/java/com/cappielloantonio/play/ui/fragment/SettingsFragment.java new file mode 100644 index 00000000..f8fab89e --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/fragment/SettingsFragment.java @@ -0,0 +1,28 @@ +package com.cappielloantonio.play.ui.fragment; + +import android.os.Bundle; + +import androidx.preference.ListPreference; +import androidx.preference.PreferenceFragmentCompat; + +import com.cappielloantonio.play.R; +import com.cappielloantonio.play.helper.ThemeHelper; + +public class SettingsFragment extends PreferenceFragmentCompat { + private static final String TAG = "SettingsFragment"; + + @Override + public void onCreatePreferences(Bundle savedInstanceState, String rootKey) { + setPreferencesFromResource(R.xml.global_preferences, rootKey); + + ListPreference themePreference = findPreference("themePref"); + if (themePreference != null) { + themePreference.setOnPreferenceChangeListener( + (preference, newValue) -> { + String themeOption = (String) newValue; + ThemeHelper.applyTheme(themeOption); + return true; + }); + } + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/ui/fragment/SyncFragment.java b/app/src/main/java/com/cappielloantonio/play/ui/fragment/SyncFragment.java new file mode 100644 index 00000000..b217d277 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/ui/fragment/SyncFragment.java @@ -0,0 +1,206 @@ +package com.cappielloantonio.play.ui.fragment; + +import android.os.Bundle; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Toast; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.cappielloantonio.play.databinding.FragmentSyncBinding; +import com.cappielloantonio.play.interfaces.MediaCallback; +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Artist; +import com.cappielloantonio.play.model.Genre; +import com.cappielloantonio.play.model.Playlist; +import com.cappielloantonio.play.model.Song; +import com.cappielloantonio.play.repository.AlbumRepository; +import com.cappielloantonio.play.repository.ArtistRepository; +import com.cappielloantonio.play.repository.GenreRepository; +import com.cappielloantonio.play.repository.PlaylistRepository; +import com.cappielloantonio.play.repository.SongRepository; +import com.cappielloantonio.play.ui.activities.MainActivity; +import com.cappielloantonio.play.util.PreferenceUtil; +import com.cappielloantonio.play.util.SyncUtil; + +import org.jellyfin.apiclient.model.dto.BaseItemDto; + +import java.util.ArrayList; +import java.util.List; + +public class SyncFragment extends Fragment { + private static final String TAG = "SyncFragment"; + + private MainActivity activity; + private FragmentSyncBinding bind; + + private ArrayList progressing; + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + activity = (MainActivity) getActivity(); + + bind = FragmentSyncBinding.inflate(inflater, container, false); + View view = bind.getRoot(); + syncLibraries(); + + return view; + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + bind = null; + } + + private void showProgressBar() { + bind.loadingProgressBar.setVisibility(View.VISIBLE); + } + + private void syncLibraries() { + progressing = new ArrayList<>(); + + SyncUtil.getLibraries(requireContext(), new MediaCallback() { + @Override + public void onError(Exception exception) { + Log.e(TAG, "onError: " + exception.getMessage()); + } + + @Override + public void onLoadMedia(List media) { + List libraries = (List) media; + + for (BaseItemDto itemDto : libraries) { + if (itemDto.getCollectionType().equals("music")) + SyncUtil.musicLibrary = itemDto; + } + + startSyncing(); + } + }); + } + + private void startSyncing() { + showProgressBar(); + syncAlbums(); + syncArtists(); + syncGenres(); + syncPlaylist(); + syncSongs(); + } + + private void syncAlbums() { + SyncUtil.getAlbums(requireContext(), new MediaCallback() { + @Override + public void onError(Exception exception) { + Log.e(TAG, "onError: " + exception.getMessage()); + setProgress(false); + } + + @Override + public void onLoadMedia(List media) { + AlbumRepository repository = new AlbumRepository(activity.getApplication()); + repository.insertAll((ArrayList) media); + setProgress(true); + } + }); + } + + private void syncArtists() { + SyncUtil.getArtists(requireContext(), new MediaCallback() { + @Override + public void onError(Exception exception) { + Log.e(TAG, "onError: " + exception.getMessage()); + setProgress(false); + } + + @Override + public void onLoadMedia(List media) { + ArtistRepository repository = new ArtistRepository(activity.getApplication()); + repository.insertAll((ArrayList) media); + setProgress(true); + } + }); + } + + private void syncGenres() { + SyncUtil.getGenres(requireContext(), new MediaCallback() { + @Override + public void onError(Exception exception) { + Log.e(TAG, "onError: " + exception.getMessage()); + setProgress(false); + } + + @Override + public void onLoadMedia(List media) { + GenreRepository repository = new GenreRepository(activity.getApplication()); + repository.insertAll((ArrayList) media); + setProgress(true); + } + }); + } + + private void syncPlaylist() { + SyncUtil.getPlaylists(requireContext(), new MediaCallback() { + @Override + public void onError(Exception exception) { + Log.e(TAG, "onError: " + exception.getMessage()); + setProgress(false); + } + + @Override + public void onLoadMedia(List media) { + PlaylistRepository repository = new PlaylistRepository(activity.getApplication()); + repository.insertAll((ArrayList) media); + setProgress(true); + } + }); + } + + private void syncSongs() { + SyncUtil.getSongs(requireContext(), new MediaCallback() { + @Override + public void onError(Exception exception) { + Log.e(TAG, "onError: " + exception.getMessage()); + setProgress(false); + } + + @Override + public void onLoadMedia(List media) { + SongRepository repository = new SongRepository(activity.getApplication()); + repository.insertAll((ArrayList) media); + setProgress(true); + } + }); + } + + private void setProgress(boolean step) { + if (step) { + progressing.add(25); + bind.loadingProgressBar.setProgress(bind.loadingProgressBar.getProgress() + 25, true); + } else { + progressing.add(0); + } + + countProgress(); + } + + private void countProgress() { + if (progressing.size() == 5) { + if (bind.loadingProgressBar.getProgress() == 100) + terminate(); + else + Toast.makeText(requireContext(), "Sync error", Toast.LENGTH_SHORT).show(); + } + } + + private void terminate() { + PreferenceUtil.getInstance(requireContext()).setSync(true); + activity.goToHome(); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/util/PreferenceUtil.java b/app/src/main/java/com/cappielloantonio/play/util/PreferenceUtil.java new file mode 100644 index 00000000..c4bce9f3 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/util/PreferenceUtil.java @@ -0,0 +1,85 @@ +package com.cappielloantonio.play.util; + +import android.content.Context; +import android.content.SharedPreferences; + +import androidx.preference.PreferenceManager; + +import com.cappielloantonio.play.helper.ThemeHelper; + +public class PreferenceUtil { + public static final String SERVER = "server"; + public static final String USER = "user"; + public static final String TOKEN = "token"; + + public static final String SYNC = "sync"; + + public static final String HOST_URL = "host"; + public static final String IMAGE_CACHE_SIZE = "image_cache_size"; + + private static PreferenceUtil sInstance; + + private final SharedPreferences mPreferences; + + private PreferenceUtil(final Context context) { + mPreferences = PreferenceManager.getDefaultSharedPreferences(context); + } + + public static PreferenceUtil getInstance(final Context context) { + if (sInstance == null) { + sInstance = new PreferenceUtil(context.getApplicationContext()); + } + + return sInstance; + } + + public String getTheme() { return mPreferences.getString("themePref", ThemeHelper.DEFAULT_MODE ); } + + public String getServer() { + return mPreferences.getString(SERVER, "https://jellyfin.org"); + } + + public void setServer(String server) { + final SharedPreferences.Editor editor = mPreferences.edit(); + editor.putString(SERVER, server); + editor.apply(); + } + + public String getUser() { + return mPreferences.getString(USER, ""); + } + + public void setUser(String user) { + final SharedPreferences.Editor editor = mPreferences.edit(); + editor.putString(USER, user); + editor.apply(); + } + + public String getToken() { + return mPreferences.getString(TOKEN, ""); + } + + public void setToken(String token) { + final SharedPreferences.Editor editor = mPreferences.edit(); + editor.putString(TOKEN, token); + editor.apply(); + } + + public Boolean getSync() { + return mPreferences.getBoolean(SYNC, false); + } + + public void setSync(Boolean sync) { + final SharedPreferences.Editor editor = mPreferences.edit(); + editor.putBoolean(SYNC, sync); + editor.apply(); + } + + public final String getHostUrl() { + return mPreferences.getString(HOST_URL, "undefined"); + } + + public final int getImageCacheSize() { + return Integer.parseInt(mPreferences.getString(IMAGE_CACHE_SIZE, "400000000")); + } +} \ No newline at end of file diff --git a/app/src/main/java/com/cappielloantonio/play/util/SyncUtil.java b/app/src/main/java/com/cappielloantonio/play/util/SyncUtil.java new file mode 100644 index 00000000..9f0b1d98 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/util/SyncUtil.java @@ -0,0 +1,177 @@ +package com.cappielloantonio.play.util; + +import android.content.Context; + +import com.cappielloantonio.play.App; +import com.cappielloantonio.play.interfaces.MediaCallback; +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Artist; +import com.cappielloantonio.play.model.Genre; +import com.cappielloantonio.play.model.Playlist; +import com.cappielloantonio.play.model.Song; + +import org.jellyfin.apiclient.interaction.Response; +import org.jellyfin.apiclient.model.dto.BaseItemDto; +import org.jellyfin.apiclient.model.querying.ArtistsQuery; +import org.jellyfin.apiclient.model.querying.ItemFields; +import org.jellyfin.apiclient.model.querying.ItemQuery; +import org.jellyfin.apiclient.model.querying.ItemsByNameQuery; +import org.jellyfin.apiclient.model.querying.ItemsResult; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class SyncUtil { + public static BaseItemDto musicLibrary; + + public static void getLibraries(Context context, MediaCallback callback) { + String id = App.getApiClientInstance(context).getCurrentUserId(); + + App.getApiClientInstance(context).GetUserViews(id, new Response() { + @Override + public void onResponse(ItemsResult result) { + List libraries = new ArrayList<>(); + libraries.addAll(Arrays.asList(result.getItems())); + + callback.onLoadMedia(libraries); + } + + @Override + public void onError(Exception exception) { + exception.printStackTrace(); + } + }); + } + + public static void getSongs(Context context, MediaCallback callback) { + ItemQuery query = new ItemQuery(); + + query.setIncludeItemTypes(new String[]{"Audio"}); + query.setFields(new ItemFields[]{ItemFields.MediaSources}); + query.setUserId(App.getApiClientInstance(context).getCurrentUserId()); + query.setRecursive(true); + query.setParentId(musicLibrary.getId()); + + App.getApiClientInstance(context).GetItemsAsync(query, new Response() { + @Override + public void onResponse(ItemsResult result) { + ArrayList songs = new ArrayList<>(); + + for (BaseItemDto itemDto : result.getItems()) { + songs.add(new Song(itemDto)); + } + + callback.onLoadMedia(songs); + } + + @Override + public void onError(Exception exception) { + callback.onError(exception); + } + }); + } + + public static void getAlbums(Context context, MediaCallback callback) { + ItemQuery query = new ItemQuery(); + + query.setIncludeItemTypes(new String[]{"MusicAlbum"}); + query.setUserId(App.getApiClientInstance(context).getCurrentUserId()); + query.setRecursive(true); + query.setParentId(musicLibrary.getId()); + + App.getApiClientInstance(context).GetItemsAsync(query, new Response() { + @Override + public void onResponse(ItemsResult result) { + List albums = new ArrayList<>(); + for (BaseItemDto itemDto : result.getItems()) { + albums.add(new Album(itemDto)); + } + + callback.onLoadMedia(albums); + } + + @Override + public void onError(Exception exception) { + exception.printStackTrace(); + } + }); + } + + public static void getArtists(Context context, MediaCallback callback) { + ArtistsQuery query = new ArtistsQuery(); + + query.setFields(new ItemFields[]{ItemFields.Genres}); + query.setUserId(App.getApiClientInstance(context).getCurrentUserId()); + query.setRecursive(true); + query.setParentId(musicLibrary.getId()); + + App.getApiClientInstance(context).GetAlbumArtistsAsync(query, new Response() { + @Override + public void onResponse(ItemsResult result) { + List artists = new ArrayList<>(); + for (BaseItemDto itemDto : result.getItems()) { + artists.add(new Artist(itemDto)); + } + + callback.onLoadMedia(artists); + } + + @Override + public void onError(Exception exception) { + exception.printStackTrace(); + } + }); + } + + public static void getPlaylists(Context context, MediaCallback callback) { + ItemQuery query = new ItemQuery(); + + query.setIncludeItemTypes(new String[]{"Playlist"}); + query.setUserId(App.getApiClientInstance(context).getCurrentUserId()); + query.setRecursive(true); + query.setParentId(musicLibrary.getId()); + + App.getApiClientInstance(context).GetItemsAsync(query, new Response() { + @Override + public void onResponse(ItemsResult result) { + List playlists = new ArrayList<>(); + for (BaseItemDto itemDto : result.getItems()) { + playlists.add(new Playlist(itemDto)); + } + + callback.onLoadMedia(playlists); + } + + @Override + public void onError(Exception exception) { + exception.printStackTrace(); + } + }); + } + + public static void getGenres(Context context, MediaCallback callback) { + ItemsByNameQuery query = new ItemsByNameQuery(); + + query.setUserId(App.getApiClientInstance(context).getCurrentUserId()); + query.setRecursive(true); + query.setParentId(musicLibrary.getId()); + + App.getApiClientInstance(context).GetGenresAsync(query, new Response() { + @Override + public void onResponse(ItemsResult result) { + List genres = new ArrayList<>(); + for (BaseItemDto itemDto : result.getItems()) { + genres.add(new Genre(itemDto)); + } + + callback.onLoadMedia(genres); + } + + @Override + public void onError(Exception exception) { + exception.printStackTrace(); + } + }); + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/viewmodel/HomeViewModel.java b/app/src/main/java/com/cappielloantonio/play/viewmodel/HomeViewModel.java new file mode 100644 index 00000000..3d4438a7 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/viewmodel/HomeViewModel.java @@ -0,0 +1,41 @@ +package com.cappielloantonio.play.viewmodel; + +import androidx.lifecycle.ViewModel; + +import com.cappielloantonio.play.model.Song; + +import java.util.ArrayList; +import java.util.List; + +public class HomeViewModel extends ViewModel { + + public List getDiscoverSongList() { + List discover_songs = new ArrayList<>(); + discover_songs.add(new Song("Holiday", "American Idiot")); + discover_songs.add(new Song("Brioschi", "Stanza Singola")); + discover_songs.add(new Song("HappySad", "Ceri Singles")); + discover_songs.add(new Song("Falling back to Earth", "Haken")); + + return discover_songs; + } + + public List getRecentSongList() { + List recent_songs = new ArrayList<>(); + recent_songs.add(new Song("Holiday", "American Idiot")); + recent_songs.add(new Song("Brioschi", "Stanza Singola")); + recent_songs.add(new Song("HappySad", "Ceri Singles")); + recent_songs.add(new Song("Falling back to Earth", "Haken")); + + return recent_songs; + } + + public List getMostPlayedSongList() { + List most_played_songs = new ArrayList<>(); + most_played_songs.add(new Song("Holiday", "American Idiot")); + most_played_songs.add(new Song("Brioschi", "Stanza Singola")); + most_played_songs.add(new Song("HappySad", "Ceri Singles")); + most_played_songs.add(new Song("Falling back to Earth", "Haken")); + + return most_played_songs; + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/viewmodel/LibraryViewModel.java b/app/src/main/java/com/cappielloantonio/play/viewmodel/LibraryViewModel.java new file mode 100644 index 00000000..4cdaf630 --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/viewmodel/LibraryViewModel.java @@ -0,0 +1,77 @@ +package com.cappielloantonio.play.viewmodel; + +import android.app.Application; + +import androidx.annotation.NonNull; +import androidx.lifecycle.AndroidViewModel; +import androidx.lifecycle.LiveData; + +import com.cappielloantonio.play.model.Album; +import com.cappielloantonio.play.model.Artist; +import com.cappielloantonio.play.model.Genre; +import com.cappielloantonio.play.model.Playlist; +import com.cappielloantonio.play.repository.GenreRepository; + +import java.util.ArrayList; +import java.util.List; + +public class LibraryViewModel extends AndroidViewModel { + private GenreRepository genreRepository; + private LiveData> allGenres; + + public LibraryViewModel(@NonNull Application application) { + super(application); + + genreRepository = new GenreRepository(application); + allGenres = genreRepository.getListLiveGenres(); + } + + public LiveData> getGenreList() { + return allGenres; + } + + public ArrayList getAlbumSample() { + ArrayList albums = new ArrayList<>(); + albums.add(new Album("1", "aaaa", 1, "1", "qqqq", "", "")); + albums.add(new Album("2", "ssss", 1, "2", "wwww", "", "")); + albums.add(new Album("3", "dddd", 1, "3", "eeee", "", "")); + albums.add(new Album("4", "ffff", 1, "4", "rrrr", "", "")); + albums.add(new Album("5", "gggg", 1, "5", "tttt", "", "")); + albums.add(new Album("6", "hhhh", 1, "6", "yyyy", "", "")); + albums.add(new Album("7", "jjjj", 1, "7", "uuuu", "", "")); + albums.add(new Album("8", "kkkk", 1, "8", "iiii", "", "")); + albums.add(new Album("9", "llll", 1, "9", "oooo", "", "")); + + return albums; + } + + public ArrayList getArtistSample() { + ArrayList artists = new ArrayList<>(); + artists.add(new Artist("1", "dhgr", "", "")); + artists.add(new Artist("2", "kdnu", "", "")); + artists.add(new Artist("3", "wfty", "", "")); + artists.add(new Artist("4", "hfds", "", "")); + artists.add(new Artist("5", "jgab", "", "")); + artists.add(new Artist("6", "iudg", "", "")); + artists.add(new Artist("7", "istr", "", "")); + artists.add(new Artist("8", "dger", "", "")); + artists.add(new Artist("9", "jhjk", "", "")); + + return artists; + } + + public ArrayList getPlaylist() { + ArrayList playlists = new ArrayList<>(); + playlists.add(new Playlist("1", "sdad", "", "")); + playlists.add(new Playlist("2", "rwef", "", "")); + playlists.add(new Playlist("3", "khjf", "", "")); + playlists.add(new Playlist("4", "thfd", "", "")); + playlists.add(new Playlist("5", "jhku", "", "")); + playlists.add(new Playlist("6", "tuid", "", "")); + playlists.add(new Playlist("7", "hfrt", "", "")); + playlists.add(new Playlist("8", "qedg", "", "")); + playlists.add(new Playlist("9", "tugh", "", "")); + + return playlists; + } +} diff --git a/app/src/main/java/com/cappielloantonio/play/viewmodel/SongViewModel.java b/app/src/main/java/com/cappielloantonio/play/viewmodel/SongViewModel.java new file mode 100644 index 00000000..ee74622d --- /dev/null +++ b/app/src/main/java/com/cappielloantonio/play/viewmodel/SongViewModel.java @@ -0,0 +1,40 @@ +package com.cappielloantonio.play.viewmodel; + +import android.app.Application; + +import androidx.annotation.NonNull; +import androidx.lifecycle.AndroidViewModel; +import androidx.lifecycle.LiveData; + +import com.cappielloantonio.play.model.Song; +import com.cappielloantonio.play.repository.SongRepository; + +import java.util.List; + +public class SongViewModel extends AndroidViewModel { + private SongRepository repository; + private LiveData> allSongs; + + public SongViewModel(@NonNull Application application) { + super(application); + + repository = new SongRepository(application); + allSongs = repository.getListLiveSongs(); + } + + public boolean exist(Song song) { + return repository.exist(song); + } + + public void insert(Song song) { + repository.insert(song); + } + + public void delete(Song song) { + repository.delete(song); + } + + public LiveData> getAllSongs() { + return allSongs; + } +} diff --git a/app/src/main/res/drawable/bottom_nav_selector.xml b/app/src/main/res/drawable/bottom_nav_selector.xml new file mode 100644 index 00000000..c69010c7 --- /dev/null +++ b/app/src/main/res/drawable/bottom_nav_selector.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/bottom_nav_shape.xml b/app/src/main/res/drawable/bottom_nav_shape.xml new file mode 100644 index 00000000..1a94901f --- /dev/null +++ b/app/src/main/res/drawable/bottom_nav_shape.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/ic_close.xml b/app/src/main/res/drawable/ic_close.xml new file mode 100644 index 00000000..16d6d37d --- /dev/null +++ b/app/src/main/res/drawable/ic_close.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/ic_favorites.xml b/app/src/main/res/drawable/ic_favorites.xml new file mode 100644 index 00000000..e6646709 --- /dev/null +++ b/app/src/main/res/drawable/ic_favorites.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_filter.xml b/app/src/main/res/drawable/ic_filter.xml new file mode 100644 index 00000000..4a5ee6a7 --- /dev/null +++ b/app/src/main/res/drawable/ic_filter.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_graphic_eq.xml b/app/src/main/res/drawable/ic_graphic_eq.xml new file mode 100644 index 00000000..3932127d --- /dev/null +++ b/app/src/main/res/drawable/ic_graphic_eq.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_home.xml b/app/src/main/res/drawable/ic_home.xml new file mode 100644 index 00000000..ad6065c4 --- /dev/null +++ b/app/src/main/res/drawable/ic_home.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_qr_code.xml b/app/src/main/res/drawable/ic_qr_code.xml new file mode 100644 index 00000000..fefd5c80 --- /dev/null +++ b/app/src/main/res/drawable/ic_qr_code.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_search.xml b/app/src/main/res/drawable/ic_search.xml new file mode 100644 index 00000000..da931c27 --- /dev/null +++ b/app/src/main/res/drawable/ic_search.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_settings.xml b/app/src/main/res/drawable/ic_settings.xml new file mode 100644 index 00000000..282c986f --- /dev/null +++ b/app/src/main/res/drawable/ic_settings.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/font/bold.ttf b/app/src/main/res/font/bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..54e7059cf36359cb5a3860085714a95306af0dea GIT binary patch literal 100820 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 DEZ%x^ literal 0 HcmV?d00001 diff --git a/app/src/main/res/font/open_sans_font_family.xml b/app/src/main/res/font/open_sans_font_family.xml new file mode 100644 index 00000000..4fbd1655 --- /dev/null +++ b/app/src/main/res/font/open_sans_font_family.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/font/regular.ttf b/app/src/main/res/font/regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..29bfd35a2bfdd92b6e8b4ec2970f4d1eebf49357 GIT binary patch literal 96932 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

_T_kl)Xoan=RX{3lY#VQTZ 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml new file mode 100644 index 00000000..61a83162 --- /dev/null +++ b/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,31 @@ + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/fragment_home.xml b/app/src/main/res/layout/fragment_home.xml new file mode 100644 index 00000000..f4fc4d84 --- /dev/null +++ b/app/src/main/res/layout/fragment_home.xml @@ -0,0 +1,194 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +