343 lines
13 KiB
Kotlin
343 lines
13 KiB
Kotlin
/*
|
|
* Copyright (c) 2020 Hemanth Savarla.
|
|
*
|
|
* Licensed under the GNU General Public License v3
|
|
*
|
|
* This is free software: you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details.
|
|
*
|
|
*/
|
|
package code.name.monkey.retromusic.activities.bugreport
|
|
|
|
import android.app.Activity
|
|
import android.app.Dialog
|
|
import android.content.ClipData
|
|
import android.content.ClipboardManager
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.net.Uri
|
|
import android.os.Bundle
|
|
import android.text.TextUtils
|
|
import android.view.MenuItem
|
|
import android.view.inputmethod.EditorInfo
|
|
import android.widget.Toast
|
|
import androidx.annotation.StringDef
|
|
import androidx.annotation.StringRes
|
|
import androidx.appcompat.app.AlertDialog
|
|
import code.name.monkey.appthemehelper.ThemeStore
|
|
import code.name.monkey.appthemehelper.util.ATHUtil
|
|
import code.name.monkey.appthemehelper.util.MaterialUtil
|
|
import code.name.monkey.appthemehelper.util.TintHelper
|
|
import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper
|
|
import code.name.monkey.retromusic.R
|
|
import code.name.monkey.retromusic.activities.base.AbsThemeActivity
|
|
import code.name.monkey.retromusic.activities.bugreport.model.DeviceInfo
|
|
import code.name.monkey.retromusic.activities.bugreport.model.Report
|
|
import code.name.monkey.retromusic.activities.bugreport.model.github.ExtraInfo
|
|
import code.name.monkey.retromusic.activities.bugreport.model.github.GithubLogin
|
|
import code.name.monkey.retromusic.activities.bugreport.model.github.GithubTarget
|
|
import code.name.monkey.retromusic.misc.DialogAsyncTask
|
|
import com.google.android.material.dialog.MaterialAlertDialogBuilder
|
|
import com.google.android.material.floatingactionbutton.FloatingActionButton
|
|
import com.google.android.material.textfield.TextInputLayout
|
|
import java.io.IOException
|
|
import kotlinx.android.synthetic.main.activity_bug_report.*
|
|
import kotlinx.android.synthetic.main.bug_report_card_device_info.*
|
|
import kotlinx.android.synthetic.main.bug_report_card_report.*
|
|
import org.eclipse.egit.github.core.Issue
|
|
import org.eclipse.egit.github.core.client.GitHubClient
|
|
import org.eclipse.egit.github.core.client.RequestException
|
|
import org.eclipse.egit.github.core.service.IssueService
|
|
|
|
private const val RESULT_SUCCESS = "RESULT_OK"
|
|
private const val RESULT_BAD_CREDENTIALS = "RESULT_BAD_CREDENTIALS"
|
|
private const val RESULT_INVALID_TOKEN = "RESULT_INVALID_TOKEN"
|
|
private const val RESULT_ISSUES_NOT_ENABLED = "RESULT_ISSUES_NOT_ENABLED"
|
|
private const val RESULT_UNKNOWN = "RESULT_UNKNOWN"
|
|
|
|
@StringDef(
|
|
RESULT_SUCCESS,
|
|
RESULT_BAD_CREDENTIALS,
|
|
RESULT_INVALID_TOKEN,
|
|
RESULT_ISSUES_NOT_ENABLED,
|
|
RESULT_UNKNOWN
|
|
)
|
|
@Retention(AnnotationRetention.SOURCE)
|
|
private annotation class Result
|
|
|
|
open class BugReportActivity : AbsThemeActivity() {
|
|
|
|
private var deviceInfo: DeviceInfo? = null
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
setDrawUnderStatusBar()
|
|
super.onCreate(savedInstanceState)
|
|
setContentView(R.layout.activity_bug_report)
|
|
setStatusbarColorAuto()
|
|
setNavigationbarColorAuto()
|
|
setTaskDescriptionColorAuto()
|
|
|
|
initViews()
|
|
|
|
if (TextUtils.isEmpty(title)) setTitle(R.string.report_an_issue)
|
|
|
|
deviceInfo = DeviceInfo(this)
|
|
airTextDeviceInfo.text = deviceInfo.toString()
|
|
}
|
|
|
|
private fun initViews() {
|
|
val accentColor = ThemeStore.accentColor(this)
|
|
val primaryColor = ATHUtil.resolveColor(this, R.attr.colorSurface)
|
|
toolbar.setBackgroundColor(primaryColor)
|
|
setSupportActionBar(toolbar)
|
|
ToolbarContentTintHelper.colorBackButton(toolbar)
|
|
supportActionBar?.setDisplayHomeAsUpEnabled(true)
|
|
TintHelper.setTintAuto(optionUseAccount, accentColor, false)
|
|
optionUseAccount?.setOnClickListener {
|
|
inputTitle.isEnabled = true
|
|
inputDescription.isEnabled = true
|
|
inputUsername.isEnabled = true
|
|
inputPassword.isEnabled = true
|
|
|
|
optionAnonymous.isChecked = false
|
|
sendFab.hide(object : FloatingActionButton.OnVisibilityChangedListener() {
|
|
override fun onHidden(fab: FloatingActionButton?) {
|
|
super.onHidden(fab)
|
|
sendFab.setImageResource(R.drawable.ic_send)
|
|
sendFab.show()
|
|
}
|
|
})
|
|
}
|
|
TintHelper.setTintAuto(optionAnonymous, accentColor, false)
|
|
optionAnonymous.setOnClickListener {
|
|
inputTitle.isEnabled = false
|
|
inputDescription.isEnabled = false
|
|
inputUsername.isEnabled = false
|
|
inputPassword.isEnabled = false
|
|
|
|
optionUseAccount.isChecked = false
|
|
sendFab.hide(object : FloatingActionButton.OnVisibilityChangedListener() {
|
|
override fun onHidden(fab: FloatingActionButton?) {
|
|
super.onHidden(fab)
|
|
sendFab.setImageResource(R.drawable.ic_open_in_browser)
|
|
sendFab.show()
|
|
}
|
|
})
|
|
}
|
|
|
|
inputPassword.setOnEditorActionListener { _, actionId, _ ->
|
|
if (actionId == EditorInfo.IME_ACTION_SEND) {
|
|
reportIssue()
|
|
return@setOnEditorActionListener true
|
|
}
|
|
false
|
|
}
|
|
|
|
airTextDeviceInfo.setOnClickListener { copyDeviceInfoToClipBoard() }
|
|
|
|
TintHelper.setTintAuto(sendFab, accentColor, true)
|
|
sendFab.setOnClickListener { reportIssue() }
|
|
|
|
MaterialUtil.setTint(inputLayoutTitle, false)
|
|
MaterialUtil.setTint(inputLayoutDescription, false)
|
|
MaterialUtil.setTint(inputLayoutUsername, false)
|
|
MaterialUtil.setTint(inputLayoutPassword, false)
|
|
}
|
|
|
|
private fun reportIssue() {
|
|
if (optionUseAccount.isChecked) {
|
|
if (!validateInput()) return
|
|
val username = inputUsername.text.toString()
|
|
val password = inputPassword.text.toString()
|
|
sendBugReport(GithubLogin(username, password))
|
|
} else {
|
|
copyDeviceInfoToClipBoard()
|
|
|
|
val i = Intent(Intent.ACTION_VIEW)
|
|
i.data = Uri.parse(ISSUE_TRACKER_LINK)
|
|
i.flags = Intent.FLAG_ACTIVITY_NEW_TASK
|
|
startActivity(i)
|
|
}
|
|
}
|
|
|
|
private fun copyDeviceInfoToClipBoard() {
|
|
val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
|
|
val clip = ClipData.newPlainText(getString(R.string.device_info), deviceInfo?.toMarkdown())
|
|
clipboard.setPrimaryClip(clip)
|
|
Toast.makeText(
|
|
this@BugReportActivity,
|
|
R.string.copied_device_info_to_clipboard,
|
|
Toast.LENGTH_LONG
|
|
).show()
|
|
}
|
|
|
|
private fun validateInput(): Boolean {
|
|
var hasErrors = false
|
|
|
|
if (optionUseAccount.isChecked) {
|
|
if (TextUtils.isEmpty(inputUsername.text)) {
|
|
setError(inputLayoutUsername, R.string.bug_report_no_username)
|
|
hasErrors = true
|
|
} else {
|
|
removeError(inputLayoutUsername)
|
|
}
|
|
|
|
if (TextUtils.isEmpty(inputPassword.text)) {
|
|
setError(inputLayoutPassword, R.string.bug_report_no_password)
|
|
hasErrors = true
|
|
} else {
|
|
removeError(inputLayoutPassword)
|
|
}
|
|
}
|
|
|
|
if (TextUtils.isEmpty(inputTitle.text)) {
|
|
setError(inputLayoutTitle, R.string.bug_report_no_title)
|
|
hasErrors = true
|
|
} else {
|
|
removeError(inputLayoutTitle)
|
|
}
|
|
|
|
if (TextUtils.isEmpty(inputDescription.text)) {
|
|
setError(inputLayoutDescription, R.string.bug_report_no_description)
|
|
hasErrors = true
|
|
} else {
|
|
removeError(inputLayoutDescription)
|
|
}
|
|
|
|
return !hasErrors
|
|
}
|
|
|
|
private fun setError(editTextLayout: TextInputLayout, @StringRes errorRes: Int) {
|
|
editTextLayout.error = getString(errorRes)
|
|
}
|
|
|
|
private fun removeError(editTextLayout: TextInputLayout) {
|
|
editTextLayout.error = null
|
|
}
|
|
|
|
private fun sendBugReport(login: GithubLogin) {
|
|
if (!validateInput()) return
|
|
|
|
val bugTitle = inputTitle.text.toString()
|
|
val bugDescription = inputDescription.text.toString()
|
|
|
|
val extraInfo = ExtraInfo()
|
|
onSaveExtraInfo()
|
|
|
|
val report = Report(bugTitle, bugDescription, deviceInfo, extraInfo)
|
|
val target = GithubTarget("h4h13", "RetroMusicPlayer")
|
|
|
|
ReportIssueAsyncTask.report(this, report, target, login)
|
|
}
|
|
|
|
private fun onSaveExtraInfo() {}
|
|
|
|
override fun onOptionsItemSelected(item: MenuItem): Boolean {
|
|
if (item.itemId == android.R.id.home) {
|
|
onBackPressed()
|
|
}
|
|
return super.onOptionsItemSelected(item)
|
|
}
|
|
|
|
private class ReportIssueAsyncTask private constructor(
|
|
activity: Activity,
|
|
private val report: Report,
|
|
private val target: GithubTarget,
|
|
private val login: GithubLogin
|
|
) : DialogAsyncTask<Void, Void, String>(activity) {
|
|
|
|
override fun createDialog(context: Context): Dialog {
|
|
return AlertDialog.Builder(context).show()
|
|
}
|
|
|
|
@Result
|
|
override fun doInBackground(vararg params: Void): String {
|
|
val client: GitHubClient = if (login.shouldUseApiToken()) {
|
|
GitHubClient().setOAuth2Token(login.apiToken)
|
|
} else {
|
|
GitHubClient().setCredentials(login.username, login.password)
|
|
}
|
|
|
|
val issue = Issue().setTitle(report.title).setBody(report.description)
|
|
try {
|
|
IssueService(client).createIssue(target.username, target.repository, issue)
|
|
return RESULT_SUCCESS
|
|
} catch (e: RequestException) {
|
|
return when (e.status) {
|
|
STATUS_BAD_CREDENTIALS -> {
|
|
if (login.shouldUseApiToken()) RESULT_INVALID_TOKEN else RESULT_BAD_CREDENTIALS
|
|
}
|
|
STATUS_ISSUES_NOT_ENABLED -> RESULT_ISSUES_NOT_ENABLED
|
|
else -> {
|
|
e.printStackTrace()
|
|
RESULT_UNKNOWN
|
|
}
|
|
}
|
|
} catch (e: IOException) {
|
|
e.printStackTrace()
|
|
return RESULT_UNKNOWN
|
|
}
|
|
}
|
|
|
|
override fun onPostExecute(@Result result: String) {
|
|
super.onPostExecute(result)
|
|
|
|
val context = context ?: return
|
|
|
|
when (result) {
|
|
RESULT_SUCCESS -> tryToFinishActivity()
|
|
RESULT_BAD_CREDENTIALS -> MaterialAlertDialogBuilder(context)
|
|
.setTitle(R.string.bug_report_failed)
|
|
.setMessage(R.string.bug_report_failed_wrong_credentials)
|
|
.setPositiveButton(android.R.string.ok, null)
|
|
.show()
|
|
RESULT_INVALID_TOKEN -> MaterialAlertDialogBuilder(context)
|
|
.setTitle(R.string.bug_report_failed)
|
|
.setMessage(R.string.bug_report_failed_invalid_token)
|
|
.setPositiveButton(android.R.string.ok, null).show()
|
|
RESULT_ISSUES_NOT_ENABLED -> MaterialAlertDialogBuilder(context)
|
|
.setTitle(R.string.bug_report_failed)
|
|
.setMessage(R.string.bug_report_failed_issues_not_available)
|
|
.setPositiveButton(android.R.string.ok, null)
|
|
|
|
else -> MaterialAlertDialogBuilder(context)
|
|
.setTitle(R.string.bug_report_failed)
|
|
.setMessage(R.string.bug_report_failed_unknown)
|
|
.setPositiveButton(android.R.string.ok) { _, _ -> tryToFinishActivity() }
|
|
.setNegativeButton(android.R.string.cancel) { _, _ -> tryToFinishActivity() }
|
|
}
|
|
}
|
|
|
|
private fun tryToFinishActivity() {
|
|
val context = context
|
|
if (context is Activity && !context.isFinishing) {
|
|
context.finish()
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
|
|
fun report(
|
|
activity: Activity,
|
|
report: Report,
|
|
target: GithubTarget,
|
|
login: GithubLogin
|
|
) {
|
|
ReportIssueAsyncTask(activity, report, target, login).execute()
|
|
}
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
|
|
private const val STATUS_BAD_CREDENTIALS = 401
|
|
private const val STATUS_ISSUES_NOT_ENABLED = 410
|
|
private const val ISSUE_TRACKER_LINK = "https://github.com/h4h13/RetroMusicPlayer"
|
|
}
|
|
}
|