810 lines
35 KiB
Kotlin
810 lines
35 KiB
Kotlin
package com.yingmao.clash.act
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.content.Intent
|
|
import android.graphics.Color
|
|
import android.net.Uri
|
|
import android.os.Build
|
|
import android.os.Bundle
|
|
import android.text.Spannable
|
|
import android.text.SpannableStringBuilder
|
|
import android.text.TextUtils
|
|
import android.text.method.HideReturnsTransformationMethod
|
|
import android.text.method.LinkMovementMethod
|
|
import android.text.style.BackgroundColorSpan
|
|
import android.util.Log
|
|
import android.view.View
|
|
import android.view.ViewGroup
|
|
import android.view.inputmethod.InputMethodManager
|
|
import android.widget.*
|
|
import androidx.core.content.FileProvider
|
|
import androidx.lifecycle.ViewModelProvider
|
|
import androidx.lifecycle.lifecycleScope
|
|
import com.yingmao.clash.view.dialog.RxDialogShapeLoading
|
|
import com.yingmao.clash.net.http.entity.LoginRsp
|
|
|
|
import com.tencent.mmkv.MMKV
|
|
import com.yingmao.clash.BuildConfig
|
|
import com.yingmao.clash.R
|
|
import com.yingmao.clash.app.MainApplication
|
|
import com.yingmao.clash.base.BaseActivity
|
|
import com.yingmao.clash.conf.BZYConstants
|
|
import com.yingmao.clash.entity.CheckLoginRsp
|
|
import com.yingmao.clash.listener.AsyncBodyCallback
|
|
import com.yingmao.clash.listener.AsyncCallback
|
|
import com.yingmao.clash.listener.DownLoadListener
|
|
import com.yingmao.clash.net.http.HttpReqType
|
|
import com.yingmao.clash.net.http.HttpStatus
|
|
import com.yingmao.clash.net.http.entity.AppVersionCheckRsp
|
|
import com.yingmao.clash.util.AESUtil
|
|
import com.yingmao.clash.util.CommonUtils
|
|
import com.yingmao.clash.util.Utils
|
|
import com.yingmao.clash.view.PasswordTransformationMethodBigDot
|
|
import com.yingmao.clash.view.RxToast
|
|
import com.yingmao.clash.view.dialog.DialogAppVersion
|
|
import com.yingmao.clash.view.dialog.DialogDoMainChoose
|
|
import com.yingmao.clash.vm.LoginAtyVM
|
|
import com.yingmao.clash.vm.SplashAtyVM
|
|
import kotlinx.coroutines.MainScope
|
|
import kotlinx.coroutines.async
|
|
import kotlinx.coroutines.launch
|
|
import java.io.File
|
|
|
|
class LoginActivity : BaseActivity(), View.OnClickListener {
|
|
private lateinit var loginViewMode: LoginAtyVM
|
|
private lateinit var splashAtyVM: SplashAtyVM
|
|
private lateinit var usernameEt: EditText
|
|
private lateinit var passwordEt: EditText
|
|
private lateinit var usernameErrorTv: TextView
|
|
private lateinit var passwordErrorTv: TextView
|
|
private lateinit var rxDialogShapeLoading: RxDialogShapeLoading
|
|
private lateinit var rememberPasswordCB: CheckBox
|
|
private lateinit var userAgreementCB: CheckBox
|
|
private lateinit var userAgreementTv: TextView
|
|
private lateinit var loginUserName: String
|
|
private var username_encrypt = ""
|
|
private var password_encrypt = ""
|
|
private var user_oaid = ""
|
|
private var registerHost = ""
|
|
private var kefuHost = ""
|
|
|
|
companion object {
|
|
private const val LOGIN_TO_REGISTER_REQUEST_CODE = 1
|
|
const val REGISTER_TO_LOGIN_RESULT_CODE = 2
|
|
}
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
super.onCreate(savedInstanceState)
|
|
setContentView(R.layout.layout_activity_login)
|
|
//点击输入框外边隐藏输入法 必须在setContentView之后调用
|
|
setupUI(findViewById<ViewGroup>(android.R.id.content).getChildAt(0))
|
|
loginViewMode = ViewModelProvider(this).get(LoginAtyVM::class.java)
|
|
splashAtyVM = ViewModelProvider(this).get(SplashAtyVM::class.java)
|
|
observe(this, loginViewMode)
|
|
initViews()
|
|
loginViewMode.upgradeVersion()
|
|
}
|
|
|
|
override fun httpLoading(httpStatus: HttpStatus.Loading) {
|
|
super.httpLoading(httpStatus)
|
|
if (httpStatus.reqType == HttpReqType.LOGIN) {
|
|
showLoadingDialog(resources.getString(R.string.LoggingIn))
|
|
} else if (httpStatus.reqType == HttpReqType.CHECK_LOGIN) {
|
|
showLoadingDialog(resources.getString(R.string.LoggingIn))
|
|
}
|
|
}
|
|
|
|
private fun showLoadingDialog(content: String) {
|
|
if (!::rxDialogShapeLoading.isInitialized) {
|
|
rxDialogShapeLoading = RxDialogShapeLoading(this)
|
|
}
|
|
rxDialogShapeLoading.setMessage(content)
|
|
if (!rxDialogShapeLoading.isShowing) {
|
|
rxDialogShapeLoading.show()
|
|
}
|
|
}
|
|
|
|
private fun hideLoadingDialog() {
|
|
if (::rxDialogShapeLoading.isInitialized && rxDialogShapeLoading.isShowing) {
|
|
rxDialogShapeLoading.cancel()
|
|
}
|
|
}
|
|
|
|
override fun httpSuccess(httpStatus: HttpStatus.Success) {
|
|
super.httpSuccess(httpStatus)
|
|
if (httpStatus.reqType == HttpReqType.LOGIN) {
|
|
//LoginRsp(isPointCard=2, code=1000, data=Data(password=123456, phoneNumber=123456, phToken=1351418999069523968, vpnToken=ve3f/wy8iql72kmt1ptuvguh/stk1frhbxqbd7nvk/y=, userId=080743151296), phLogin=PhLogin(needBuy=false, vpn=, mobile=123456), message=登录成功)
|
|
val rsp = httpStatus.rsp
|
|
com.cncat.vpn.common.log.Log.d("HttpReqType.LOGIN rsp==>${rsp}")
|
|
if (rsp is LoginRsp) {
|
|
if (rsp.code == "1000") {
|
|
val mmkv = MMKV.defaultMMKV()
|
|
mmkv.encode(BZYConstants.MMKV_KEY_TOKEN, rsp.data?.vpnToken)
|
|
mmkv.encode(BZYConstants.MMKV_KEY_PH_TOKEN, rsp.data?.phToken)
|
|
mmkv.encode(BZYConstants.MMKV_KEY_USER_ID, rsp.data?.userId)
|
|
mmkv.encode(BZYConstants.MMKV_KEY_REMEMBER_USERNAME, loginUserName)
|
|
mmkv.encode(BZYConstants.MMKV_KEY_IS_REGISTER, true) //如果登录过一次也算注册过
|
|
loginViewMode.checkLogin()
|
|
} else {
|
|
hideLoadingDialog()
|
|
RxToast.error(
|
|
"(${rsp.code})${if (rsp.message.isNullOrEmpty()) resources.getString(R.string.LoginFailed) else rsp.message}",
|
|
Toast.LENGTH_LONG
|
|
)
|
|
}
|
|
}
|
|
} else if (httpStatus.reqType == HttpReqType.CHECK_LOGIN) {
|
|
hideLoadingDialog()
|
|
//CheckLoginRsp:CheckLoginRsp(msg=请求成功, code=0, data=UserData(identifier=000000670b14728a06, selectProductId=1, vpnServerIntervalTime=0, productName=一级测试模板产品名称, expired=true, vpnExpireTime=1608480000000, mobilePhone=111111, needBuy=true, identityType=mobile, userVpnList=[UserVpnListItem(expireTime=1608480000000, productId=1, productName=一级测试模板产品名称)], identityId=000000670b14728a06, nickname=111111, vpnServerToken=, intervalTime=60, openVpn=false))
|
|
val rsp = httpStatus.rsp
|
|
if (rsp is CheckLoginRsp) {
|
|
if (rsp.code == 0) {
|
|
rsp.data?.let { MainApplication.setUserInfo(it) }
|
|
val expired = rsp.data?.expired
|
|
val isPerfect = rsp.data?.isPerfect
|
|
val userCommand = rsp.data?.userCommand
|
|
val mmkv = MMKV.defaultMMKV()
|
|
mmkv.encode(BZYConstants.MMKV_KEY_VPN_EXPIRED, expired ?: true)
|
|
mmkv.encode(
|
|
BZYConstants.MMKV_KEY_VPN_VALID_PERIOD,
|
|
rsp.data?.vpnExpireTime ?: 0
|
|
)
|
|
mmkv.encode(BZYConstants.MMKV_KEY_IS_PERFECT, isPerfect ?: true)
|
|
mmkv.encode(BZYConstants.MMKV_KEY_VPN_UserCommand, userCommand ?: "")
|
|
toMain()
|
|
// loginViewMode.getServiceAclAndSet()
|
|
} else {
|
|
hideLoadingDialog()
|
|
RxToast.error(
|
|
"(${rsp.code})${if (rsp.msg.isNullOrEmpty()) resources.getString(R.string.CheckLoginFailure) else rsp.msg}",
|
|
Toast.LENGTH_LONG
|
|
)
|
|
}
|
|
}
|
|
}else if(httpStatus.reqType == HttpReqType.GETAPPVERION){
|
|
(httpStatus.rsp as AppVersionCheckRsp).let { avcr ->
|
|
com.cncat.vpn.common.log.Log.i("App_VERION_CHECK ==>$avcr")
|
|
if (avcr.code == 200) {
|
|
avcr.data?.let { md ->
|
|
if (md.isForce) { //强制更新
|
|
if (!TextUtils.isEmpty(md.versionPath)) {
|
|
showUpdateDialog(md.versionPath!!, md.illustrate!!, true)
|
|
}
|
|
} else if (md.isUpgrade) { //更新
|
|
if (!TextUtils.isEmpty(md.versionPath)) {
|
|
showUpdateDialog(md.versionPath!!, md.illustrate!!, false)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var dialogDoMainChoose: DialogDoMainChoose? = null
|
|
override fun httpFailure(httpStatus: HttpStatus.Failure) {
|
|
super.httpFailure(httpStatus)
|
|
if (httpStatus.reqType == HttpReqType.LOGIN) {
|
|
SplashHelper(splashAtyVM).getHostWithFallback { success ->
|
|
MainScope().launch {
|
|
if (success) {
|
|
if (dialogDoMainChoose == null) {
|
|
dialogDoMainChoose = DialogDoMainChoose(this@LoginActivity)
|
|
}
|
|
if (dialogDoMainChoose?.isShowing == false) {
|
|
dialogDoMainChoose?.setOnTryButtonListener(object :
|
|
DialogDoMainChoose.OnTryButtonListener {
|
|
override fun tryButton() {
|
|
var currentHost = MMKV.defaultMMKV()
|
|
.decodeString(BZYConstants.MMKV_KEY_CURRENT_HOST, "")
|
|
// com.cncat.vpn.common.log.Log.d("tryButton CHECK_LOGIN currentHost==>${currentHost}")
|
|
loginViewMode.login(username_encrypt, password_encrypt,user_oaid)
|
|
}
|
|
|
|
override fun cancel() {
|
|
com.cncat.vpn.common.log.Log.d("tryButton CHECK_LOGIN cancel")
|
|
dialogDoMainChoose?.dismiss()
|
|
}
|
|
})
|
|
dialogDoMainChoose?.setOnListItemListener(object :
|
|
DialogDoMainChoose.OnListItemListener {
|
|
override fun listItemClick() {
|
|
loginViewMode.login(username_encrypt, password_encrypt,user_oaid)
|
|
|
|
}
|
|
|
|
})
|
|
dialogDoMainChoose?.show()
|
|
}
|
|
} else {
|
|
if (::rxDialogShapeLoading.isInitialized && rxDialogShapeLoading.isShowing) {
|
|
rxDialogShapeLoading.cancel()
|
|
}
|
|
RxToast.error(resources.getString(R.string.LoginException))
|
|
}
|
|
}
|
|
}
|
|
// if (super.switchServer()) {
|
|
// loginViewMode.login(username_encrypt, password_encrypt)
|
|
// } else {
|
|
// if (::rxDialogShapeLoading.isInitialized && rxDialogShapeLoading.isShowing) {
|
|
// rxDialogShapeLoading.cancel()
|
|
// }
|
|
// RxToast.error(resources.getString(R.string.LoginException))
|
|
// }
|
|
} else if (httpStatus.reqType == HttpReqType.CHECK_LOGIN) {
|
|
if (::rxDialogShapeLoading.isInitialized && rxDialogShapeLoading.isShowing) {
|
|
rxDialogShapeLoading.cancel()
|
|
}
|
|
Log.e(
|
|
"LoginActivity",
|
|
resources.getString(R.string.LoginException) + "${httpStatus.msg}"
|
|
)
|
|
// Logger.i("检查登录异常${httpStatus.msg}")
|
|
RxToast.error(resources.getString(R.string.LoginException))
|
|
}
|
|
}
|
|
|
|
private fun toMain() {
|
|
startActivity(Intent(this, NewMainActivity::class.java))
|
|
finish()
|
|
}
|
|
|
|
private fun initViews() {
|
|
var bindAccount = intent.getStringExtra(BZYConstants.EXTRA_Bind_Account);
|
|
var username = MMKV.defaultMMKV().decodeString(BZYConstants.MMKV_KEY_REMEMBER_USERNAME)
|
|
if (!TextUtils.isEmpty(bindAccount)) {
|
|
username = bindAccount
|
|
}
|
|
|
|
val password = MMKV.defaultMMKV().decodeString(BZYConstants.MMKV_KEY_REMEMBER_PASSWORD)
|
|
usernameEt = findViewById(R.id.et_username)
|
|
usernameEt.setText(username)
|
|
passwordEt = findViewById(R.id.et_password)
|
|
passwordEt.transformationMethod = PasswordTransformationMethodBigDot()
|
|
passwordEt.setText(password)
|
|
usernameErrorTv = findViewById(R.id.tv_username_error)
|
|
passwordErrorTv = findViewById(R.id.tv_password_error)
|
|
val isChecked =
|
|
MMKV.defaultMMKV().decodeBool(BZYConstants.MMKV_KEY_REMEMBER_IS_CHECKED, true)
|
|
rememberPasswordCB = findViewById(R.id.cb_remember_password)
|
|
if (!isChecked) {
|
|
rememberPasswordCB.setTextColor(Color.parseColor("#828282"))
|
|
} else {
|
|
rememberPasswordCB.setTextColor(Color.parseColor("#828282"))
|
|
}
|
|
rememberPasswordCB.isChecked = isChecked
|
|
rememberPasswordCB.setOnCheckedChangeListener { _, isChecked ->
|
|
if (!isChecked) {
|
|
// MMKV.defaultMMKV().removeValueForKey(BZYConstants.MMKV_KEY_REMEMBER_USERNAME)
|
|
MMKV.defaultMMKV().removeValueForKey(BZYConstants.MMKV_KEY_REMEMBER_PASSWORD)
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_REMEMBER_IS_CHECKED, false)
|
|
rememberPasswordCB.setTextColor(Color.parseColor("#4F4F4F"))
|
|
} else {
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_REMEMBER_IS_CHECKED, true)
|
|
rememberPasswordCB.setTextColor(Color.parseColor("#4F4F4F"))
|
|
}
|
|
}
|
|
val userAgreementIsChecked =
|
|
MMKV.defaultMMKV().decodeBool(BZYConstants.MMKV_KEY_USER_AGREEMENT_IS_CHECKED)
|
|
userAgreementTv = findViewById(R.id.tv_user_agreement)
|
|
|
|
userAgreementCB = findViewById(R.id.cb_user_agreement)
|
|
if (!userAgreementIsChecked) {
|
|
userAgreementTv.setTextColor(Color.parseColor("#828282"))
|
|
} else {
|
|
userAgreementTv.setTextColor(Color.parseColor("#4F4F4F"))
|
|
}
|
|
userAgreementCB.isChecked = userAgreementIsChecked
|
|
userAgreementCB.setOnCheckedChangeListener { _, isChecked ->
|
|
if (!isChecked) {
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_USER_AGREEMENT_IS_CHECKED, false)
|
|
userAgreementTv.setTextColor(Color.parseColor("#828282"))
|
|
} else {
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_USER_AGREEMENT_IS_CHECKED, true)
|
|
userAgreementTv.setTextColor(Color.parseColor("#4F4F4F"))
|
|
}
|
|
}
|
|
initUserAgreementView(userAgreementTv)
|
|
val passwordHideCb = findViewById<CheckBox>(R.id.cb_password_hide)
|
|
passwordHideCb.setOnCheckedChangeListener(IOnCheckedChangeListener())
|
|
|
|
val loginTv = findViewById<TextView>(R.id.tv_login)
|
|
loginTv.setOnClickListener(this)
|
|
|
|
val registerTv = findViewById<TextView>(R.id.tv_register)
|
|
registerTv.setOnClickListener(this)
|
|
|
|
val forgetPwdTv = findViewById<TextView>(R.id.tv_forget_pwd)
|
|
|
|
forgetPwdTv.setOnClickListener(this)
|
|
findViewById<TextView>(R.id.tv_kefu).setOnClickListener(this)
|
|
if (Utils.isHarmonyOs()) {
|
|
findViewById<TextView>(R.id.tv_hongmeng_tip).visibility = View.VISIBLE
|
|
}
|
|
|
|
if (BuildConfig.productId.isEmpty()) {
|
|
findViewById<TextView>(R.id.tv_tip_default_psw).visibility = View.GONE
|
|
}
|
|
}
|
|
|
|
private fun initUserAgreementView(textView: TextView) {
|
|
val config = resources.configuration
|
|
val language = config.locale.language
|
|
if (language.equals("en")) {
|
|
val spannableStringBuilder =
|
|
SpannableStringBuilder(resources.getString(R.string.AgreeAgreement))
|
|
val clickableSpan: MyClickableSpan = object : MyClickableSpan() {
|
|
override fun onClick(view: View) {
|
|
val backgroundColorSpan = BackgroundColorSpan(Color.parseColor("#4072FE"))
|
|
spannableStringBuilder.setSpan(
|
|
backgroundColorSpan,
|
|
5,
|
|
24,
|
|
Spannable.SPAN_EXCLUSIVE_INCLUSIVE
|
|
)
|
|
textView.text = spannableStringBuilder
|
|
val intent = Intent(this@LoginActivity, AgreementAndPrivacyActivity::class.java)
|
|
intent.putExtra(
|
|
BZYConstants.EXTRA_KEY_AGREEMENT,
|
|
BZYConstants.EXTRA_PRIVACY_AGREEMENT
|
|
)
|
|
startActivity(intent)
|
|
}
|
|
}
|
|
spannableStringBuilder.setSpan(clickableSpan, 5, 24, Spannable.SPAN_EXCLUSIVE_INCLUSIVE)
|
|
|
|
val privacyClickableSpan: MyClickableSpan = object : MyClickableSpan() {
|
|
override fun onClick(view: View) {
|
|
val backgroundColorSpan = BackgroundColorSpan(Color.parseColor("#4072FE"))
|
|
spannableStringBuilder.setSpan(
|
|
backgroundColorSpan,
|
|
27,
|
|
resources.getString(R.string.AgreeAgreement).length,
|
|
Spannable.SPAN_EXCLUSIVE_INCLUSIVE
|
|
)
|
|
textView.text = spannableStringBuilder
|
|
val intent = Intent(this@LoginActivity, AgreementAndPrivacyActivity::class.java)
|
|
intent.putExtra(
|
|
BZYConstants.EXTRA_KEY_AGREEMENT,
|
|
BZYConstants.EXTRA_USER_AGREEMENT
|
|
)
|
|
startActivity(intent)
|
|
}
|
|
}
|
|
spannableStringBuilder.setSpan(
|
|
privacyClickableSpan,
|
|
27,
|
|
resources.getString(R.string.AgreeAgreement).length,
|
|
Spannable.SPAN_EXCLUSIVE_INCLUSIVE
|
|
)
|
|
textView.text = spannableStringBuilder
|
|
textView.movementMethod = LinkMovementMethod.getInstance()
|
|
} else {
|
|
val spannableStringBuilder =
|
|
SpannableStringBuilder(resources.getString(R.string.AgreeAgreement))
|
|
val clickableSpan: MyClickableSpan = object : MyClickableSpan() {
|
|
override fun onClick(view: View) {
|
|
val backgroundColorSpan = BackgroundColorSpan(Color.parseColor("#4072FE"))
|
|
spannableStringBuilder.setSpan(
|
|
backgroundColorSpan,
|
|
2,
|
|
8,
|
|
Spannable.SPAN_EXCLUSIVE_INCLUSIVE
|
|
)
|
|
textView.text = spannableStringBuilder
|
|
val intent = Intent(this@LoginActivity, AgreementAndPrivacyActivity::class.java)
|
|
intent.putExtra(
|
|
BZYConstants.EXTRA_KEY_AGREEMENT,
|
|
BZYConstants.EXTRA_PRIVACY_AGREEMENT
|
|
)
|
|
startActivity(intent)
|
|
}
|
|
}
|
|
spannableStringBuilder.setSpan(clickableSpan, 2, 8, Spannable.SPAN_EXCLUSIVE_INCLUSIVE)
|
|
|
|
val privacyClickableSpan: MyClickableSpan = object : MyClickableSpan() {
|
|
override fun onClick(view: View) {
|
|
val backgroundColorSpan = BackgroundColorSpan(Color.parseColor("#4072FE"))
|
|
spannableStringBuilder.setSpan(
|
|
backgroundColorSpan,
|
|
9,
|
|
15,
|
|
Spannable.SPAN_EXCLUSIVE_INCLUSIVE
|
|
)
|
|
textView.text = spannableStringBuilder
|
|
val intent = Intent(this@LoginActivity, AgreementAndPrivacyActivity::class.java)
|
|
intent.putExtra(
|
|
BZYConstants.EXTRA_KEY_AGREEMENT,
|
|
BZYConstants.EXTRA_USER_AGREEMENT
|
|
)
|
|
startActivity(intent)
|
|
}
|
|
}
|
|
spannableStringBuilder.setSpan(
|
|
privacyClickableSpan,
|
|
9,
|
|
15,
|
|
Spannable.SPAN_EXCLUSIVE_INCLUSIVE
|
|
)
|
|
textView.text = spannableStringBuilder
|
|
textView.movementMethod = LinkMovementMethod.getInstance()
|
|
}
|
|
|
|
}
|
|
|
|
override fun onClick(v: View?) {
|
|
if (v != null) {
|
|
when (v.id) {
|
|
R.id.tv_login -> {
|
|
val username = usernameEt.text.toString().trim()
|
|
if (username.isBlank()) {
|
|
usernameErrorTv.visibility = View.VISIBLE
|
|
usernameErrorTv.text = getString(R.string.please_input_username)
|
|
getFocusAndShowSoftInput(usernameEt)
|
|
return
|
|
}
|
|
if (!CommonUtils.checkUsername(username)) {
|
|
usernameErrorTv.visibility = View.VISIBLE
|
|
usernameErrorTv.text = getString(R.string.username_input_error)
|
|
getFocusAndShowSoftInput(usernameEt)
|
|
return
|
|
}
|
|
usernameErrorTv.visibility = View.INVISIBLE
|
|
usernameErrorTv.text = ""
|
|
|
|
val password = passwordEt.text.toString().trim()
|
|
if (password.isBlank()) {
|
|
passwordErrorTv.visibility = View.VISIBLE
|
|
passwordErrorTv.text = getString(R.string.please_input_password)
|
|
getFocusAndShowSoftInput(passwordEt)
|
|
return
|
|
}
|
|
passwordErrorTv.visibility = View.INVISIBLE
|
|
passwordErrorTv.text = ""
|
|
if (rememberPasswordCB.isChecked) {
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_REMEMBER_USERNAME, username)
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_REMEMBER_PASSWORD, password)
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_REMEMBER_IS_CHECKED, true)
|
|
} else {
|
|
// MMKV.defaultMMKV().removeValueForKey(BZYConstants.MMKV_KEY_REMEMBER_USERNAME)
|
|
MMKV.defaultMMKV()
|
|
.removeValueForKey(BZYConstants.MMKV_KEY_REMEMBER_PASSWORD)
|
|
MMKV.defaultMMKV().encode(BZYConstants.MMKV_KEY_REMEMBER_IS_CHECKED, false)
|
|
}
|
|
if (TextUtils.isEmpty(username)) {
|
|
return
|
|
}
|
|
username_encrypt = AESUtil.byteArrayToHexStr(
|
|
AESUtil.encrypt(username)
|
|
)
|
|
password_encrypt = AESUtil.byteArrayToHexStr(
|
|
AESUtil.encrypt(password)
|
|
)
|
|
Log.d("OALD","OAID.....::"+MainApplication.OAID)
|
|
user_oaid=AESUtil.byteArrayToHexStr(
|
|
AESUtil.encrypt(MainApplication.OAID)
|
|
)
|
|
loginUserName = username
|
|
if (!userAgreementCB.isChecked) {
|
|
RxToast.warning(resources.getString(R.string.ReadAgreement))
|
|
return
|
|
}
|
|
loginViewMode.login(username_encrypt, password_encrypt,user_oaid)
|
|
}
|
|
|
|
R.id.tv_register -> {
|
|
// val intent = Intent(applicationContext, RegisterActivity::class.java)
|
|
// startActivityForResult(intent, LOGIN_TO_REGISTER_REQUEST_CODE)
|
|
if (TextUtils.isEmpty(registerHost)) {
|
|
if (BuildConfig.is_tz) {
|
|
getTzRegister()
|
|
} else {
|
|
if (BuildConfig.is_ym) {
|
|
getYmRegister()
|
|
} else {
|
|
getBzyRegister()
|
|
}
|
|
}
|
|
} else {
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(registerHost)))
|
|
}
|
|
}
|
|
|
|
R.id.tv_kefu -> {
|
|
var mmkvHost = MMKV.defaultMMKV()
|
|
.decodeString(BZYConstants.MMKV_KEY_KEFU_HOST, "")
|
|
if (TextUtils.isEmpty(kefuHost)) {
|
|
if (BuildConfig.is_tz) {
|
|
getTzKefu(mmkvHost)
|
|
} else {
|
|
if (BuildConfig.is_ym) {
|
|
getYmKefu(mmkvHost)
|
|
} else {
|
|
getBzyKefu(mmkvHost)
|
|
}
|
|
}
|
|
} else {
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(kefuHost)))
|
|
}
|
|
}
|
|
|
|
R.id.tv_forget_pwd -> {
|
|
val intent = Intent(applicationContext, ForGetPwdActivity::class.java)
|
|
startActivity(intent)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private fun getYmRegister() {
|
|
var mmkvHost = MMKV.defaultMMKV()
|
|
.decodeString(BZYConstants.MMKV_KEY_REGISTER_HOST, "")
|
|
// com.cncat.vpn.common.log.Log.d("mmkvHost==>${mmkvHost}")
|
|
loginViewMode.getRegisterHost(object : AsyncBodyCallback {
|
|
override suspend fun suc(str: String) {
|
|
// com.cncat.vpn.common.log.Log.d("str==>${str}")
|
|
if (str != mmkvHost) {
|
|
MMKV.defaultMMKV()
|
|
.encode(BZYConstants.MMKV_KEY_REGISTER_HOST, str)
|
|
}
|
|
// mmkvHost = str
|
|
registerHost = str
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(str)))
|
|
}
|
|
|
|
override fun err() {
|
|
if (!TextUtils.isEmpty(mmkvHost)) {
|
|
startActivity(
|
|
Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse(mmkvHost)
|
|
)
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
}
|
|
|
|
private fun getTzRegister() {
|
|
var mmkvHost = MMKV.defaultMMKV()
|
|
.decodeString(BZYConstants.MMKV_KEY_REGISTER_HOST, "")
|
|
// com.cncat.vpn.common.log.Log.d("mmkvHost==>${mmkvHost}")
|
|
loginViewMode.getTzRegisterHost(object : AsyncBodyCallback {
|
|
override suspend fun suc(str: String) {
|
|
// com.cncat.vpn.common.log.Log.d("str==>${str}")
|
|
if (str != mmkvHost) {
|
|
MMKV.defaultMMKV()
|
|
.encode(BZYConstants.MMKV_KEY_REGISTER_HOST, str)
|
|
}
|
|
// mmkvHost = str
|
|
registerHost = str
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(str)))
|
|
}
|
|
|
|
override fun err() {
|
|
if (!TextUtils.isEmpty(mmkvHost)) {
|
|
startActivity(
|
|
Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse(mmkvHost)
|
|
)
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
}
|
|
|
|
private fun getBzyRegister() {
|
|
var mmkvHost = MMKV.defaultMMKV()
|
|
.decodeString(BZYConstants.MMKV_KEY_REGISTER_HOST, "")
|
|
// com.cncat.vpn.common.log.Log.d("mmkvHost==>${mmkvHost}")
|
|
loginViewMode.getBzyRegisterHost(object : AsyncBodyCallback {
|
|
override suspend fun suc(str: String) {
|
|
// com.cncat.vpn.common.log.Log.d("str==>${str}")
|
|
if (str != mmkvHost) {
|
|
MMKV.defaultMMKV()
|
|
.encode(BZYConstants.MMKV_KEY_REGISTER_HOST, str)
|
|
}
|
|
// mmkvHost = str
|
|
registerHost = str
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(str)))
|
|
}
|
|
|
|
override fun err() {
|
|
if (!TextUtils.isEmpty(mmkvHost)) {
|
|
startActivity(
|
|
Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse(mmkvHost)
|
|
)
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
}
|
|
|
|
|
|
private fun getYmKefu(mmkvHost: String?) {
|
|
loginViewMode.getYmKefuHost(object : AsyncBodyCallback {
|
|
override suspend fun suc(str: String) {
|
|
if (str != mmkvHost) {
|
|
MMKV.defaultMMKV()
|
|
.encode(BZYConstants.MMKV_KEY_KEFU_HOST, str)
|
|
}
|
|
kefuHost = str
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(str)))
|
|
}
|
|
|
|
override fun err() {
|
|
if (!TextUtils.isEmpty(mmkvHost)) {
|
|
startActivity(
|
|
Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse(mmkvHost)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
private fun getBzyKefu(mmkvHost: String?) {
|
|
loginViewMode.getBzyKefuHost(object : AsyncBodyCallback {
|
|
override suspend fun suc(str: String) {
|
|
if (str != mmkvHost) {
|
|
MMKV.defaultMMKV()
|
|
.encode(BZYConstants.MMKV_KEY_KEFU_HOST, str)
|
|
}
|
|
kefuHost = str
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(str)))
|
|
}
|
|
|
|
override fun err() {
|
|
if (!TextUtils.isEmpty(mmkvHost)) {
|
|
startActivity(
|
|
Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse(mmkvHost)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
private fun getTzKefu(mmkvHost: String?) {
|
|
loginViewMode.getTzKefuHost(object : AsyncBodyCallback {
|
|
override suspend fun suc(str: String) {
|
|
if (str != mmkvHost) {
|
|
MMKV.defaultMMKV()
|
|
.encode(BZYConstants.MMKV_KEY_KEFU_HOST, str)
|
|
}
|
|
kefuHost = str
|
|
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(str)))
|
|
}
|
|
|
|
override fun err() {
|
|
if (!TextUtils.isEmpty(mmkvHost)) {
|
|
startActivity(
|
|
Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse(mmkvHost)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
|
|
super.onActivityResult(requestCode, resultCode, data)
|
|
if (requestCode == LOGIN_TO_REGISTER_REQUEST_CODE) {
|
|
data?.let {
|
|
usernameEt.setText(it.extras?.getString("username"))
|
|
passwordEt.setText(it.extras?.getString("password"))
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun getFocusAndShowSoftInput(editText: EditText) {
|
|
editText.requestFocus()
|
|
val imm: InputMethodManager = editText.context
|
|
.getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager
|
|
imm.toggleSoftInput(0, InputMethodManager.SHOW_FORCED)
|
|
}
|
|
|
|
private inner class IOnCheckedChangeListener : CompoundButton.OnCheckedChangeListener {
|
|
override fun onCheckedChanged(buttonView: CompoundButton?, isChecked: Boolean) {
|
|
if (isChecked){
|
|
passwordEt.transformationMethod = HideReturnsTransformationMethod.getInstance()
|
|
passwordEt.setSelection(passwordEt.text.length)
|
|
} else{
|
|
passwordEt.transformationMethod = PasswordTransformationMethodBigDot()
|
|
passwordEt.setSelection(passwordEt.text.length)
|
|
}
|
|
|
|
}
|
|
}
|
|
private fun showUpdateDialog(url: String, illustrate: String, isForce: Boolean) {
|
|
if (TextUtils.isEmpty(url)) {
|
|
RxToast.error(resources.getString(R.string.downloadEmpty))
|
|
return
|
|
}
|
|
var notice = illustrate
|
|
if (TextUtils.isEmpty(illustrate)) {
|
|
notice = resources.getString(R.string.NewVersion)
|
|
}
|
|
var isDownloaded = false;
|
|
var isFinish = false
|
|
var downFilePath = ""
|
|
|
|
val dialog = DialogAppVersion(this,
|
|
notice,
|
|
url,
|
|
isForce,
|
|
object : DialogAppVersion.OnClickListener {
|
|
override fun ok(tv_down: TextView, pb_down: ProgressBar) {
|
|
if (isFinish) {
|
|
installApk(downFilePath)
|
|
return
|
|
}
|
|
if (isDownloaded) {
|
|
RxToast.info(resources.getString(R.string.downloading))
|
|
return
|
|
}
|
|
isDownloaded = true
|
|
splashAtyVM.downLoadFile(url, object : DownLoadListener {
|
|
@SuppressLint("SetTextI18n")
|
|
override fun loading(progress: Int) {
|
|
lifecycleScope.async {
|
|
pb_down.progress = progress
|
|
tv_down.text = resources.getString(R.string.download) + "$progress%"
|
|
}
|
|
}
|
|
|
|
override fun finish(path: String) {
|
|
com.cncat.vpn.common.log.Log.d("down finish path==>$path")
|
|
isFinish = true
|
|
downFilePath = path
|
|
installApk(path)
|
|
}
|
|
|
|
override fun error(msg: String) {
|
|
com.cncat.vpn.common.log.Log.d("down error msg==>$msg")
|
|
}
|
|
|
|
})
|
|
}
|
|
|
|
override fun cancel() {
|
|
}
|
|
})
|
|
dialog.show()
|
|
}
|
|
fun installApk(filePath: String) {
|
|
val file = File(filePath)
|
|
val uri: Uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
|
|
FileProvider.getUriForFile(this, "${applicationContext.packageName}.fileprovider", file)
|
|
} else {
|
|
Uri.fromFile(file)
|
|
}
|
|
|
|
val intent = Intent(Intent.ACTION_VIEW).apply {
|
|
setDataAndType(uri, "application/vnd.android.package-archive")
|
|
flags = Intent.FLAG_ACTIVITY_NEW_TASK
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
|
|
addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
|
|
}
|
|
}
|
|
startActivity(intent)
|
|
}
|
|
} |