343 lines
13 KiB
Kotlin
343 lines
13 KiB
Kotlin
package org.moire.ultrasonic.activity
|
|
|
|
import android.app.AlertDialog
|
|
import android.app.SearchManager
|
|
import android.content.Intent
|
|
import android.content.res.Resources
|
|
import android.media.AudioManager
|
|
import android.os.Bundle
|
|
import android.preference.PreferenceManager
|
|
import android.provider.MediaStore
|
|
import android.provider.SearchRecentSuggestions
|
|
import android.view.KeyEvent
|
|
import android.view.Menu
|
|
import android.view.MenuItem
|
|
import android.view.View
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import androidx.appcompat.widget.Toolbar
|
|
import androidx.drawerlayout.widget.DrawerLayout
|
|
import androidx.fragment.app.FragmentContainerView
|
|
import androidx.navigation.NavController
|
|
import androidx.navigation.findNavController
|
|
import androidx.navigation.fragment.NavHostFragment
|
|
import androidx.navigation.ui.AppBarConfiguration
|
|
import androidx.navigation.ui.navigateUp
|
|
import androidx.navigation.ui.onNavDestinationSelected
|
|
import androidx.navigation.ui.setupActionBarWithNavController
|
|
import androidx.navigation.ui.setupWithNavController
|
|
import com.google.android.material.navigation.NavigationView
|
|
import org.koin.android.ext.android.inject
|
|
import org.koin.android.viewmodel.ext.android.viewModel
|
|
import org.moire.ultrasonic.R
|
|
import org.moire.ultrasonic.data.ActiveServerProvider.Companion.isOffline
|
|
import org.moire.ultrasonic.domain.PlayerState
|
|
import org.moire.ultrasonic.fragment.ServerSettingsModel
|
|
import org.moire.ultrasonic.provider.SearchSuggestionProvider
|
|
import org.moire.ultrasonic.service.DownloadFile
|
|
import org.moire.ultrasonic.service.MediaPlayerController
|
|
import org.moire.ultrasonic.service.MediaPlayerLifecycleSupport
|
|
import org.moire.ultrasonic.subsonic.ImageLoaderProvider
|
|
import org.moire.ultrasonic.util.Constants
|
|
import org.moire.ultrasonic.util.FileUtil
|
|
import org.moire.ultrasonic.util.NowPlayingEventDistributor
|
|
import org.moire.ultrasonic.util.NowPlayingEventListener
|
|
import org.moire.ultrasonic.util.SubsonicUncaughtExceptionHandler
|
|
import org.moire.ultrasonic.util.ThemeChangedEventDistributor
|
|
import org.moire.ultrasonic.util.ThemeChangedEventListener
|
|
import org.moire.ultrasonic.util.Util
|
|
import timber.log.Timber
|
|
|
|
|
|
/**
|
|
* The main Activity of Ultrasonic which loads all other screens as Fragments
|
|
*/
|
|
class NavigationActivity : AppCompatActivity() {
|
|
var chatMenuItem: MenuItem? = null
|
|
var bookmarksMenuItem: MenuItem? = null
|
|
var sharesMenuItem: MenuItem? = null
|
|
var podcastsMenuItem: MenuItem? = null
|
|
var nowPlayingView: FragmentContainerView? = null
|
|
var nowPlayingHidden = false
|
|
|
|
private lateinit var appBarConfiguration : AppBarConfiguration
|
|
private lateinit var nowPlayingEventListener : NowPlayingEventListener
|
|
private lateinit var themeChangedEventListener : ThemeChangedEventListener
|
|
|
|
private val serverSettingsModel: ServerSettingsModel by viewModel()
|
|
private val lifecycleSupport: MediaPlayerLifecycleSupport by inject()
|
|
private val mediaPlayerController: MediaPlayerController by inject()
|
|
private val imageLoaderProvider: ImageLoaderProvider by inject()
|
|
private val nowPlayingEventDistributor: NowPlayingEventDistributor by inject()
|
|
private val themeChangedEventDistributor: ThemeChangedEventDistributor by inject()
|
|
|
|
private var infoDialogDisplayed = false
|
|
private var currentFragmentId: Int = 0
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
setUncaughtExceptionHandler()
|
|
Util.applyTheme(this)
|
|
|
|
super.onCreate(savedInstanceState)
|
|
|
|
volumeControlStream = AudioManager.STREAM_MUSIC
|
|
setContentView(R.layout.navigation_activity)
|
|
nowPlayingView = findViewById(R.id.now_playing_fragment)
|
|
|
|
val toolbar = findViewById<Toolbar>(R.id.toolbar)
|
|
setSupportActionBar(toolbar)
|
|
|
|
val host: NavHostFragment = supportFragmentManager
|
|
.findFragmentById(R.id.nav_host_fragment) as NavHostFragment? ?: return
|
|
|
|
val navController = host.navController
|
|
|
|
val drawerLayout : DrawerLayout? = findViewById(R.id.drawer_layout)
|
|
appBarConfiguration = AppBarConfiguration(
|
|
setOf(R.id.mainFragment, R.id.selectArtistFragment, R.id.searchFragment,
|
|
R.id.playlistsFragment, R.id.sharesFragment, R.id.bookmarksFragment,
|
|
R.id.chatFragment, R.id.podcastFragment, R.id.settingsFragment,
|
|
R.id.aboutFragment, R.id.playerFragment),
|
|
drawerLayout)
|
|
|
|
setupActionBar(navController, appBarConfiguration)
|
|
|
|
setupNavigationMenu(navController)
|
|
|
|
navController.addOnDestinationChangedListener { _, destination, _ ->
|
|
val dest: String = try {
|
|
resources.getResourceName(destination.id)
|
|
} catch (e: Resources.NotFoundException) {
|
|
Integer.toString(destination.id)
|
|
}
|
|
Timber.d("Navigated to $dest")
|
|
|
|
currentFragmentId = destination.id
|
|
// Handle the hiding of the NowPlaying fragment when the Player is active
|
|
if (currentFragmentId == R.id.playerFragment) {
|
|
hideNowPlaying()
|
|
} else {
|
|
if (!nowPlayingHidden) showNowPlaying()
|
|
}
|
|
|
|
// Hides menu items for Offline mode
|
|
setMenuForServerSetting()
|
|
}
|
|
|
|
// Determine first run and migrate server settings to DB as early as possible
|
|
var showWelcomeScreen = Util.isFirstRun(this)
|
|
val areServersMigrated: Boolean = serverSettingsModel.migrateFromPreferences()
|
|
|
|
// If there are any servers in the DB, do not show the welcome screen
|
|
showWelcomeScreen = showWelcomeScreen and !areServersMigrated
|
|
|
|
loadSettings()
|
|
showInfoDialog(showWelcomeScreen)
|
|
|
|
nowPlayingEventListener = object : NowPlayingEventListener {
|
|
override fun onDismissNowPlaying() {
|
|
nowPlayingHidden = true;
|
|
hideNowPlaying();
|
|
}
|
|
|
|
override fun onHideNowPlaying() {
|
|
hideNowPlaying()
|
|
}
|
|
|
|
override fun onShowNowPlaying() {
|
|
showNowPlaying()
|
|
}
|
|
}
|
|
|
|
themeChangedEventListener = object : ThemeChangedEventListener {
|
|
override fun onThemeChanged() { recreate() }
|
|
}
|
|
|
|
nowPlayingEventDistributor.subscribe(nowPlayingEventListener)
|
|
themeChangedEventDistributor.subscribe(themeChangedEventListener)
|
|
}
|
|
|
|
override fun onResume() {
|
|
super.onResume()
|
|
|
|
setMenuForServerSetting()
|
|
Util.registerMediaButtonEventReceiver(this, false)
|
|
// Lifecycle support's constructor registers some event receivers so it should be created early
|
|
lifecycleSupport.onCreate()
|
|
|
|
if (!nowPlayingHidden) showNowPlaying()
|
|
else hideNowPlaying()
|
|
}
|
|
|
|
override fun onDestroy() {
|
|
super.onDestroy()
|
|
Util.unregisterMediaButtonEventReceiver(this, false)
|
|
nowPlayingEventDistributor.unsubscribe(nowPlayingEventListener)
|
|
themeChangedEventDistributor.unsubscribe(themeChangedEventListener)
|
|
imageLoaderProvider.clearImageLoader()
|
|
}
|
|
|
|
override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
|
|
val isVolumeDown = keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
|
|
val isVolumeUp = keyCode == KeyEvent.KEYCODE_VOLUME_UP
|
|
val isVolumeAdjust = isVolumeDown || isVolumeUp
|
|
val isJukebox = mediaPlayerController.isJukeboxEnabled
|
|
if (isVolumeAdjust && isJukebox) {
|
|
mediaPlayerController.adjustJukeboxVolume(isVolumeUp)
|
|
return true
|
|
}
|
|
return super.onKeyDown(keyCode, event)
|
|
}
|
|
|
|
private fun setupNavigationMenu(navController: NavController) {
|
|
val sideNavView = findViewById<NavigationView>(R.id.nav_view)
|
|
sideNavView?.setupWithNavController(navController)
|
|
|
|
// The exit menu is handled here manually
|
|
val exitItem: MenuItem = sideNavView.menu.findItem(R.id.menu_exit)
|
|
exitItem.setOnMenuItemClickListener { item ->
|
|
if (item.itemId == R.id.menu_exit) {
|
|
setResult(Constants.RESULT_CLOSE_ALL)
|
|
mediaPlayerController.stopJukeboxService()
|
|
imageLoaderProvider.getImageLoader().stopImageLoader()
|
|
finish()
|
|
exit()
|
|
}
|
|
true
|
|
}
|
|
|
|
chatMenuItem = sideNavView.menu.findItem(R.id.chatFragment)
|
|
bookmarksMenuItem = sideNavView.menu.findItem(R.id.bookmarksFragment)
|
|
sharesMenuItem = sideNavView.menu.findItem(R.id.sharesFragment)
|
|
podcastsMenuItem = sideNavView.menu.findItem(R.id.podcastFragment)
|
|
}
|
|
|
|
private fun setupActionBar(navController: NavController, appBarConfig: AppBarConfiguration) {
|
|
setupActionBarWithNavController(navController, appBarConfig)
|
|
}
|
|
|
|
override fun onCreateOptionsMenu(menu: Menu): Boolean {
|
|
val retValue = super.onCreateOptionsMenu(menu)
|
|
val navigationView = findViewById<NavigationView>(R.id.nav_view)
|
|
if (navigationView == null) {
|
|
menuInflater.inflate(R.menu.navigation, menu)
|
|
return true
|
|
}
|
|
return retValue
|
|
}
|
|
|
|
override fun onOptionsItemSelected(item: MenuItem): Boolean {
|
|
return item.onNavDestinationSelected(findNavController(R.id.nav_host_fragment))
|
|
|| super.onOptionsItemSelected(item)
|
|
}
|
|
|
|
override fun onSupportNavigateUp(): Boolean {
|
|
return findNavController(R.id.nav_host_fragment).navigateUp(appBarConfiguration)
|
|
}
|
|
|
|
// TODO: Test if this works with external Intents
|
|
// android.intent.action.SEARCH and android.media.action.MEDIA_PLAY_FROM_SEARCH calls here
|
|
override fun onNewIntent(intent: Intent?) {
|
|
super.onNewIntent(intent)
|
|
if (intent == null) return;
|
|
|
|
if (intent.getBooleanExtra(Constants.INTENT_EXTRA_NAME_SHOW_PLAYER, false))
|
|
{
|
|
findNavController(R.id.nav_host_fragment).navigate(R.id.playerFragment)
|
|
return
|
|
}
|
|
|
|
val query = intent.getStringExtra(SearchManager.QUERY)
|
|
|
|
if (query != null) {
|
|
val autoPlay = intent.action == MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
|
|
val suggestions = SearchRecentSuggestions(this, SearchSuggestionProvider.AUTHORITY, SearchSuggestionProvider.MODE)
|
|
suggestions.saveRecentQuery(query, null)
|
|
|
|
val bundle = Bundle()
|
|
bundle.putString(Constants.INTENT_EXTRA_NAME_QUERY, query)
|
|
bundle.putBoolean(Constants.INTENT_EXTRA_NAME_AUTOPLAY, autoPlay)
|
|
findNavController(R.id.nav_host_fragment).navigate(R.id.searchFragment, bundle)
|
|
}
|
|
}
|
|
|
|
private fun loadSettings() {
|
|
PreferenceManager.setDefaultValues(this, R.xml.settings, false)
|
|
val preferences = Util.getPreferences(this)
|
|
if (!preferences.contains(Constants.PREFERENCES_KEY_CACHE_LOCATION)) {
|
|
val editor = preferences.edit()
|
|
editor.putString(Constants.PREFERENCES_KEY_CACHE_LOCATION, FileUtil.getDefaultMusicDirectory(this).path)
|
|
editor.apply()
|
|
}
|
|
}
|
|
|
|
private fun exit() {
|
|
lifecycleSupport.onDestroy()
|
|
Util.unregisterMediaButtonEventReceiver(this, false)
|
|
finish()
|
|
}
|
|
|
|
private fun showInfoDialog(show: Boolean) {
|
|
if (!infoDialogDisplayed) {
|
|
infoDialogDisplayed = true
|
|
if (show) {
|
|
AlertDialog.Builder(this)
|
|
.setIcon(android.R.drawable.ic_dialog_info)
|
|
.setTitle(R.string.main_welcome_title)
|
|
.setMessage(R.string.main_welcome_text)
|
|
.setPositiveButton(R.string.common_ok) { dialog, i ->
|
|
dialog.dismiss()
|
|
findNavController(R.id.nav_host_fragment).navigate(R.id.settingsFragment)
|
|
}.show()
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun setUncaughtExceptionHandler() {
|
|
val handler = Thread.getDefaultUncaughtExceptionHandler()
|
|
if (handler !is SubsonicUncaughtExceptionHandler) {
|
|
Thread.setDefaultUncaughtExceptionHandler(SubsonicUncaughtExceptionHandler(this))
|
|
}
|
|
}
|
|
|
|
private fun showNowPlaying() {
|
|
if (!Util.getShowNowPlayingPreference(this)) {
|
|
hideNowPlaying()
|
|
return
|
|
}
|
|
|
|
// The logic for nowPlayingHidden is that the user can dismiss NowPlaying with a gesture,
|
|
// and when the MediaPlayerService requests that it should be shown, it returns
|
|
nowPlayingHidden = false;
|
|
// Do not show for Player fragment
|
|
if (currentFragmentId == R.id.playerFragment) {
|
|
hideNowPlaying()
|
|
return
|
|
}
|
|
|
|
if (nowPlayingView != null) {
|
|
val playerState: PlayerState = mediaPlayerController.playerState
|
|
if (playerState == PlayerState.PAUSED || playerState == PlayerState.STARTED) {
|
|
val file: DownloadFile? = mediaPlayerController.currentPlaying
|
|
if (file != null) {
|
|
val song = file.song
|
|
nowPlayingView?.visibility = View.VISIBLE
|
|
}
|
|
} else {
|
|
hideNowPlaying()
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun hideNowPlaying() {
|
|
nowPlayingView?.visibility = View.GONE
|
|
}
|
|
|
|
private fun setMenuForServerSetting() {
|
|
val visibility = !isOffline(this)
|
|
chatMenuItem?.isVisible = visibility
|
|
bookmarksMenuItem?.isVisible = visibility
|
|
sharesMenuItem?.isVisible = visibility
|
|
podcastsMenuItem?.isVisible = visibility
|
|
}
|
|
}
|