241 lines
8.7 KiB
Kotlin
241 lines
8.7 KiB
Kotlin
package com.lagradost.cloudstream3.utils
|
|
|
|
import android.app.Activity
|
|
import android.content.ComponentName
|
|
import android.content.ContentValues
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.content.pm.PackageManager
|
|
import android.media.AudioAttributes
|
|
import android.media.AudioFocusRequest
|
|
import android.media.AudioManager
|
|
import android.net.ConnectivityManager
|
|
import android.net.NetworkCapabilities
|
|
import android.net.Uri
|
|
import android.os.Build
|
|
import android.provider.MediaStore
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import com.google.android.gms.cast.framework.CastContext
|
|
import com.google.android.gms.cast.framework.CastState
|
|
import com.google.android.gms.common.ConnectionResult
|
|
import com.google.android.gms.common.GoogleApiAvailability
|
|
import com.google.android.gms.common.wrappers.Wrappers
|
|
import com.lagradost.cloudstream3.*
|
|
import com.lagradost.cloudstream3.mvvm.logError
|
|
import com.lagradost.cloudstream3.ui.result.ResultFragment
|
|
import com.lagradost.cloudstream3.utils.UIHelper.navigate
|
|
import java.net.URL
|
|
import java.net.URLDecoder
|
|
|
|
object AppUtils {
|
|
fun getVideoContentUri(context: Context, videoFilePath: String): Uri? {
|
|
val cursor = context.contentResolver.query(
|
|
MediaStore.Video.Media.EXTERNAL_CONTENT_URI, arrayOf(MediaStore.Video.Media._ID),
|
|
MediaStore.Video.Media.DATA + "=? ", arrayOf(videoFilePath), null
|
|
)
|
|
return if (cursor != null && cursor.moveToFirst()) {
|
|
val id = cursor.getInt(cursor.getColumnIndex(MediaStore.MediaColumns._ID))
|
|
cursor.close()
|
|
Uri.withAppendedPath(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, "" + id)
|
|
} else {
|
|
val values = ContentValues()
|
|
values.put(MediaStore.Video.Media.DATA, videoFilePath)
|
|
context.contentResolver.insert(
|
|
MediaStore.Video.Media.EXTERNAL_CONTENT_URI, values
|
|
)
|
|
}
|
|
}
|
|
|
|
fun Context.openBrowser(url: String) {
|
|
try {
|
|
val components = arrayOf(ComponentName(applicationContext, MainActivity::class.java))
|
|
val intent = Intent(Intent.ACTION_VIEW)
|
|
intent.data = Uri.parse(url)
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
|
|
startActivity(
|
|
Intent.createChooser(intent, null)
|
|
.putExtra(Intent.EXTRA_EXCLUDE_COMPONENTS, components)
|
|
)
|
|
else
|
|
startActivity(intent)
|
|
} catch (e : Exception) {
|
|
logError(e)
|
|
}
|
|
}
|
|
|
|
fun splitQuery(url: URL): Map<String, String> {
|
|
val queryPairs: MutableMap<String, String> = LinkedHashMap()
|
|
val query: String = url.query
|
|
val pairs = query.split("&").toTypedArray()
|
|
for (pair in pairs) {
|
|
val idx = pair.indexOf("=")
|
|
queryPairs[URLDecoder.decode(pair.substring(0, idx), "UTF-8")] =
|
|
URLDecoder.decode(pair.substring(idx + 1), "UTF-8")
|
|
}
|
|
return queryPairs
|
|
}
|
|
|
|
/** Any object as json string */
|
|
fun Any.toJson(): String {
|
|
return mapper.writeValueAsString(this)
|
|
}
|
|
|
|
/**| S1:E2 Hello World
|
|
* | Episode 2. Hello world
|
|
* | Hello World
|
|
* | Season 1 - Episode 2
|
|
* | Episode 2
|
|
* **/
|
|
fun Context.getNameFull(name: String?, episode: Int?, season: Int?): String {
|
|
val rEpisode = if (episode == 0) null else episode
|
|
val rSeason = if (season == 0) null else season
|
|
|
|
val seasonName = getString(R.string.season)
|
|
val episodeName = getString(R.string.episode)
|
|
val seasonNameShort = getString(R.string.season_short)
|
|
val episodeNameShort = getString(R.string.episode_short)
|
|
|
|
if (name != null) {
|
|
return if (rEpisode != null && rSeason != null) {
|
|
"$seasonNameShort${rSeason}:$episodeNameShort${rEpisode} $name"
|
|
} else if (rEpisode != null) {
|
|
"$episodeName $rEpisode. $name"
|
|
} else {
|
|
name
|
|
}
|
|
} else {
|
|
if (rEpisode != null && rSeason != null) {
|
|
return "$seasonName $rSeason - $episodeName $rEpisode"
|
|
} else if (rSeason == null) {
|
|
return "$episodeName $rEpisode"
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//private val viewModel: ResultViewModel by activityViewModels()
|
|
|
|
fun AppCompatActivity.loadResult(
|
|
url: String,
|
|
apiName: String,
|
|
startAction: Int = 0,
|
|
startValue: Int = 0
|
|
) {
|
|
this.runOnUiThread {
|
|
// viewModelStore.clear()
|
|
this.navigate(
|
|
R.id.global_to_navigation_results,
|
|
ResultFragment.newInstance(url, apiName, startAction, startValue)
|
|
)
|
|
}
|
|
}
|
|
|
|
fun Activity?.loadSearchResult(
|
|
card: SearchResponse,
|
|
startAction: Int = 0,
|
|
startValue: Int = 0
|
|
) {
|
|
(this as AppCompatActivity?)?.loadResult(card.url, card.apiName, startAction, startValue)
|
|
}
|
|
|
|
fun Activity.requestLocalAudioFocus(focusRequest: AudioFocusRequest?) {
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && focusRequest != null) {
|
|
val audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager
|
|
audioManager.requestAudioFocus(focusRequest)
|
|
} else {
|
|
val audioManager: AudioManager =
|
|
getSystemService(Context.AUDIO_SERVICE) as AudioManager
|
|
audioManager.requestAudioFocus(
|
|
null,
|
|
AudioManager.STREAM_MUSIC,
|
|
AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
|
|
)
|
|
}
|
|
}
|
|
|
|
private var currentAudioFocusRequest: AudioFocusRequest? = null
|
|
private var currentAudioFocusChangeListener: AudioManager.OnAudioFocusChangeListener? = null
|
|
var onAudioFocusEvent = Event<Boolean>()
|
|
|
|
private fun getAudioListener(): AudioManager.OnAudioFocusChangeListener? {
|
|
if (currentAudioFocusChangeListener != null) return currentAudioFocusChangeListener
|
|
currentAudioFocusChangeListener = AudioManager.OnAudioFocusChangeListener {
|
|
onAudioFocusEvent.invoke(
|
|
when (it) {
|
|
AudioManager.AUDIOFOCUS_GAIN -> false
|
|
AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE -> false
|
|
AudioManager.AUDIOFOCUS_GAIN_TRANSIENT -> false
|
|
else -> true
|
|
}
|
|
)
|
|
}
|
|
return currentAudioFocusChangeListener
|
|
}
|
|
|
|
fun Context.isCastApiAvailable(): Boolean {
|
|
val isCastApiAvailable =
|
|
GoogleApiAvailability.getInstance()
|
|
.isGooglePlayServicesAvailable(applicationContext) == ConnectionResult.SUCCESS
|
|
try {
|
|
applicationContext?.let { CastContext.getSharedInstance(it) }
|
|
} catch (e: Exception) {
|
|
println(e)
|
|
// track non-fatal
|
|
return false
|
|
}
|
|
return isCastApiAvailable
|
|
}
|
|
|
|
fun Context.isConnectedToChromecast(): Boolean {
|
|
if (isCastApiAvailable()) {
|
|
val castContext = CastContext.getSharedInstance(this)
|
|
if (castContext.castState == CastState.CONNECTED) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
fun Context.isUsingMobileData(): Boolean {
|
|
val conManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
|
|
val networkInfo = conManager.allNetworks
|
|
return networkInfo.any {
|
|
conManager.getNetworkCapabilities(it)
|
|
?.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == true
|
|
}
|
|
}
|
|
|
|
fun Context.isAppInstalled(uri: String): Boolean {
|
|
val pm = Wrappers.packageManager(this)
|
|
var appInstalled = false
|
|
appInstalled = try {
|
|
pm.getPackageInfo(uri, PackageManager.GET_ACTIVITIES)
|
|
true
|
|
} catch (e: PackageManager.NameNotFoundException) {
|
|
false
|
|
}
|
|
return appInstalled
|
|
}
|
|
|
|
fun getFocusRequest(): AudioFocusRequest? {
|
|
if (currentAudioFocusRequest != null) return currentAudioFocusRequest
|
|
currentAudioFocusRequest = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN).run {
|
|
setAudioAttributes(AudioAttributes.Builder().run {
|
|
setUsage(AudioAttributes.USAGE_MEDIA)
|
|
setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
|
|
build()
|
|
})
|
|
setAcceptsDelayedFocusGain(true)
|
|
getAudioListener()?.let {
|
|
setOnAudioFocusChangeListener(it)
|
|
}
|
|
build()
|
|
}
|
|
} else {
|
|
null
|
|
}
|
|
return currentAudioFocusRequest
|
|
}
|
|
} |