Release scan

[Dinico414]

import android.content.pm.PackageManager
import android.content.Context
import android.content.SharedPreferences
import android.preference.PreferenceManager
import kotlinx.coroutines.*
import kotlinx.serialization.*
import kotlinx.serialization.json.*
import java.net.HttpURLConnection
import java.net.URL
import java.io.BufferedReader
import java.io.InputStreamReader

@serializable
data class Release(
val tag_name: String,
val name: String,
val prerelease: Boolean,
val assets: List
)

@serializable
data class Asset(
val name: String,
val browser_download_url: String
)

suspend fun getLatestReleases(
owner: String,
repo: String,
personalAccessToken: String? = null
): List = withContext(Dispatchers.IO) {
val url = URL("https://api.github.com/repos/$owner/$repo/releases")
val connection = url.openConnection() as HttpURLConnection
connection.requestMethod = "GET"
if (personalAccessToken != null) {
connection.setRequestProperty("Authorization", "token $personalAccessToken")
}
val responseCode = connection.responseCode
if (responseCode == HttpURLConnection.HTTP_OK) {
val reader = BufferedReader(InputStreamReader(connection.inputStream))
val response = reader.readText()
reader.close()
Json.decodeFromString<List>(response)
} else {
throw Exception("GitHub API request failed with response code: $responseCode")
}
}

fun getCurrentAppVersion(context: Context): String {
return try {
val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
packageInfo.versionName
} catch (e: PackageManager.NameNotFoundException) {
"Unknown"
}
}

fun main() = runBlocking {
val owner = "YOUR_GITHUB_USERNAME"
val repo = "YOUR_REPO_NAME"
val personalAccessToken = "YOUR_PERSONAL_ACCESS_TOKEN" // Optional
val context: Context = TODO("Hier muss der Context übergeben werden")
val sharedPreferences: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(context)
val releaseSwitchValue = sharedPreferences.getBoolean("release_switch", true) // Default: Releases

try {
    val currentVersion = getCurrentAppVersion(context)
    println("Aktuelle App-Version: $currentVersion")

    val releases = getLatestReleases(owner, repo, personalAccessToken)
    val filteredReleases = if (releaseSwitchValue) {
        releases.filter { !it.prerelease } // Nur Releases
    } else {
        releases // Releases und Pre-Releases
    }

    filteredReleases.forEach { release ->
        println("Tag: ${release.tag_name}")
        println("Name: ${release.name}")
        println("Pre-release: ${release.prerelease}")
        release.assets.forEach { asset ->
            println("  Asset: ${asset.name}")
            println("  Download URL: ${asset.browser_download_url}")
        }
        if (release.tag_name != currentVersion) {
            println("Eine neue Version ist verfügbar!")
        } else {
            println("Die App ist auf dem neuesten Stand.")
        }
        println("---")
    }
} catch (e: Exception) {
    println("Error: ${e.message}")
}

}

[Dinico414]

package com.xenon.store

import android.content.Intent
import android.content.SharedPreferences
import android.content.pm.PackageManager
import android.os.Bundle
import android.os.Environment
import android.util.Log
import android.view.Menu
import android.view.View
import android.widget.Button
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.app.AppCompatDelegate
import androidx.core.content.FileProvider
import androidx.preference.PreferenceManager
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import com.google.android.material.appbar.AppBarLayout
import com.google.android.material.progressindicator.LinearProgressIndicator
import com.xenon.store.R.id
import com.xenon.store.R.string
import com.xenon.store.activities.SettingsActivity
import com.xenon.store.databinding.ActivityMainBinding
import kotlinx.coroutines.*
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import okhttp3.Call
import okhttp3.Callback
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import java.io.File
import java.io.FileOutputStream
import java.io.IOException
import java.net.HttpURLConnection
import java.net.SocketTimeoutException
import java.net.URL
import java.net.UnknownHostException

@Suppress("UNUSED_PARAMETER", "SameParameterValue")
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
private lateinit var sharedPreferences: SharedPreferences

private var owner = "Dinico414"
private var filePath = "app/release/app-release.apk"
private var personalAccessToken = BuildConfig.personalAccessToken

private var xenonStoreRepo = "XenonStore"
private var todoRepo = "TodoList"
private var calculatorRepo = "Calculator"
private var fileexplorerRepo = "FileExplorer"

private var hasCheckedForUpdates = false

@Serializable
data class Release(
    val tag_name: String,
    val name: String,
    val prerelease: Boolean,
    val assets: List<Asset>
)

@Serializable
data class Asset(
    val name: String,
    val browser_download_url: String
)

override fun onCreate(savedInstanceState: Bundle?) {
    val sharedPreferenceManager = SharedPreferenceManager(this)
    AppCompatDelegate.setDefaultNightMode(sharedPreferenceManager.themeFlag[sharedPreferenceManager.theme])
    super.onCreate(savedInstanceState)
    binding = ActivityMainBinding.inflate(layoutInflater)
    setContentView(binding.root)

    setupToolbar()
    sharedPreferences = getPreferences(MODE_PRIVATE)

    val downloadButton1: Button = findViewById(id.download_1)
    val downloadButton2: Button = findViewById(id.download_2)
    val downloadButton3: Button = findViewById(id.download_3)
    val downloadButton4: Button = findViewById(id.download_4)

    updateButtonText(downloadButton1, xenonStoreRepo)
    updateButtonText(downloadButton2, todoRepo)
    updateButtonText(downloadButton3, calculatorRepo)
    updateButtonText(downloadButton4, fileexplorerRepo)

    val swipeRefreshLayout: SwipeRefreshLayout = findViewById(id.swipe_refresh_layout)
    swipeRefreshLayout.setOnRefreshListener {
        updateButtonText(findViewById(id.download_1), xenonStoreRepo)
        updateButtonText(findViewById(id.download_2), todoRepo)
        updateButtonText(findViewById(id.download_3), calculatorRepo)
        updateButtonText(findViewById(id.download_4), fileexplorerRepo)
        swipeRefreshLayout.isRefreshing = false
        hasCheckedForUpdates = false
    }
    findViewById<AppBarLayout>(id.appbar).also {
        it.addOnOffsetChangedListener { appBarLayout, verticalOffset ->
            val totalScrollRange = appBarLayout.totalScrollRange
            val alpha = 1.0f + (verticalOffset.toFloat() / totalScrollRange * 5)
            downloadButton1.alpha = alpha
        }
    }
}

override fun onResume() {
    super.onResume()
    if (!hasCheckedForUpdates) {
        updateButtonText(findViewById(id.download_1), xenonStoreRepo)
        updateButtonText(findViewById(id.download_2), todoRepo)
        updateButtonText(findViewById(id.download_3), calculatorRepo)
        updateButtonText(findViewById(id.download_4), fileexplorerRepo)
        hasCheckedForUpdates = true
    }
}

private fun setupToolbar() {
    binding.toolbar.setOnMenuItemClickListener { menuItem ->
        when (menuItem.itemId) {
            id.action_share -> {
                val sendIntent: Intent = Intent().apply {
                    action = Intent.ACTION_SEND
                    putExtra(
                        Intent.EXTRA_TEXT,
                        "https://www.dropbox.com/scl/fi/xopqi9tvgr1vphukyozr5/app-release.apk?rlkey=z5qeobkr3wxuhby588ix8n0o9&st=bl0e41h0&dl=1"
                    )
                    type = "text/plain"
                }
                val shareIntent = Intent.createChooser(sendIntent, null)
                startActivity(shareIntent)
            }
            id.settings -> openSettingsActivity()
            else -> return@setOnMenuItemClickListener false
        }
        return@setOnMenuItemClickListener true
    }
}

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    menuInflater.inflate(R.menu.menu_main, menu)
    return true
}

private val requestPermissionLauncher =
    registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
        if (result.resultCode == RESULT_OK) {
            setStoragePermissionGranted(true)
        } else {
            Toast.makeText(
                this, "Permission denied. Cannot download the file.", Toast.LENGTH_SHORT
            ).show()
        }
    }

private fun openSettingsActivity() {
    startActivity(Intent(applicationContext, SettingsActivity::class.java))
}

private fun isStoragePermissionGranted(): Boolean {
    return sharedPreferences.getBoolean(KEY_STORAGE_PERMISSION_GRANTED, false)
}

private fun setStoragePermissionGranted(granted: Boolean) {
    sharedPreferences.edit().putBoolean(KEY_STORAGE_PERMISSION_GRANTED, granted).apply()
}

private fun setRepositoryDetails(
    owner: String,
    repo: String,
    filePath: String,
    personalAccessToken: String
) {
    this.owner = owner
    this.filePath = filePath
    this.personalAccessToken = personalAccessToken
}

private fun downloadFile(progressBarId: Int, button: Button, repo: String) {
    // ... (Download-Code bleibt unverändert) ...
}

private fun launchInstallPrompt(file: File) {
    // ... (Installationsaufforderung-Code bleibt unverändert) ...
}

private fun updateButtonText(button: Button, repo: String) {
    if (button == findViewById(id.download_1)) {
        val packageName = packageNameFromRepo(repo)
        if (isAppInstalled(packageName)) {
            checkUpdates(button, repo)
        } else {
            button.visibility = View.GONE
        }
    } else {
        val packageName = packageNameFromRepo(repo)
        if (isAppInstalled(packageName)) {
            checkUpdates(button, repo)
            button.setOnClickListener {
                val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
                startActivity(launchIntent)
            }
        } else {
            button.text = getString(string.install)
            button.setOnClickListener {
                setRepositoryDetails(owner, repo, filePath, personalAccessToken)
                downloadFile(getProgressBarId(repo), button, repo)
            }
        }
    }
}

private fun getProgressBarId(repo: String): Int {
    return when (repo) {
        xenonStoreRepo -> id.progressbar_1
        todoRepo -> id.progressbar_2
        calculatorRepo -> id.progressbar_3
        fileexplorerRepo -> id.progressbar_4
        else -> throw IllegalArgumentException("Invalid repository name")
    }
}

private fun checkUpdates(button: Button, repo: String) = CoroutineScope(Dispatchers.IO).launch {
    val context = this@MainActivity
    val sharedPreferences

[Dinico414]

    val sharedPreferences: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(context)
    val releaseSwitchValue = sharedPreferences.getBoolean("release_switch", true) // Default: Releases

    try {
        val currentVersion = getCurrentAppVersion(packageNameFromRepo(repo))
        Log.d("UpdateCheck", "Aktuelle App-Version: $currentVersion")

        val releases = getLatestReleases(owner, repo, personalAccessToken)
        val filteredReleases = if (releaseSwitchValue) {
            releases.filter { !it.prerelease } // Nur Releases
        } else {
            releases // Releases und Pre-Releases
        }

        if (filteredReleases.isNotEmpty()) {
            val latestRelease = filteredReleases.first() // Nehme das neueste Release

            launch(Dispatchers.Main) { // Zurück zum Main-Thread für UI-Updates
                if (latestRelease.tag_name != currentVersion) {
                    button.text = getString(string.update)
                    button.visibility = View.VISIBLE
                    fadeIn(button)

                    // Setze Klick-Listener, um das Update herunterzuladen
                    button.setOnClickListener {
                        setRepositoryDetails(owner, repo, filePath, personalAccessToken)
                        downloadFile(getProgressBarId(repo), button, repo)
                    }
                } else {
                    if (button == findViewById(id.download_1)) {
                        button.visibility = View.GONE
                    } else {
                        button.text = getString(string.open)

                        button.setOnClickListener {
                            val launchIntent =
                                packageManager.getLaunchIntentForPackage(packageNameFromRepo(repo))
                            startActivity(launchIntent)
                        }
                    }
                }
            }
        } else {
            launch(Dispatchers.Main) {
                Toast.makeText(
                    applicationContext, "Keine Releases gefunden.", Toast.LENGTH_SHORT
                ).show()
                button.text = getString(string.open)
            }
        }
    } catch (e: Exception) {
        launch(Dispatchers.Main) {
            Toast.makeText(
                applicationContext, "Update-Check fehlgeschlagen: ${e.message}", Toast.LENGTH_SHORT
            ).show()
            Log.e("UpdateCheck", "Fehler beim Update-Check", e)
            button.text = getString(string.open)
        }
    }
}

private fun getCurrentAppVersion(packageName: String): String {
    return try {
        val packageInfo = packageManager.getPackageInfo(packageName, 0)
        packageInfo.versionName
    } catch (e: PackageManager.NameNotFoundException) {
        "Unknown"
    }
}

private suspend fun getLatestReleases(
    owner: String,
    repo: String,
    personalAccessToken: String? = null
): List<Release> = withContext(Dispatchers.IO) {
    val url = URL("https://api.github.com/repos/$owner/$repo/releases")
    val connection = url.openConnection() as HttpURLConnection
    connection.requestMethod = "GET"
    if (personalAccessToken != null) {
        connection.setRequestProperty("Authorization", "token $personalAccessToken")
    }
    val responseCode = connection.responseCode
    if (responseCode == HttpURLConnection.HTTP_OK) {
        val reader = java.io.BufferedReader(java.io.InputStreamReader(connection.inputStream))
        val response = reader.readText()
        reader.close()
        Json.decodeFromString<List<Release>>(response)
    } else {
        throw Exception("GitHub API request failed with response code: $responseCode")
    }
}

private fun fadeIn(view: View) {
    view.visibility = View.VISIBLE
    view.alpha = 0f
    view.animate().alpha(1f).setDuration(300).setListener(null)
}

private fun isAppInstalled(packageName: String): Boolean {
    val packageManager = packageManager
    return try {
        packageManager.getPackageInfo(packageName, 0)
        true
    } catch (e: Exception) {
        false
    }
}

private fun packageNameFromRepo(repo: String): String {
    return when (repo) {
        xenonStoreRepo -> "com.xenon.store"
        todoRepo -> "com.xenon.todolist"
        calculatorRepo -> "com.xenon.calculator"
        fileexplorerRepo -> "com.xenon.fileexplorer"
        else -> ""
    }
}

companion object {
    private const val KEY_STORAGE_PERMISSION_GRANTED = "storage_permission_granted"
}

}

[Dinico414]

val sharedPreferenceManager = SharedPreferenceManager(this)
val releaseSwitchValue = sharedPreferenceManager.releaseSwitch